Java学习Day22--Collection集合

泛型

泛型:类型参数化,参数化类型,将类型作为参数传入

<任意的大写字母,可以有多个>

泛型的传入的类型只能是引用类型

如果没有写,默认Object

public class TypeDemo<T,E> {
    
    
    T name;
    E color;

    public T test(E e){
    
    
        return null;
    }
    public static void main(String[] args) {
    
    

        TypeDemo<String,Integer>t = new TypeDemo();
        t.test(1);
        t.color=1;
        t.name="Str";


        ArrayList lis = new ArrayList();
        lis.add("a");
        lis.add(1);
        lis.add(true);

        for (int i = 0; i < lis.size(); i++) {
    
    
            Object sc = lis.get(i);
            if (sc instanceof String) {
    
    
                String s1 = (String) sc;
            }
            if (sc instanceof Integer) {
    
    
                Integer s2 = (Integer) sc;
            }
            if (sc instanceof Boolean) {
    
    
                Boolean s3 = (Boolean) sc;
            }

        }

    }
}

集合的概念

集合就是用来装元素的容器

数组也是一个容器,长度一旦定义不能改变,只能存储同一种类型的数据

为什么提供许多的集合类来存储数据?

1.集合的长度是可变的

2.不同的数据存储,操作方式不同(数组,链表,树,哈希表)

集合的体系

Collection接口中的方法

集合中默认可以存储任意数据类型,建议使用泛型,存储同一种类型的数据

 public static void main(String[] args) {
    
    
        //String类型,只能传入String类型数据
        Collection<String> c = new ArrayList<String>();
        c.add("abc");//添加数据
        c.add("ab");
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        //c.clear();//清空数组
        System.out.println(c.remove("a"));//删除指定元素,有则返回true
        System.out.println(c.remove("f"));//没有返回false
        System.out.println(c.contains("a"));//是否包含
        System.out.println(c.isEmpty());//是否为空
        //有条件的删除
        c.removeIf(new Predicate<String>() {
    
    
            @Override
            public boolean test(String s) {
    
    
                return s.startsWith("a");//如果以a开头的都被删除
            }
        });
        System.out.println(c);
        c.stream().forEach((a)-> System.out.println(a));
        /*
        集合转数组
         */
        Object [] obj  =c.toArray();
        String [] str = c.toArray(new String[c.size()]);
        System.out.println(Arrays.toString(str));
        System.out.println(Arrays.toString(obj));
        /*
        数组转集合
         */
        Collection c1=Arrays.asList(1,2,3,4);
        ArrayList alist = new ArrayList<>(c1);
        System.out.println(alist.remove(1));
        System.out.println(alist);
       test(1,2,3,4);
    }
    /*
    int...a 可变长度的参数,本质是一个数组
    一个参数列表中只能有一个可变长度的参数,并且只能放在参数列表的末尾
     */
    public static void test(int a,int...b){
    
    
        System.out.println(a);
        System.out.println(Arrays.toString(b));
    }

List接口特点

可以存储重复元素

有序的(按照元素的存入的顺序排列)

ArrayList

底层是数组实现,查询快,增删慢

创建之初,在底层创建一个默认长度的数组,当数组内容加满了之后,会扩容一个新的数组为原来的1.5倍

缺点:扩容后,元素不能存储,空间浪费

LinkedList

底层链表实现,查询慢,增删快

元素查询时,从第一个节点向后查找,增加删除元素时,其他元素位置不动,只需要改变指针域的值即可

ArrayList中的方法

public static void main(String[] args) {
    
    
        /*
        调用默认无参的构造方法时,创建ArrayList对象时,并没有实际的创建数组
        在第一次添加元素时创建,默认长度为10
        ArrayList最大容量 MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
         */
        ArrayList<String> alist = new ArrayList<>();
        /*
        调用有参构造方法,创建ArrayList对象时,创建一个指定长度的数组
         */
        ArrayList<String> alist1 = new ArrayList<>(5);

        alist.add("1");
        alist.add("2");
        alist.add("3");
        alist.add("4");
        alist.add("5");
        alist.add("6");
        alist.add("7");
        alist.add("8");
        alist.add("9");
        alist.add("10");
        //当add添加元素后,数组满了之后会扩容为原来的1.5倍
        alist.add("11");
        System.out.println(alist);

        System.out.println("获取指定索引的数"+alist.get(2));
        alist.set(2,"12");//改变指定索引的元素
        System.out.println(alist);

        System.out.println(alist.indexOf("4"));//从前获取元素的索引位置
        System.out.println(alist.lastIndexOf("10"));//从后开始获取元素的索引位置

        List<String> list = alist.subList(2,5);//获取指定索引区间的元素
        System.out.println(list);

    }

public static void main(String[] args) {
    
    
        ArrayList<String> alist = new ArrayList<>();

        alist.add("a");
        alist.add("b");
        alist.add("d");
        alist.add("c");
        alist.add("b");

    //集合排序
        alist.sort(new Comparator<String>() {
    
    
            @Override
            public int compare(String o1, String o2) {
    
    
                return o1.compareTo(o2);
            }
        });
        System.out.println(alist);
    }

ArrayList中的关于All的方法

 public static void main(String[] args) {
    
    
        ArrayList<String> alist = new ArrayList<>();
        alist.add("a");
        alist.add("b");
        alist.add("c");
        alist.add("d");
        alist.add("f");
        ArrayList<String> alist1 = new ArrayList<>();
        alist1.add("a");
        alist1.add("b");
        alist1.add("c");
        alist1.add("d");
        alist1.add("e");

        //alist.forEach((a)-> System.out.println(a));

        //addAll 合并两个集合中的元素,相当于求并集
       /* alist.addAll(alist1);//
        System.out.println(alist);*/

        //containsAll 是否包含另一个集合中的元素,包含则返回true
        /*System.out.println(alist.containsAll(alist1));*/

        //removeAll 删除两个集合中相同的元素,有变化则返回true,相当求差4集
        /*System.out.println(alist.removeAll(alist1));
        System.out.println(alist);*/

        //retainAll 保留两个集合中相同的元素,有变化则返回true 相当于求交集
        System.out.println(alist.retainAll(alist1));
        System.out.println(alist);
    }

removeRange受保护的方法,在子类中访问

    public static void main(String[] args) {
    
    
        MyArrayList mylist = new MyArrayList();
        mylist.add("1");
        mylist.add("2");
        mylist.add("3");
        mylist.add("4");
        mylist.add("5");
        /*
        受保护的方法,在子类中访问
        删除1-4区间的元素,包括1不包括4
         */
        mylist.removeRange(1,4);
        System.out.println(mylist);
    }

LinkedList中的方法(未完)

    public static void main(String[] args) {
    
    
        LinkedList<String> llist = new LinkedList<>();
        llist.add("a");
        llist.add("b");
        llist.add("c");
        llist.add("d");
        llist.add("e");
        //查找某个元素从头结点或者尾结点开始查找,所有查询效率低
        System.out.println(llist.get(3));
    }