JAVA基础部分复习(二、集合类型)

对于这些常用的集合，建议还是需要先了解一下底层实现原理，这样在不同的使用场景下才能选择更好的方案。

Set介绍以及对比，常用方法：

package cn.review.day02;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.TreeSet;

import org.junit.Test;

/**
 * Set集合复习
 * Set集合用于存储无序，不重复的元素,可以存储一个null值。
 * 其中Set集合主要分为：HashSet，LinkedSet,TreeSet
 *
 * 集合性能分析:
 *         HashSet和TreeSet是Set集合中用得最多的I集合。HashSet总是比TreeSet集合性能好，因为HashSet不需要额维护元素的顺序。
 *        LinkedHashSet需要用额外的链表维护元素的插入顺序，因此在插入时性能比HashSet低，但在迭代访问（遍历）时性能更高。
 *        因为插入的时候即要计算hashCode又要维护链表，而遍历的时候只需要按链表来访问元素。
 * @author dyq
 *
 */
public class ReviewSet {
    @Test
    public void setTest() {
        /**
         * HashSet:实现了set接口，存储元素是无序的，从底层代码可以看到是用HashMap来实现的，是一个value相同key不同的HashMap
         * 使用hashCode的算法来存储元素，因此具有比较好的读写性能,是非线程安全的。
         */
        HashSet<String> hashSet = new HashSet<String>();
        hashSet.add("aaa");
        hashSet.add("bbb");
        hashSet.add("ccc");
        hashSet.add("ddd");
        Iterator<String> iter0 = hashSet.iterator();
        while(iter0.hasNext()) {
            System.out.println(iter0.next()+"=====");
        }
        System.out.println(hashSet);
        /**
         * LinkedHashSet:从底层代码可以看到继承了HashSet，实现了Set接口。
         * LinkedHashSet存储元素使用一个链表来维护元素的插入顺序，读取的时候按照插入顺序读取。
         * LinkedHashSet本质上也是从LinkedHashMap而来，LinkedHashSet的所有方法都继承自HashSet, 而它能维持元素的插入顺序的性质则继承自LinkedHashMap。
         * 同时LinkedHashSet是非线程安全的。
         *
         */
        LinkedHashSet<String> lhSet = new LinkedHashSet<String>();
        lhSet.add("aaa");
        lhSet.add("bbb");
        lhSet.add("ccc");
        Iterator<String> iter = lhSet.iterator();
        while(iter.hasNext()) {
            System.out.println(iter.next()+"------");
        }
        System.out.println(lhSet);
        /**
         * TreeSet:从源码中可以看到，TreeSet实现了NavigableSet集合，而NavigableSet继承于SortedSet。
         * TreeSet底层是用TreeMap来实现的，其原理是红黑树，默认是自然升序排序，同时也可以定制排序，需要关联一个 Comparator对象，由Comparator提供排序逻辑。
         * 因为会默认调用compareTo比较元素大小，做升序排序，所以TreeSet只允许存储同一类元素。
         * TreeSet同样是非线程安全的。
         */
        //本集合使用自定义排序倒序排序。
        TreeSet<Integer> treeSet = new TreeSet<Integer>(new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                int a1 = (Integer)o1;
                int a2 = (Integer)o2;
                return a1<a2?1:a1>a2?-1:0;
            }
        });
        treeSet.add(3);
        treeSet.add(1);
        treeSet.add(8);
        treeSet.add(2);
        System.out.println(treeSet);
    }

    /**
     * 获取字符串的hashCode值
     */
    @Test
    public void hashCodeTest() {
        String str = "aa";
        String str1 = "aa";
        System.out.println(str.hashCode());
        System.out.println(str1.hashCode());
    }

}

List介绍以及对比，常用方法：

package cn.review.day02;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Vector;

import org.junit.Test;

/**
 * List集合
 * List是继承于Collection接口，除了Collection通用的方法以外，扩展了部分只属于List的方法。
 * List是一个有序的集合，和set不同的是，List允许存储项的值为空，也允许存储相等值的存储项.
 * List包含：ArrayList,LinkedList,Vector
 * @author dyq
 *
 */
public class ReviewList {

    @Test
    public void listTest() {
        /**
         * ArrayList:底层是一个数组实现的列表，由于数据是存入数组中的，因此也跟数组的特点一样，查询很快，但是中间部分的插入和删除都很。
         * 适用于多查找的场景
         * 非线程安全的。
         */
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("1111");
        arrayList.add("2222");
        System.out.println(arrayList.toString());

        /**
         * LinkedList:底层是由链表实现，插入和删除方便，适用于多次数据替换的场景
         */
        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add("1111");
        linkedList.add("2222");
        System.out.println(linkedList.toString());
        /**
         * Vector:Vector就是ArrayList的线程安全版，它的方法前都加了synchronized锁，其他实现逻辑都相同。
         * 由于锁的原因导致Vector要比ArrayList慢。
         */
        Vector<String> vector = new Vector<String>();
        vector.add("3333");
        vector.add("4444");
        System.out.println(vector.toString());
    }
}

Map介绍以及对比，常用方法：

package cn.review.day02;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

import org.junit.Test;

/**
 * Map：用于保存具有映射关系的数据，key-value形式，key不能重复。
 * Map－－－实现Map
 * Map.Entry－－Map的内部类，描述Map中的按键/数值对。
 * SortedMap---扩展Map，使按键保持升序排列
 *
 * 常用Map类型介绍:HashMap,HashTable,LinkedHashMap,TreeMap
 *
 * @author dyq
 *
 */
public class ReviewMap {
    @Test
    public void mapTest() {
        /**
         * HashMap:非同步的，所以是线程不安全的，异步的所以读写速度都很快。
         * HashMap中允许key或者value为null
         */
        HashMap<String, String> hashMap = new HashMap<String,String>();
        hashMap.put("1","aaa");
        hashMap.put(null,null);
        for(Map.Entry<String, String> entry : hashMap.entrySet()) {
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }

        /**
         * Hashtable:查看源码发现，其方法使用synchronized关键字修饰，为同步的，线程安全的，所以读写速度都会变慢。
         * Hashtable中不允许key或者value的值为null。
         */
        Hashtable<String,String> hashTable = new Hashtable<String,String>();
        hashTable.put("1","aaa");
        hashTable.put("2","bbb" );
        for(Map.Entry<String, String> entry :hashTable.entrySet()) {
            System.out.println(entry.getKey()+"--"+entry.getValue());
        }
        /**
         * LinkedHashMap:查看源码发现，继承了HashMap,其底层使用双向链表维护键值对的顺序，迭代顺序与键值对插入的顺序一致。
         * LinkedHashMap需要维护插入时候的顺序，所以性能低于HashMap，但是在迭代元素的时候有很好的性能，因为它是用链表来
         * 维护内部的顺序。
         */
        LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<String,String>();
        linkedHashMap.put("1","aaa");
        linkedHashMap.put("2","bbb");
        for(Map.Entry<String, String> entry : linkedHashMap.entrySet()) {
            System.out.println(entry.getKey()+"--"+entry.getValue());
        }
        /**
         * TreeMap:查看源码发现，继承了SortedMap，基于红黑树对所有的key进行排序，有两种排序 方式：自然排序和定制排序。
         * 自定义排序需要关联一个Comparator对象，重写compare方法。
         */
        TreeMap<String, String> treeMap = new TreeMap<String,String>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        treeMap.put("1", "aaa");
        treeMap.put("2", "bbb");
        for(Map.Entry<String, String> entry:treeMap.entrySet()) {
            System.out.println(entry.getKey()+"--"+entry.getValue());
        }

    }
}