Java集合类--List集合，Set集合，Map集合

集合可以看作一个容器，Java中提供了不同的集合类，这些类具有不同的存储对象的方式，同时提供了相应的方法，以便用户对集合进行遍历、添加、删除、查找指定的对象。

1.集合类概述：

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

1.1 常用集合：

1.1.1 List集合

List集合继承了Collection接口

1.1.2 Set集合

List集合继承了Collection接口

1.1.3 Map集合

2.Collection接口

Collection接口是集合类层次结构中的根接口，Collection接口通常不能直接使用，但该接口提供了添加元素，删除元素，管理数据的方法。因为Set和List集合都继承了Collection接口，所以Set集合和List集合都具备这些增删改查方法。

Collection接口的常用方法
方法	功能描述
add(E e)	将指定的对象添加到该集合中
remove(Object obj)	将指定的对象从该集合中移除
isEmpty()	返回boolean值，用于判断该集合是否为空
iterator()	返回在此Collection元素上进行迭代的迭代器，用于遍历集合中的对象
size()	返回int型值，获取该集合中的元素个数

package setclass;

import java.util.*;     //导入java.util包，所有使用集合的实例都要添加该语句

public class Muster {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();   // 实例化集合类对象
        list.add("a");  //向集合中添加数据
        list.add("b");
        list.add("c");
        Iterator<String> it = list.iterator();  //创建list这个集合的迭代器
        while (it.hasNext()) {      //判断是否有下一个元素
            String str = (String) it.next();    //迭代器.next()方法用于获取下一个元素
            System.out.println(str);
        }
    }
}

输出：
        a
        b
        c

iterator的next()方法返回的是Object对象。

3.List集合

List集合包含List接口及List接口的所有实现类。List集合允许元素重复，类似Java数组，可通过索引访问List集合中的元素。

3.1 List接口

List接口因为继承了Collection接口，所以具备Collection接口的所有方法，除此之外，List接口还额外实现了2种非常重要的方法：

3.1.1 get(int index):获取指定索引位置元素

3.1.2 set(int index, object obj):修改集合中指定索引位置处的元素为object;

3.2 List接口的实现类

3.2.1 ArrayList

优点：

ArrayList类实现了可变数组，允许保存所有元素，包括null,并可以根据索引位置对集合进行快速的随机访问；

缺点：

向指定的索引位置插入对象或者删除对象的速度较慢。

ArrayList类实现List接口的语法:

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

E可以是Java合法的数据类型，如String;

3.2.2 LinkedList

优点：

LinkedList类采用链表结构保存对象。便于向集合中插入/删除对象，这种LinkedList类效率较高；

缺点：

对于根据索引位置随机访问集合中的对象，LinkedList类实现List集合的效率较低；

LinkedList类实现List接口的语法：

List<E e> list = new LinkedList<>();

E可以是Java合法的数据类型，如String;

package setclass;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Gather {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();  //创建集合对象
        list.add("a");
        list.add("b");
        list.add("c");
        int i = (int) (Math.random() * list.size());   //根据结合长度获取0~2之间的随机数
        System.out.println("随机获得集合中的元素：" + list.get(i));
        list.remove(2); //将索引为2的位置的元素从集合中移除
        System.out.println("将索引为2位置的元素移除后，集合的元素有：");
        Iterator<String> it = list.iterator();
        int j = 0;
        while (j < list.size()) {
            System.out.println(list.get(j));
            j++;
        }
    }
}

输出：
        随机获得集合中的元素：c
        将索引为2位置的元素移除后，集合的元素有：
        a
        b

4.Set集合

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

4.1 Set接口

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

4.2 Set接口的实现类

4.2.1 HashSet

HashSet类实现Set接口，由哈希表(实际上就是一个HashMap实例)支持，不保证Set集合的迭代顺序，此类允许使用null元素。

4.2.2 TreeSet

TreeSet不仅实现了Set接口，还实现了java.utl.SortedSet接口，因此TreeSet实现的Set集合在遍历时按照自然顺序递增排序，也开一按照指定比较器递增排序。

TreeSet类增加的方法
方法	功能描述
first()	返回此Set集合中第一个（最低）元素
last()	返回此Set集合中最后一个（最高）元素
comparator()	返回对此Set集合中元素进行排序的比较器，如果此Set使用自然排序，则返回null
headSet(E toElement)	返回一个新的Set集合，新集合是toElement(不包含)之前的所有对象
tailSet(E fromElement)	返回一个新的Set集合，新集合是fromElement(包含)之后的所有对象
subSet(E fromElement, E toElement)	返回一个新的Set集合，新集合是fromElementn(包含)到toElement(不包含)之间的所有对象

package setclass;

import java.util.Iterator;
import java.util.TreeSet;

public class updateStu implements Comparable<Object> {   //创建类，实现Comparator接口
    String name;
    long id;

    public updateStu(String name, int id) {      //构造方法
        this.name = name;
        this.id = id;
    }

    public int compareTo(Object o) {
        updateStu up_stu = (updateStu) o;
        int result = id > up_stu.id ? 1 : (id == up_stu.id ? 0 : -1);   //对比两个对象id大小
        return result;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public static void main(String[] args) {
        updateStu stu1 = new updateStu("春田1", 101);
        updateStu stu2 = new updateStu("春田2", 102);
        updateStu stu3 = new updateStu("春田3", 103);
        updateStu stu4 = new updateStu("春田4", 104);

        TreeSet<updateStu> tree = new TreeSet<>();
        tree.add(stu1);
        tree.add(stu2);
        tree.add(stu3);
        tree.add(stu4);

        Iterator<updateStu> it = tree.iterator();       //Set集合中所有对象的迭代器
        System.out.println("TreeSet集合中的所有元素：");
        while (it.hasNext()) {
            updateStu up_stu = (updateStu) it.next();
            System.out.println(up_stu.getId() + " " + up_stu.getName());
        }

        it = tree.headSet(stu3).iterator();    //截取stu2对象之前的所有对象集合
        System.out.println("截取前面的部分集合：");
        while (it.hasNext()) {
            updateStu up_stu = (updateStu) it.next();
            System.out.println(up_stu.getId() + " " + up_stu.getName());
        }

        it = tree.subSet(stu1, stu3).iterator();
        System.out.println("截取中间部分的集合：");
        while (it.hasNext()) {
            updateStu up_stu3 = (updateStu) it.next();
            System.out.println(up_stu3.getId() + " " + up_stu3.getName());
        }
    }
}

输出：
        TreeSet集合中的所有元素：
        101 春田1
        102 春田2
        103 春田3
        104 春田4
        截取前面的部分集合：
        101 春田1
        102 春田2
        截取中间部分的集合：
        101 春田1
        102 春田2

存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的CompareTo(Object o)方法比较此对象与指定对象的顺序，如果该对象小于，等于或大于指定对象，则分别返回负整数，0，正整数。

5.Map集合

Map集合提供的是key-value的映射关系，Map中不能包含相同的key，可以有相同的value,Map集合包含Map接口以及Map接口的所有实现类。

Map结合中允许值对象时null，而且允许多个。

5.1 Map接口

Map接口中的常用方法
方法	功能描述
put(K key, V value)	向集合中添加指定的key-value的映射关系
get(Object key)	获取key的对象，如果存在指定的key对象，则返回该key对象的值，否则返回null
containsKey(Object key)	如果此集合包含指定key的映射关系，则返回true,否则返回false
containsValue(Object key)	如果此集合包含指定value的映射关系，则返回true,否则返回false
keySet()	返回此集合中所有key对象形成的Set集合
valueSet()	返回该集合中所有值对象形成的Collection集合

package mapclass;

import java.util.*;

public class UpdateStu {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();  //创建map实例
        map.put("01", "春田1");
        map.put("02", "春田2");

        Set<String> set = map.keySet(); //构建所有key对象的集合
        Iterator<String> it = set.iterator();   //构建集合迭代器
        System.out.println("key集合中的元素：");
        while (it.hasNext()) {
            String stu = it.next();
            System.out.println(stu);
        }

        Collection<String> coll = map.values(); //构建Map集合中所有values值的集合
        it = coll.iterator();
        System.out.println("value集合中的元素：");
        while (it.hasNext()) {
            String stu = it.next();
            System.out.println(stu);
        }
    }
}

输出：
        key集合中的元素：
        01
        02
        value集合中的元素：
        春田1
        春田2

5.2 Map接口的实现类

Map接口的实现类有HashMap和TreeMap。

5.2.1 HashMap

HashMap类是基于hash表的Map接口实现，HashMap通过哈希码对其内部的映射关系进行快速查找，并允许使用null键和null值，但是必须保证键的唯一性。

优点：

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

缺点：

此类不保证映射的顺序；

5.2.2 TreeMap

TreeMap类不仅实现了Map接口，还实现了java.util.SortedMap接口，因此，集合中的映射关系具有顺序。

优点：

集合中的映射关系具有顺序；

缺点：

在添加、删除、定位映射关系时，效率较低，且不允许键为null；

package mapclass;

import java.util.*;

public class MapText {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();   //由HashMap实现的Map对象

        Emp emp = new Emp("105", "春田1");     //创建Mmp对象
        Emp emp1 = new Emp("103", "春田2");
        Emp emp2 = new Emp("101", "春田3");
        Emp emp3 = new Emp("102", "春田4");
        Emp emp4 = new Emp("104", "春田5");

        map.put(emp.getE_id(), emp.getE_name());     //将对象添加到集合中
        map.put(emp1.getE_id(), emp1.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());

        Set<String> key_set = map.keySet();     //获取Map集合中的所有Key对象集合
        Iterator<String> it = key_set.iterator();       //获取keyset集合对象迭代器
        while (it.hasNext()) {
            String key_str = (String) it.next();
            String name = (String) map.get(key_str);     //通过key获取Map对象value
            System.out.println(key_str + " " + name);
        }

        TreeMap<String, String> tree_map = new TreeMap<>();  //创建TreeMap集合对象
        tree_map.putAll(map);       //将集合对象map添加到TreeMap集合对象中
        Iterator<String> iter = tree_map.keySet().iterator();
        System.out.println("TreeMap类实现的Map集合，键对象升序：");
        while (iter.hasNext()) {
            String key_treemap_str = (String) iter.next();
            String name = tree_map.get(key_treemap_str);
            System.out.println(key_treemap_str + " " + name);
        }

    }
}

输出：
        101 春田3
        102 春田4
        103 春田2
        104 春田5
        105 春田1
        TreeMap类实现的Map集合，键对象升序：
        101 春田3
        102 春田4
        103 春田2
        104 春田5
        105 春田1