LinkedHashSet、Map、Map接口HashMap、Hashtable，TreeSet、TreeMap、如何选择使用集合实现类，Collections工具类
一、Set接口实现类LinkedHashSet
实现继承图：
1、LinkedHashSet的全面说明
1) LinkedHashSet是 HashSet的子类
2) LinkedHashSet底层是一个LinkedHashMap，底层维护了一个数组+双
向链表
3)LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序(图)，这使得元素看起来是以插入顺序保存的。
4) LinkedHashSet 不允许添重复元素
底层结构展示：
LinkedHashSet练习：
package com.hspedu.set_; import java.util.LinkedHashSet; import java.util.Set; @SuppressWarnings({"all"}) public class LinkedHashSetSource { public static void main(String[] args) { //分析一下LinkedHashSet的底层机制 Set set = new LinkedHashSet(); set.add(new String("AA")); set.add(456); set.add(456); set.add(new Customer("刘", 1001)); set.add(123); set.add("SP"); System.out.println("set=" + set); //1. LinkedHashSet 加入顺序和取出元素/数据的顺序一致 //2. LinkedHashSet 底层维护的是一个LinkedHashMap(是HashMap的子类) //3. LinkedHashSet 底层结构 (数组table+双向链表) //4. 添加第一次时，直接将 数组table 扩容到 16 ,存放的结点类型是 LinkedHashMap$Entry //5. 数组是 HashMap$Node[] 存放的元素/数据是 LinkedHashMap$Entry类型 /* //继承关系是在内部类完成. static class Entry<K,V> extends HashMap.Node<K,V> { Entry<K,V> before, after; Entry(int hash, K key, V value, Node<K,V> next) { super(hash, key, value, next); } } */ } } class Customer { private String name; private int no; public Customer(String name, int no) { this.name = name; this.no = no; } }
二、Map
继承实现:
1、Map接口实现类的特点[很实用]：
注意:这里讲的是JDK8的Map接口特点 Map_.java
1)、Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value
2) 、Map 中的key 和 value可以是任何引用类型的数据，会封装到HashMap$Node对象中
3) 、Map中的key 不允许重复,原因和HashSet一样,前面分析过源码.、允许存在一个为null的key
4) 、Map 中的value可以重复
5) 、Map 的key 可以为null, value也可以为null，注意key为null, 只能有一个,value 为null ,可以多个.
6)、常用String类作为Map的key
7) 、key和 value 之间存在单向一对一关系,即通过指定的key总能找到对应的value（加入重复的会将value值替换为新的）
特点：
8)、Map存放数据的key-value示意图,一对k-v是放在一个Node中的，有因为Node实现了 Entry 接口，有些书上也说一对k-v示就是一个Entry(如图)[代码演示]
案例：
import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; @SuppressWarnings({"all"}) public class MapSource_ { public static void main(String[] args) { Map map = new HashMap(); map.put("no1", "hello");//k-v map.put("no2", "张无忌");//k-v map.put(new Car(), new Person());//k-v //老韩解读 //1. k-v 最后是 HashMap$Node node = newNode(hash, key, value, null) //2. k-v 为了方便程序员的遍历，还会 创建 EntrySet 集合 ，该集合存放的元素的类型 Entry, 而一个Entry // 对象就有k,v EntrySet<Entry<K,V>> 即： transient Set<Map.Entry<K,V>> entrySet; //3. entrySet 中， 定义的类型是 Map.Entry ，但是实际上存放的还是 HashMap$Node // 这时因为 static class Node<K,V> implements Map.Entry<K,V> //4. 当把 HashMap$Node 对象 存放到 entrySet 就方便我们的遍历, 因为 Map.Entry 提供了重要方法 // K getKey(); V getValue(); Set set = map.entrySet(); System.out.println(set.getClass());// HashMap$EntrySet for (Object obj : set) { //System.out.println(obj.getClass()); //HashMap$Node //为了从 HashMap$Node 取出k-v //1. 先做一个向下转型 Map.Entry entry = (Map.Entry) obj; System.out.println(entry.getKey() + "-" + entry.getValue() ); } Set set1 = map.keySet(); System.out.println(set1.getClass()); Collection values = map.values(); System.out.println(values.getClass()); } }
2、Map接口和常用方法：
1)put:添加
2) remove:根据键删除映射关系
3) get:根据键获取值
4) size:获取元素个数
5) isEmpty:判断个数是否为0
6) clear:清除
7) containsKey:查找键是否存在
Map遍历方式：
1）containsKey:查找键是否存在
2) keySet:获取所有的键
3) entrySet:获取所有关系k-v
4)values:获取所有的值
import java.util.Collection; import java.util.LinkedHashMap; import java.util.Set; public class LinkedHashMap_ { public static void main(String[] args) { LinkedHashMap map = new LinkedHashMap(); for (int i = 0;i<5;i++) { map.put("hello"+i,"hello+"+i); } System.out.println(map); //获取key的一个集合 Set set = map.keySet(); for (Object o:set ) { System.out.println(o +"-"+map.get(o)); } //获取value的一个集合 Collection values = map.values(); for (Object v:values ) { System.out.println(v); } // Set set1 = map.entrySet(); for (Object e :set1) { System.out.println(e); //第二种遍历，将每个EntrySet转型为Map.Entry // Map.Entry entry = (Map.Entry) e; // System.out.println(entry.getKey() +"-" +entry.getValue()); } } }
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class MapExercise { public static void main(String[] args) { HashMap map = new HashMap(); for (int i = 0; i < 3; i++) { map.put(i,new Man(i,"man"+i,i*10000)); } Set set = map.keySet(); Iterator iterator = set.iterator(); while (iterator.hasNext()) { Object next = iterator.next(); Man o = (Man) map.get(next); if (o.getSal()>18000) System.out.println(next +"-"+map.get(next)); } Set entrySet = map.entrySet(); for (Object o :entrySet) { Map.Entry entry = (Map.Entry) o; Object value = entry.getValue(); Man man = (Man) value; if (man.getSal()>18000) System.out.println(man); } } } class Man{ private int id; private String name; private int sal; public Man(int id, String name, int sal) { this.id = id; this.name = name; this.sal = sal; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getSal() { return sal; } public void setSal(int sal) { this.sal = sal; } @Override public String toString() { return "Man{" + "id=" + id + ", name='" + name + '\'' + ", sal=" + sal + '}'; } }
三、HashMap：
1) Map接口的常用实现类:HashMap、Hashtable和Properties.
2) HashMap是 Map 接口使用频率最高的实现类。
3) HashMap 是以 key-val对的方式来存储数据(HashMap$Node类型)
4) key 不能重复，但是值可以重复,允许使用null键和null值。
5)如果添加相同的key，则会覆盖原来的key-val ,等同于修改.(key不会替换,val会替换)
6)与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的. (jdk8的hashMap底层数组+链表+红黑树)
7) HashMap没有实现同步，因此是线程不安全的,方法没有做同步互斥的操作,没有synchronized
HashMap底层机制及原码剖析：
原码分析：
import java.util.HashMap; @SuppressWarnings({"all"}) public class HashMapSource1 { public static void main(String[] args) { HashMap map = new HashMap(); map.put("java", 10);//ok map.put("php", 10);//ok map.put("java", 20);//替换value System.out.println("map=" + map);// /*解读HashMap的源码+图解 1. 执行构造器 new HashMap() 初始化加载因子 loadfactor = 0.75 HashMap$Node[] table = null 2. 执行put 调用 hash方法，计算 key的 hash值 (h = key.hashCode()) ^ (h >>> 16) public V put(K key, V value) {//K = "java" value = 10 return putVal(hash(key), key, value, false, true); } 3. 执行 putVal final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i;//辅助变量 //如果底层的table 数组为null, 或者 length =0 , 就扩容到16 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //取出hash值对应的table的索引位置的Node, 如果为null, 就直接把加入的k-v //, 创建成一个 Node ,加入该位置即可 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k;//辅助变量 // 如果table的索引位置的key的hash相同和新的key的hash值相同， // 并 满足(table现有的结点的key和准备添加的key是同一个对象 || equals返回真) // 就认为不能加入新的k-v if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode)//如果当前的table的已有的Node 是红黑树，就按照红黑树的方式处理 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //如果找到的结点，后面是链表，就循环比较 for (int binCount = 0; ; ++binCount) {//死循环 if ((e = p.next) == null) {//如果整个链表，没有和他相同,就加到该链表的最后 p.next = newNode(hash, key, value, null); //加入后，判断当前链表的个数，是否已经到8个，到8个，后 //就调用 treeifyBin 方法进行红黑树的转换 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && //如果在循环比较过程中，发现有相同,就break,就只是替换value ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; //替换，key对应value afterNodeAccess(e); return oldValue; } } ++modCount;//每增加一个Node ,就size++ if (++size > threshold[12-24-48])//如size > 临界值，就扩容 resize(); afterNodeInsertion(evict); return null; } 5. 关于树化(转成红黑树) //如果table 为null ,或者大小还没有到 64，暂时不树化，而是进行扩容. //否则才会真正的树化 -> 剪枝 final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); } */ } }
四、HashTable
基本介绍：
1)存放的元素是键值对:即K-VI2) hashtable的键和值都不能为null
3) hashTable使用方法基本上和HashMap一样
4) hashTable是线程安全的，hashMap是线程不安全的
5)简单看下底层结构
HashTable和HashMap对比
五、Map接口实现的类-Properties（是继承Hashtable的子类）
基本介绍
1.Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形
式来保存数据。
2.他的使用特点和Hashtable类似
3.Properties还可以用于从xoxox.properties文件中，加载数据到Properties类对象,
并进行读取和修改
4．说明:工作后 Xx.properties文件通常作为配置文件
常用的方法：
put（）；增加，修改（如果是相同的key，就会替换value）
get();获取对应key的值
remove();删除
六，TreeSet
import java.util.Comparator; import java.util.TreeSet; @SuppressWarnings({"all"}) public class TreeSet_ { public static void main(String[] args) { //1. 当我们使用无参构造器，创建TreeSet时，仍然是无序的 //2.希望添加的元素，按照字符串大小来排序 //3. 使用TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类) // 并指定排序规则 //4. 简单看看源码 /* 1. 构造器把传入的比较器对象，赋给了 TreeSet的底层的 TreeMap的属性this.comparator public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; } 2. 在 调用 treeSet.add("tom"), 在底层会执行到 if (cpr != null) {//cpr 就是我们的匿名内部类(对象) do { parent = t; //动态绑定到我们的匿名内部类(对象)compare cmp = cpr.compare(key, t.key); if (cmp < 0) t = t.left; else if (cmp > 0) t = t.right; else //如果相等，即返回0,这个Key就没有加入 return t.setValue(value); } while (t != null); } */ // TreeSet treeSet = new TreeSet(); TreeSet treeSet = new TreeSet(new Comparator() { @Override public int compare(Object o1, Object o2) { //下面 调用String的 compareTo方法进行字符串大小比较 //如果要求加入的元素，按照长度大小排序 //return ((String) o2).compareTo((String) o1); return ((String) o1).length() - ((String) o2).length(); } }); //添加数据. treeSet.add("jack"); treeSet.add("tom");//3 treeSet.add("sp"); treeSet.add("a"); treeSet.add("abc");//3 System.out.println("treeSet=" + treeSet); } }
七、TreeMap
import java.util.Comparator; import java.util.TreeMap; @SuppressWarnings({"all"}) public class TreeMap_ { public static void main(String[] args) { //使用默认的构造器，创建TreeMap, 是无序的(也没有排序) /* 老韩要求：按照传入的 k(String) 的大小进行排序 */ // TreeMap treeMap = new TreeMap(); TreeMap treeMap = new TreeMap(new Comparator() { @Override public int compare(Object o1, Object o2) { //按照传入的 k(String) 的大小进行排序 //按照K(String) 的长度大小排序 //return ((String) o2).compareTo((String) o1); return ((String) o2).length() - ((String) o1).length(); } }); treeMap.put("jack", "杰克"); treeMap.put("tom", "汤姆"); treeMap.put("kristina", "克瑞斯提诺"); treeMap.put("smith", "斯密斯"); treeMap.put("hbn", "逻辑门");//加入不了 System.out.println("treemap=" + treeMap); /* 解读源码： 1. 构造器. 把传入的实现了 Comparator接口的匿名内部类(对象)，传给给TreeMap的comparator public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; } 2. 调用put方法 2.1 第一次添加, 把k-v 封装到 Entry对象，放入root Entry<K,V> t = root; if (t == null) { compare(key, key); // type (and possibly null) check root = new Entry<>(key, value, null); size = 1; modCount++; return null; } 2.2 以后添加 Comparator<? super K> cpr = comparator; if (cpr != null) { do { //遍历所有的key , 给当前key找到适当位置 parent = t; cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的compare if (cmp < 0) t = t.left; else if (cmp > 0) t = t.right; else //如果遍历过程中，发现准备添加Key 和当前已有的Key 相等，就不添加 return t.setValue(value); } while (t != null); } */ } }
八、Collections工具类
1) Collections是一个操作Set、List 和 Map等集合的工具类
2) Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作
排序操作:(均为static方法)
1) reverse(List):反转 List 中元素的顺序
2) shuffle(List):对List集合元素进行随机排序
3) sort(List):根据元素的自然顺序对指定List 集合元素按升序排序
4) sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
5) swap(List, int,int):将指定list集合中的i处元素和j处元素进行交换
查找、替换：
import java.util.*;
@SuppressWarnings({"all"}) public class Collections_ { public static void main(String[] args) { //创建ArrayList 集合，用于测试. List list = new ArrayList(); list.add("tom"); list.add("smith"); list.add("king"); list.add("milan"); list.add("tom"); // reverse(List)：反转 List 中元素的顺序 Collections.reverse(list); System.out.println("list=" + list); // shuffle(List)：对 List 集合元素进行随机排序 // for (int i = 0; i < 5; i++) { // Collections.shuffle(list); // System.out.println("list=" + list); // } // sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序 Collections.sort(list); System.out.println("自然排序后"); System.out.println("list=" + list); // sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序 //我们希望按照 字符串的长度大小排序 Collections.sort(list, new Comparator() { @Override public int compare(Object o1, Object o2) { //可以加入校验代码. return ((String) o2).length() - ((String) o1).length(); } }); System.out.println("字符串长度大小排序=" + list); // swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换 //比如 Collections.swap(list, 0, 1); System.out.println("交换后的情况"); System.out.println("list=" + list); //Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素 System.out.println("自然顺序最大元素=" + Collections.max(list)); //Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素 //比如，我们要返回长度最大的元素 Object maxObject = Collections.max(list, new Comparator() { @Override public int compare(Object o1, Object o2) { return ((String)o1).length() - ((String)o2).length(); } }); System.out.println("长度最大的元素=" + maxObject); //Object min(Collection) //Object min(Collection，Comparator) //上面的两个方法，参考max即可 //int frequency(Collection，Object)：返回指定集合中指定元素的出现次数 System.out.println("tom出现的次数=" + Collections.frequency(list, "tom")); //void copy(List dest,List src)：将src中的内容复制到dest中 ArrayList dest = new ArrayList(); //为了完成一个完整拷贝，我们需要先给dest 赋值，大小和list.size()一样 for(int i = 0; i < list.size(); i++) { dest.add(""); } //拷贝 Collections.copy(dest, list); System.out.println("dest=" + dest); //boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值 //如果list中，有tom 就替换成 汤姆 Collections.replaceAll(list, "tom", "汤姆"); System.out.println("list替换后=" + list); } }
九、开发中如何选择集合实现类：
使用stream对集合进行排序之类的操作：
public static void lambdaTest(){ ArrayList<Animal> arrayList = new ArrayList<>(); arrayList.add(new Animal("andy", 10)); arrayList.add(new Animal("lili", 21)); arrayList.add(new Animal("lucy", 14)); arrayList.add(new Animal("mark", 15)); arrayList.add(new Animal("alice", 8)); arrayList.add(new Animal("tank", 4)); arrayList.add(new Animal("aid", 19)); arrayList.add(new Animal("rich", 11)); List<String> list = arrayList.stream().map(Animal::getName).collect(Collectors.toList()); System.out.println("获取一个对应的名字列表:"+list.toString()); List<String> collect = arrayList.stream().sorted(Comparator.comparing((Animal::getAge))) .map(Animal::getName).collect(Collectors.toList()); System.out.println("排序后的集合："+collect.toString()); Collections.sort(arrayList,(o1, o2) -> o2.getAge() - o1.getAge()); List<String> stringList = arrayList.stream().map(Animal::getName).collect(Collectors.toList()); System.out.println("检验是否倒序排序："+stringList); List<String> strings = arrayList.stream().sorted(Comparator.comparing((Animal::getAge),Comparator.reverseOrder()) ) .map(Animal::getName).collect(Collectors.toList()); System.out.println("测试1检验是否实现倒排序："+strings.toString()); List<String> collect1 = arrayList.stream().sorted(Comparator.comparing(Animal::getAge).reversed()).limit(5) .map(Animal::getName).collect(Collectors.toList()); System.out.println("测试2检验是否实现倒排序："+collect1.toString()); }
浙公网安备 33010602011771号