目录

Map集合接口

Map接口简介

HashMap子类

LinkedHashMap子类

Hashtable子类

Map.Entry接口

利用Iterator实现Map的输出

自定义Map的Key类型

集合工具类

Stack栈操作

Queue队列

Properties属性操作

Collections工具类

---

学习笔记

Map集合接口

在之前已经学习了Collection接口以及其子接口，可以发现在Collection之中所保存的数据都只是单个对象，而在数据结构里面除了可以进行单个对象的保存之外，也可以进行二元偶对象的一个保存（key=value）的形式保存，而存储二元偶对象的核心意义在于需要通过key获取value。

在开发里面：Collection集合保存数据的目的是为了输出，Map集合保存数据的目的是为了进行key的查找。

Map接口简介

Map接口是进行二元偶对象保存的最大父接口，该接口定义如下：

public interface Map<K,V>

该接口为一个独立的父接口，并且在进行接口对象实例化的时候需要设置Key与Value的类型，也就是说需要保存两个内容，在Map接口里面定义有许多的操作方法，但是需要记住以下的核心操作方法：

No.	方法名称	类型	描述
01	public V put​(K key, V value)	普通	向集合之中保存数据
02	public V get​(Object key)	普通	根据Key查询数据
03	public Set<Map.Entry<K,V>> entrySet​()	普通	将Map集合转为Set集合
04	public boolean containsKey​(Object key)	普通	查询Key是否存在
05	public Set<K> keySet​()	普通	将Map集合中的Key转为Set集合
06	public V remove​(Object key)	普通	根据Key删除指定的数据

从JDK1.9之后Map接口里面也扩充一些静态的方法供用户使用。

范例; 观察Map的集合特点

package cn.ren.demo;import java.util.Map;
public class JavaAPIDemo {public static void main(String[] args) throws Exception {Map<String, Integer> map = Map.of("one",1, "two",2, "three",3, null,0) ;System.out.println(map);}	
}

在Map集合之中数据的保存就是按照”lkey = value“的形式存储的，并且使用of()方法操作的时候里面的数据不允许重复的，如果重复会出现”java.lang.IllegalArgumentException“异常，如果设置的内容为空，则会出现”java.lang.NullPointerException“异常信息。

对于现在见到的of()方法严格意义上讲并不是Map集合的标准用法，因为正常开发之中需要通过Map的子类进行接口对象的实例化，常用的子类：HashMap、Hashtable、TreeMap、LinkedHashMap。

HashMap子类

HashMap是Map接口之中最为常见的子类，该类的主要特点是无序存储（看见Hash第一反应是无序），通过Java的文档首先来观察一下HashMap子类的定义形式：

public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable

该类定义继承形式符合之前的集合定义的形式，依然提供有抽象类、依然需要重复实现Map接口。

范例：观察Map集合的使用

  

package cn.ren.demo;import java.util.HashMap;
import java.util.Map;
public class JavaAPIDemo {public static void main(String[] args) throws Exception {Map<String, Integer> map = new HashMap<String, Integer>() ;map.put("One",1) ;map.put("Two",2) ;map.put("Three", 3) ;map.put("One", 101) ; // key重复map.put(null, 0) ;   // key为空map.put("zero", null) ;	// value为空System.out.println(map);System.out.println(map.get("One")); // key存在System.out.println(map.get(null));  // key存在System.out.println("zero -- " + map.get("zero"));  // key存在System.out.println(map.get("Ten"));  // key不存在		}	
}

以上操作形式为Map集合使用的最标准的操作形式，通过代码可以发现，通过HashMap实例化的Map接口里面可以针对key或value保存null的数据，同时也发现即使 保存的key重复，也不会出现错误，而是出现内容的替换。

但是对于Map接口之中提供的put()方法是具有返回值的，这个返回值指的是在重复key的情况下返回旧的value。

范例: 观察put()方法

package cn.ren.demo;import java.util.HashMap;
import java.util.Map;
public class JavaAPIDemo {public static void main(String[] args) throws Exception {Map<String, Integer> map = new HashMap<String, Integer>() ;System.out.println(map.put("One",100)) ;  // key不重复返回nullSystem.out.println(map.put("One",101)) ;  // 重复返回旧数据}	
}

在设置相同的key的内容的时候put()方法会返回原始的数据内容。

清楚HashMap的基本功能之后下面就需要研究一下HashMap之中给出的源代码。HashMap之中肯定要存储大量的数据，那么对于数据的存储Map是如何进行的？

当使用无参构造的时候会出现一个loadFactor属性，并且该属性默认的内容为”0.75“。
	在使用put()进行数据保存的时候会调用一个putVal()方法，同时会将key进行hash处理（生成一个hash码），而对于putVal()方法里面依然会提供一个Node节点类进行数据的保存，而在使用putVal()方法的操作过程之中会调用一个resize()的方法进行容量的扩充

当使用无参构造的时候会出现一个loadFactor属性，并且该属性默认的内容为”0.75“。

在使用put()进行数据保存的时候会调用一个putVal()方法，同时会将key进行hash处理（生成一个hash码），而对于putVal()方法里面依然会提供一个Node节点类进行数据的保存，而在使用putVal()方法的操作过程之中会调用一个resize()的方法进行容量的扩充

面试题：在进行HashMap的put()操作的时候，如何实现容量扩充的？

• 在HashMap类里面提供有一个”DEFAULT_INITIAL_CAPACITY “常量，作为初始化的容量配置，而这个这个常量的默认大小为16个元素，也就是说默认可以保存的最大内容是16；
• 当保存的容量超过了一个阈值（DEFAULT_LOAD_FACTOR = 0.75f），相当于”容量*阈值 = 12“ 即12个元素的时候就会进行容量的扩充；
• 在进行扩充的时候HashMap采用的是成倍扩充的方式，即：每次都扩充两倍的容量；

面试题：请解释HashMap的工作原理（JDK1.8之后）

• 在进行HashMap之中进行数据存储的依然是利用了Node类完成的，那么在这种情况下证明可以使用的数据结构：链表（”n“）、二叉树("logn")；
• 从JDK1.8开始，HashMap的实现出现了改变，因为其要适应于大数据时代的海量数据问题 ，所以对其存储发生了变化，并且在HashMap类的内部提供有一个重要的常量：static final int TREEIFY_THRESHOLD = 8;，在进行HashMap进行数据保存的时候没有超过阈值8（TREEIFY_THRESHOLD），那么会按照链表的形式进行保存，如果超过了这个阈值就会将使用红黑树，红黑树实现树的平衡，利用左旋或右旋的方式保证数据的性能。

LinkedHashMap子类

HashMap虽然是Map集合最为常用的一个子类，本身所保存的数据都是无序的（有序与否对Map没有影响），如果现在希望Map集合之中保存的数据顺序为其增加顺序，则就可以更换子类为LinkedHashMap(基于链表实现的)。

public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>

既然是链表的保存，所以一般在使用LinkedHashMap类的时候往往数据量都不要特别大因为会造成数据量攀升，因为会造成时间复杂度攀升，通过继承的结构可以发现LinkedHashMap是HashMap子类，继承关系如下：

范例：使用LinkedHashMap

package cn.ren.demo;import java.util.LinkedHashMap;
import java.util.Map;
public class JavaAPIDemo {public static void main(String[] args) throws Exception {Map<String, Integer> map = new LinkedHashMap<String, Integer>() ;map.put("one", 1) ;map.put("two", 2) ;map.put("three", 3) ;map.put(null, 0) ;map.put("zero", null) ;System.out.println(map);}	
}

通过此时的程序可以发现当使用LinkedHashMap进行存储之后所有的数据的存储顺序为其保存顺序。

Hashtable子类

Hashtable子类是从JDK1.0的时候提供的，与Vector、Enumeration属于最早的一批动态数组的实现类，后来为了将其保存下载所以让其多实现了Map接口，Hahtable定义结构如下：

public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, Serializable

Hashtable继承结构如下：

范例：观察Hashtable的使用

package cn.ren.demo;import java.util.Hashtable;
import java.util.Map;
public class JavaAPIDemo {public static void main(String[] args) throws Exception {Map<String, Integer> map = new Hashtable<String, Integer>() ;map.put("one", 1) ;map.put("two", 2) ;map.put("three", 3) ;System.out.println(map);}	
}

通过观察可以发现在Hashtable里面设置的Key和Value都不允许为null，否则会出现“java.lang.NullPointerException”。

面试题：Hashmap与Hashtable的区别？

• HashMap中的方法都属于异步操作，非线程安全，HashMap允许保存null的数据;
• Hashtable中的方法都属于同步方法，线程安全，Hashtable不允许保存null的数据，否则会出现“java.lang.NullPointerException”。

Map.Entry接口

虽然已经清楚了Map集合的操作形式，但是依然有一个核心的问题要解决，Map集合里面是如何进行数据存储的？对于List而言（LinkedList子类）依靠的是链表的形式实现数据的存储，那么在进行数据存储的时候一定要将数据保存在Node节点之中，虽然在Hashmap里面也可以见到Node类型定义，通过源代码的定义可以发现，HashMap类中的Node内部类本身实现了Map.Entry接口。

static class Node<K,V> implements Map.Entry<K,V>{}

所以可以得出结论：所有的Key和Value的数据都封装在Map.Entry接口之中，而此接口定义如下：

public static interface Map.Entry<K,V>

并且在这个内部接口，提供两个重要的操作方法：

• 获取key：public K getKey​()
• 获取value：public V getValue​()

在JDK1.9以前的开发版本之中，使用者基本上都不会去考虑创建Map.Entry的对象，实际上在正常开发过程使用者也不需要关心Map.Entry对象创建，从1.9之后追加有一个新的方法：

• 创建Map.Entry对象：public static <K,V> Map.Entry<K,V> entry​(K k, V v)；

”范例：创建Map.Entry对象

package cn.ren.demo;import java.util.Map;
public class JavaAPIDemo {public static void main(String[] args) throws Exception {Map.Entry<String, Integer> entry = Map.entry("one", 1) ;System.out.println("获取KEY：" + entry.getKey() + "、获取VALUE:" + entry.getValue());System.out.println(entry.getClass().getName()); // 观察使用的子类}	
}

.

通过分析可以发现在整个的Map集合里面，Map.Entry的主要作用作为Key和Value的包装类使用，大部分情况下在在进行数据存储的时候都会将Key和Value包装为一个Map.Entry对象类型使用。

利用Iterator实现Map的输出

对于集合的输出而言，最标准的做法就是利用Iterator接口完成，但是需要明确一点的是，并没有一个方法返回Iterator的接口对象，所以这中情况下就需要分析不提供接口实例化Iterator方法的原因是什么？下面进行Collection和Map集合的存储结构进行一个比较。

发现在Map集合里面保存的实际上是一组Map.Entry接口对象（里面包装的是Key与Value），所以整个Map来讲Map依然实现的是单值的保存，这样在Map集合里面提供有一个方法：“public Set<Map.Entry<K,V>>entrySet()”，将全部的Map集合转化为Set集合。

经过分析可以发现如果要想使用Iterator实现Map集合的输出必须通过以下步骤实现：

• 利用Map接口中提供的entrySet()方法将Map集合转为Set集合；
• 利用Set接口中的Iterator()方法将Set集合转为Iterator接口实例；
• 利用Iterator进行迭代输出，获取每一组的Map.Entry对象，随后通过getKey()与getValue()获取数据；

范例：利用Iterator输出Map集合

package cn.ren.demo;import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class JavaAPIDemo {public static void main(String[] args) throws Exception {Map<String, Integer> map = new HashMap<String, Integer>() ;map.put("one", 1) ;map.put("two", 2) ;Set<Map.Entry<String, Integer>> set = map.entrySet() ;Iterator<Map.Entry<String, Integer>> iter = set.iterator() ;while(iter.hasNext()) {Map.Entry<String, Integer> me = iter.next() ;System.out.println("获取KEY：" + me.getKey() + "    获取Value:" + me.getValue());}}	
}

注意：iter.next()获取值后会将指针后移

虽然Map集合本身支持有迭代输出的支持，但是从实际开发来讲Map最主要的用法是实现Key的查找操作，另外需要提醒的是，如果现在不使用Iterator而使用foreach()羽凡输出，则也需要将Map集合转为Set集合；

范例：使用foreach输出Map集合

package cn.ren.demo;import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class JavaAPIDemo {public static void main(String[] args) throws Exception {Map<String, Integer> map = new HashMap<String, Integer>() ;map.put("one", 1) ;map.put("two", 2) ;Set<Map.Entry<String, Integer>> set = map.entrySet() ;for(Map.Entry<String, Integer> temp : set ) {System.out.println("获取KEY：" + temp.getKey() + " 、获取VALUE: " + temp.getValue());}}	
}

由于Map迭代输出的情况相对较少，所以对于此类的语法应该深入理解一下，并且一定要掌握。

自定义Map的Key类型

在使用Map集合的时候可以发现对于Key和Value的类型实际上都可以由使用者任意决定，那么就可以使用自定义的类进行Key的设置。对于自定义Key类型所在的类一定要覆写hashCode()与equals()方法，否则无法查找到。下面分析源代码：

在进行数据保存的时候发现会自动使用传入的key的数据生成一个hash码，也就是说存储的时候是有hash数值存在的。

在根据Key获取数据的时候依然要将传入的key通过hash()的方法来获取其对应的hash码，那么也就证明，查询的过程之中，首先利用hashCode()来进行数据查询，当使用getCode()方法查询的时候还需要使用到equals()方法。

未覆写hashCode()与equals()方法：

范例：使用自定义类作为Key类型，覆写了

package cn.ren.demo;import java.util.HashMap;
import java.util.Map;
import java.util.Set;
class Person {private String name ;private int age ;public Person(String name, int age) {this.name = name ;this.age = age ;}public String toString() {return "[姓名：" + this.name  + "、年龄：" + this.age + "]"; }@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (age != other.age)return false;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}
}
public class JavaAPIDemo {public static void main(String[] args) throws Exception {Map<Person, String > map = new HashMap<Person, String>() ;map.put(new Person("张三", 18), "Person01") ;map.put(new Person("李四", 28), "Person02") ;System.out.println(map.get(new Person("李四", 28))); Set<Map.Entry<Person, String>> set = map.entrySet() ;for(Map.Entry<Person, String> temp : set ) {System.out.println("获取KEY：" + temp.getKey() + " 、获取VALUE: " + temp.getValue());}}	
}

虽然允许你使用自定义的类作为Key类型，但是也需要注意一点，在实际开发之中对于Map集合的Key常用的类型就三种：String、Long、Integer，尽量使用系统类。

面试题：如果进行HashMap进行数据操作的时候出现了Hash冲突（hash码相同），HashMap是怎么解决的？

• 当出现Hash冲突之后为了保证程序的正常执行，会在冲突的位置上将所有的Hash冲突的内容转为链表保存。

集合工具类

Stack栈操作

栈是一种先进后出的操作。例如：在文本编辑器上都有撤销功能，每次使用的时候会发现最后一次编辑工作是最早撤销的，那么这个功能就是利用栈来实现的。栈的基本操作形式如下：

在Java程序里面使用Stack来描述栈的操作，这个类的定义如下：

public class Stack<E>
extends Vector<E>

可以发现Stack是Vector的子类，但是它使用的并不是Vactor类之中所提供的方法：

• 入栈：public E push​(E item)
• 出栈：public E pop​()

范例：实现栈的操作

package cn.ren.demo;import java.util.Stack;public class JavaAPIDemo {public static void main(String[] args) throws Exception {Stack<String> all = new Stack<String>() ;all.push("A") ;all.push("B") ;all.push("C") ;   System.out.println(all.pop());System.out.println(all.pop());System.out.println(all.pop()); System.out.println(all.pop());    // 无数据}	
}

通过此时的操作可以发现，所有的数据保存之后将按照倒叙的顺序进行弹出，如果栈已经空了则会抛出空栈异常。

Queue队列

Queue描述的是一个队列，而队列的主要特点是实现先进先出的操作形式。其基本的操作形式如下：

如果将队列应用在多线程的“生产者与消费者”的模型处理上，那么对于消费者生产过快的情况就没有必要等待消费者消费数据了，可以将所有的内容保存在队列之中，队列的实现可以使用LinkedList子类来完成，观察这个类的定义：

队列的使用主要依靠Queue接口之中提供的方法来处理，提供有如下的方法：

• 向队列之中追加数据：public boolean offer​(E e) ,可以直接使用add()方法；
• 通过队列获取数据：public E poll​()，弹出后删除数据；

范例：队列操作

package cn.ren.demo;import java.util.LinkedList;
import java.util.Queue;public class JavaAPIDemo {public static void main(String[] args) throws Exception {Queue<String> queue = new LinkedList<String>() ;queue.offer("A") ;  // 追加队列数据，通过队尾追加queue.offer("B") ;queue.offer("C") ;System.out.println(queue.poll());System.out.println(queue.poll());System.out.println(queue.poll());System.out.println(queue.poll());   // 无数据}	
}

除了LinkedList子类之外，还有一个优先队列的概念，可以使用PriorityQueue实现优先级队列（比较功能），这个类定义如下：

public class PriorityQueue<E>
extends AbstractQueue<E>
implements Serializable

范例：使用优先级队列

package cn.ren.demo;import java.util.PriorityQueue;
import java.util.Queue;public class JavaAPIDemo {public static void main(String[] args) throws Exception {Queue<String> queue = new PriorityQueue<String>() ;queue.offer("X") ;  // 追加队列数据，通过队尾追加queue.offer("B") ;queue.offer("C") ;System.out.println(queue.poll());System.out.println(queue.poll());System.out.println(queue.poll());System.out.println(queue.poll());   // 无数据}	
}

对于队列的选用原则也是需要根据实际的项目环境来决定的。

Properties属性操作

在之前国际化程序部分有资源文件（*.properties），那么这类文件的存储结构是按照“key=value”形式，而这种结构的保存形式与Map集合很相似，但是唯一的区别在于其所保存的内容只能够是字符串，但是为了方便描述属性的定义，Java.util包里面提供有Properties类型，此类是Hashtable的子类。

public class Properties
extends Hashtable<Object,Object>

可以发现在继承Hashtable的时候为Hashtable中定义的泛型为Object，实际上Properties是不需要操作泛型的，因为它可以操作的类型只能是String类型，在Properties之中如果要想实现属性操作可以采用如下的方法进行实现：

NO.	方法名称	类型	描述
01	public Object setProperty​(String key, String value)	普通	设置属性
02	public String getProperty​(String key)	普通	获取属性，Key不存在返回空
03	public String getProperty​(String key,String defaultValue)	普通	获取属性，不存在返回默认值
04	public void store​(OutputStream out,String comments) throws IOException	普通	输出属性内容
05	public void load​(InputStream inStream) throws IOException	普通	通过输入流读取属性内容

范例：观察属性的设置和取得

package cn.ren.demo;import java.util.Properties;public class JavaAPIDemo {public static void main(String[] args) throws Exception {// 设置内容只允许是字符串Properties prop = new Properties() ;prop.setProperty("ren", "java") ;prop.setProperty("renjiayou ", "57") ;System.out.println(prop.getProperty("ren"));System.out.println(prop.getProperty("asd", "NotFound"));System.out.println(prop.getProperty("asd"));}	
}

通过代码可以发现Properties里面可以向Map集合那样进行内容的设置与获取，但是唯一的差别是它只能够操作String类型，另外需要注意的是，之所以会提供有Properties类还有一个重要的功能是它可以通过输出流输出属性，也可以使用输入流读取属性内容。

范例：将属性内容保存在文件之中

package cn.ren.demo;import java.io.File;
import java.io.FileOutputStream;
import java.util.Properties;public class JavaAPIDemo {public static void main(String[] args) throws Exception {// 设置内容只允许是字符串Properties prop = new Properties() ;prop.setProperty("ren", "java") ;prop.setProperty("renjiayou ", "57") ;prop.setProperty("beijin", "北京") ;prop.store(new FileOutputStream(new File("d:" + File.separator + "info.properties")), "中文的注释看不见————english") ;}	
}

通过程序执行可以发现，的确可以实现资源文件的输入处理，但是如果输出的是中文则自动帮助用户进行转码处理。可以通过Eclipse查看。

范例：读取资源文件

package cn.ren.demo;import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;public class JavaAPIDemo {public static void main(String[] args) throws Exception {// 设置内容只允许是字符串Properties prop = new Properties() ;prop.load(new FileInputStream(new File("d:" + File.separator + "info.properties"))) ;System.out.println(prop.getProperty("beijin"));}	
}

使用Properties类型的最大特点是可以进行资源内容的输入与输出的处理操作，但是在实际开发之中Properties主要用于读取配置资源的信息，这一点主要是在标准设计之中做程序初始化准备的时候使用。

Collections工具类

Collections是Java提供的一组集合数据的操作工具类，也就是说利用它可以实现各个集合的操作。

范例：使用Colections操作List集合

  

package cn.ren.demo;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class JavaAPIDemo {public static void main(String[] args) throws Exception {List<String> all = new ArrayList<String>() ;Collections.addAll(all, "Hello", "World", "ren") ;System.out.println(all);}	
}

范例：数据的反转

package cn.ren.demo;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class JavaAPIDemo {public static void main(String[] args) throws Exception {List<String> all = new ArrayList<String>() ;Collections.addAll(all, "Hello", "World", "ren") ;Collections.reverse(all);System.out.println(all);}	
}

范例：使用二分查找

package cn.ren.demo;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class JavaAPIDemo {public static void main(String[] args) throws Exception {List<String> all = new ArrayList<String>() ;Collections.addAll(all, "Hello", "World", "ren", "45") ;Collections.sort(all);  // 先进行排序System.out.println(all);System.out.println(Collections.binarySearch(all, "ren"));}	
}

大部分情况下对于集合的使用没有这么多的复杂要求，更多情况下就是利用集合保存数据要么进行输出要么进行查询。

面试题：Collection与Collections的区别？

• Collection是集合的接口，允许保存单值对象；
• Collections是集合操作的工具类；