javaSE学习 集合

集合

二.简单认识泛型
2.1泛型的引用
2.2泛型的定义

一、Interfaces接口

1.Collection接口

collection 是操作集合的工具类

Collection ：用来存储管理一组对象 objects ，这些对象一般被成为元素 elements

1.1Collection常用方法说明

方法签名	说明
boolean add(E e)	将元素 e 放入集合中
void clear()	删除集合中的所有元素
boolean isEmpty()	判断集合是否没有任何元素，俗称空集合
boolean remove(Object e)	如果元素 e 出现在集合中，删除其中一个
int size()	返回集合中的元素个数
Object[] toArray()	返回一个装有所有集合中元素的数组

集合类都要+尖括号<包装类>，<>是放的数据类型

Collection<String> collection=new ArraryList<>();
//通过这个接口，引用了具体的实现类，看具体的实现类和接口的关系
ArrayList<String> arrayList=new ArrayList<>();
//具体类具体实现；

（1）、接口和类之间的关系是implements，同样该类需要实现我们接口当中的抽象方法！！！

（2）、接口和接口直接的关系：使用extends关键字来维护，意为：扩展，该接口扩展了其他接口的功能。

public static void main(String[] args) {
    
    
        Collection<String> collection=new ArrayList<>();
    //add方法，以顺序表的形式+；
        collection.add("hello");
        collection.add("haha");
        collection.add("ola");
        System.out.println(collection);

    //删除数组中的耨一个元素
        collection.remove("haha");
        System.out.println(collection);

      //删除集合中的所有元素  
        collection.clear();
        System.out.println(collection);

    //判断集合是否没有任何元素，俗称空集合
        System.out.println(collection.isEmpty());
    //返回集合中的元素个数
        System.out.println(collection.size());

      
    }

1.2 object[] toArray()

这两个比较不同特别说一下；

定义：返回一个装有所有集合中元素的数组

看一组代码：

 Object[] objects=collection.toArray();
 String[] objects2=(String[])collection.toArray();//编译报错
 System.out.println(Arrays.toString(objects2));

通过代码和这组图可得出一个结论Object[] 不能转换为其他数组,。

再来看看这组代码：

Object a=1.0;
Double o=(Double) a;
System.out.println(a);

在编译器里是可以通过的，所以得出的结论是：在Java中数组不能整体进行转化，但是可以单个转化。

2、Map接口说明

方法签名	说明
V get(Object k)	根据指定的 k 查找对应的 v
V getOrDefault(Object k, V defaultValue)	根据指定的 k 查找对应的 v，没有找到用默认值代替
V put(K key, V value)	将指定的 k-v 放入 Map
boolean containsKey(Object key)	判断是否包含 key
boolean containsValue(Object value)	判断是否包含 value
Set<Map.Entry<K, V>> entrySet()	将所有键值对返回
boolean isEmpty()	判断是否为空
int size()	返回键值对的数量

2.1 Map的常用方法说明

 public static void main(String[] args) {
    
    
        Map<String,String> map=new HashMap<>();
     //将指定的 k-v 放入 Map
        map.put("国家奖学金","小红");
        map.put("国家励志奖学金","小明");
        map.put("助学奖学金","小王");
        System.out.println(map);
     //根据指定的 k 查找对应的 v
        String v= map.get("国家奖学金");
        System.out.println(v);
     //根据指定的 k 查找对应的 v，没有找到用默认值代替
        String v1=map.getOrDefault("贫困助奖学金","小张");
        System.out.println(v1);
      //判断是否包含 key
        System.out.println(map.containsKey("助学奖学金"));
      //判断是否包含 value      
       System.out.println(map.containsValue("xiaohong"));
       //判断是否为空
        System.out.println(map.isEmpty());
     //返回键值对的数量
        System.out.println(map.size());
        
    }

2.2 Set<Map.Entry<K, V>> entrySet()

这一组类型简单说就是把key和value打包成一个整体，用循环把每个数组遍历出来，而且这个整体的类型就是Map.Entry<K,V>.

Set<Map.Entry<String,String>> entrySet= map.entrySet();
        for (Map.Entry<String,String> entry:entrySet) {
            System.out.println(entry);
        }

二.简单认识泛型

2.1 泛型的引用

在顺序表中，使用数组的时候通常我们只能定义一种数据类型，如果输入了另外的类型就会报错。

在此可以说明一下，object是java中所有类的祖先。

所以为了解决可以通用类型，我们可以把顺序表换成Object类。

这样编译器就没有报错，但是又有另外的问题出现：

1、相当与一个垃圾桶了，什么东西都可以放；

2、知道是什么类型，但还是需要强制类型转换；

为了解决这上面的问题，就此产生泛型

2.2泛型的定义

1.尖括号<>是泛型的标志，

class MyArrayList<T> {
    
    //<T>占位符，表示当前类是一个泛型类
    public T[] elem;
    public int usedSize;
    
    public MyArrayList (){
    
    
        this.elem=(T[])new Object[10];//!!!
    }

    public void add(T val) {
    
    
        this.elem[this.usedSize]=val;
        this.usedSize++;
    }

    public T get(int pos) {
    
    
        return this.elem[pos];
    }
}
class Person {
    
    

}
  public class TestDome2 {
    
    

    public static void main(String[] args) {
    
    
        Person person=new Person();
        System.out.println(person);
        //自动进行类型的检查
        MyArrayList<String> myArrayList=new MyArrayList();
        System.out.println(myArrayList);
        
        //泛型的泛型参数一定是类类型，如果是简单类型，那么必须是对应的包装类
        MyArrayList<Integer> myArrayList1=new MyArrayList<>();
        System.out.println(myArrayList1);
         MyArrayList<Person> myArrayList2=new MyArrayList<>();
        System.out.println(myArrayList2);

    }

注意事项：

this.elem=(T[])new Object[10];必须这样写

this.elem=new T [10];按照逻辑可以这么写，但是在jvm开发过程中，是遗留下来的问题。

泛型的意义：

1、自动进行类型的检查；

2、自动进行类型的转换；

3、泛型的泛型参数一定是类类型，如果是简单类型，那么必须是对应的包装类

但是运行出来会出现乱码：

这就要牵扯到泛型是怎么编译的？了解即可

有一种机制是：擦除机制，只作用于编译期间，换句话说，泛型就是编译时期的一种机制。运行期间 没有泛型的概念,所以运行的时候是运行的Object类。（擦除成了Object类）