JavaSE——Collection集合

Collection集合

数组和集合的区别【理解】

• 相同点

  都是容器,可以存储多个数据

• 不同点

  • 数组的长度是不可变的,集合的长度是可变的

  • 数组可以存基本数据类型和引用数据类型

    集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

public class CollectionDemo1 {
    public static void main(String[] args) {
        //多态 List和Set集合都是Collection接口的子类
        Collection list1=new ArrayList();
        list1.add("张三");
        list1.add("张三");
        list1.add("李四");
        list1.add(18);
        list1.add(18);
        list1.add(true);
        list1.add(true);

        //List集合 有序、有索引、可重复
        System.out.println(list1);
        //-->[张三, 张三, 18, 18, true, true]

        Collection list2=new HashSet();
        list2.add("张三");
        list2.add("张三");
        list2.add("李四");
        list2.add(18);
        list2.add(18);
        list2.add(true);
        list2.add(true);

        //Set集合 无序、无索引、不可重复
        System.out.println(list2);
        //-->[李四, 张三, 18, true]

        Collection<String> list3=new ArrayList<>();
        //集合支持泛型，但只支持引用数据类型，基本数据类型要用其包装类
        list3.add("Java");
        System.out.println(list3);//-->[Java]
        //list3.add(22);--报错
        Collection<Integer> list4=new ArrayList<>();
        list4.add(22);
        System.out.println(list4);//-->[22]
    }
}

集合类体系结构【理解】

Collection 集合概述和使用【应用】

• Collection集合概述

  • 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素

  • JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

• 创建Collection集合的对象

  • 多态的方式

  • 具体的实现类ArrayList

• Collection集合常用方法

  方法名	说明
  boolean add(E e)	添加元素
  boolean remove(Object o)	从集合中移除指定的元素
  boolean removeIf(Object o)	根据条件进行移除
  void clear()	清空集合中的元素
  boolean contains(Object o)	判断集合中是否存在指定的元素
  boolean isEmpty()	判断集合是否为空
  int size()	集合的长度，也就是集合中元素的个数

public class CollectionApiDemo {
    public static void main(String[] args) {
        //今后集合都要用泛型定义，规范代码
        Collection<String> list=new ArrayList<>();
        //1.添加.add(),添加成功之后返回一个true
        list.add("张三");
        list.add("李四");
        list.add("aaa");
        System.out.println(list.add("add方法的返回值"));
        //-->true
        System.out.println(list);
        //-->[张三, 李四, aaa, add方法的返回值]

        //2.清空.clear()
        /*list.clear();
        System.out.println(list);*/
        //-->[]

        //3.判断集合是否为空.isEmpty()，是空则返回true
        System.out.println(list.isEmpty());
        //-->false

        //4.获取集合大小.size()
        System.out.println(list.size());
        //-->4

        //5.判断集合中是否包含某个元素.contains()，若包含则返回true
        System.out.println(list.contains("aaa"));
        //-->true
        System.out.println(list.contains("AAA"));
        //-->false

        //6.删除某个元素，如果有多个重复元素则默认删除前面的第一个，如果删除成功则返回true
        System.out.println(list);//-->[张三, 李四, aaa, add方法的返回值]
        System.out.println(list.remove("张三"));//-->true
        System.out.println(list);//-->[李四, aaa, add方法的返回值]
        System.out.println(list.remove("王五"));//-->false
        System.out.println(list);//-->[李四, aaa, add方法的返回值]

        //7.把集合转换成数组.toArray()
        Collection<String> list2=new ArrayList<>();
        list2.add("111");
        list2.add("222");
        list2.add("333");
        Object[] arrs=list2.toArray();
        System.out.println("数组:"+Arrays.toString(arrs));
        //-->数组:[111, 222, 333]
        System.out.println("===========拓展===========");
        //用.addAll()可以一个集合的元素全部倒入到另一个集合
        list.addAll(list2);
        System.out.println(list);
        //-->[李四, aaa, add方法的返回值, 111, 222, 333]
    }
}

Collection集合的遍历【应用】

• 迭代器介绍

  • 迭代器,集合的专用遍历方式

  • Iterator<E> iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

• Iterator中的常用方法

  boolean hasNext(): 判断当前位置是否有元素可以被取出 ​ E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

• Collection集合的遍历

public class CollectionIteratorDemo1 {
    public static void main(String[] args) {
        Collection<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        //1.得到当前集合的迭代器对象.iterator()，返回一个迭代器
        //Ctrl+Alt+V 自动接收返回值对象
        Iterator<String> iterator = list.iterator();
        //创建一个字符串用于接收迭代器迭代出的结果
        //String next;
        //迭代器包含.next()可以按顺序将迭代到的结果取出，每次迭代后迭代器会移动到下一个索引位置
        //迭代器的默认位置为0索引，先取元素后移位
        /*
        next= iterator.next();
        System.out.println(next);//-->aaa
        next=iterator.next();
        System.out.println(next);//-->bbb
        next=iterator.next();
        System.out.println(next);//-->ccc
        next=iterator.next();
        System.out.println(next);//-->ddd
        next=iterator.next();
        System.out.println(next);//已经迭代取出所有元素，越界了
        //-->Exception in thread "main" java.util.NoSuchElementException
        */

        //iterator迭代器包含一个.hasNext()用于判断是否存在下一个元素，如果存在则返回true
        //可以用来创建while循环进行迭代器遍历
        while (iterator.hasNext()) {
            String next =  iterator.next();
            System.out.print(next+" ");
            //-->aaa bbb ccc ddd
        }

    }
}

增强for循环【应用】

• 介绍

  • 它是JDK5之后出现的,其内部原理是一个Iterator迭代器

  • 实现Iterable接口的类才可以使用迭代器和增强for

  • 简化数组和Collection集合的遍历

• 格式

  for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {

  // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

  }

• 代码

public class CollectionIteratorDemo2 {
    //foreach遍历（增强for循环）
    //for(元素类型 变量名 : 集合/数组){循环体};
    public static void main(String[] args) {
        Collection<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        int[] arr={1,2,3};

        for (String s : list) {
            System.out.print(s+" ");
            //-->a b c
        }

        System.out.println("");

        for (int i : arr) {
            System.out.print(i+" ");
            //-->1 2 3
        }


    }
}

JDK8以后的forEach遍历集合利用Lambda表达式进行简化

public class CollectionIteratorDemo3 {
    //JDK8之后使用Lambda表达式进行forEach遍历集合
    public static void main(String[] args) {
        Collection<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //forEach遍历提供了一个匿名内部类，源码内写了一个增强for循环遍历
        //Consumer是一个函数式接口，所以可以用Lambda表达式简化
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        //Lambda简化
        //1.去头
        list.forEach((String s)->{
                System.out.println(s);
            }
        );

        //2.去类型
        list.forEach((s)->{
                    System.out.println(s);
                }
        );

        //3.去大括号
        list.forEach((s)-> System.out.println(s));
    }
}