首先给出结论，ArrayList，LinkedList，HashMap,StringBuilder是不安全的。vector,HashTable,StringBuffer是线程安全的。下面用代码来看看。

---

Java API中所用的集合类，都是实现了Collection接口，他的一个类继承结构如下： Collection<–List<–Vector Collection<–List<–ArrayList Collection<–List<–LinkedList Collection<–Set<–HashSet Collection<–Set<–HashSet<–LinkedHashSet Collection<–Set<–SortedSet<–TreeSet Vector : 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用，它不可能走入Array的限制。性能也就不可能超越Array。所以，在可能的情况下，我们要多运用Array。另外很重要的一点就是Vector“sychronized”的，这个也是Vector和ArrayList的唯一的区别。 ArrayList：同Vector一样是一个基于Array上的链表，但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些，但是当运行到多线程环境中时，可需要自己在管理线程的同步问题。 LinkedList：LinkedList不同于前面两种List，它不是基于Array的，所以不受Array性能的限制。它每一个节点（Node）都包含两方面的内容：1.节点本身的数据（data）；2.下一个节点的信息（nextNode）。所以当对LinkedList做添加，删除动作的时候就不用像基于Array的List一样，必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了。这就是LinkedList的优势。 List总结： 1. 所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]； 2. 所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]； 3. 所有的List中可以有null元素，例如[ tom,null,1 ]； 4. 基于Array的List（Vector，ArrayList）适合查询，而LinkedList（链表）适合添加，删除操作。 HashSet：虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的，这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。

---

1. ArrayList测试

package testThread;

import java.util.ArrayList;
import java.util.List;

class Ticket implements  Runnable {
    private static int t=0;
    List<Integer> data = new ArrayList<>();
    boolean flag=true;  
    public void run() { 
        while (flag) {
            if (t<100) {
                  data.add(t);
                  t++;
                  //System.out.println(t);
                    }else {                                             
                        flag=false;
                        System.out.println("数据宽度"+data.size());                                 
                        for (int i = 0; i < data.size(); i++) {
                            System.out.println(data.get(i));
                        }
                    }           
        }

    }   
}
public class thread1 {
     public static  void main(String[] args)
     {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);   
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();     
        t3.start();

     }
}


ArrayList测试结果 

  

2.LinkedList

package te;
import java.util.LinkedList;
import java.util.List;

class Ticket implements  Runnable {
    private static int t=0;
    List<Integer> data = new LinkedList<Integer>();
    boolean flag=true;  
    public void run() { 
        while (flag) {
            if (t<100) {
                  data.add(t);
                  t++;
                  //System.out.println(t);
                    }else {                                             
                        flag=false;
                        System.out.println("数据宽度"+data.size());                                 
                        for (int i = 0; i < data.size(); i++) {
                            System.out.println(data.get(i));
                        }
                    }           
        }

    }   
}
public class Thread7 {
     public static  void main(String[] args)
     {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);   
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();     
        t3.start();

     }
}


LinkedList结果 



3.HashMap



package te;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

class Ticket implements  Runnable {
    private static int t=0;
    Map data = new HashMap<Integer,Integer>();
    boolean flag=true;  
    public void run() { 
        while (flag) {
            if (t<100) {
                  data.put(t,t);
                  t++;
                  //System.out.println(t);
                    }else {                                             
                        flag=false;                                                         
                        Collection da=data.values();
                        Iterator<Integer> it=da.iterator();
                        while (it.hasNext()) {
                            Integer integer = (Integer) it.next();
                            System.err.println(integer);

                        }
                    }           
        }

    }   
}
public class Thread7 {
     public static  void main(String[] args)
     {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);   
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();     
        t3.start();

     }
}


HashMap测试 

 

4.vector

package te;
import java.util.Vector;

class Ticket implements  Runnable {
    private static int t=0;
    Vector<Integer> vector=new Vector<Integer>();
    boolean flag=true;  
    public void run() { 
        while (flag) {
            if (t<100) {
                  vector.add(t);
                  t++;            
                    }else {                                             
                        flag=false;                                                         
                        for(int i=0;i<vector.size();i++)
                        {
                            System.out.println(vector.get(i));
                        }
                    }           
        }

    }   
}
public class Thread7 {
     public static  void main(String[] args)
     {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);   
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();     
        t3.start();

     }
}


vector线程是安全的 

5.stringbuilder和stringbuffer



package te;

class Ticket implements  Runnable {
    private static int t=0;

     StringBuffer sb = new StringBuffer();  
     StringBuilder sc=new StringBuilder();
    boolean flag=true;  
     public void run() {    
        while (flag) {
            if (t<100) {
                  sb.append(t+"a ");
                  sc.append(t+"a ");
                  t++;            
                    }else {                                             
                        flag=false;                                                         
                        System.out.println("stringbuffer"+sb);
                        System.out.println("stringbuilder"+sc);
                    }           
        }

    }   
}
public class Thread7 {
     public static  void main(String[] args)
     {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);   
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();     
        t3.start();

     }
}


结果测试 stringbuilder是不安全的 



6.分析总结  

  凡是线程不安全的,我们可以来看源码来分析 ，这是arraylist的源码，我们很容易发现这是由于没有synchronized关键字。

 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
      

再来看看vector,有synchronized关键字。

 public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

先讲下什么是数据结构

        程序设计= 数据结构 + 算法

数据结构由以下构成:

1.  数      据：是描述客观事物的符号，是计算机可以操作的对象，是能被计算机识别，并输入给计算机处理的符号集合，数据不仅仅指我们通常所说的数值类型， 还包括字符及声音，图像，视频等非数值类型 。
2. 数 据  项：在数据结构中，我们把数据项定义为最小单位，是有助于我们更好的解决问题。
3. 数据元素：一个数据元素可以由若干个数据项组成，并且有一定意义的基本单位，在计算机中通常作为整体处理，也被成为记录。例如如人由眼，耳，手，鼻，口，脚，这些数据项 数据项是数据不可分割的最小单位，组成一个数据元素。数据元素才是我们在数据结构建立数据模型的着眼点。
4. 数据类型：在一种程序设计语言中，变量所具有的数据种类。整型、浮点型、字符型等等 ​​​​​​
5. 物理结构/存储结构：数据在计算机中的表示。物理结构是描述数据具体在内存中的存储（如：顺序结构、链式结构、索引结构、哈希结构等。
6. 逻辑结构：数据之间的相互关系。在数据结构中,从逻辑上可以将其分为线性结构和非线性结构

•  集合 结构中的数据元素除了同属于一种类型外，别无其它关系。
• 线性结构 数据元素之间一对一的关系
• 树形结构 数据元素之间一对多的关系
• 图状结构或网状结构 结构中的数据元素之间存在多对多的关系

总结：数据结构就是研究数据的逻辑结构和物理结构以及它们之间相互关系，并对这种结构定义相应的运算，而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。

算法的概念：

   算法：算法是计算机处理信息的本质，因为计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一个指定的任务。

   算法的五大特性

1. 输入: 算法具有0个或多个输入。
2. 输出: 算法至少有1个或多个输出。
3. 有穷性: 算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内完成。
4. 确定性：算法中的每一步都有确定的含义，不能出现歧义。
5. 可行性：算法的每一步都是可行的，也就是说每一步都能够执行有限的次数完成。

java中数据结构有什么用？

当你用着java里面的容器类很爽的时候，你有没有想过，怎么ArrayList就像一个无限扩充的数组，也好像链表之类的。好用吗？好用，这就是数据结构的用处，只不过你在不知不觉中使用了。

现实世界的存储，我们使用的工具和建模。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还能方便地查询到所需要的数据吗？而算法，在这么多的数据中如何做到最快的插入，查找，删除，也是在追求更快。

 

我们java是面向对象的语言，就好似自动档轿车，C语言好似手动档吉普。数据结构呢？是变速箱的工作原理。你完全可以不知道变速箱怎样工作，就把自动档的车子从 A点 开到 B点，而且未必就比懂得的人慢。写程序这件事，和开车一样，经验可以起到很大作用，但如果你不知道底层是怎么工作的，就永远只能开车，既不会修车，也不能造车。当然了，数据结构内容比较多，细细的学起来也是相对费功夫的，不可能达到一蹴而就。我们将常见的数据结构：堆栈、队列、数组、链表和红黑树 这几种给大家介绍一下。

数据存储的常用结构有：栈、队列、数组、链表和红黑树。我们分别来了解一下：

栈

• 栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。简单的说：采用该结构的集合，对元素的存取有如下的特点
• 先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。
• 栈的入口、出口的都是栈的顶端位置。

                    

• 压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
• 弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

队列

• 队列：queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。

简单的说，采用该结构的集合，对元素的存取有如下的特点：

• 先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
• 队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。
• 

数组 

• 数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。

简单的说,采用该结构的集合，对元素的存取有如下的特点：

• 查找元素快：通过索引，可以快速访问指定位置的元素。

• 增删元素慢，指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图

• 指定索引位置删除元素：**需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图
•  

 

红黑树

 

• 二叉树**：binary tree ,是每个结点不超过2的有序树（tree） 。

简单的理解，就是一种类似于我们生活中树的结构，只不过每个结点上都最多只能有两个子结点。

二叉树是每个节点最多有两个子树的树结构。顶上的叫根结点，两边被称作“左子树”和“右子树”。

如图：

我们要说的是二叉树的一种比较有意思的叫做红黑树，红黑树本身就是一颗二叉查找树，将节点插入后，该树仍然是一颗二叉查找树。也就意味着，树的键值仍然是有序的。

红黑树的约束:

1. 节点可以是红色的或者黑色的

2. 根节点是黑色的

3. 叶子节点(特指空节点)是黑色的

4. 每个红色节点的子节点都是黑色的

5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同

红黑树的特点:

​ 速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍

 

好了开始说正事哈：

java集合体系：

单例集合 的体系：

---------| Collection 单例集合的根接口

------------------| List  如果是实现了List接口的集合类， 具备的特点：有序，重复。

-------------------------| ArraryList  底层 是使用了Object数组实现的，特点： 查询速度快，增删慢。

-------------------------| LinkedList 底层是使用了链表数据结构实现 的， 特点： 查询速度慢，增删快。

-------------------------| Vector Vector的实现与ArrayList是一致，但是是线程安全 的，操作效率低。 jdk1.0的时候出现的

------------------| Set  如果是实现了Set接口的集合类，具备的特点：无序，不可重复。

--------------------------| HashSet  底层是使用了一个哈希表支持的， 特点：存取速度快。

---------------------------------| LinkedHashSet 继承了HashSet  链表和哈希表组合的一个数据存储结构。 特点：有顺序的插入。

--------------------------| TreeSet  底层是使用了红黑树（二叉树）数据结构实现的， 特点：会对元素进行排序存储。（目前已经被淘汰了。）

 

双列集合：
-------------| Map  如果是实现了Map接口的集合类，具备的特点： 存储的数据都是以键值对的形式存在的，键不可重复，值可以重复。

----------------------| HashMap<K,V>：

--------------------------------| LinkedHashMap<K,V> ：继承HashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

----------------------| TreeMap

----------------------| Hashtable 

 

 

1.1 List接口介绍

java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了`List`接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

看完API，我们总结一下：

List接口特点：

1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。

2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。

3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

1.2 List接口中常用方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法，如下：

• public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。

• public E get(int index):返回集合中指定位置的元素。

• public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。

• public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

List集合特有的方法

public class ListDemo {
    public static void main(String[] args) {

         // 创建List集合对象
    	List<String> list = new ArrayList<String>();
    	
    	// 往 尾部添加 指定元素
    	list.add("图图");
    	list.add("小美");
    	list.add("不高兴");
    	
    	System.out.println(list);
    	// add(int index,String s) 往指定位置添加
    	list.add(1,"没头脑");
    	
    	System.out.println(list);
    	// String remove(int index) 删除指定位置元素  返回被删除元素
    	// 删除索引位置为2的元素 
    	System.out.println("删除索引位置为2的元素");
    	System.out.println(list.remove(2));
    	
    	System.out.println(list);
    	
    	// String set(int index,String s)
    	// 在指定位置 进行 元素替代（改） 
    	// 修改指定位置元素
    	list.set(0, "三毛");
    	System.out.println(list);
    	
    	// String get(int index)  获取指定位置元素
    	
    	// 跟size() 方法一起用  来 遍历的 
    	for(int i = 0;i<list.size();i++){
    		System.out.println(list.get(i));
    	}
    	//还可以使用增强for
    	for (String string : list) {
			System.out.println(string);
		}  	
	}
}

List的子类 

------------------- ArrayList集合

 java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

------------------- LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

LinkedList是一个双向链表，那么双向链表是什么样子的呢，我们用个图了解下

 

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：

• public void addFirst(E e):将指定元素插入此列表的开头。

• public void addLast(E e):将指定元素添加到此列表的结尾。

• public E getFirst():返回此列表的第一个元素。

• public E getLast():返回此列表的最后一个元素。

• public E removeFirst():移除并返回此列表的第一个元素。

• public E removeLast():移除并返回此列表的最后一个元素。

• public E pop():从此列表所表示的堆栈处弹出一个元素。

• public void push(E e):将元素推入此列表所表示的堆栈。

• public boolean isEmpty()：如果列表不包含元素，则返回true。

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        //添加元素
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        System.out.println(link);
        // 获取元素
        System.out.println(link.getFirst());
        System.out.println(link.getLast());
        // 删除元素
        System.out.println(link.removeFirst());
        System.out.println(link.removeLast());

        while (!link.isEmpty()) { //判断集合是否为空
            System.out.println(link.pop()); //弹出集合中的栈顶元素
        }

        System.out.println(link);
    }
}

Set接口 

java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。

tips:Set集合取出元素的方式可以采用：迭代器、增强for。

HashSet集合介绍 

java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持，由于我们暂时还未学习，先做了解。

HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。

我们先来使用一下Set集合存储，看下现象，再进行原理的讲解:

public class HashSetDemo {
    public static void main(String[] args) {
        //创建 Set集合
        HashSet<String>  set = new HashSet<String>();

        //添加元素
        set.add(new String("cba"));
        set.add("abc");
        set.add("bac"); 
        set.add("cba");  
        //遍历
        for (String name : set) {
            System.out.println(name);
        }
    }
}

输出结果如下，说明集合中不能存储重复元素： 

cba
abc
bac

tips:根据结果我们发现字符串"cba"只存储了一个，也就是说重复的元素set集合不存储。 

 

HashSet集合存储数据的结构（哈希表）

什么是哈希表呢？

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。

看到这张图就有人要问了，这个是怎么存储的呢？

为了方便大家的理解我们结合一个存储流程图来说明一下：

 总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

创建自定义Student类

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age &&
               Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class HashSetDemo2 {
    public static void main(String[] args) {
        //创建集合对象   该集合中存储 Student类型对象
        HashSet<Student> stuSet = new HashSet<Student>();
        //存储 
        Student stu = new Student("于谦", 43);
        stuSet.add(stu);
        stuSet.add(new Student("郭德纲", 44));
        stuSet.add(new Student("于谦", 43));
        stuSet.add(new Student("郭麒麟", 23));
        stuSet.add(stu);

        for (Student stu2 : stuSet) {
            System.out.println(stu2);
        }
    }
}
执行结果：
Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]

 LinkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类java.util.LinkedHashSet，它是

演示代码如下:

public class LinkedHashSetDemo {
	public static void main(String[] args) {
		Set<String> set = new LinkedHashSet<String>();
		set.add("bbb");
		set.add("aaa");
		set.add("abc");
		set.add("bbc");
        Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}
结果：
  bbb
  aaa
  abc
  bbc

 

TreeSet（目前已经被淘汰了）

------------------| TreeSet  底层是使用了红黑树（二叉树）数据结构实现的， 特点：会对元素进行排序存储。
TreeSet要注意的事项：
    1. 往TreeSet添加元素的时候，如果元素本身具备自然顺序的特性，那么会根据元素自然顺序的特性进行排序存储。
    2. 往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，那么元素所属的类必须要实现Comparable接口，把元素的比较规则定义
    在CompareTo方法上。
    3. 往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，而且元素所属的类没有实现COmparable接口，那么必须要在创建
    TreeSet对象的时候传入比较器。
    4. 如果比较的方法(CompareTo 或者Compare )返回的是0的时候，那么该元素就被视为重复元素，不允许添加。
    比较器的定义格式：  自定义一个类实现COmparator接口即可。    
        class 类名  implements Comparator{    
        }

 

泛型

泛型：泛型是jdk1.5出现的新特性。
泛型的好处：
    1. 将运行时出现 的问题提前至了编译时。
    2. 避免了无谓强制类型转换。
自定义泛型： 自定义泛型就是一个数据类型的占位符或者理解为一个数据类型的变量。    
泛型方法:
    修饰符  <声明自定义的泛型>返回值类型  函数名(自定义的泛型  变量名..)
泛型方法要注意的事项： 
    1. 泛型方法中 的自定义泛型的具体数据类型是在调用该函数的时候传入实参时确定的。
    2. 自定义泛型所用 的标识符只要符合标识符 的命名规则即可。但是我们一般都习惯使用一个大写字母表示。
泛型类：
    泛型类的定义格式    
        class 类名<声明自定义的泛型>{    
        }
泛型类要注意的事项：
    1. 泛型类上的自定义泛型是在使用该类创建对象的时候指定具体的数据类型的。
    2. 如果一个类已经自定义了泛型，使用该类创建对象的时候如果没有指定泛型的具体数据类型，那么默认为Object类型。
    3. 静态的函数不能使用类上自定义的泛型，如果静态函数需要使用，必须要在函数上自定义泛型。
泛型接口：
    泛型接口的定义格式：
        
        interface 接口名<声明自定义的泛型>{
        }
    
泛型接口要注意事项：
    1. 泛型接口上的自定义泛型是在实现该接口的时候指定具体数据类型的。
    2. 如果实现接口的时候没有指定接口上 的自定义泛型的具体数据类型，那么默认为Object数据类型。
    3. 如果需要在创建接口实现类对象的时候才指定接口上自定义泛型，那么需要以下格式：    class<T> 类名  implements  接口<T>

泛型上下限：
    ? super Integer   允许是Integer数据类型或者是Integer父类类型       泛型的下限
    ?  extedns Number  允许是Number数据类型或者是Number子类的数据类型   泛型的上限。

 

 

双列集合：

-------------| Map  如果是实现了Map接口的集合类，具备的特点： 存储的数据都是以键值对的形式存在的，键不可重复，值可以重复。

-------------------| HashMap 

-----------------------------| LinkedHashMap 

------------------| TreeMap

------------------| Hashtable 
 

 

Map接口中的常用方法

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。

• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。

• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。

• boolean containsKey(Object key) 判断集合中是否包含指定的键。

• public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。

• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

     
     添加：
         put(K key, V value) 
         putAll(Map<? extends K,? extends V> m) 
     
     删除
         remove(Object key) 
         clear() 

     获取：
         get(Object key) 
         size() 
     
     判断：
         containsKey(Object key) 
         containsValue(Object value) 
         isEmpty() 

Map接口的方法演示

public class MapDemo {
    public static void main(String[] args) {
        //创建 map对象
        HashMap<String, String>  map = new HashMap<String, String>();

        //添加元素到集合
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("邓超", "孙俪");
        System.out.println(map);

        //String remove(String key)
        System.out.println(map.remove("邓超"));
        System.out.println(map);

        // 想要查看 黄晓明的媳妇 是谁
        System.out.println(map.get("黄晓明"));
        System.out.println(map.get("邓超"));    
    }
}

 

tips:使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

Map集合遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()

2. 遍历键的Set集合，得到每一个键。

3. 根据键，获取键所对应的值。方法提示:get(K key)

代码演示：

public class MapDemo01 {
    public static void main(String[] args) {
        //创建Map集合对象 
        HashMap<String, String> map = new HashMap<String,String>();
        //添加元素到集合 
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");

        //获取所有的键  获取键集
        Set<String> keys = map.keySet();
        // 遍历键集 得到 每一个键
        for (String key : keys) {
          	//key  就是键
            //获取对应值
            String value = map.get(key);
            System.out.println(key+"的CP是："+value);
        }  
    }
}

遍历图解：

 

 

Entry键值对对象

我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

• public K getKey()：获取Entry对象中的键。

• public V getValue()：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法：

• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

Map集合遍历键值对方式

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。

2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。

3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()

4. public class MapDemo02 {
       public static void main(String[] args) {
           // 创建Map集合对象 
           HashMap<String, String> map = new HashMap<String,String>();
           // 添加元素到集合 
           map.put("胡歌", "霍建华");
           map.put("郭德纲", "于谦");
           map.put("薛之谦", "大张伟");
   
           // 获取 所有的 entry对象  entrySet
           Set<Entry<String,String>> entrySet = map.entrySet();
   
           // 遍历得到每一个entry对象
           for (Entry<String, String> entry : entrySet) {
              	// 解析 
               String key = entry.getKey();
               String value = entry.getValue();  
               System.out.println(key+"的CP是:"+value);
           }
       }
   }

   遍历图解：

tips：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

HashMap
  HashMap的存储原理：
    往HashMap添加元素的时候，首先会调用键的hashCode方法得到元素 的哈希码值，然后经过运算就可以算出该
    元素在哈希表中的存储位置。 
    情况1： 如果算出的位置目前没有任何元素存储，那么该元素可以直接添加到哈希表中。
    情况2：如果算出 的位置目前已经存在其他的元素，那么还会调用该元素的equals方法与这个位置上的元素进行比较
    ，如果equals方法返回 的是false，那么该元素允许被存储，如果equals方法返回的是true，那么该元素被视为
    重复元素，不允存储。

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

编写测试类： 

public class HashMapTest {
    public static void main(String[] args) {
        //1,创建Hashmap集合对象。
        Map<Student,String>map = new HashMap<Student,String>();
        //2,添加元素。
        map.put(newStudent("lisi",28), "上海");
        map.put(newStudent("wangwu",22), "北京");
        map.put(newStudent("zhaoliu",24), "成都");
        map.put(newStudent("zhouqi",25), "广州");
        map.put(newStudent("wangwu",22), "南京");
        
        //3,取出元素。键找值方式
        Set<Student>keySet = map.keySet();
        for(Student key: keySet){
            Stringvalue = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }
    }
}

 

• 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。

• 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("刘德华", "朱丽倩");
        Set<Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() + "  " + entry.getValue());
        }
    }
}

结果:

邓超  孙俪
李晨  范冰冰
刘德华  朱丽倩

 TreeMap（基本没人使用了）

TreeMap   TreeMap也是基于红黑树（二叉树）数据结构实现 的， 特点：会对元素的键进行排序存储。

TreeMap 要注意的事项：
    1.  往TreeMap添加元素的时候，如果元素的键具备自然顺序，那么就会按照键的自然顺序特性进行排序存储。
    2.  往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性， 那么键所属的类必须要实现Comparable接口，把键
    的比较规则定义在CompareTo方法上。
    
    3. 往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性，而且键所属的类也没有实现Comparable接口，那么就必须
    在创建TreeMap对象的时候传入比较器

 

常见面试题   HashMap 和 HashTable 有什么区别?

1. HashMap 是线程不安全的,HashMap 是一个接口,是 Map 的一个子接口,是将键映射到值得对象,不允许键值重复,允许空键和空值;由于非线程安全,HashMap 的效率要较 HashTable 的效率高一些.
2. HashTable 是线程安全的一个集合,不允许 null 值作为一个 key 值或者 Value 值;
3. HashTable 是 sychronize,多个线程访问时不需要自己为它的方法实现同步,而 HashMap 在被多个线程访问的时候需要自己为它的方法实现同步

 

最后再赋两张图

最后最后  ：写文章不易，未经本人许可，严禁转载！！！！！