Java基础 第四章 集合List、Set、Map

一、结构特点

List、Set、Map的特点

类型	List	Set	Map
存储数据	存储单列数据	存储单列数据	存储键值对这样的双列数据
顺序	有序	无序	无序
重复性	允许重复	不允许重复	键是不允许重复，值是允许重复

二、Connection接口

List 有序,可重复

类型	ArrayList	Vector	LinkedList
底层数据结构	数组	数组	链表
查询	查询快	查询快	查询慢
增删	增删慢	增删慢	增删快
线性安全	线程不安全	线程安全	线程不安全
效率	效率高	效率低	效率高

Set 无序,唯一

类型	HashSet	LinkedHashSet	TreeSet
底层数据结构	哈希表	链表和哈希表	红黑树
顺序	无序	有序 （FIFO插入）	有序（自然排序、比较器排序）
唯一性	依赖两个方法：hashCode()和equals()	由哈希表保证元素唯一	根据比较的返回值是否是0来决定

import java.util.*;

public class ListTest {
    public static void main(String[] args){
        TreeSet<String> treeSet = new TreeSet<String>();
        HashSet<String> hashSet = new HashSet<String>();
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();

        for (String data : Arrays.asList("B", "E", "D", "C", "A","F","G")) {
            hashSet.add(data);
            linkedHashSet.add(data);
            treeSet.add(data);
        }

        System.out.println(treeSet);
        System.out.println(hashSet);
        System.out.println(linkedHashSet);

        ArrayList<String> arrayList = new ArrayList<String>();
        Vector<String> vector = new Vector<String>();
        LinkedList<String> linkedList =new LinkedList<String>();

        String[] arr = {"B", "E", "D", "C", "A","F","G","F"};

        for (String data : arr) {
            arrayList.add(data);
            vector.add(data);
            linkedList.add(data);
        }

        System.out.println(arrayList);
        System.out.println(vector);
        System.out.println(linkedList);
    }
}

[A, B, C, D, E, F, G]
[A, B, C, D, E, F, G]
[B, E, D, C, A, F, G]
[B, E, D, C, A, F, G, F]
[B, E, D, C, A, F, G, F]
[B, E, D, C, A, F, G, F]

Process finished with exit code 0

List的排序：

/**
*
*list的排序需要重写compare
**/
import java.util.ArrayList;
import java.util.Comparator;

public class ListSort {
    public static void main(String[] args) {
        int[] arr = { 49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1,3};
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for(int i=0;i<arr.length;i++){
            arrayList.add(arr[i]);
        }
        System.out.println(arrayList);
        arrayList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //从大到小
                return o2.compareTo(o1);
                //从小到大
//                return o1.compareTo(o2);
            }
        });
        System.out.println(arrayList);
    }
}

三、Map接口

Map集合概述
1、将键映射到值的对象
2、一个映射不能包含重复的键
3、每个键最多只能映射到一个值

HashMap和Hashtable比较

类型	HashMap	Hashtable
线性安全	非线程安全	线程安全
效率	效率高	效率低
null值	支持 null 值和 null 键	不支持 null 值和 null 键

TreeMap与HashMap、Hashtable的区别
TreeMap会根据建值进行排序，HashMap、Hashtable是无序的

3.1、Map的使用

import java.util.*;

public class HashMapTest {
    public static void main(String[] args){
        HashMap<String,String> hashMap = new HashMap<String, String>();
        TreeMap<String,String> treeMap = new TreeMap<String, String>();
        Hashtable<String,String> hashtable = new Hashtable<String, String>();

        hashMap.put("11","B");
        hashMap.put("13","A");
        hashMap.put("12","C");
        hashMap.put("10","D");
        System.out.println(hashMap);

        treeMap.put("31","B");
        treeMap.put("33","A");
        treeMap.put("32","C");
        treeMap.put("30","D");

        System.out.println(treeMap);
        hashtable.put("21","A");
        hashtable.put("23","B");
        hashtable.put("22","C");
        hashtable.put("20","D");
        System.out.println(hashtable);
    }
}

{11=B, 12=C, 13=A, 10=D}
{30=D, 31=B, 32=C, 33=A}
{23=B, 22=C, 21=A, 20=D}

3.2、HashMap的遍历

import java.util.*;

public class HashMapTest {
    public static void main(String[] args){
        Map<String, Integer> tempMap = new HashMap<String, Integer>();
        tempMap.put("a", 1);
        tempMap.put("b", 2);
        tempMap.put("c", 3);
        // JDK1.4中
        // 遍历方法一 hashmap entrySet() 遍历
        System.out.println("方法一");
        Iterator it = tempMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println("key=" + key + " value=" + value);
        }
        System.out.println("");
        // JDK1.5中,应用新特性For-Each循环
        // 遍历方法二
        System.out.println("方法二");
        for (Map.Entry<String, Integer> entry : tempMap.entrySet()) {
            String key = entry.getKey().toString();
            String value = entry.getValue().toString();
            System.out.println("key=" + key + " value=" + value);
        }
        System.out.println("");

        // 遍历方法三 hashmap keySet() 遍历
        System.out.println("方法三");
        for (Iterator i = tempMap.keySet().iterator(); i.hasNext();) {
            Object obj = i.next();
            System.out.println(obj);// 循环输出key
            System.out.println("key=" + obj + " value=" + tempMap.get(obj));
        }
        for (Iterator i = tempMap.values().iterator(); i.hasNext();) {
            Object obj = i.next();
            System.out.println(obj);// 循环输出value
        }
        System.out.println("");

        // 遍历方法四 treemap keySet()遍历
        System.out.println("方法四");
        for (Object o : tempMap.keySet()) {
            System.out.println("key=" + o + " value=" + tempMap.get(o));
        }
        System.out.println("11111");

        // java如何遍历Map <String, ArrayList> map = new HashMap <String,ArrayList>();

        Map<String, ArrayList> map = new HashMap<String, ArrayList>();
        Set<String> keys = map.keySet();
        Iterator<String> iterator = keys.iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            ArrayList arrayList = map.get(key);
            for (Object o : arrayList) {
                System.out.println(o + "遍历过程");
            }
        }
        System.out.println("2222");
        Map<String, List> mapList = new HashMap<String, List>();
        for (Map.Entry entry : mapList.entrySet()) {
            String key = entry.getKey().toString();
            List<String> values = (List) entry.getValue();
            for (String value : values) {
                System.out.println(key + " --> " + value);
            }
        }
    }
}

方法一
key=a value=1
key=b value=2
key=c value=3

方法二
key=a value=1
key=b value=2
key=c value=3

方法三
a
key=a value=1
b
key=b value=2
c
key=c value=3
1
2
3

方法四
key=a value=1
key=b value=2
key=c value=3
11111
2222