CYBSKY HomeArchivesTagsCategories
Java 集合详解
字数总计: 3.3k|阅读时长: 12 分钟

==作者：YB-Chi==

[toc]

集合是什么？

　　Java集合类存放于 java.util 包中，是一个用来存放对象的容器。

注意：

  1. 集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer 类后存入的，Java中每一种基本类型都有对应的引用类型。

  2. 集合存放的是多个对象的引用，对象本身还是放在堆内存中。

  3. 集合可以存放不同类型，不限数量的数据类型。

Java 集合框架图

image

上述所有的集合类，除了 map 系列的集合，即左边集合都实现了 Iterator 接口，这是一个用于遍历集合中元素的接口，主要hashNext(),next(),remove()三种方法。它的一个子接口 ListIterator 在它的基础上又添加了三种方法，分别是 add(),previous(),hasPrevious()。也就是说如果实现 Iterator 接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历后的元素不会再被遍历到，通常无序集合实现的都是这个接口，比如HashSet；而那些元素有序的集合，实现的一般都是 LinkedIterator接口，实现这个接口的集合可以双向遍历，既可以通过next()访问下一个元素，又可以通过previous()访问前一个 元素，比如ArrayList。

　　还有一个特点就是抽象类的使用。如果要自己实现一个集合类，去实现那些抽象的接口会非常麻烦，工作量很大。这个时候就可以使用抽象类，这些抽象类中给我们提供了许多

现成的实现，我们只需要根据自己的需求重写一些方法或者添加一些方法就可以实现自己需要的集合类，工作量大大降低。

集合详解

Iterator:

迭代器，它是Java集合的顶层接口（不包括 map 系列的集合，Map接口 是 map 系列集合的顶层接口）

  • Object next()：返回迭代器刚越过的元素的引用，返回值是 Object，需要强制转换成自己需要的类型

  • boolean hasNext()：判断容器内是否还有可供访问的元素

  • void remove()：删除迭代器刚越过的元素

所以除了 map 系列的集合，我们都能通过迭代器来对集合中的元素进行遍历。

注意：我们可以在源码中追溯到集合的顶层接口，比如 Collection 接口，可以看到它继承的是类 Iterable

1
2
public interface Collection<E> extends Iterable<E> {
	//Query Operations

那这就得说明一下 Iterator 和 Iterable 的区别：

Iterable ：存在于 java.lang 包中。

1
2
3
4
5
6
public interface Iterable<T> {
	/**
	 * Return an iterator over elements of type {@code T}.
	 * @return an Iterator.
	 * /
	 Iterator<T> interator();

我们可以看到，里面封装了 Iterator 接口。所以只要实现了只要实现了Iterable接口的类，就可以使用Iterator迭代器了。

Iterator ：存在于 java.util 包中。核心的方法next(),hasnext(),remove()。

这里我们引用一个Iterator 的实现类 ArrayList 来看一下迭代器的使用：暂时先不管 List 集合是什么，只需要看看迭代器的用法就行了

1
2
3
4
5
6
7
8
9
10
11
12
13
//产生一个 List 集合，典型实现为 ArrayList。
List list = new ArrayList();
//添加三个元素
list.add("Tom");
list.add("Bob");
list.add("Marry");
//构造 List 的迭代器
Iterator it = list.iterator();
//通过迭代器遍历元素
while(it.hasNext()){
	Object obj = it.next();
	System.out.println(obj);
}

Collection:

List 接口和 Set 接口的父接口

1
public interface Collection<E> extends Iterable<E> {

　　看一下 Collection 集合的使用例子：

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
//我们这里将 ArrayList集合作为 Collection 的实现类
Collection collection = new ArrayList();

//添加元素
collection.add("Tom");
collection.add("Bob");

//删除指定元素
collection.remove("Tom");

//删除所有元素
Collection c = new ArrayList();
c.add("Bob");
collection.removeAll(c);

//检测是否存在某个元素
collection.contains("Tom");

//判断是否为空
collection.isEmpty();

//利用增强for循环遍历集合
for(Object obj : collection){
	System.out.println(obj);
}
//利用迭代器 Iterator
Iterator iterator = collection.iterator();
while(iterator.hasNext()){
	Object obj = iterator.next();
	System.out.println(obj);
}

List :

有序，可以重复的集合。

1
public interface List<E> extends Collection<E> {

由于 List 接口是继承于 Collection 接口，所以基本的方法如上所示。

List 接口的三个典型实现：

  1. List list1 = new ArrayList();

　　　　底层数据结构是数组，查询快，增删慢;线程不安全，效率高

  1. List list2 = new Vector();

　　　　底层数据结构是数组，查询快，增删慢;线程安全，效率低,几乎已经淘汰了这个集合

  1. List list3 = new LinkedList();

　　　　底层数据结构是链表，查询慢，增删快;线程不安全，效率高

怎么记呢？我们可以想象：

　　数组就像身上编了号站成一排的人，要找第10个人很容易，根据人身上的编号很快就能找到。但插入、删除慢，要望某个位置插入或删除一个人时，后面的人身上的编号都要变。当然，加入或删除的人始终末尾的也快。

　　链表就像手牵着手站成一圈的人，要找第10个人不容易，必须从第一个人一个个数过去。但插入、删除快。插入时只要解开两个人的手，并重新牵上新加进来的人的手就可以。删除一样的道理。

除此之外，List 接口遍历还可以使用普通 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
//产生一个 List 集合，典型实现为 ArrayList
List list = new ArrayList();
//添加三个元素
list.add("Tom");
list.add("Bob");
list.add("Marry");
//构造 List 的迭代器
Iterator it = list.iterator();
//通过迭代器遍历元素
while(it.hasNext()){
	Object obj = it.next();
	//System.out.println(obj);
}

//在指定地方添加元素
list.add(2, 0);

//在指定地方替换元素
list.set(2, 1);

//获得指定对象的索引
int i=list.indexOf(1);
System.out.println("索引为："+i);

//遍历：普通for循环
for(int j=0;j<list.size();j++){
	 System.out.println(list.get(j));
}

Set：

典型实现 HashSet()是一个无序，不可重复的集合

Set hashSet = new HashSet();

  1. HashSet:不能保证元素的顺序；不可重复；不是线程安全的；集合元素可以为 NULL;

  2. 其底层其实是一个数组，存在的意义是加快查询速度。我们知道在一般的数组中，元素在数组中的索引位置是随机的，元素的取值和元素的位置之间不存在确定的关系，因此，在数组中查找特定的值时，需要把查找值和一系列的元素进行比较，此时的查询效率依赖于查找过程中比较的次数。而 HashSet 集合底层数组的索引和值有一个确定的关系：index=hash(value),那么只需要调用这个公式，就能快速的找到元素或者索引。

  3. 对于 HashSet: 如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

    3.1 当向HashSet集合中存入一个元素时，HashSet会先调用该对象的hashCode（）方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置

    3.1.1 如果 hashCode 值不同，直接把该元素存储到 hashCode() 指定的位置
    3.1.2. 如果 hashCode 值相同，那么会继续判断该元素和集合对象的 equals() 作比较

    3.2.1 hashCode 相同，equals 为 true，则视为同一个对象，不保存在 hashSet（）中
    3.2.2 hashCode 相同，equals 为 false，则存储在之前对象同槽位的链表上，这非常麻烦，我们应该约束这种情况，即保证：如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

注意：每一个存储到 哈希 表中的对象，都得提供 hashCode() 和 equals() 方法的实现，用来判断是否是同一个对象
　　　对于 HashSet 集合，我们要保证如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

　　
常见的 hashCode()算法：

image

Set linkedHashSet = new LinkedHashSet();

　　不可以重复，有序
　　因为底层采用 链表 和 哈希表的算法。链表保证元素的添加顺序，哈希表保证元素的唯一性

Set treeSet = new TreeSet();

　　TreeSet:有序；不可重复，底层使用 红黑树算法，擅长于范围查询。

  • 如果使用 TreeSet() 无参数的构造器创建一个 TreeSet 对象, 则要求放入其中的元素的类必须实现 Comparable 接口所以, 在其中不能放入 null 元素

  • 必须放入同样类的对象.(默认会进行排序) 否则可能会发生类型转换异常.我们可以使用泛型来进行限制

1
2
3
4
Set treeSet = new TreeSet();
treeSet.add(1);  //添加一个 Integer 类型的数据
treeSet.add("a");   //添加一个 String 类型的数据
System.out.println(treeSet);  //会报类型转换异常的错误

image

  • 自动排序：添加自定义对象的时候，必须要实现 Comparable 接口，并要覆盖 compareTo(Object obj) 方法来自定义比较规则

　　　　如果 this > obj,返回正数 1

　　　　如果 this < obj,返回负数 -1

　　　　如果 this = obj,返回 0 ，则认为这两个对象相等

两个对象通过 Comparable 接口 compareTo(Object obj) 方法的返回值来比较大小, 并进行升序排列

image

  • 定制排序: 创建 TreeSet 对象时, 传入 Comparator 接口的实现类. 要求: Comparator 接口的 compare 方法的返回值和 两个元素的 equals() 方法具有一致的返回值 
  • 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
    public class TreeSetTest {
        public static void main(String[] args) {
            Person p1 = new Person(1);
            Person p2 = new Person(2);
            Person p3 = new Person(3);
             
            Set<Person> set = new TreeSet<>(new Person());
            set.add(p1);
            set.add(p2);
            set.add(p3);
            System.out.println(set);  //结果为[1, 2, 3]
        }
     
    }
     
    class Person implements Comparator<Person>{
        public int age;
        public Person(){}
        public Person(int age){
            this.age = age;
        }
        @Override
        /***
         * 根据年龄大小进行排序
         */
        public int compare(Person o1, Person o2) {
            // TODO Auto-generated method stub
            if(o1.age > o2.age){
                return 1;
            }else if(o1.age < o2.age){
                return -1;
            }else{
                return 0;
            }
        }

        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return ""+this.age;
        }
    }

当需要把一个对象放入 TreeSet 中，重写该对象对应的 equals() 方法时，应保证该方法与 compareTo(Object obj) 方法有一致的结果

以上三个 Set 接口的实现类比较：
　　共同点：1、都不允许元素重复
　　　　　　2、都不是线程安全的类，解决办法：Set set = Collections.synchronizedSet(set 对象)

　　不同点：
　　　　HashSet:不保证元素的添加顺序，底层采用 哈希表算法，查询效率高。判断两个元素是否相等，equals() 方法返回 true,hashCode() 值相等。即要求存入 HashSet 中的元素要覆盖 equals() 方法和 hashCode()方法

　　　　LinkedHashSet:HashSet 的子类，底层采用了 哈希表算法以及 链表算法，既保证了元素的添加顺序，也保证了查询效率。但是整体性能要低于 HashSet　　　　

　　　　TreeSet:不保证元素的添加顺序，但是会对集合中的元素进行排序。底层采用 红-黑 树算法（树结构比较适合范围查询）

Map：

key-value 的键值对，key 不允许重复，value 可以

  1. 严格来说 Map 并不是一个集合，而是两个集合之间 的映射关系。

  2. 这两个集合没每一条数据通过映射关系，我们可以看成是一条数据。即 Entry(key,value）。Map 可以看成是由多个 Entry 组成。

  3. 因为 Map 集合即没有实现于 Collection 接口，也没有实现 Iterable 接口，所以不能对 Map 集合进行 for-each 遍历。

image

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
Map<String,Object> hashMap = new HashMap<>();
        //添加元素到 Map 中
        hashMap.put("key1", "value1");
        hashMap.put("key2", "value2");
        hashMap.put("key3", "value3");
        hashMap.put("key4", "value4");
        hashMap.put("key5", "value5");
         
        //删除 Map 中的元素,通过 key 的值
        hashMap.remove("key1");
         
        //通过 get(key) 得到 Map 中的value
        Object str1 = hashMap.get("key1");
         
        //可以通过 添加 方法来修改 Map 中的元素
        hashMap.put("key2", "修改 key2 的 Value");
         
        //通过 map.values() 方法得到 Map 中的 value 集合
        Collection<Object> value = hashMap.values();
        for(Object obj : value){
            //System.out.println(obj);
        }
         
        //通过 map.keySet() 得到 Map 的key 的集合，然后 通过 get(key) 得到 Value
        Set<String> set = hashMap.keySet();
        for(String str : set){
            Object obj = hashMap.get(str);
            //System.out.println(str+"="+obj);
        }
         
        //通过 Map.entrySet() 得到 Map 的 Entry集合，然后遍历
        Set<Map.Entry<String, Object>> entrys = hashMap.entrySet();
        for(Map.Entry<String, Object> entry: entrys){
            String key = entry.getKey();
            Object value2 = entry.getValue();
            System.out.println(key+"="+value2);
        }
         
        System.out.println(hashMap);

　　Map 的常用实现类：

image

Map 和 Set 集合的关系

  1. 都有几个类型的集合。HashMap 和 HashSet ，都采 哈希表算法；TreeMap 和 TreeSet 都采用 红-黑树算法；LinkedHashMap 和 LinkedHashSet 都采用 哈希表算法和红-黑树算法。

  2. 分析 Set 的底层源码，我们可以看到，Set 集合 就是 由 Map 集合的 Key 组成。

image

　　　　　　　　

文章作者: CYBSKY
文章链接: https://cybsky.top/2022/10/27/cyb-mds/java/code/Java 集合详解/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 CYBSKY！
CodeJava