集合（Java）详解
目录
Java 集合框架概述
集合框架
Collection 接口方法
List 接口
ArrayList
LinkedList
Vector
ArrayList, LinkedList, Vector 异同
Set 接口
HashSet
为什么用 Eclipse/IDEA 重写 hashCode 方法，有 31 这个数字？
LinkedHashSet
TreeSet
自然排序
定制排序
Iterator 迭代器接口
foreach
Map 接口
HashMap
HashMap源码中的重要常量
负载因子值的大小，对 HashMap 的影响
LinkedHashMap
TreeMap
Hashtable
Properties
Collections 工具类
Java 集合框架概述
● 一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用 Array 存储对象方面具有 一些弊端 ，而 Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
◆ 数组在内存存储方面的特点：
数组初始化以后，长度就确定了。
数组声明的类型，就决定了进行元素初始化时的类型。
◆ 数组在存储数据方面的弊端：
数组初始化以后，长度就不可变了，不便于 扩展。
数组中提供的属性和方法少，不便于进行添加、删除、插入等操作， 且效率 不 高。
同时无法直接获取存储元素的个数。
数组存储的数据是有序的、可以重复的。 存储数据的特点单一。
● Java 集合类可以用于存储数量不等的多个对象 ，还可用于保存具有映射关系的关联数组。
集合框架
Collection 接口：单列数据，定义了存取一组对象的方法的集合。
List：元素有序、可重复的集合。
ArrayList
Vector
LinkedList
Set：元素无序、不可重复的集合。
HashSet
LinkedHashSet
TreeSet
Map 接口：双列数据，保存具有映射关系“key-value对”的集合。
HashMap
LinkedHashMap
Hashtable
Properties
TreeMap
Collection 接口方法
● Collection 接口是 List 、 Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合 。
● JDK 不提供此接口的任何直接实现，而是提供更具体的子接口（如： Set 和 List)实现 。
● 在 Java5 之前， Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object 类型处理； 从 JDK 5.0 增加了泛型以后， Java 集合可以记住容器中对象的数据类型。
增加
add(Object obj)：将元素obj添加到集合coll中
addAll(Collection coll)：将集合coll中的元素添加到当前集合
获取有效元素的个数
int size()：获取添加的元素的个数
清空集合
void clear()：清空集合元素
判空
boolean isEmpty()：判断当前集合是否为空
@Test
public void test(){
Collection coll = new ArrayList();
//add(Object e):将元素e添加到集合coll中
coll.add("AA");
coll.add("BB");
coll.add(123);//自动装箱
coll.add(new Date());
//size():获取添加的元素的个数
System.out.println(coll.size());//4
//addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add("CC");
coll.addAll(coll1);
System.out.println(coll.size());//6
System.out.println(coll); //[AA, BB, 123, Wed Jun 22 17:50:21 GMT+08:00 2022, 456, CC]
//clear():清空集合元素
coll.clear();
//isEmpty():判断当前集合是否为空
System.out.println(coll.isEmpty()); //true
}
是否包含某个元素
boolean contains(Object obj)：通过equals方法来判断是否为同一个对象。
boolean containsAll(Collection c)：也是调用元素的equals方法。
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
// Person p = new Person("Jerry",20);
// coll.add(p);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//1.contains(Object obj):判断当前集合中是否包含obj
//我们在判断时会调用obj对象所在类的equals()。
boolean contains = coll.contains(123);
System.out.println(contains); //true
System.out.println(coll.contains(new String("Tom"))); //true
System.out.println(coll.contains(new Person("Jerry",20)));//false -->true
// System.out.println(coll.contains(p));//true
//2.containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
Collection coll1 = Arrays.asList(123,4567);
System.out.println(coll.containsAll(coll1)); //false
}
删除
boolean remove(Object obj)：通过equals找到要删除的元素，且只删除第一个。
boolean removeAll(Collection coll)：取当前集合的差集。
@Test
public void test(){
//3.remove(Object obj):从当前集合中移除obj元素。
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
coll.remove(1234);
System.out.println(coll); //[123, 456, Person{name='Jerry', age=20}, Tom, false]
coll.remove(new Person("Jerry",20));
System.out.println(coll); //[123, 456, Tom, false]
//4. removeAll(Collection coll1):差集：从当前集合中移除coll1中所有的元素。
Collection coll1 = Arrays.asList(123,456);
coll.removeAll(coll1);
System.out.println(coll); //[Tom, false]
}
取两集合的交集
boolean retainAll(Collection c)：结果保存在当前集合，不会影响集合c。
集合是否相等
boolean equals(Object obj)
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add(123);
coll1.add(new Person("Jerry",20));
coll1.add(new String("Tom"));
coll1.add(false);
System.out.println(coll.equals(coll1)); //false
//5.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
Collection coll2 = Arrays.asList(123,456,789);
coll.retainAll(coll2);
System.out.println(coll); //[123, 456]
}转成对象数组
Object[] toArray()：集合--->数组
获取集合对象的哈希值
hashCode()：返回当前对象的哈希值
@Test
public void test4(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//7.hashCode():返回当前对象的哈希值
System.out.println(coll.hashCode()); //-1200490100
//8.集合 --->数组：toArray()
Object[] arr = coll.toArray();
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] +" "); //123 456 Person{name='Jerry', age=20} Tom false
}
System.out.println();
//拓展：数组 --->集合:调用Arrays类的静态方法asList()
List list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list); //[AA, BB, CC]
List arr1 = Arrays.asList(new int[]{123, 456});
System.out.println(arr1.size());//1
List arr2 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr2.size());//2
} 遍历
iterator()：返回迭代器对象，用于集合遍历。
@Test
public void test5(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next() + " "); //123 456 Person{name='Jerry', age=20} Tom false
}
}List 接口
存储有序的、可重复的数据。
List 除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法。
void add(int index, Object ele):在index位置插入ele元素。
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来 Object get(int index):获取指定index位置的元素。
int indexOf(Object obj):返回obj在集合中首次出现的位置。
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。
Object remove(int index):移除指定index位置的元素，并返回此元素。
Object set(int index, Object ele):设置指定index位置的元素为ele。
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合。
ArrayList
作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储。
void add(int index, Object ele)：在index位置插入ele元素。
boolean addAll(int index, Collection eles)：从index位置开始将eles中的所有元素添加进来。Object get(int index)：获取指定index位置的元素
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
System.out.println(list);
//1、void add(int index, Object ele):在index位置插入ele元素
list.add(1,"BB");
System.out.println(list);
//2、boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1, 2, 3);
list.addAll(list1);
System.out.println(list.size());//9
//3、Object get(int index):获取指定index位置的元素
System.out.println(list.get(0));
}
int indexOf(Object obj)：返回obj在集合中首次出现的位置。如果不存在，返回-1.
int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
Object remove(int index)：移除指定index位置的元素，并返回此元素
Object set(int index, Object ele)：设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex位置的左闭右开区间的子集合
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
//4、int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
int index = list.indexOf(4567);
System.out.println(index);
//5、int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
System.out.println(list.lastIndexOf(456));
//6、Object remove(int index):移除指定index位置的元素，并返回此元素
Object obj = list.remove(0);
System.out.println(obj);
System.out.println(list);
//7、Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"CC");
System.out.println(list);
//8、List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
List subList = list.subList(2, 4);
System.out.println(subList);
System.out.println(list);
}
遍历
@Test
public void test3(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
//方式一：Iterator迭代器方式
Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println();
//方式二：增强for循环
for(Object obj : list){
System.out.println(obj);
}
System.out.println("");
//方式三：普通for循环
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
}
LinkedList
对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储。
新增方法
void addFirst(Object obj)
void addLast(Object obj)
Object getFirst()
Object getLast()
Object removeFirst()
Object removeLast()
Vector
作为List接口比较老的实现类；线程安全的，效率低；底层使用Object[] elementData存储。
新增方法
void addElement(Object obj)
void insertElementAt(Object obj, int index)
void setElementAt(Object obj, int index)
void removeElement(Object obj)
void removeAllElements()
ArrayList, LinkedList, Vector 异同
Set 接口
存储无序的、不可重复的数据
1、Set 接口 是 Collection 的子接口， set 接口没有 提供额外 的方法。
2、Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。
3、Set 判断两个对象是否相同不是使用 == 运算符，而是 根据 equals() 方法。
HashSet
特点：
1、不能保证元素的排列顺序。
2、HashSet 不是线程安全的。
3、集合元素可以是 null。
HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。
对于存放在Set 容器中的对象，对应的类一定要重写 equals() 和 hashCode(Object obj) 方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。
向HashSet中添加元素的过程
当向 HashSet 集合中存入一个元素时， HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值 ，然后根据 hashCode 值 ，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置 。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素 越是散列分布该散列函数设计的越好）。
如果两个元素的 hashCode() 值相等， 会再继续调用 equals 方法，如果 equals 方法结果为 true 添加失败；如果 为 false 那么会保存该元素 ，但是该数组的位置已经有元素了，那么会通过 链表的方式继续链接 。
如果两个元素的 equals() 方法返回 true ，但它们的 hashCode () 返回值不相等， hashSet 将会把它们存储在不同的位置，但依然可以添加成功 。
以HashSet为例说明：
1. 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
2. 不可重复性：保证添加的元素按照equals()判断时，不能返回true.即：相同的元素只能添加一个。
向HashSet中添加元素a时,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断
数组此位置上是否已经有元素：
如果此位置上没有其他元素，则元素a添加成功。 --->情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
如果hash值不相同，则元素a添加成功。 --->情况2
如果hash值相同，进而需要调用元素a所在类的equals()方法：
equals()返回true,元素a添加失败
equals()返回false,则元素a添加成功。 --->情况3
对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素。
jdk 8 :原来的元素在数组中，指向元素a
总结：七上八下
为什么用 Eclipse/IDEA 重写 hashCode 方法，有 31 这个数字？
LinkedHashSet
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
LinkedHashSet 插入性能略低于 HashSet 但在迭代访问 Set 里的全部元素时有很好的性能。
LinkedHashSet 不允许集合元素重复。
TreeSet
TreeSet 可以确保集合元素处于排序 状态，底层使用红黑树结构存储数据。
TreeSet 两种排序方法： 自然排序（Comparable接口） 和 定制排序（Comparator接口） 。默认情况下，TreeSet 采用 自然排序。
自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().
自然排序
@Test
public void test1(){
TreeSet set = new TreeSet();
//失败：不能添加不同类的对象
// set.add(123);
// set.add(456);
// set.add("AA");
// set.add(new User("Tom",12));
//举例一：
// set.add(34);
// set.add(-34);
// set.add(43);
// set.add(11);
// set.add(8);
//举例二：
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
其中User.java为：
public class User implements Comparable{
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
System.out.println("User equals()....");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() { //return name.hashCode() + age;
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
//按照姓名从大到小排列,年龄从小到大排列
@Override
public int compareTo(Object o) {
if(o instanceof User){
User user = (User)o;
// return -this.name.compareTo(user.name);
int compare = -this.name.compareTo(user.name);
if(compare != 0){
return compare;
}else{
return Integer.compare(this.age,user.age);
}
}else{
throw new RuntimeException("输入的类型不匹配");
}
}
}
定制排序
@Test
public void test2(){
Comparator com = new Comparator() {
//按照年龄从小到大排列
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return Integer.compare(u1.getAge(),u2.getAge());
}else{
throw new RuntimeException("输入的数据类型不匹配");
}
}
};
TreeSet set = new TreeSet(com);
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Mary",33));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
Iterator 迭代器接口
Iterator 对象称为迭代器（设计模式的一种），主要用于遍历 Collection 集合中的元素。
GOF 给迭代器模式的定义为：提供一种方法访问一个容器 (container) 对象中各个元素，而又不需暴露该对象的内部细节。 迭代器模式，就是为容器而生。
Collection 接口继承了 java.lang.Iterable 接口，该接口有一个 iterator() 方法，那么所有实现了 Collection 接口的集合类都有一个 iterator() 方法，用以返回一个实现了Iterator 接口的对象 。
Iterator 仅用于遍历集合 Iterator 本身并不提供承装对象的能力。如果需要 创建Iterator 对象，则必须有一个被迭代的集合。
集合对象每次调用 iterator() 方法都得到一个全新的迭代器对象 ，默认游标都在集合的第一个元素 之前 。
集合元素的遍历操作，使用迭代器Iterator接口 1.内部的方法：hasNext() 和 next() 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。 3.内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
Iterator iterator = coll.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
}
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//删除集合中"Tom"
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
if("Tom".equals(obj)){
iterator.remove();
}
}
//遍历集合
iterator = coll.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
foreach
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//for(集合元素的类型 局部变量 : 集合对象)
//内部仍然调用了迭代器。
for(Object obj : coll){
System.out.println(obj);
}
} @Test
public void test2(){
int[] arr = new int[]{1,2,3,4,5,6};
//for(数组元素的类型 局部变量 : 数组对象)
for(int i : arr){
System.out.println(i);
}
} @Test
public void test3(){
String[] arr = new String[]{"MM","MM","MM"};
//方式一：增强for循环
for(String s : arr){
s = "GG";
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " "); // MM MM MM
}
//方式二：普通for赋值
for(int i = 0;i < arr.length;i++){
arr[i] = "GG";
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " "); //GG GG GG
}
}Map 接口
双列数据，存储key-value对的数据。
Map结构的理解：
Map中的key：无序的、不可重复的，使用Set存储所有的key ---> key所在的类要重写equals()和hashCode() （以HashMap为例）
Map中的value：无序的、可重复的，使用Collection存储所有的value --->value所在的类要重写equals()
一个键值对：key-value构成了一个Entry对象。
Map中的entry：无序的、不可重复的，使用Set存储所有的entry。
添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
@Test
public void test(){
Map map = new HashMap();
//1、添加 Object put(Object key, Object value)
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
//2、还可以用于修改 Object put(Object key, Object value)
map.put("AA",87);
System.out.println(map);
//3、void putAll(Map m): 将m中的所有key-value对存放到当前map中
Map map1 = new HashMap();
map1.put("CC",123);
map1.put("DD",123);
map.putAll(map1);
System.out.println(map);
//4、remove(Object key)：移除指定key的key-value对，并返回value
Object value = map.remove("CC");
System.out.println(value);
System.out.println(map);
//5、clear()：清空当前map中的所有数据
map.clear();//与map = null操作不同
System.out.println(map.size());
System.out.println(map);
}
元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
@Test
public void test(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
//6、Object get(Object key)：获取指定key对应的value
System.out.println(map.get(45));
//7、containsKey(Object key)：是否包含指定的key
boolean isExist = map.containsKey("BB");
System.out.println(isExist);
//8、boolean containsValue(Object value)：是否包含指定的value
isExist = map.containsValue(123);
System.out.println(isExist);
//9、int size()：返回map中key-value对的个数
System.out.println(map.size());
map.clear();
//10、boolean isEmpty()：判断当前map是否为空
System.out.println(map.isEmpty());
}元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
@Test
public void test(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,1234);
map.put("BB",56);
//1、 Set keySet()：遍历所有的key集
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println();
//2、Collection values()：遍历所有的value集
Collection values = map.values();
for(Object obj : values){
System.out.println(obj);
}
System.out.println();
//Set entrySet()：遍历所有的key-value对构成的Set集合
//方式一：entrySet()
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
//entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
System.out.println();
//方式二：
Set keySet = map.keySet();
Iterator iterator2 = keySet.iterator();
while(iterator2.hasNext()){
Object key = iterator2.next();
Object value = map.get(key);
System.out.println(key + "=====" + value);
}
}
HashMap
1、HashMap 是 Map 接口 使用频率最高 的实现类。
2、允许使用 null 键和 null 值，与 HashSet 一样，不保证映射的 顺序。
3、所有 的 key 构成的集合是 Set: 无序的、不可重复 的。所以， key 所在的类要重写：equals() 和 hashCode()。
4、所有 的 value 构成的集合是 Collection: 无序的、可以重复 的。所以， value 所在的类要重写： equals()。
5、一 个 key value 构成一 个 entry。
6、所有的 entry 构成的集合是 Set: 无序的、不可重复的。
7、HashMap 判断两个 key 相等的标准 是：两个 key 通过 equals() 方法返回 true hashCode 值也相等。
8、HashMap 判断两个 value 相等的标准 是：两个 value 通过 equals() 方法返回 true 。
HashMap源码中的重要常量
DEFAULT_INITIAL_CAPACITY：HashMap 的默认容量， 16。
MAXIMUM_CAPACITY：HashMap 的最大支持容量， 2^30。
DEFAULT_LOAD_FACTOR：HashMap 的默认加载因子。
TREEIFY_THRESHOLD：Bucket 中链表长度大于该默认值，转化为红黑树。
UNTREEIFY_THRESHOLD：Bucket 中红黑树存储的 Node 小于该默认值，转化为链表。
MIN_TREEIFY_CAPACITY：桶中的 Node 被树化时最小的 hash 表容量。（当桶中 Node 的数量大到需要变红黑树时，若 hash 表容量小于 MIN_TREEIFY_CAPACITY 时，此时应执行resize 扩容操作这个 MIN_TREEIFY_CAPACITY 的值至少是 TREEIFY_THRESHOLD 的 4倍。）
table：存储元素的数组，总是 2 的 n 次幂。
entrySet：存储具体元素的集。
size：HashMap 中存储的键值对的数量。
modCount：HashMap 扩容和结构改变的次数。
threshold：扩容的临界值， 容量填充因子。
loadFactor：填充因子。
负载因子值的大小，对 HashMap 的影响
LinkedHashMap
1、LinkedHashMap 是 HashMap 的 子类。
2、在 HashMap 存储结构的基础上，使用了一对双向链表来记录添加元素的顺序。
3、与 LinkedHashSet 类似 LinkedHashMap 可以维护 Map 的迭代。
顺序：迭代顺序与 Key V alue 对的插入顺序一致。
TreeMap
1、TreeMap 存储 Key-Value 对 时， 需要根据 key-value 对进行排序。
TreeMap 可以保证所有的 Key-Value 对处于有序状态 。
2、TreeSet 底层使用 红黑树 结构存储数据。
3、TreeMap 的 Key 的排序：
自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException。
定制排序 ：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口。
4、TreeMap 判断 两个 key 相等的标准 ：两个 key 通过 compareTo() 方法或者 compare() 方法返回 0 。
自然排序
//自然排序
@Test
public void test1(){
TreeMap map = new TreeMap();
User u1 = new User("Tom",23);
User u2 = new User("Jerry",32);
User u3 = new User("Jack",20);
User u4 = new User("Rose",18);
map.put(u1,98);
map.put(u2,89);
map.put(u3,76);
map.put(u4,100);
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
}public class User implements Comparable{
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
System.out.println("User equals()....");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() { //return name.hashCode() + age;
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
//按照姓名从大到小排列,年龄从小到大排列
@Override
public int compareTo(Object o) {
if(o instanceof User){
User user = (User)o;
// return -this.name.compareTo(user.name);
int compare = -this.name.compareTo(user.name);
if(compare != 0){
return compare;
}else{
return Integer.compare(this.age,user.age);
}
}else{
throw new RuntimeException("输入的类型不匹配");
}
}
}
定制排序
//定制排序
@Test
public void test2(){
//核心部分
TreeMap map = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return Integer.compare(u1.getAge(),u2.getAge());
}
throw new RuntimeException("输入的类型不匹配！");
}
});
User u1 = new User("Tom",23);
User u2 = new User("Jerry",32);
User u3 = new User("Jack",20);
User u4 = new User("Rose",18);
map.put(u1,98);
map.put(u2,89);
map.put(u3,76);
map.put(u4,100);
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
}Hashtable
1、Hashtable 是个古老的 Map 实现 类， JDK1.0 就提供了。不同于 HashMap，Hashtable 是线程安全的。
2、Hashtable 实现原理和 HashMap 相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用 。
3、与 HashMap 不同， Hashtable 不允许使用 null 作为 key 和 value。
4、与 HashMap 一样， Hashtable 也不能保证其中 Key Value 对的顺序。
5、Hashtable 判断两个 key 相等、两个 value 相等的标准 与 HashMap 一致。
Properties
1、Properties 类是 Hashtable 的子类，该对象用于处理属性文件。
2、由于属性文件里的 key 、 value 都是字符串类型，所以 Properties 里的 key和 value 都是字符串类型。
3、存取数据时，建议使用 setProperty (String key,String value) 方法 和 getProperty (String key) 方法.
public class PropertiesTest {
//Properties:常用来处理配置文件。key和value都是String类型
public static void main(String[] args) {
FileInputStream fis = null;
try {
Properties pros = new Properties();
fis = new FileInputStream("jdbc.properties");
pros.load(fis);//加载流对应的文件
String name = pros.getProperty("name");
String password = pros.getProperty("password");
System.out.println("name = " + name + ", password = " + password);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Collections 工具类
1、Collections 是一个操作 Set 、 List 和 Map 等集合的工具类。
2、Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。
3、排序操作 ：（均为 static 方法）
reverse(List)： 反转 List 中元素的顺序。
shuffle(List)： 对 List 集合元素进行随机排序。
sort(List)： 根据元素的自然顺序对指定 List 集合元素按升序排序。
sort(List, Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序。
swap(List, int, int)： 将指定 list 集合中的 i 处元素和 j 处元素进行交换。
4、Collections 类中提供了多个 synchronizedXxx () 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素。
Object max(Collection, Comparator) 根据 Comparator 指定的顺序，返回给定集合中的最大元素。
Object min(Collection)
Object min(Collection, Comparator)
int frequency(Collection, Object)：返回指定集合中指定元素的出现次数。
void copy(List dest, List src )：将 src 中的内容复制到 dest 中。
boolean replaceAll (List list, Object oldVal, Object newVal)：使用新值替换List 对象的所有旧值。
//void copy(List dest,List src)：将src中的内容复制到dest中
//注意有坑
@Test
public void test(){
List list = new ArrayList();
list.add(123);
list.add(43);
list.add(765);
list.add(-97);
list.add(0);
//报异常：IndexOutOfBoundsException("Source does not fit in dest")
// List dest = new ArrayList();
// Collections.copy(dest,list);
//目标集合的容量不应小于旧集合
//正确的：
List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest.size());//list.size();
Collections.copy(dest,list);
System.out.println(dest);
/*
Collections 类中提供了多个 synchronizedXxx() 方法，
该方法可使将指定集合包装成线程同步的集合，从而可以解决
多线程并发访问集合时的线程安全问题
*/
//返回的list1即为线程安全的List
List list1 = Collections.synchronizedList(list);
}