写在前面

集合部分的内容实在太多了，本篇博客主要是对本章内容的总结回顾，对于ArrayList、HashMap的底层源码后面会专门找个时间重新写~

概述

本章内容主要学习：Collection接口，及其两个子接口List、Set的实现子类，Iterator迭代器接口；Map接口及其实现子类。其中List的实现子类有ArrayList、LinkedList、Vector等,Set的实现子类有HashSet、LinkedHashSet、TreeSet等；Map的实现子类有HashMap、LinkedHashMap、TreeMap、Hashtable、Properties等，下面是两大接口的继承树：
Collection：

Map:

两种体系的对比：

Collection接口

概述

1.Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。
2.JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List)实现。
3.在 Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object 类型处理；从 JDK 5.0 增加了泛型以后，Java 集合可以记住容器中对象的数据类型。

Collection接口常用方法

part1

1.boolean add(Object obj):添加一个元素
2.boolean addAll(Collection coll):增加一个集合
3.int size():返回一个集合的有效元素个数
4.void clear():清空集合的元素
5.boolean isEmpty():判断是否为空集合
demo01:

package com.deserts;import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;/*** 测试Collextion接口方法1：* boolean add(Object obj):添加一个元素* boolean addAll(Collection coll):增加一个集合* int size():返回一个集合的有效元素个数* void clear():清空集合的元素* boolean isEmpty():判断是否为空集合*/
public class Demo01 {public static void main(String[] args) {Collection coll = new ArrayList();//add(Object obj):添加一个元素coll.add(123);//自动装箱coll.add("deserts");coll.add(new Date());coll.add(3.1415926);System.out.println(coll);Collection coll1 = new ArrayList();coll1.add(456);coll1.add("xuan");//addAll(Collection coll):增加一个集合coll.addAll(coll1);System.out.println(coll);//int size():返回一个集合的有效元素个数System.out.println("coll.size: " + coll.size());//void clear():清空集合的元素coll.clear();//boolean isEmpty():判断是否为空集合System.out.println(coll.isEmpty());}
}

part2

1.boolean contains(Object obj)：是通过元素的equals方法来判断是否是同一个对象
2.boolean containsAll(Collection c)：也是调用元素的equals方法来比较的。 拿两个集合的元素挨个比较。
3. boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。 只会删除找到的第一个元素
4. boolean removeAll(Collection coll)：取当前集合的差集

demo02:

package com.deserts;import java.util.ArrayList;
import java.util.Collection;/*** 测试Collextion接口方法2：* boolean contains(Object obj)：是通过元素的equals方法来判断是否是同一个对象* boolean containsAll(Collection c)：也是调用元素的equals方法来比较的。* 拿两个集合的元素挨个比较。* boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。* 只会删除找到的第一个元素* boolean removeAll(Collection coll)：取当前集合的差集**/
public class Demo02 {public static void main(String[] args) {Collection coll = new ArrayList();coll.add(123);//自动装箱coll.add("deserts");coll.add(false);coll.add(3.1415926);//boolean contains(Object obj)：是通过元素的equals方法来判断是否是同一个对象System.out.println("coll is contain 123: " + coll.contains(123));Collection coll1 = new ArrayList();coll1.add(123);//自动装箱coll1.add("deserts");//boolean containsAll(Collection c)：也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。System.out.println("coll is contain coll1: " + coll.containsAll(coll1));//boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。System.out.println("是否移除3.1415926成功: " + coll.remove(3.1415926));System.out.println(coll);//boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素System.out.println("coll、coll1求差集: " + coll.removeAll(coll1));System.out.println(coll);}
}

part3

1.boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响c
2.boolean equals(Object obj)：集合是否相等
3.Object[] toArray()：转成对象数组
4.int hashCode()：获取集合对象的哈希值
5.Iterator iterator()：返回迭代器对象，用于集合遍历

demo03:

package com.deserts;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;/*** 测试Collextion接口方法3：* boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响c* boolean equals(Object obj)：集合是否相等* Object[] toArray()：转成对象数组* int hashCode()：获取集合对象的哈希值* Iterator iterator()：返回迭代器对象，用于集合遍历*/
public class Demo03 {public static void main(String[] args) {Collection coll = new ArrayList();coll.add(123);coll.add("deserts");coll.add(false);coll.add(3.1415926);Collection coll1 = new ArrayList();coll1.add(123);coll1.add("deserts");coll1.add(false);//boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响ccoll.retainAll(coll1);System.out.println(coll);//boolean equals(Object obj)：集合是否相等System.out.println(coll.equals(coll1));System.out.println("$$$$$$$$$$$$$$$$$$$");//Object[] toArray()：转成对象数组Object[] obj = coll.toArray();System.out.println(Arrays.toString(obj));//int hashCode()：获取集合对象的哈希值System.out.println(coll.hashCode());System.out.println("*******************");//Iterator iterator()：返回迭代器对象，用于集合遍历Iterator it = coll.iterator();while (it.hasNext()){System.out.println(it.next());}}
}

Iterator迭代器接口

概述

1.Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
2.Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象，则必须有一个被迭代的集合。
3.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

常用方法

Iterator接口作为迭代器主要功能是遍历，用于遍历的两个方法是：boolean hasNext(); E next();除此之外，还提供了remove()方法

原理：

除了使用Iterator接口，还可使用for each循环（增强for循环）进行遍历
demo:

package com.deserts;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;/*** 测试两种遍历方式*/
public class demo04 {public static void main(String[] args) {Collection coll = new ArrayList();coll.add(123);coll.add("deserts");coll.add(false);coll.add(3.1415926);//Iterator迭代器输出Iterator it = coll.iterator();while (it.hasNext()){System.out.println(it.next());}System.out.println("*********************");//for each输出for(Object obj: coll){System.out.println(obj);}}
}

List接口

概述

List接口是Collection子接口之一，是在JDK1.2新增的，它的子类ArrayList、LinkedList也是在JDK1.2新增的，同时JDK1.0就有的Vector也是它的子类

List接口方法

1.void add(int index, Object ele):在index位置插入ele元素
2. boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
3.Object get(int index):获取指定index位置的元素
4.int indexOf(Object obj):返回obj在集合中首次出现的位置
5. int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
6.Object remove(int index):移除指定index位置的元素，并返回此元素
7. Object set(int index, Object ele):设置指定index位置的元素为ele
8. List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

demo

package com.desertss.demo;import java.util.ArrayList;/*** 测试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位置的子集合**/
public class Demo01 {public static void main(String[] args) {ArrayList list = new ArrayList();list.add(123);list.add(456);list.add(true);list.add(123);list.add("deserts");//void add(int index, Object ele):在index位置插入ele元素list.add(2,"MM");System.out.println(list);ArrayList list1 = new ArrayList();list1.add("xuan");list1.add(false);//boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来System.out.println(list.addAll(1,list1));System.out.println(list);//Object get(int index):获取指定index位置的元素System.out.println(list.get(4));//int indexOf(Object obj):返回obj在集合中首次出现的位置System.out.println(list.indexOf(123));//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置System.out.println(list.lastIndexOf(123));//Object remove(int index):移除指定index位置的元素，并返回此元素System.out.println(list.remove(4));System.out.println(list);//Object set(int index, Object ele):设置指定index位置的元素为elelist.set(0,789);System.out.println(list.get(0));//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合Object list2 = list.subList(2,5);System.out.println(list2);}
}

ArrayList

概述

1.ArrayList 是 List 接口的典型实现类、主要实现类
2.本质上，ArrayList是对象引用的一个”变长”数组

底层

1.jdk 7情况下： ArrayList list = new ArrayList(); //底层创建了长度是10的Object[]数组elementData list.add(123);//elementData[0] = new Integer(123); ist.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

2.jdk 8中ArrayList的变化： ArrayList list = new ArrayList();//底层Object[] elementData初始化为.并没有创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]，后续的添加和扩容操作与jdk7 无异。
3.jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象 的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

LinkedList

概述

对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高

新增方法

底层

LinkedList底层的核心是一个内部类Node，这个类声明了属性item、next、prev分别来表示存储内容、链表头、链表尾，链表头记录下一个元素的位置，链表尾记录前一个元素的位置。

Vector

概述

1.Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
2.在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。

新增方法

关于三者的异同

Set接口

概述

1.Set接口是Collection的子接口，set接口没有提供额外的方法
2.Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。
3.Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法

HashSet

概述

向HashSet中添加元素的过程

1.当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）
2.如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。
3.如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。

重写hashCode()的原则

1.在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
2.当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode() 方法的返回值也应相等。
3.对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。

重写equals()原则

LinkedHashSet

LinkedHashSet用的比较少，下列是简单介绍：

TreeSet

TreeSet主要是排序用，掌握了Java比较器就问题不大。需要注意的是，添加元素时不再使用haseCode()、equals()来比较，这时需要用到我们的java比较器。

自然排序

定制排序

代码示例：

package com.desertss.demo;import java.util.Comparator;
import java.util.Iterator;
import java.util.Objects;
import java.util.TreeSet;public class Demo05 {public static void main(String[] args) {//定制排序：先按价格从大到小排序，再按名字从小到大排序Comparator comparator = new Comparator() {@Overridepublic int compare(Object o1, Object o2) {if (o1 instanceof Goods && o2 instanceof Goods){Goods g1 = (Goods)o1;Goods g2 = (Goods)o2;int com = -Double.compare(g1.getPrice(),g2.getPrice());if (com == 0){return g1.getName().compareTo(g2.getName());}else {return com;}}throw new RuntimeException("类型不匹配");}};TreeSet set = new TreeSet(comparator);set.add(new Goods("辣条",3.5));set.add(new Goods("快乐水",2.5));set.add(new Goods("薯片",4));set.add(new Goods("雪糕",5.5));set.add(new Goods("酸奶",6.5));Iterator it = set.iterator();while (it.hasNext()){System.out.println(it.next());}}
}
class Goods implements Comparable{private String Name;private double price;public Goods(String name, double price) {Name = name;this.price = price;}public String getName() {return Name;}public double getPrice() {return price;}@Overridepublic String toString() {return "Goods{" +"Name='" + Name + '\'' +", price=" + price +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Goods goods = (Goods) o;return Double.compare(goods.price, price) == 0 &&Objects.equals(Name, goods.Name);}@Overridepublic int hashCode() {return Objects.hash(Name, price);}//自然排序,先按名字再按价格排序@Overridepublic int compareTo(Object o) {if(o instanceof Goods){Goods g = (Goods)o;int compare = this.Name.compareTo(g.Name);if(compare == 0){return Double.compare(this.price,g.price);}else {return compare;}}throw new RuntimeException("输入类型不匹配");}
}

Map接口

概述

常用方法

添加、删除、修改操作：

• 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中的所有数据
  demo:

package com.deserts.demo;import java.util.HashMap;
import java.util.Map;/***  添加、删除、修改操作：*  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中的所有数据**/
public class Demo01 {public static void main(String[] args) {Map map = new HashMap();//Object put(Object key,Object value)map.put("xiaoming",95);map.put("lihua",59);map.put("zhangsan",82);map.put("lisi",74);map.put("wangwu",100);System.out.println(map);Map map1 = new HashMap();map1.put("bajie",44);map1.put("wukong",64);map1.put("laosha",76);//void putAll(Map m)map.putAll(map1);System.out.println(map);//void clear()：清空当前map中的所有数据map.clear();System.out.println(map.isEmpty());}
}

元素查询的操作：

• 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是否相等
  demo:

package com.deserts.demo;import java.util.HashMap;
import java.util.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是否相等*/
public class Demo02 {public static void main(String[] args) {Map map = new HashMap();map.put("xiaoming",95);map.put("lihua",59);map.put("zhangsan",82);map.put("lisi",74);map.put("wangwu",100);//Object get(Object key)：获取指定key对应的valueSystem.out.println(map.get("lihua"));//boolean containsKey(Object key)：是否包含指定的keySystem.out.println(map.containsKey("zhangsan"));//boolean containsValue(Object value)：是否包含指定的valueSystem.out.println(map.containsValue(95));//int size()：返回map中key-value对的个数System.out.println(map.size());//boolean equals(Object obj)：判断当前map和参数对象obj是否相等System.out.println(map.equals("zhangsan"));}
}

元视图操作的方法：

• Set keySet()：返回所有key构成的Set集合
• Collection values()：返回所有value构成的Collection集合
• Set entrySet()：返回所有key-value对构成的Set集合
  demo：

package com.deserts.demo;import java.util.*;/***  元视图操作的方法：*  Set keySet()：返回所有key构成的Set集合*  Collection values()：返回所有value构成的Collection集合*  Set entrySet()：返回所有key-value对构成的Set集合*/
public class Demo03 {public static void main(String[] args) {Map map = new HashMap();map.put("xiaoming",95);map.put("lihua",59);map.put("zhangsan",82);map.put("lisi",74);map.put("wangwu",100);//Set keySet()：返回所有key构成的Set集合Set set = map.keySet();Iterator it = set.iterator();while (it.hasNext()){System.out.println(it.next());}System.out.println();//Collection values()：返回所有value构成的Collection集合Collection values = map.values();for(Object obj: values){System.out.println(obj);}System.out.println();//Set entrySet()：返回所有key-value对构成的Set集合Set set1 = map.entrySet();Iterator it1 = set1.iterator();while (it1.hasNext()){Map.Entry entry = (Map.Entry)it1.next();System.out.println(entry.getKey() + "--->" + entry.getValue());}}
}

HashMap

概述

结构图：

底层

JDK8.0之前：

JDK8.0的变化：

有关源码分析，会在后面找时间写博客分析

LinkedHashMap

概况

TreeMap

概述

自然排序demo:

package com.deserts.demo;import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;/*** TreeMap自然排序测试*/
public class Demo04 {public static void main(String[] args) {Student s1 = new Student("zhangsan", 85);Student s2 = new Student("lisi", 95);Student s3 = new Student("wangwu", 68);Student s4 = new Student("lihua", 59);Student s5 = new Student("xiaoming", 74);TreeMap map = new TreeMap();map.put(s1,18);map.put(s2,20);map.put(s3,19);map.put(s4,18);map.put(s5,19);Set set = map.entrySet();Iterator it = set.iterator();while (it.hasNext()){Map.Entry entry = (Map.Entry)it.next();System.out.println(entry.getKey() + "--->" + entry.getValue());}}
}
class Student implements Comparable{private String name;private int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", score=" + score +'}';}@Overridepublic int compareTo(Object o) {if(o instanceof Student){Student s = (Student)o;return this.name.compareTo(s.name);}throw new RuntimeException("类型不匹配");}
}

定制排序demo:

package com.deserts.demo;import java.util.*;/*** Map定制排序测试*/
public class Demo05 {public static void main(String[] args) {Student1 s1 = new Student1("zhangsan", 85);Student1 s2 = new Student1("lisi", 95);Student1 s3 = new Student1("wangwu", 68);Student1 s4 = new Student1("lihua", 59);Student1 s5 = new Student1("xiaoming", 74);TreeMap map = new TreeMap(new Comparator() {@Overridepublic int compare(Object o1, Object o2) {if(o1 instanceof Student1 && o2 instanceof Student1) {Student1 s1 = (Student1)o1;Student1 s2 = (Student1)o2;return -Integer.compare(s1.getScore(),s2.getScore());}throw new RuntimeException("类型不匹配");}});map.put(s1,18);map.put(s2,20);map.put(s3,19);map.put(s4,18);map.put(s5,19);Set set = map.entrySet();Iterator it = set.iterator();while (it.hasNext()){Map.Entry entry = (Map.Entry)it.next();System.out.println(entry.getKey() + "--->" + entry.getValue());}}}
class Student1{private String name;private int score;public Student1(String name, int score) {this.name = name;this.score = score;}public String getName() {return name;}public int getScore() {return score;}@Overridepublic String toString() {return "Student1{" +"name='" + name + '\'' +", score=" + score +'}';}
}

Hashtable

Hashtable已经很少用了，下面是简介：

Properties

Properties主要用于处理属性文件

Collection工具类

Collections 是一个操作 Set、List 和 Map 等集合的工具类

排序方法：

查找、替换

同步控制

补充内容

写在最后

集合的内容真的是学这么久JavaSE以来内容最多最难的一章，还需要多花时间，可以是数据结构还没学写在源码不能看得特别清晰。下面就要进入泛型的学习了，冲冲冲！