Java集合详

【1】数组，集合都是对多个数据进行存储操作的，简称为容器。
PS:这里的存储指的是内存层面的存储，而不是持久化存储（.txt,.avi,.jpg,数据库）。

特点：
（1）数组一旦指定了长度，那么长度就被确定了，不可以更改。
int[] arr = new int[6];
（2）数组一旦声明了类型以后，数组中只能存放这个类型的数据。数组中只能存放同一种类型的数据。
int[] arr,String[] s,double[] d.....

缺点：
（1）数组一旦指定了长度，那么长度就被确定了，不可以更改。
（2）删除，增加元素  效率低。
（3）数组中实际元素的数量是没有办法获取的，没有提供对应的方法或者属性来获取
（4）数组存储：有序，可重复 ，对于无序的，不可重复的数组不能满足要求。

【2】正因为上面的缺点，引入了一个新的存储数据的结构---》集合
 

 增加：add(E e) addAll(Collection c)
 删除：clear() remove(Object o)
 修改：
 查看：iterator() size()
 判断：contains(Object o)  equals(Object o) isEmpty()

public static void main(String[] args) {
    Collection col = new ArrayList();
    //添加
    //1、add(E e)
    col.add(18);
    System.out.println(col);
    //2、addAll(Collection c)
    List list = Arrays.asList(new Integer[]{11, 15, 3, 7, 1});
    col.addAll(list);

    //删除、
    //1、clear() 
    //col.clear();清空集合
    System.out.println(col);
    System.out.println("集合中元素的数量为："+col.size());
    System.out.println("集合是否为空："+col.isEmpty());
    //2、remove(Object o)
    boolean isRemove = col.remove(15);
    System.out.println(col);
    System.out.println("集合中数据是否被删除："+isRemove);

    //判断
    Collection col2 = new ArrayList();
    col2.add(18);
    col2.add(12);
    col2.add(11);
    col2.add(17);
    Collection col3 = new ArrayList();
    col3.add(18);
    col3.add(12);
    col3.add(11);
    col3.add(17);
    System.out.println(col2.equals(col3));
    System.out.println(col2==col3);//地址一定不相等  false
    System.out.println("是否包含元素："+col3.contains(117));

}

 接口不能创建对象，利用实现类创建对象

Collection col = new ArrayList();

只能存放引用数据类型的数据，不能是基本数据类型

基本数据类型自动装箱，对应包装类。int--->Integer

方式一：

public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(18);
        col.add(12);
        col.add(11);
        col.add(17);
        col.add("abc");
        col.add(9.8);
        //方式1：增强for循环
        for(Object o:col){
            System.out.println(o);
        }
    }

 方式二：

public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(18);
        col.add(12);
        col.add(11);
        col.add(17);
        col.add("abc");
        col.add(9.8);   
        //方式2：iterator()迭代器
        Iterator it = col.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

增加：add(int index, E element)
删除：remove(int index)  remove(Object o)
修改：set(int index, E element)
查看：get(int index)

 添加：

List list = new ArrayList();
list.add(13);
list.add(17);
list.add(6);
list.add(-1);
list.add(2);
list.add("abc");
System.out.println(list);
//在某个索引处添加
list.add(3,66);
System.out.println(list);
list.set(3,77);
System.out.println(list);

删除：

list.remove(2);
//在集合中存入的是Integer类型数据的时候，调用remove方法调用的是：remove(int index)
//根据索引来删除
System.out.println(list);
list.remove("abc");
System.out.println(list);

 修改：

list.set(4,55);
System.out.println(list);
list.set(4,99);
System.out.println(list);

 查看：

 Object o = list.get(0);
 System.out.println(o);

方式一：

//方式1：普通for循环：
        System.out.println("---------------------");
        for(int i = 0;i 
方式二：
 
//方式2：增强for循环：
        System.out.println("---------------------");
        for(Object obj:list){
            System.out.println(obj);
        }
 
方式三：
 
//方式3：迭代器：
        System.out.println("---------------------");
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
 
 ArrayList: 
包含一定泛型类容，以及对集合的一些补充
 
CSDNhttps://mp.csdn.net/mp_blog/creation/editor/124676600
 
泛型： 
方便以后API的阅读
 
1、概述： 
泛型就相当于标签
 形式：<>  
 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，
 JDK1.5之 后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。
 
2、自定义泛型 
泛型类的定义和实例化：
 
//GenericTes就是一个普通的类
//GenericTest 就是一个泛型类
//<>里面就是一个参数类型，这个类型现在是不确定的，相当于一个占位
public class GenericTest {
    int age;
    String name;
    E sex;
    public void a(E n){
    }
    public void b(E[] m){
    }
}
class Test{
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //GenericTest进行实例化：
        //(1)实例化的时候不指定泛型：如果实例化的时候不明确的指定类的泛型，那么认为此泛型为Object类型
        GenericTest gt1 = new GenericTest();
        gt1.a("abc");
        gt1.a(17);
        gt1.a(9.8);
        gt1.b(new String[]{"a","b","c"});
        //（2）实例化的时候指定泛型：---》推荐方式
        GenericTest gt2 = new GenericTest<>();
        gt2.sex = "男";
        gt2.a("abc");
        gt2.b(new String[]{"a","b","c"});
        
    }
}
 
继承情况：
 
 （1）父类指定泛型
 
class SubGenericTest extends GenericTest{
}
class Demo{
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //指定父类泛型，那么子类就不需要再指定泛型了，可以直接使用
        SubGenericTest sgt = new SubGenericTest();
        sgt.a(19);
    }
}
 
（2）父类不指定泛型
 
 如果父类不指定泛型，那么子类也会变成一个泛型类，那这个E的类型可以在创建子类对象的时候确定
 
class SubGenericTest2 extends GenericTest{
}
class Demo2{
    //这是main方法，程序的入口
    public static void main(String[] args) {
        SubGenericTest2 s = new  SubGenericTest2<>();
        s.a("abc");
        s.sex = "女";
    }
}
 
细节：
 
（1）泛型类可以使用多个参数类型：
 
public class TestGeneric{
    A age;
    B name;
    C sex;
    public void a(A m,B n,C x){

    }
}
 
（2） 泛型类的构造器的写法：
 
public TestGeneric(){
}
 
 （3）不同泛型的引用类型不可以相互赋值
 
public void(){
    ArrayList list1 = null;
    ArrayList list2 = null;
    //list1 = list2;报错
}
 
 （4）当泛型参数存在继承情况时
 
Object obj = new Object();
String s = new String();
obj = s;//多态的一种形式

Object[] objArray = new Object[10];
String[] strArray = new Stirng[10];
objArray = strArray;//多态的一种形式

List