1. Collection集合

1.1 数组和集合的区别

  • 相同点
    都是容器,可以存储多个数据
  • 不同点
    • 数组的长度是不可变的,集合的长度是可变的
    • 数组可以存基本数据类型和引用数据类型
      集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

1.2 Colletion集合体系结构

graph TD;
    A{Collection}-->B{List};
    B-->B1(ArrayList);
    B-->B2(LinkedList);
    B-->B3(Vector);
    A-->C{Set};
    C-->C1(HashSet);
    C-->C2(TreeSet);
    C1-->C11(LinkedHashSet);

List系列集合：添加的元素是有序，可重复，有索引的

Set系列集合：添加到元素是无序，不重复，无索引的

1.3 Collection集合概述和使用

常用API
方法名 说明
boolean add(E e) 添加元素
boolean remove(Object o) 从集合中移除指定的元素
boolean removeIf(Object o) 根据条件进行移除
void clear() 清空集合中的元素
boolean contains(Object o) 判断集合中是否存在指定的元素
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中元素的个数
代码实现
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
61
62
63
64
65
66
import java.util.ArrayList;
import java.util.Collection;

public class A01_CollectionDemo1 {
    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

    }
}

1.4 Collection集合遍历方式

  • 迭代器遍历
  • 增强for遍历
  • Lambda表达式遍历

1.4.1 迭代器遍历

迭代器在Java中的类是Iterator，迭代器是集合专用的遍历方式

=迭代器就好比是一个箭头，默认执行集合的0索引处=

最大特点：迭代器不依赖索引，像数组一样靠偏移

常用方法
  • Collection集合获取迭代器| 方法名称 | 说明 |
    | ——– | —- |
    | | |
  • Iterator中的常用方法| 方法名称 | 说明 |
    | —————– | ———————————————————– |
    | boolean hasNext() | 判断当前位置是否有元素，有元素则返回true，没有元素返回false |
    | E next() | 获取当前位置的元素，并将迭代器对象移向下一个位置 |
代码实现
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
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class A03_CollectionDemo3 {
    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. 迭代器遍历时，不能用集合的方法进行增加或者删除（得看源码）

1. Map集合

1.1 Map集合体系结构

graph TD;
    A(Map) --> B(HashMap);
    A --> C(TreeMap);
    B --> D(LinkedHashMap);
    A --> E(HashTable);
    E --> F(Properties);
    G(Dictionary) --> E;

1.2 Map集合概述和特点

概述
1
interface Map<K,V>  K：键的类型；V：值的类型
常用API
方法名 说明
V put(K key,V value) 添加元素
V remove(Object key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsValue(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中键值对的个数 
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
import java.util.HashMap;
import java.util.Map;

public class A01_MapDemo1 {
    public static void main(String[] args) {
        /*
            V put(K key,V value)                    添加元素
            V remove(Object key)                    根据键删除键值对元素
            void clear()                            移除所有的键值对元素
            boolean containsKey(Object key)         判断集合是否包含指定的键
            boolean containsValue(Object value)     判断集合是否包含指定的值
            boolean isEmpty()                       判断集合是否为空
            int size()                              集合的长度，也就是集合中键值对的个数
        */


        //1.创建Map集合的对象
        Map<String, String> m = new HashMap<>();

        //2.添加元素
        //put方法的细节：
        //添加/覆盖
        //在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中,方法返回null
        //在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。

        m.put("郭靖", "黄蓉");
        m.put("韦小宝","沐剑屏");
        m.put("尹志平","小龙女");

        //String value2 = m.put("韦小宝", "双儿");
        //System.out.println(value2);

        //删除
        //String result = m.remove("郭靖");//黄蓉
        //System.out.println(result);

        //清空
        //m.clear();

        //判断是否包含
        /*boolean keyResult = m.containsKey("郭靖");
        System.out.println(keyResult);

        boolean valueResult = m.containsValue("小龙女2");
        System.out.println(valueResult);*/

       /* boolean result = m.isEmpty();
        System.out.println(result);*/

        int size = m.size();
        System.out.println(size);


        //3.打印集合
        System.out.println(m);

    }
}
Map集合的三种遍历方式
  1. 键找值
  2. 键值对
  3. Lambda表达式
    1
    map.forEach((key, value)-> System.out.println(key + "=" + value));

2. HashMap

2.1 HashMap集合概述和特点

没有格外方法，跟Map方法一样。

由键决定：无序，不重复，无索引

底层原理

  • HashMap底层是哈希表结构的
  • 依赖hashCode方法和equals方法保证键的唯一
  • 如果键要存储的是自定义对象，需要重写hashCode和equals方法

2.2 LinkedHashMap

  • 由键决定：有序，不重复，无索引
  • 有序指的是存储和取出的元素顺序一致
  • 原理：底层数据结构依然是哈希表，只是每个键值对元素由额外的多了一个双链表的机制激励存储的顺序