Java知识梳理 | 详析三大集合类（附实用例程 + 实践练习题）

0.提要

List接口的实现类
List接口的常用实现类有ArrayList与LinkedList.

ArrayList类
a. 实现了可变的数组，允许保存所有元素，包括null,并可以根据索引位置对集合进行快速的随机访问；
b. 缺点是向指定的索引位置插入对象或删除对象的速度较慢。

LinkedList类
a.采用链表结构保存对象。
b.优点是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用LinkedList类实现的List集合的效率较高：
c. 但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较低。

Set集合

Set集合中的对象不按特定的方式排序，只是简单地把对象加入集合中；

Set集合中不能包含重复对象；

Set集合由Set接口和Set接口的实现类组成。

Set接口继承了Collection接口，因此包含Collection接口的所有方法。

Set接口常用的实现类有HashSet类与TreeSet类。

HashSet类
a. 实现Set接口，由哈希表（实际上是一个HashMap实例）支持。
b. 它不保证Set的迭代顺序，特别是它不保证该顺序恒久不变。
c .此类允许使用null元素。

TreeSet类
a. 不仅实现了Set接口，还实现了java.util.SortedSet接口，
b. 因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序；*********%%%%%%%%%%***********
c. 也可以按照指定比较器递增排序；
d. 即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。

Map集合

Map集合没有继承Collection接口，其提供的是key到value的映射；

Map中不能包含相同的key,每个key只能映射一个value；

key还决定了存储对象在映射中的存储位置，
但不是由key对象本身决定的，而是通过一种“散列技术”进行处理，产生一个散列码的整数值；

散列码通常用作一个偏移量，该偏移量对应分配给映射的内存区域的起始位置，从而确定存储对象在映射中的存储位置；

Map集合包括Map接口以及Map接口的所有实现类。

Map接口

Map接口提供了将key映射到值的对象。

一个映射不能包含重复的key，每个key最多只能映射到一个值。

Map接口中同样提供了集合的常用方法，除此之外还包括如下表所示的常用方法：

注意：Map集合中允许值对象是null，而且没有个数限制，例如，可通过“map.put("05",null)”语句向集合中添加对象。

5.2 Map接口的实现类

Map接口常用的实现类有HashMap和TreeMap；

建议使用HashMap类实现Map集合；

由HashMap类实现的Map集合添加和删除映射关系效率更高；

HashMap是基于哈希表的Map接口的实现；

HashMap通过哈希码对其内部的映射关系进行快速查找；

TreeMap中的映射关系存在一定的顺序；

如果希望Map集合中的对象也存在一定的顺序，应该使用TreeMap类实现Map集合。

HashMap类
a .是基于哈希表的Map接口的实现；
b. 此实现提供所有可选的映射操作，并允许使用null值和null键，但必须保证键的唯一性。
c .HashMap通过哈希表对其内部的映射关系进行快速查找。
d. 此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

TreeMap类
a. 不仅实现了Map接口，还实现了java.util.SortedMap接囗，因此，集合中的映射关系具有一定的顺序。
b. 但在添加、删除和定位映射关系时，TreeMap类比HashMap类性能稍差。
c. 由于TreeMap类实现的Map集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是null。

**可以通过HashMap类创建Map集合，

当需要顺序输出时，再创建一个完成相同映射关系的TreeMap类实例。如文中综合实例：**

1. 集合类概述

1.1. java.util包中提供了一些集合类，这些集合类又被称为容器。

1.2. 关于容器，集合类与数组的不同之处：

数组的长度是固定的，集合的长度是可变的；
数组用来存放基本类型的数据，集合用来存放对象的引用。

1.3. 常用的集合有List集合、Set集合和Map集合；
　　List与Set继承了Collection接口，各接口还提供了不同的实现类。

常用集合类的继承关系如下：

2. Collection接口

Collection接口是层次结构中的根接口；
构成Collection的单位称为元素；
Collection接口通常不能直接使用，但该接口提供了添加元素、删除元素、管理数据的方法。
由于List接口与Set接口都继承了Collection接口，因此这些方法对List集合与Set集合是通用的。

常用方法如下表：

下面是一个综合实例，把表中的方法都用一遍：

（Ps：

iterator迭代器有点儿像一个指针一样的东西，指向list对象中的某一个元素；
it.hasNext()中迭代器的hasNext()第一次用的时候，指向第一个元素，next()同理）

package com.lzw;

import java.util.*;

public class Muster { // 创建类Muster
    public static void main(String args[]) {
        Collection<String> list = new ArrayList<>(); // 实例化集合类对象
        list.add("a"); // 向集合添加数据
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        System.out.println("Now add a&b&c&d&e to the list , its size is:"+list.size());
        System.out.println("Print out all element of the list:");
        Iterator<String> it = list.iterator(); // 创建迭代器
        while (it.hasNext()) { // 判断是否有下一个元素
            String str = (String) it.next(); // 获取集合中元素
            System.out.println(str);
        }
        System.out.println("------------------------------------------------");
        list.remove("a");
        list.remove("b");
        list.remove("c");
        System.out.println("Now remove a&b&c of the list , its size is:"+list.size());
        System.out.println("Print out all element of the list:");
        Iterator<String> it1 = list.iterator(); 
        while(it1.hasNext()){
            String str = (String)it1.next();
            System.out.println(str);
        }
        System.out.println("Now is the list Empty?   "+list.isEmpty());
        System.out.println("------------------------------------------------");
        list.remove("d");
        list.remove("e");
        System.out.println("Now remove d&e of the list , its size is:"+list.size());
        System.out.println("Now is the list Empty?   "+list.isEmpty());
    }
}

输出结果：

Now add a&b&c&d&e to the list , its size is:5
Print out all element of the list:
a
b
c
d
e
------------------------------------------------
Now remove a&b&c of the list , its size is:2
Print out all element of the list:
d
e
Now is the list Empty?   false
------------------------------------------------
Now remove d&e of the list , its size is:0
Now is the list Empty?   true

3. List集合

List集合包括List接口以及接口的所有实现类。
List集合中的元素允许重复，各元素的顺序就是对象插入的顺序。
类似Java数组，用户可通过使用索引（元素在集合中的位置）来访问集合中的元素。

3.1 List接口

List接口继承了Collection接口，因此包含Collection中的所有方法。

此外，List接口还定义了以下两个非常重要的方法:
get(int index):获得指定索引位置的元素;
set(int index，Object obj)：将集合中指定索引位置的对象修改为指定的对象。

3.2 List接口的实现类

List接口的常用实现类有ArrayList与LinkedList.

ArrayList类
a. 实现了可变的数组，允许保存所有元素，包括null,并可以根据索引位置对集合进行快速的随机访问；
b. 缺点是向指定的索引位置插入对象或删除对象的速度较慢。

LinkedList类
a.采用链表结构保存对象。
b.优点是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用LinkedList类实现的List集合的效率较高：
c. 但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较低。

使用List集合时通常声明为List类型，可通过不同的实现类来实例化集合。
分别通过ArrayList、LinkedList类实例化List集合，代码如下：

List<E> list = new ArrayList<>();
List<E> list2 = new LinkedList<>();

在上面的代码中，E可以是合法的Java数据类型。
例如，如果集合中的元素为字符串类型，那么E可以修改为String。

下面是一个综合实例:

import java.util.*;

public class Gather { // 创建类Gather
    public static void main(String[] args) { // 主方法
        List<String> list = new ArrayList<>(); // 创建集合对象
        list.add("a"); // 向集合添加元素
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        int i = (int) (Math.random() * (list.size())); // 获得0~4之间的随机数
        System.out.println("随机获取数组中的元素：" + list.get(i));
        list.remove(2); // 将指定索引位置的元素从集合中移除
        System.out.println("将索引是'2'的元素从数组移除后，数组中的元素是：");
        for (int j = 0; j < list.size(); j++) { // 循环遍历集合
            System.out.println(list.get(j));
        }
    }
}

输出结果：

随机获取数组中的元素：c
将索引是'2'的元素从数组移除后，数组中的元素是：
a
b
d
e

4. Set集合

Set集合中的对象不按特定的方式排序，只是简单地把对象加入集合中；
Set集合中不能包含重复对象；
Set集合由Set接口和Set接口的实现类组成。
Set接口继承了Collection接口，因此包含Collection接口的所有方法。

Set接口常用的实现类有HashSet类与TreeSet类。

HashSet类
a. 实现Set接口，由哈希表（实际上是一个HashMap实例）支持。
b. 它不保证Set的迭代顺序，特别是它不保证该顺序恒久不变。
c .此类允许使用null元素。

TreeSet类
a. 不仅实现了Set接口，还实现了java.util.SortedSet接口，
b. 因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序；*********%%%%%%%%%%***********
c. 也可以按照指定比较器递增排序；
d. 即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。

TreeSet类新增的方法如下表：

几个需要注意的地方：

compareTo()方法中书写的内容正是TreeSet类实现的Set集合在遍历集合时那自然顺序递增排序的依据；

使用compareTo()方法的前提是要让使用的类实现Comparable接口；

Set顺序遍历时，依据compareTo()方法中书写的规则进行自然顺序递增排序，而非add()的顺序；

headSet()/subSet()/tailSet()三个方法再截取时，所谓的“之前、之后、之间”也是相对于自然顺序递增排序之的Set结合，而非add()的顺序；

注意上表中包含和不包含的运用；

（可参考下面实例加深了解）

下面是一个综合实例：

import java.util.*;
public class UpdateStu implements Comparable<Object> {
    String name;
    long id;
    
    //构造方法
    public UpdateStu(String name, long id) {
        this.id = id;
        this.name = name;
    }
    
    //定义排序规则
    public int compareTo(Object o) {
        UpdateStu upstu = (UpdateStu) o;
        int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);
        return result;
    }
    
    //getter & setter
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    public static void main(String[] args) {
        UpdateStu stu1 = new UpdateStu("李同学", 01011);//呐！01011是八进制！！！！！！！！！！！！！！！！！
        UpdateStu stu2 = new UpdateStu("陈同学", 01021);
        UpdateStu stu3 = new UpdateStu("王同学", 01051);
        UpdateStu stu4 = new UpdateStu("马同学", 01012);
        
        TreeSet<UpdateStu> tree = new TreeSet<>();
        tree.add(stu1);
        tree.add(stu2);
        tree.add(stu3);
        tree.add(stu4);
        
        Iterator<UpdateStu> it = tree.iterator();
        System.out.println("Set集合中的所有元素：");
        while (it.hasNext()) {
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }
        System.out.println("李马陈王是自然排序，其对应的对象名顺序是：");
        System.out.println("stu1");
        System.out.println("stu4");
        System.out.println("stu2");
        System.out.println("stu3");
        System.out.println(" ");
        System.out.println("tree.first().getName()：" + tree.first().getName());
        System.out.println("tree.last().getName()：" + tree.last().getName());

        
        System.out.println("------------------------------------------------");
        it = tree.headSet(stu3).iterator();
        System.out.println("截取stu3前面部分的集合：");
        while (it.hasNext()) {
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }
        
        System.out.println("------------------------------------------------");
        it = tree.subSet(stu2, stu3).iterator();
        System.out.println("截取stu2&stu3中间部分的集合");
        while (it.hasNext()) {
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }
        
        System.out.println("------------------------------------------------");
        it = tree.tailSet(stu1).iterator();
        System.out.println("截取stu1后面部分的集合");
        while (it.hasNext()) {
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }
    }
}

输出结果：

Set集合中的所有元素：
521 李同学
522 马同学
529 陈同学
553 王同学
李马陈王是自然排序，其对应的对象名顺序是：
stu1
stu4
stu2
stu3
 
tree.first().getName()：李同学
tree.last().getName()：王同学
------------------------------------------------
截取stu3前面部分的集合：
521 李同学
522 马同学
529 陈同学
------------------------------------------------
截取stu2&stu3中间部分的集合
529 陈同学
------------------------------------------------
截取stu1后面部分的集合
521 李同学
522 马同学
529 陈同学
553 王同学

最后强调：

存入TreeSet类实现的set集合必须实现Comparable接口，该接口中的compareTo(Object o)方法
比较此对象(this/实现本接口的类的实例化对象)与指定对象(传进来的作为参数的对象)的顺序；
如果该对象小于、等于或大于指定对象，则分别返回负整数、0或正整数。

5. Map集合

Map集合没有继承Collection接口，其提供的是key到value的映射；
Map中不能包含相同的key,每个key只能映射一个value；
key还决定了存储对象在映射中的存储位置，但不是由key对象本身决定的，而是通过一种“散列技术”进行处理，产生一个散列码的整数值；
散列码通常用作一个偏移量，该偏移量对应分配给映射的内存区域的起始位置，从而确定存储对象在映射中的存储位置；
Map集合包括Map接口以及Map接口的所有实现类。

5.1 Map接口

Map接口提供了将key映射到值的对象。
一个映射不能包含重复的key，每个key最多只能映射到一个值。
Map接口中同样提供了集合的常用方法，除此之外还包括如下表所示的常用方法：

下面是一个综合实例：

import java.util.*;

public class UpdateStu {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>(); // 创建Map实例
        map.put("01", "李同学"); // 向集合中添加对象
        map.put("02", "魏同学");
        map.put("03", "王同学");
        map.put("04", "陈同学");
        map.put("05", "张同学");
        map.put("06", "赵同学");
        
        Set<String> set = map.keySet(); // 构建Map集合中所有key对象的集合
        Iterator<String> it = set.iterator(); // 创建集合迭代器
        System.out.println("key集合中的元素(map.keySet() + iterator())：");
        while (it.hasNext()) { // 遍历集合
            System.out.println(it.next());
        }
        System.out.println("------------------------------------------------");
        
        Collection<String> coll = map.values(); // 构建Map集合中所有values值集合
        it = coll.iterator();
        System.out.println("values集合中的元素(map.values() + iterator())：");
        while (it.hasNext()) { // 遍历集合
            System.out.println(it.next());
        }
        System.out.println("------------------------------------------------");
        
        System.out.println("map.get(\"01\")" + map.get("01"));
        System.out.println("map.get(\"02\")" + map.get("02"));
        System.out.println("map.get(\"03\")" + map.get("03"));
        System.out.println("------------------------------------------------");
        
        System.out.println("map.containsKey(\"01\")" + map.containsKey("01"));
        System.out.println("map.containsKey(\"10\")" + map.containsKey("10"));
        System.out.println("map.containsValue(\"李同学\")" + map.containsValue("李同学"));
        System.out.println("map.containsValue(\"许同学\")" + map.containsValue("许同学"));
    }
}

输出结果：

key集合中的元素(map.keySet() + iterator())：
01
02
03
04
05
06
------------------------------------------------
values集合中的元素(map.values() + iterator())：
李同学
魏同学
王同学
陈同学
张同学
赵同学
------------------------------------------------
map.get("01")李同学
map.get("02")魏同学
map.get("03")王同学
------------------------------------------------
map.containsKey("01")true
map.containsKey("10")false
map.containsValue("李同学")true
map.containsValue("许同学")false

注意：Map集合中允许值对象是null，而且没有个数限制，例如，可通过“map.put("05",null)”语句向集合中添加对象。

5.2 Map接口的实现类

Map接口常用的实现类有HashMap和TreeMap；
建议使用HashMap类实现Map集合；
由HashMap类实现的Map集合添加和删除映射关系效率更高；
HashMap是基于哈希表的Map接口的实现；
HashMap通过哈希码对其内部的映射关系进行快速查找；
TreeMap中的映射关系存在一定的顺序；
如果希望Map集合中的对象也存在一定的顺序，应该使用TreeMap类实现Map集合。

HashMap类
a .是基于哈希表的Map接口的实现；
b. 此实现提供所有可选的映射操作，并允许使用null值和null键，但必须保证键的唯一性。
c .HashMap通过哈希表对其内部的映射关系进行快速查找。
d. 此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

TreeMap类
a. 不仅实现了Map接口，还实现了java.util.SortedMap接囗，因此，集合中的映射关系具有一定的顺序。
b. 但在添加、删除和定位映射关系时，TreeMap类比HashMap类性能稍差。
c. 由于TreeMap类实现的Map集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是null。

可以通过HashMap类创建Map集合，
当需要顺序输出时，再创建一个完成相同映射关系的TreeMap类实例。如下的综合实例：

首先是一个Emp类文件：

public class Emp {
    private String e_id;
    private String e_name;
    public Emp( String e_id,String e_name) {
        this.e_id = e_id;
        this.e_name = e_name;
    }
    public String getE_id() {
        return e_id;
    }
    public void setE_id(String e_id) {
        this.e_id = e_id;
    }
    public String getE_name() {
        return e_name;
    }
    public void setE_name(String e_name) {
        this.e_name = e_name;
    }
    
}

测试用主类：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class MapText { // 创建类MapText
    public static void main(String[] args) { // 主方法
        Map<String, String> map = new HashMap<>(); // 由HashMap实现的Map对象
        Emp emp = new Emp("351", "张三"); // 创建Emp对象
        Emp emp2 = new Emp("512", "李四");
        Emp emp3 = new Emp("853", "王一");
        Emp emp4 = new Emp("125", "赵六");
        Emp emp5 = new Emp("341", "黄七");

        map.put(emp4.getE_id(), emp4.getE_name()); // 将对象添加到集合中
        map.put(emp5.getE_id(), emp5.getE_name());
        map.put(emp.getE_id(), emp.getE_name());
        map.put(emp2.getE_id(), emp2.getE_name());
        map.put(emp3.getE_id(), emp3.getE_name());

//      Set<String> set = map.keySet(); // 获取Map集合中的key对象集合
        Iterator<String> it = map.keySet().iterator();
        System.out.println("HashMap类实现的Map集合，无序：");
        while (it.hasNext()) { // 遍历Map集合
            String str = (String) it.next();
            String name = (String) map.get(str);
            System.out.println(str + " " + name);
        }
        
        System.out.println( );
        
        TreeMap<String, String> treemap = new TreeMap<>(); // 创建TreeMap集合对象
        treemap.putAll(map); // 向集合添加对象
        Iterator<String> iter = treemap.keySet().iterator();
        System.out.println("TreeMap类实现的Map集合，键对象升序：");
        while (iter.hasNext()) { // 遍历TreeMap集合对象
            String str = (String) iter.next(); // 获取集合中的所有key对象
            String name = (String) treemap.get(str); // 获取集合中的所有values值
            System.out.println(str + " " + name);
        }
    }
}

输出结果：

HashMap类实现的Map集合，无序：
341 黄七
125 赵六
512 李四
853 王一
351 张三

TreeMap类实现的Map集合，键对象升序：
125 赵六
341 黄七
351 张三
512 李四
853 王一

6. 实践练习题

将1～100之间的所有正整数存放在一个List集合中，并将集合中索引位置是10的对象从集合中移除。

import java.util.*;
public class Text {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        for(int i = 1 ;i<=100;i++){
            list.add(new Integer(i));
            }
        list.remove(list.get(10));
        System.out.println("ok");
    }
}

输出结果：

ok

分别向Set集合以及List集合中添加"A” “a” "c” "C” "a”5个元素，观察重复值"a”能否
重复地在List集合以及Set集合中添加。

import java.util.*;
public class Text {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();  //HashSet是Set的子接口
        set.add("a");
        set.add("c");
        set.add("A");
        set.add("a"); 
        set.add("C");
        
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add("A");
        list.add("a"); 
        list.add("C");
        
        System.out.println(set);
       System.out.println(list);
    }
}

输出结果：

[a, A, c, C]
[a, c, A, a, C]

创建Map集合，创建Emp对象，并将Emp对象添加到集合中(Emp对象的id作为Map集合的键），并将id为“015”的对象从集合中移除。

首先是Emp.java:

public class Emp {
    private String e_id;
    private String e_name;
    public Emp( String e_id,String e_name) {
        this.e_id = e_id;
        this.e_name = e_name;
    }
    public String getE_id() {
        return e_id;
    }
    public void setE_id(String e_id) {
        this.e_id = e_id;
    }
    public String getE_name() {
        return e_name;
    }
    public void setE_name(String e_name) {
        this.e_name = e_name;
    }
    
}

然后是主类：

import java.util.*;

public class Text {
    public static void main(String[] args) {
        Map<String, String> map = new TreeMap<>();
        
        Emp emp = new Emp("001", "张三");
        Emp emp2 = new Emp("005", "李四");
        Emp emp3 = new Emp("004", "王五");
        Emp emp4 = new Emp("010", "赵六");
        Emp emp5 = new Emp("015", "魏七");
        
        map.put(emp.getE_id(), emp.getE_name());
        map.put(emp2.getE_id(), emp2.getE_name());
        map.put(emp3.getE_id(), emp3.getE_name());
        map.put(emp4.getE_id(), emp4.getE_name());
        map.put(emp5.getE_id(), emp5.getE_name());
        
        map.remove("015");
        for (String string : map.keySet()) {
            System.out.println(map.get(string));
        }
    }
}

输出结果：

张三
王五
李四
赵六

参考资料：《Java从入门到精通》

最后编辑于：2019.04.19 02:15:51

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 207,113评论 6赞 481
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,644评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 153,340评论 0赞 344
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,449评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,445评论 5赞 374
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,166评论 1赞 284
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,442评论 3赞 401
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,105评论 0赞 261
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,601评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,066评论 2赞 325
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,161评论 1赞 334
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,792评论 4赞 323
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,351评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,352评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,584评论 1赞 261
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,618评论 2赞 355
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,916评论 2赞 344

Java知识梳理 | 详析三大集合类（附实用例程 + 实践练习题）

0.提要

1. 集合类概述

2. Collection接口

3. List集合

3.1 List接口

3.2 List接口的实现类

4. Set集合

5. Map集合

5.1 Map接口

5.2 Map接口的实现类

6. 实践练习题

推荐阅读更多精彩内容