集合体系结构

image-20220917142018634

list集合特点:添加到元素是有序、可靠、有索引

Set集合特点:添加的元素是无序、不重复、无索引

Collection 是单列集合的祖宗接口,他的功能是全部单列集合都可以继承使用的

image-20220917142308047

常用方法示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 public static void main(String[] args) {
/*
        public boolean add(E e)             添加
        public void clear()                 清空
        public boolean remove(E e)          删除
        public boolean contains(Object obj) 判断是否包含
        public boolean isEmpty()            判断是否为空
        public int size()                   集合长度


       注意点：
        Collection是一个接口,我们不能直接创建他的对象。
        所以，现在我们学习他的方法时，只能创建他实现类的对象。
        实现类：ArrayList
*/
        //目的：为了学习Collection接口里面的方法
        //自己在做一些练习的时候，还是按照之前的方式去创建对象。
        Collection<String> coll = new ArrayList<>();


        //1.添加元素
        //细节1：如果我们要往List系列集合中添加数据，那么方法永远返回true，因为List系列的是允许元素重复的。
        //细节2：如果我们要往Set系列集合中添加数据，如果当前要添加元素不存在，方法返回true，表示添加成功。
        //                                       如果当前要添加的元素已经存在，方法返回false，表示添加失败。
        //                                       因为Set系列的集合不允许重复。
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);

        //2.清空
        //coll.clear();

        //3.删除
        //细节1：因为Collection里面定义的是共性的方法，所以此时不能通过索引进行删除。只能通过元素的对象进行删除。
        //细节2：方法会有一个布尔类型的返回值，删除成功返回true，删除失败返回false
        //如果要删除的元素不存在，就会删除失败。
        System.out.println(coll.remove("aaa"));
        System.out.println(coll);


        //4.判断元素是否包含
        //细节：底层是依赖equals方法进行判断是否存在的。
        //所以，如果集合中存储的是自定义对象，也想通过contains方法来判断是否包含，那么在javabean类中，一定要重写equals方法。
        boolean result1 = coll.contains("bbb");
        System.out.println(result1);



        //5.判断集合是否为空
        boolean result2 = coll.isEmpty();
        System.out.println(result2);//false


        //6.获取集合的长度
        coll.add("ddd");
        int size = coll.size();
        System.out.println(size);//3

    }

面试题:为什么重写 equals 还要重写 hashcode？

对于任何一个对象，不论是使用继承自Object的equals方法还是重写equals方法。hashCode方法实际上必须要完成的一件事情就是，为该equals方法认定为相同的对象返回相同的哈希值。如果只重写equals方法没有重写hashCode方法，就会导致equals认定相同的对象却拥有不同的哈希值。就违背了hashCode方法中“相同对象必须有相同哈希值”的约定。

Colletion遍历方式

迭代器遍历

image-20220917145141647

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public static void main(String[] args) {
       /*
           Collection系列集合三种通用的遍历方式：
               1.迭代器遍历
               2.增强for遍历
               3.lambda表达式遍历


            迭代器遍历相关的三个方法：
                   Iterator<E> iterator()  ：获取一个迭代器对象
                   boolean hasNext()       ：判断当前指向的位置是否有元素
                   E next()                ：获取当前指向的元素并移动指针
       */

       //1.创建集合并添加元素
       Collection<String> coll = new ArrayList<>();
       coll.add("aaa");
       coll.add("bbb");
       coll.add("ccc");
       coll.add("ddd");

       //2.获取迭代器对象
       //迭代器就好比是一个箭头，默认指向集合的0索引处
       Iterator<String> it = coll.iterator();
       //3.利用循环不断的去获取集合中的每一个元素
       while(it.hasNext()){
           //4.next方法的两件事情：获取元素并移动指针
           String str = it.next();
           System.out.println(str);
       }

   }

迭代器的细节注意点：

  1. 报错NoSuchElementException
  2. 迭代器遍历完毕，指针不会复位
  3. 循环中只能用一次next方法
  4. 迭代器遍历时，不能用集合的方法进行增加或者删除

增强for遍历

  • 增强for的底层就是迭代器，为了简化迭代器的代码书写的。
  • 它是JDK5之后出现的，其内部原理就是一个lterator迭代器
  • 所有的单列集合和数组才能用增强for进行遍历。

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public static void main(String[] args) {
      /* Collection系列集合三种通用的遍历方式：
       1.迭代器遍历
       2.增强for遍历
       3.lambda表达式遍历

       增强for格式：
           for(数据类型 变量名: 集合/数组){

           }

       快速生成方式：
           集合的名字 + for 回车

       */

       //1.创建集合并添加元素
       Collection<String> coll = new ArrayList<>();
       coll.add("zhangsan");
       coll.add("lisi");
       coll.add("wangwu");

       //2.利用增强for进行遍历
       //注意点：
       //s其实就是一个第三方变量，在循环的过程中依次表示集合中的每一个数据
       for(String s : coll){
           s = "qqq";
       }

       System.out.println(coll);//zhangsan lisi wangwu
   }

增强for的细节

修改增强for中的变量,不会改变集合中原本的值

lambda表达式遍历

得益于JDK 8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public static void main(String[] args) {
      /* Collection系列集合三种通用的遍历方式：
       1.迭代器遍历
       2.增强for遍历
       3.lambda表达式遍历

       lambda表达式遍历：
               default void forEach(Consumer<? super T> action):
       */

       //1.创建集合并添加元素
       Collection<String> coll = new ArrayList<>();
       coll.add("zhangsan");
       coll.add("lisi");
       coll.add("wangwu");
       //2.利用匿名内部类的形式
       //底层原理：
       //其实也会自己遍历集合，依次得到每一个元素
       //把得到的每一个元素，传递给下面的accept方法
       //s依次表示集合中的每一个数据
      /* coll.forEach(new Consumer<String>() {
           @Override
           public void accept(String s) {
               System.out.println(s);
           }
       });*/

       //lambda表达式
       coll.forEach(s -> System.out.println(s));
   }

image-20220917152912460

点击下载博客: