Java第十章 集合

目录

10.1 集合类概述

10.2 Collection接口

10.3 List集合

10.3.1 List接口

 10.3.2  List接口的实现类

例10.1

结果

10.3.3  Iterator迭代器

例10.2

 结果

 10.4  Set集合

10.4.1  Set接口

 10.4.2  Set接口的实现类

 例10.3

结果

10.4.3 TreeSet的两种排序方法  

10.5  Map集合

10.5.1  Map接口

 10.5.2  Map接口的实现类

例10.4

结果

10.6  集合的使用场合

10.7  小结

10.1 集合类概述

集合类是Java数据结构的实现。Java的集合类是java.util包中的重要内容，它允许以各种方式将元素分组，并定义了各种使这些元素更容易操作的方法。Java集合类是Java将一些基本的和使用频率极高的基础类进行封装和增强后再以一个类的形式提供。集合类是可以往里面保存多个对象的类，存放的是对象，不同的集合类有不同的功能和特点，适合不同的场合，用以解决一些实际问题。百度百科

集合是一个容器，是一个载体，可以一次容纳多个对象。数组其实就是一个集合，集合实际上就是一个容器。

在实际开发中，假设链接数据库，数据库中有10条记录，那么假设把十条记录查询出来，这时java程序会把十条数据封装成10个java对象，然后将Java对象放到一个集合中，将集合传到前端，然后遍历集合，将数据一个个展现出来。

集合不能直接存储基本数据类型，另外集合也不能直接存储Java对象，集合里面存储Java对象的内存地址(集合中存储的是引用)。【注意】 list.add(100)//这里存的不是基本数据类型int，自动装箱-->Integer

java.util包中提供了一些集合类，这些集合类又被称为容器。提到容器不难想到数组，集合类与数组的不同之处是，数组的长度是固定的，集合的长度是可变的;数组用来存放基本类型的数据，集合用来存放对象的引用。常用的集合有List 集合、Set 集合和Map集合，其中List与Set继承了Collction接口，各接口还提供了不同的实现类。上述集合类的继承关系

10.2 Collection接口

Collection接口是层次结构中的根接口。构成Collection的单位称为元素。Collection 接口通常不能直接使用，但该接口提供了添加元素、删除元素和管理数据的方法。由于List接口与Set接口都继承了Collection接口，因此这些方法对List集合与Set集合是通用的。Collection接口的常用方法

10.3 List集合

List集合包括List接口以及List接口的所有实现类。List 集合中的元素允许重复，各元素的顺序就是对象插入的顺序。类似Java数组，用户可通过使用索引(元素在集合中的位置)来访问集合中的元素。

10.3.1 List接口

List接口继承了Cllection接口，因此包含Colletion中的所有方法，此外，List接口还定义了以下两个非常重要的方法

说明： 由于Cllection接口是List集合和Set集合的父接口，因此表中的方法对于List集合和Set集合都是通用的。 

 10.3.2  List接口的实现类

List集合下最常见的集合类有两个：ArrayList和LinkedList。在工作中，我都是无脑用ArrayList。我问了两个同事：“你们在项目中用过LinkedList吗？”他们都表示没有。

众所周知，ArrayList底层是数组，LinkedList底层是链表。数组遍历速度快，LinkedList增删元素快。

为什么在工作中一般就用ArrayList，而不用LinkedList呢？原因也很简单：

在工作中，遍历的需求比增删多，即便是增加元素往往也只是从尾部插入元素，而ArrayList在尾部插入元素也是O(1)
ArrayList增删没有想象中慢，ArrayList的增删底层调用的copyOf()被优化过，加上现代CPU对内存可以块操作，普通大小的ArrayList增删比LinkedList更快。
所以，在开发中，想到要用集合来装载元素，第一个想到的就是ArrayList。LinkedList用在什么地方呢？我们一般用在刷算法题上。把LinkedList当做一个先进先出的队列，LinkedList本身就实现了Queue接口，如果考虑线程安全的问题，可以看看CopyWriteOnArrayList，实际开发用得不多，但我觉得可以了解一下它的思想（CopyWriteOn），这个思想在Linux/文件系统都有用到。

List接口由于不能直接实例化，因此，在JDK中提供了其实现子类，最常用的实现子类有ArayList类与LinkedList类，分别如下。
(1) ArrayList类的优点是实现了可变的数组，允许保存所有元素，包括null, 并可以根据索引位置对集合进行快速的随机访问;缺点是向指定的索引位置插入对象或删除对象的速度较慢，因为ArayList实质上是使用数组来保存集合中的元素的，在增加和删除指定位置的元素时，虚拟机会好建新的数组，效率低，所以在对元素做大量的增删操作时不适合使用ArayList集合。

(2) LinkedList类采用链表结构保存对象，这种结构的优点是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用LinkedList类实现的List 集合的效率较高;但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较低。

使用List集合时通常声明为List类型，可通过不同的实现类来实例化集合。

例如，分别通过ArrayList、LinkedList 类实例化List集合。代码如下:

List<E> list = new ArrayList<>();

List<E> list2 = new LinkedList<>();

 在上面的代码中，E代表Java中的泛型。例如，如果集合中的元素为字符串类型，那么E可以修改为String。

例10.1

在项目中创建LstTest类，在主方法中创建List 集合对象，并使用add方法向集合中添加元素，然后随机生成一个集合长度范围内的索引，并使用get方法获取该索引对应的值:最后再使用renove方法移除集合中索引位置2处的值，并使用for循环遍历集合，输出所有的集合元素值。

import java.util.*;//导入java.util包，其他实例都要添加该语句
public class H10_1 {//创建类
	 public static void main(String[] args) { // 主方法
	  List<String> list = new ArrayList<>(); // 创建集合对象
	  list.add("a"); // 向集合添加元素
	  list.add("b");// 向集合添加元素
	  list.add("c");// 向集合添加元素
	  int i = (int) (Math.random() * list.size()); // 获得0~2之间的随机数
	  System.out.println("随机获取数组中的元素：" + list.get(i));//输出"随机获取数组中的元素：" + list.get(i)
	  list.remove(2); // 将指定索引位置的元素从集合中移除
	  System.out.println("将索引是'2'的元素从数组移除后，数组中的元素是：");//输出"将索引是'2'的元素从数组移除后，数组中的元素是："
	  for (int j = 0; j < list.size(); j++) { // 循环遍历集合
	   System.out.println(list.get(j)); // 获取指定索引处的值
	  }
	 }
	}

结果

 说明：与数组相同，集合的索引也是从0开始。

10.3.3  Iterator迭代器

 在使用了for循环遍历List集合中的元素，那么有没有其他更加快捷有效的遍历集合中元素的方法呢?答案是肯定的，在java.util 包中提供了一个Iterator 接口，该接口是一个专门对Colletion进行迭代的迭代器，其常用方法

注意：Iterator的next()方法返回的是Object。 

 程序中使用Iterator迭代器时，可以使用Collection接口中的iterator()方法返回一个Iterator对象。下面演示如何使用Iterator迭代器遍历集合。

例10.2

在项目中创建TeratorTeset类，在主方法中实例化集合对象，并向集合中添加元素， 最后通过lte
rator迭代器遍历集合，将集合中的对象以String形式输出。

import java.util.*; //导入java.util包，其他实例都要添加该语句
public class H10_2 {//创建类
		public static void main(String args[]) {//主方法
			Collection<String> list = new ArrayList<>(); // 实例化集合类对象
			list.add("a"); // 向集合添加数据
			list.add("b"); // 向集合添加数据
			list.add("c"); // 向集合添加数据
			Iterator<String> it = list.iterator(); // 创建迭代器
			while (it.hasNext()) { // 判断是否有下一个元素
				String str = (String) it.next(); // 获取集合中元素
				System.out.println(str);//输出str
			}
		}
	}

 结果

 10.4  Set集合

List和Set都是集合，一般来说：如果我们需要保证集合的元素是唯一的，就应该想到用Set集合，比如说：现在要发送一批消息给用户，我们为了减少「一次发送重复的内容给用户」这样的错误，我们就用Set集合来保存用户的信息

一般我们在开发中最多用到的也就是HashSet。TreeSet是可以排序的Set，一般我们需要有序，从数据库拉出来的数据就是有序的，可能往往写order by id desc比较多。而在开发中也很少管元素插入有序的问题，所以LinkedHashSet一般也用不上。

如果考虑线程安全的问题，可以考虑CopyOnWriteArraySet，用得就更少了（这是一个线程安全的Set，底层实际上就是CopyWriteOnArrayList)；TreeSet和LinkedHashSet更多的可能用在刷算法的时候。

Set集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，但Set集合中不能包含重复对象，Set集合由Set接口和Set接口的实现类组成。

10.4.1  Set接口

Set接口是一个不包含重复元素的集合，由于其继承了Collction接口，因此包含Collection 接口的所有方法。

由于Set集合中不允许有重复元素出现，因此，在向Set集合中添加元素时，需要先判断元素是否已经存在，再确定是否执行添加操作。

注意:Set的构造有一个约束条件，传入Collection对象不能有重复值，必须小心操作可变对象(Mutable Object)。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true,则会出现一些问题。 

 

 10.4.2  Set接口的实现类

Set接口常用的实现类有HashSet类与TreeSet类，分别如下。

(1) HashSet是Set接口的一个实现类，它不允许有重复元素。HashSet主要依据哈希算法直接将元素指定到一个地址上。当向HashSet 集合中添加一个元素时，会调用equals方法来判断该位置是否有重复元素。判断是通过比较它们的HashCode来进行比较的。HashSet集合的常用方法都是重写了Set接口中的方法。此集合允许保存null.

(2) TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口，因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序，也可以制定排序规则，让集合按照我们想要的方式进行排序。TreeSet 类新增的方法，此集合不能保存null.

说明：比较器，即Comparator接口，它提供一个抽象方法compare(T o1, T o2)，这个方法指定了两个对象的比较规则，如果o1大于o2，方法返回正数(通常为+1);如果o1等于o2，方法返回0;如果o1小于o2,方法返回负数( 通常为-1 )。
        还有另一个接口也能实现比较规则: Comparable。 它提供一个抽象方法compareTo(T o)，将调用方法的对象与参数对象进行比较，返回值的规则与上面的Comparator. compare( )方法相同。
        如果想制定TreeSet的排序规则，可以在实例化TreeSet对象时，将一个已写好的比较器作为构造参数传入，或者让TreeSet中的所有元素都实现Comparable接口。

技巧：HashSet类和TreeSet类都是Set接口的实现类，它们当中都不允许有重复元素，但HashSet类不关心元素之间的顺序，而TreeSet类则在希望按照元素的自然顺序进行排序时使用(自然顺序的意思是与插入顺序无关，而是和元素本身的内容和特质有关，例如: abc 排在abd前面)。

 例10.3

下面通过一个实例演示Set集合的使用，在项目中创建类HasSetTest，首先使用Hashset类创建个Set集合对象，并使用add()方法向其中添加4个元素，然后通过iterator迭代器遍历该集合，并输出其中的元素。

import java.util.*;//导入java.util包，其他实例都要添加该语句
public class H10_3 {//创建类
		public static void main(String[] args) {//主方法
			Set set = new HashSet();// 创建Set集合
			set.add("a");// 向集合中添加数据
			set.add("b");// 向集合中添加数据
			set.add("c");// 向集合中添加数据
			set.add("c");// 向集合中添加数据
			Iterator<String> it = set.iterator();// 创建迭代器
			while (it.hasNext()) {// 遍历HashSet集合
				String str = (String) it.next();// 获取集合中的元素
				System.out.println(str);//输出str
			}
		}
	}

结果

 从上面的运行结果可以看出，遍历出的Set集合中只有3个元素，而代码中通过add方法添加了c、c、a和b4个元素，造成这种结果的原因是Set集合中不允许有重复元素，而添加的4个元素中有两个相同的c,所以编译器默认只添加了一个c元素，另外一个并没有执行添加操作。

10.4.3 TreeSet的两种排序方法  

  一、引入排序

@Test
    public void test1() {
        TreeSet treeSet = new TreeSet();
        treeSet.add(10);
        treeSet.add(11);
        treeSet.add(13);
        treeSet.add(12);
        for (Object object : treeSet) {
            System.out.print(object + " " );
        }    
    }

运行结果：10 11 12 13

结论：默认进行升序排列

思考：但是对于自定义对象呢？

   /*  
        实体类：Book
    */
    public class Book { 
    	private Integer bookId;
	private String bookName;
	private String bookAuthor;
	private Double price;
    }
   /*  
        测试类
    */
     @Test
     public void test2() {
		
	Book book1 = new Book(1, "红楼梦", "曹雪芹",11.0);
	Book book2 = new Book(2, "西游记", "曹雪芹",13.0);
	Book book3 = new Book(3, "水浒传", "曹雪芹",12.0);
	TreeSet treeSet = new TreeSet();
	treeSet.add(book1);
	treeSet.add(book2);
	treeSet.add(book3);
	for (Object object : treeSet) {
		Book book = (Book)object;
		System.out.println(book.getBookName() + book.getPrice());
	   }
	}

 

解决方案：1、自然排序 2、定制排序

二、自定义类型排序

如果集合存储的是自定义类型，当存入自定义的引用类型的时候就必须考虑到元素要求具有可排序性，不然会引发ClassCastException异常，所以要对自定义类型进行处理，必须要实现 Comparable或Compared接口。当把一个对象加入TreeSet集合中时，TreeSet调用该对象的compareTo(Object obj)方法与容器中的其他对象比较大小，然后根据红黑树算法决定它的存储位置。

2.1 自然排序

TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系，然后将集合元素按升序排列，这种方式就是自然排序。（比较的前提：两个对象的类型相同）。

操作步骤：

1、Book类实现Comparable接口；

2、重写Comparable接口中的compareTo方法。

  /*
      Book类
      compareTo(T o) ： 比较此对象与指定对象的顺序。
      特别注意在重写Compareto方法时，注意排序 ！！！
  */ 
   public class Book implements Comparable{ // 第一步：实现Comparable接口
    	private Integer bookId;
	private String bookName;
	private String bookAuthor;
	private Double price;
        public int compareTo(Object o) {    // 第二步：重写Comparable接口中的compareTo方法。
                // 若想按照价格从小到大排序，则需要return  = 1 ，即已存在数据大于待存数据
		Book book = (Book)o;
	        int flag = (int)(this.getPrice() - book.getPrice()); 
		return flag;
 	}
    }
   /*
       测试类
   */
    @Test
    public void test3() {
	Book book1 = new Book(1, "红楼梦", "曹雪芹",11.0);
	Book book2 = new Book(2, "西游记", "曹雪芹",13.0);
	Book book3 = new Book(3, "水浒传", "曹雪芹",12.0);
	TreeSet treeSet = new TreeSet();
	treeSet.add(book1);
	treeSet.add(book2);
	treeSet.add(book3);
	for (Object object : treeSet) {
		Book book = (Book)object;
		System.out.println(book.getBookName() + book.getPrice());
	}	
}

2.2 定制排序

TreeSet的自然排序是根据集合元素的大小，TreeSet将他们以升序排列。如果需要实现定制排序，例如降序，则可以使用Comparator接口。该接口里包含一个int compare（T o1， T o2）方法，该方法用于比较o1和o2的大小。如果需要实现定制排序，则需要在创建TreeSet集合对象时，并提供一个Comparator对象与该TreeSet集合关联，由该Comparator对象负责集合元素的排序逻辑。

操作步骤：

让集合构造方法接收Comparator的实现类的compare()方法。
 

   /*  
        实体类：Book
    */
    public class Book { 
    	private Integer bookId;
	private String bookName;
	private String bookAuthor;
	private Double price;
    }
   /** 
       测试类
   */
   @Test
   public void test4() {
	Book book1 = new Book(1, "红楼梦", "曹雪芹",11.0);
	Book book2 = new Book(1, "西游记", "曹雪芹",3.0);
	Book book3 = new Book(1, "水浒传", "曹雪芹",12.0);
	/**
           compare有两个参数，o1和o2，如果
	   o1 < o2  返回负数,
	   o1 = o2  返回正数,
           o1 > o2 返回正数。
        */
	TreeSet treeSet = new TreeSet(new Comparator() {   // 匿名内部类操作
	public int compare(Object o1, Object o2) {	
               Book book1 = (Book)o1;
               Book book2 = (Book)o2;			
	       return (int)( book1.getPrice() - book2.getPrice());				
		}	
	});
		treeSet.add(book1);
		treeSet.add(book2);
		treeSet.add(book3);
		for (Object object : treeSet) {
			Book book = (Book)object;
			System.out.println(book.getBookName() + book.getPrice());
		}
	}

结果

10.5  Map集合

在现实生活中，每辆车都有唯一的车牌号，通过车牌号可以查询到这辆车的详细信息，这两者是一对一的关系，在应用程序中，如果想存储这种具有对应关系的数据，则需要使用JDK中提供的Map接口。Map接口没有继承Collection接口，其提供的是key到value的映射。Map 中不能包含相同的key,每个key只能映射一一个value,另外，key还决定了存储对象在映射中的存储位置，但不是由key对象本身决定的，而是通过一种 “ 散列技术”进行处理，产生一个散列码的整数值来确定存储对象在映射中的存储位置。Map集合包括Map接口以及Map接口的所有实现类。

10.5.1  Map接口

Map按口提供了将key映射到值的对象。一个映射不能包含重复的key,每个key最多只能映射个值。Map接口的常用方法

 10.5.2  Map接口的实现类

Map接口常用的实现类有HashMap和TreeMap两种，分别如下。

(1) HashMap类是基于哈希表的Map接口的实现，此实现提供所有可选的映射操作，并允许使用null值和null键，但必须保证键的唯-性。HashMap通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

(2) TreeMap类不仅实现了Map接口，还实现了java.util.SortedMap接口，因此，集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系时，TreeMap 类比HashMap类性能稍差.由于TreeMap类实现的Map集合中的映射关系是根据键对象按照定的顺序排列的， 因此不允许键对象是null。

例10.4

在项目中创建类HashMapTest，在主方法中创建Map集合，并向Map集合中添加键值对:然后分别获取Map集合中的所有key对象集合和所有values值集合，并输出。

import java.util.*;//导入java.util包，其他实例都要添加该语句
public class H10_4 {//创建类
	public static void main(String[] args) {//主方法
		Map<String, String> map = new HashMap<>(); // 创建Map实例
		map.put("ISBN-978654", "Java从入门到精通"); // 向集合中添加对象
		map.put("ISBN-978361", "Android从入门到精通");// 向集合中添加对象
		map.put("ISBN-978893", "21天学Android");// 向集合中添加对象
		map.put("ISBN-978756", "21天学Java");// 向集合中添加对象
		Set<String> set = map.keySet(); // 构建Map集合中所有key对象的集合
		Iterator<String> it = set.iterator(); // 创建集合迭代器
		System.out.println("key值：");//输出key值：
		while (it.hasNext()) { // 遍历集合
			System.out.print(it.next()+"\t");//输出it.next()+"\t"
		}
		Collection<String> coll = map.values(); // 构建Map集合中所有values值集合
		it = coll.iterator();
		System.out.println("\nvalues值：");//输出\nvalues值：
		while (it.hasNext()) { // 遍历集合
			System.out.print(it.next()+"\t");//输出it.next()+"\t"
		}
	}
}

结果

treemap.putAll(map)；                    //向集合添加对象

Iterator<string>iter=treemap.keyset().iterator()；  

while（iter.hasnext（））{                          //遍历treeMap集合对象

string str=（string）iter.next（）；           //获取集合中的所有key对象    

string name=（string）treemap.get（str）；      //获取集合中的所有values值

system.out.println(str+" "+name)；
 

10.6  集合的使用场合

前面介绍了java中最常见的3种集合: List集合、Set集合和Map集合，那么在实际开发中，具体何时应该选择哪种集合呢?这里我们总结了以下原则。

(1) List集合关注的是索引，其元素是顺序存放的，例如一个班的学生成绩，成绩可以重复，就可以使用List集合存取。

(2) Set集合关注唯一性，它的值不允许重复，例如每个班的学生的学号，每个学生的学号是不能重复的。

(3) Map集合关注的是唯一的标识符(KEY)，它将唯一的键映射到某个元素，例如每个班学生的学号与姓名的映射，每个学号对应一个学生的姓名，学号是不能重复的，但是学生的姓名有可能重

10.7  小结

本章主要讲解了Java中常见的集合，包括集合的父接口Collection、List 集合、Set 集合和Map集合。学习本章内容时，对于每种集合的特点应该有所了解，重点掌握遍历集合、添加对象、删除对象的方法。本章在介绍每种集合时都给出了典型的例子，以帮助读者掌握集合类的常用方法。集合是Java语言中很重要的部分，通过本章的学习，读者应该学会使用集合类。

1、Collection接口（单列集合）
Collection接口是单列集合的最顶层接口，定义了一些通用的方法。

add(E e)添加元素;  clear()清空元素;  remove(E e)移除元素;  size()元素数量;

toArray()集合转数组;  contains(E e)判断元素是否存在;  isEmpty()判断集合是否为空;

2、List 接口
特点：有索引，精准操作元素；

元素有序，存储及取出时顺序一致；

元素可重复，通过.equals()比较是否重复。

它利用索引(index)，定义了一些特殊方法：

get(int index,E e) 获取指定位置的元素；remove(int index)移除指定位置的元素; 

add(int index,E e) 将元素添加到指定位置；set(int index,E e) 用元素替换指定位置的元素；

3、ArrayList实现类

数据结构：数组； 

特点：查询快，增删慢，主要用于查询遍历数据，为最常用集合之一；

底层分析：数组结构是有序的元素序列，在内存中开辟一段连续的空间，在空间中存放元素，每个空间都有编号，通过编号可以快速找到相应元素，因此查询快；数组初始化时长度是固定的，要想增删元素，必须创建一个新数组，把源数组的元素复制进来，随后源数组销毁，耗时长，因此增删慢。

4、LinkedList实现类

数据结构：双向链表；

特点：查询慢，增删快；

底层分析：链表分为单向和双向，就是一条链子和两条链子的区别；多出的那条链子记录了元素的顺序，因此单向链表结构无序，双向链表结构有序；链表结构没有索引，因此查询慢；链表的增删只需在原有的基础上连上链子或切断链子，因此增删快。

特有方法：getFirst()  返回开头元素；  getLast()  返回结尾元素；

pop() 从所在堆栈中获取一个元素；  push(E e)  将元素推入所在堆栈；

addFirst(E e)  添加元素到开头，头插； addLast(E e) 添加元素到结尾，尾插；

5、Vector实现类(基本不用)

数据结构：数组； 

特点：查询快，增删慢

底层分析：和ArrayList一样，都是数组实现，因此具有相似的特性，它们之间的区别在于Vector是线程安全的，效率低，ArrayList是线程不安全的，但效率高。

ps:Vector在JDK1.0就出现了，在JDK1.2集合出现的时候，Vector就归为List的实现类之一，这时候ArrayList才出现。Vector是一个古老的集合，《Java编程思想》中提到了它有一些遗留的缺点，因此不建议使用。

6、Set接口
特点：元素不可重复；

元素无序，存储及取出时顺序不一致；

没有索引，因此不能使用普通For循环遍历；

Set与Collection 接口中的方法基本一致，没有进行功能上的扩充；7、HashSet实现类

数据结构：JDK1.8之前：哈希表（数组+单向链表）；JDK1.8之后：哈希表（数组+单向链表+红黑树），当链表长度超过阈值（8）时，链表将转换为红黑树。

特点：查询快，元素无序，元素不可重复，没有索引；

底层分析：哈希表底层用数组+单向链表实现，即使用链表处理冲突，同一Hash值的元素都存储在一个链表里，但是当位于一个链表中的元素较多，即Hash值相等的元素较多，通过key值依次查找的效率降低。JDK1.8之后，哈希表底层采用数据+单向链表+红黑树实现，当链表长度超过阈值（8）时，链表将转换为红黑树，极大缩短查询时间。

ps：哈希值是一个十进制的整数，是对象的地址值，是一个逻辑地址，不是实际存储的物理地址，由系统随机给出。Object类的int hashCode()方法，可以获取对象的哈希值。

7、LinkedHashSet实现类

数据结构：JDK1.8之前：哈希表（数组+双向链表）；JDK1.8之后：哈希表（数组+双向链表+红黑树），当链表长度超过阈值（8）时，链表将转换为红黑树。

特点：查询快，元素有序，元素不可重复，没有索引；

底层分析：作为HashSet的子类，只是比它多了一条链表，这条链表用来记录元素顺序，因此LinkedHashSet其中的元素有序。

8、TreeSet实现类

数据结构：红黑树     

特点：查询快，元素有序，元素不可重复，没有索引；

底层分析：TreeSet实现了继承于Set接口的SortedSet接口 ，它支持两种排序方法，自然排序和定制排序，自然排序的意思就是放入元素“a”，“b”，a会自然地排在b前面，其中还有几个特有方法。

first() 返回第一个元素； last() 返回最后一个元素；comparator() 返回排序比较器；

9、Map接口（双列集合）
特点：元素包含两个值（key,value）即键值对， key不允许重复，value可以重复, key与value是一一对应的。元素无序；

Map接口是双列集合的最顶层接口，定义了一些通用的方法。

put(key , value) 添加元素； remove(key) 删除key对应元素；

containsKey(key) 判断是否存在key对应元素；get(key) 获取key对应元素；

KeySet() 获取所有的key，存到Set集合中；entrySet() 获取所有的元素，存到Set集合中；

ps：Map集合必须保证保证key唯一，作为key，必须重写hashCode方法和equals方法，以保证key唯一。

10、HashMap实现类
数据结构：JDK1.8之前：哈希表（数组+单向链表）；JDK1.8之后：哈希表（数组+单向链表+红黑树），当链表长度超过阈值（8）时，链表将转换为红黑树。

特点：查询快，元素无序，key不允许重复但可以为null，value可以重复。

底层分析：和HashSet底层相类似，不赘述。

11、LinkedHashMap实现类
数据结构：JDK1.8之前：哈希表（数组+双向链表）；JDK1.8之后：哈希表（数组+双向链表+红黑树），当链表长度超过阈值（8）时，链表将转换为红黑树。

特点：查询快，元素有序，key不允许重复但可以为null，value可以重复。

底层分析：和LinkedHashSet底层相类似，不赘述。

12、HashTable实现类（基本不用）
数据结构：哈希表

特点：查询快，元素无序，key不允许重复并且不可以为null，value可以重复。

底层分析：HashTable和Vector一样是古老的集合，有遗留缺陷，在JDK1.2之后 被更先进的集合取代了；HashTable是线程安全的，速度慢，HashMap是线程不安全的，速度快；

ps：Hashtable的子类Properties现在依然活跃，Properties集合是一个唯一和IO流结合的集合。

13、TreeMap实现类
数据结构：红黑树

特点：查询快，元素有序，key不允许重复并且不可以为null，value可以重复。

底层分析：和TreeSet底层相类似，不赘述。