集合

1. 集合概述

• 什么是集合？有什么用？

数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。

• 集合为什么说在开发中使用较多？

集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设连接数据库，数据库当中有10条记录，那么假设把这10条记录查询出来，在java程序中会将10条数据封装成10个java对象，然后将10个java对象放到某一个集合当中，将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。

• 集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，

集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）

注意：

集合在java中本身是一个容器，是一个对象。集合中任何时候存储的都是“引用”。

• 在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。

• 什么是数据结构？ 数据存储的结构就是数据结构。

• 不同的数据结构，数据存储方式不同。例如：

数组、二叉树、链表、哈希表...

以上这些都是常见的数据结构，你使用不同的集合等同于使用了不同的数据结构。

• 你在java集合这一章节，你需要掌握的不是精通数据结构。java中已经将数据结构实现了，已经写好了这些常用的集合类，你只需要掌握怎么用，在什么情况下选择哪一种合适的集合去使用即可。

new ArrayList(); 创建一个集合，底层是数组。

new LinkedList(); 创建一个集合对象，底层是链表。

new TreeSet(); 创建一个集合对象，底层是二叉树。

• 集合在java JDK中哪个包下？

java.util.*;

所有的集合类和集合接口都在java.util包下。

• 在java中集合分为两大类：

一类是单个方式存储元素：

单个方式存储元素，这一类集合中超级父接口：java.util.Collection;

一类是以键值对儿的方式存储元素

以键值对的方式存储元素，这一类集合中超级父接口：java.util.Map;

1.2 集合的继承关系结构图

要记清楚那些是类    那些是接口  

Collection接口的说明：

• 接口 Collection类 继承 父类 Iterable 类的 iteractor 方法

Iteractor t = Collection类型的对象.iteractor();      返回一个迭代器

通过这个返回的迭代器 遍历集合中所有的元素

List接口的特点：

有序指的是：存进去和取出来的顺序相同，并不是对大小排序。

set接口特点：

        存入和取出的顺序不同，但是取出的顺序是固定的

集合继承结构图_Map 部分

总结：

关于集合Collection中常用的方法

IDEA中紫色字体是一个 实例变量

java.util.Collection   集合接口
java.util.Collections  集合工具类，方便集合的操作。

java.util.Collection接口中常用的方法

1、Collection中能存放什么元素？
  没有使用“泛型”之前，Collection中可以存储Object的所有子类型。
   使用了“泛型”之后，Collection中只能存储某个具体的类型。
   集合后期我们会学习“泛型”语法。目前先不用管。Collection中什么都能存，只要是Object的子类型就行。（集合中不能直接存储基本数据类型，也不能存java对象，只是存储java对象的内存地址。）

2、Collection中的常用方法
   boolean add(Object e)       向集合中添加元素
   int size()         获取集合中元素的个数
   void clear()     清空集合
   boolean contains(Object o)   判断当前集合中是否包含元素o，包含返回true，不包含返回false
   boolean remove(Object o)    删除集合中的某个元素。
   boolean isEmpty()                判断该集合中元素的个数是否为0
   Object[] toArray()                  调用这个方法可以把集合转换成数组。【作为了解，使用不多。】

案例如下：

public class CollectionTest01 {

   public static void main(String[] args) {

       // 创建一个集合对象

       //Collection c = new Collection(); // 接口是抽象的，无法实例化。

       // 多态

       Collection c = new ArrayList();

       // 测试Collection接口中的常用方法

       c.add(1200); // 自动装箱(java5的新特性。),实际上是放进去了一个对象的内存地址。Integer x = new Integer(1200);

       c.add(3.14); // 自动装箱

       c.add(new Object());

       c.add(new Student());

       c.add(true); // 自动装箱

       // 获取集合中元素的个数

       System.out.println("集合中元素个数是：" + c.size()); // 5

       // 清空集合

       c.clear();

       System.out.println("集合中元素个数是：" + c.size()); // 0

       // 再向集合中添加元素

       c.add("hello"); // "hello"对象的内存地址放到了集合当中。

       c.add("world");

       c.add("浩克");

       c.add("绿巨人");

       c.add(1);

       // 判断集合中是否包含"绿巨人"

       boolean flag = c.contains("绿巨人");

       System.out.println(flag); // true

       boolean flag2 = c.contains("绿巨人2");

       System.out.println(flag2); // false

       System.out.println(c.contains(1)); // true

       System.out.println("集合中元素个数是：" + c.size()); // 5

       // 删除集合中某个元素

       c.remove(1);

       System.out.println("集合中元素个数是：" + c.size()); // 4

       // 判断集合是否为空（集合中是否存在元素）

       System.out.println(c.isEmpty()); // false

       // 清空

       c.clear();

       System.out.println(c.isEmpty()); // true（true表示集合中没有元素了！）

       c.add("abc");

       c.add("def");

       c.add(100);

       c.add("helloworld!");

       c.add(new Student());

       // 转换成数组（了解，使用不多。）

       Object[] objs = c.toArray();

       for(int i = 0; i < objs.length; i++){

           // 遍历数组

           Object o = objs[i];

           System.out.println(o);

       }

   }

}

class Student{

}

关于集合遍历/迭代专题。（重点：五颗星*****）

• 当获取当前对象的迭代器调用了next（），迭代器才指向集合的第一个元素。
• 若迭代器未指向元素就调用迭代器的remove方法就会报错。

public class CollectionTest02 {

   public static void main(String[] args) {

       // 注意：以下讲解的遍历方式/迭代方式，是所有Collection通用的一种方式。

       // 在Map集合中不能用。在所有的Collection以及子类中使用。

       // 创建集合对象

       Collection c = new ArrayList(); // 后面的集合无所谓，主要是看前面的Collection接口，怎么遍历/迭代。

       // 添加元素

       c.add("abc");

       c.add("def");

       c.add(100);

       c.add(new Object());

       // 对集合Collection进行遍历/迭代

       // 第一步：获取集合对象的迭代器对象Iterator

       Iterator it = c.iterator();

       // 第二步：通过以上获取的迭代器对象开始迭代/遍历集合。

       /*

           以下两个方法是迭代器对象Iterator中的方法：

               boolean hasNext()如果仍有元素可以迭代，则返回 true。

               Object next() 返回迭代的下一个元素。

        */

       while(it.hasNext()){

           Object obj = it.next();

           System.out.println(obj);

       }

       // 一直取，不判断，会出现异常：java.util.NoSuchElementException

       /*while(true){

           Object obj = it.next();

           System.out.println(obj);

       }*/

       /*boolean hasNext = it.hasNext();

       System.out.println(hasNext);

       if(hasNext) {

           // 不管你当初存进去什么，取出来统一都是Object。

           Object obj = it.next();

           System.out.println(obj);

       }

原理图：

迭代原理：迭代器是一个对象

集合先调用父类的iterator（）方法，将得到的值传值给Iterator类的引用，这个 it 引用就是迭代器

引用调用Iterator类中的hasnext（）方法，判断下一个元素是否存在，存在的话在调用next（）方法，指向集合的第一个元素，声明一个Object类型的引用，接收元素，从而完成集合的迭代。

所以hasnext（）方法 的返回值类型是布尔类型的，next是object

下面这个图不精确，集合中存储的是对象的内存地址，不是对象。箭头顺序从左到右明白原理即可

contains（）方法的深入

1. 
   

boolean contains(Object o)
   判断集合中是否包含某个对象o
   如果包含返回true， 如果不包含返回false。

contains方法是用来判断集合中是否包含某个元素的方法，那么它在底层是怎么判断集合中是否包含某个元素的呢？
       调用了equals方法进行比对。
       equals方法返回true，就表示包含这个元素。

public class CollectionTest04 {

   public static void main(String[] args) {

       // 创建集合对象

       Collection c = new ArrayList();

       // 向集合中存储元素

       String s1 = new String("abc"); // s1 = 0x1111

       c.add(s1); // 放进去了一个"abc"

       String s2 = new String("def"); // s2 = 0x2222

       c.add(s2);

       // 集合中元素的个数

       System.out.println("元素的个数是：" + c.size()); // 2

       // 新建的对象String

       String x = new String("abc"); // x = 0x5555

       // c集合中是否包含x？结果猜测一下是true还是false？

       System.out.println(c.contains(x)); //判断集合中是否存在"abc" true

   }

}

2. 测试contains方法
   结论：存放在一个集合中的类型，一定要重写equals方法。

案例如下：

public class CollectionTest05 {

   public static void main(String[] args) {

       // 创建集合对象

       Collection c = new ArrayList();

       // 创建用户对象

       User u1 = new User("jack");

       // 加入集合

       c.add(u1);

       // 判断集合中是否包含u2

       User u2 = new User("jack");

       // 没有重写equals之前：这个结果是false

       //System.out.println(c.contains(u2)); // false

       // 重写equals方法之后，比较的时候会比较name。

       System.out.println(c.contains(u2)); // true

       c.remove(u2);

       System.out.println(c.size()); // 0

       /*Integer x = new Integer(10000);

       c.add(x);

       Integer y = new Integer(10000);

       System.out.println(c.contains(y)); // true*/

       // 创建集合对象

       Collection cc = new ArrayList();

       // 创建字符串对象

       String s1 = new String("hello");

       // 加进去。

       cc.add(s1);

       // 创建了一个新的字符串对象

       String s2 = new String("hello");

       // 删除s2

       cc.remove(s2); // s1.equals(s2) java认为s1和s2是一样的。删除s2就是删除s1。

       // 集合中元素个数是？

       System.out.println(cc.size()); // 0

   }

}

class User{

   private String name;

   public User(){}

   public User(String name){

       this.name = name;

   }

   // 重写equals方法

   // 将来调用equals方法的时候，一定是调用这个重写的equals方法。

   // 这个equals方法的比较原理是：只要姓名一样就表示同一个用户。

   public boolean equals(Object o) {

       if(o == null || !(o instanceof User)) return false;

       if(o == this) return true;

       User u = (User)o;

       // 如果名字一样表示同一个人。（不再比较对象的内存地址了。比较内容。）

       return u.name.equals(this.name);

   }

}

remove方法的深入

关于集合元素的remove
   重点：当集合的结构发生改变时，迭代器必须重新获取，如果还是用以前老的迭代器，会出现异常：      java.util.ConcurrentModificationException

   重点：在迭代集合元素的过程中，不能调用集合对象的remove方法，删除元素：
       c.remove(o); 迭代过程中不能这样。会出现：java.util.ConcurrentModificationException

   重点：在迭代元素的过程当中，一定要使用迭代器Iterator的remove方法，删除元素，不要使用集合自带的remove方法删除元素。删除的一定是迭代器指向的当前元素。

迭代器remove（）方法的底层：

• while 循环调用了 hasnext（）方法，判断是否有下一个元素，有就删除，没有就退while循环。
• 如果底层集合在迭代过程中以任何方式进行修改而不是通过调用此方法，则迭代器的行为是未指定的。

it.remove();

删除的一定是迭代器指向的当前元素。

以上代码错误的原因：

迭代器删除元素的原理：迭代器指向一个元素，然后调用hasnext（）方法，判断后面元素是否存在，存在元素，删除当前迭代器指向的元素，如果返回false，程序结束。

这里迭代器还未指向任何元素，所以报错。

改进方法：

你要先it.next()，然后用迭代器的remove删除元素，输出的是迭代器删除的集合的元素

删除的是迭代器当前指向的元素，重新获取迭代器（迭代器的remove删除元素后，会自动获取迭代器）

案例如下：

public class CollectionTest06 {

   public static void main(String[] args) {

       // 创建集合

       Collection c = new ArrayList();

       // 注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器。

       // 一定要注意：集合结构只要发生改变，迭代器必须重新获取。

       // 当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时：java.util.ConcurrentModificationException

       Iterator it = c.iterator();

       // 添加元素

       c.add(1); // Integer类型

       c.add(2);

       c.add(3);

       // 获取迭代器

       //Iterator it = c.iterator();

       /*while(it.hasNext()){

           // 编写代码时next()方法返回值类型必须是Object。

           // Integer i = it.next();

           Object obj = it.next();

           System.out.println(obj);

       }*/

       Collection c2 = new ArrayList();

       c2.add("abc");

       c2.add("def");

       c2.add("xyz");

       Iterator it2 = c2.iterator();

       while(it2.hasNext()){

           Object o = it2.next();

           // 删除元素

           // 删除元素之后，集合的结构发生了变化，应该重新去获取迭代器

           // 但是，循环下一次的时候并没有重新获取迭代器，所以会出现异常：java.util.ConcurrentModificationException

           // 出异常根本原因是：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化了）

           //c2.remove(o); // 直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不同。）

           // 使用迭代器来删除可以吗？

           // 迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）。

           it2.remove(); // 删除的一定是迭代器指向的当前元素。

           System.out.println(o);

       }

       System.out.println(c2.size()); //0

   }

}

day29天

1. 计算机英语：
      增删改查这几个单词要知道：
          增：add、save、new
          删：delete、drop、remove
          改：update、set、modify
          查：find、get、query、select

2. 数组的末尾添加元素增删效率高？

因为数组的查询效率较高，如果数组的容量未满，可以指定一个下标，将元素传递进去，效率较高。

如果数组容量满了，在末尾添加元素效率就低了，因为要先扩容。

List接口中常用的方法

1、List集合存储元素特点：有序可重复
    有序：List集合中的元素有下标。从0开始，以1递增。
    可重复：存储一个1，还可以再存储1.

2、List既然是Collection接口的子接口，那么肯定List接口有自己“特色”的方法：
   以下只列出List接口特有的常用的方法：
       void add(int index, Object elem

ent)

       Object set(int index, Object element)

       Object get(int index)

       int indexOf(Object o)

       int lastIndexOf(Object o)

       Object remove(int index)

   以上几个方法不需要死记硬背，可以自己编写代码测试一下，理解一下，以后开发的时候，还是要翻阅帮助文档。

3. 常用的方法的测试：

public class ListTest01 {

   public static void main(String[] args) {

       // 创建List类型的集合。

       //List myList = new LinkedList();

       //List myList = new Vector();

       List myList = new ArrayList();

       // 添加元素

       myList.add("A"); // 默认都是向集合末尾添加元素。

       myList.add("B");

       myList.add("C");

       myList.add("C");

       myList.add("D");

       //在列表的指定位置插入指定元素（第一个参数是下标）

       // 这个方法使用不多，因为对于ArrayList集合来说效率比较低。

       myList.add(1, "KING");

       // 迭代

       Iterator it = myList.iterator();

       while(it.hasNext()){

           Object elt = it.next();

           System.out.println(elt);

       }

       // 根据下标获取元素

       Object firstObj = myList.get(0);

       System.out.println(firstObj);

       // 因为有下标，所以List集合有自己比较特殊的遍历方式

       // 通过下标遍历。【List集合特有的方式，Set没有。】

       for(int i = 0; i < myList.size(); i++){

           Object obj = myList.get(i);

           System.out.println(obj);

       }

       // 获取指定对象第一次出现处的索引。

       System.out.println(myList.indexOf("C")); // 3

       // 获取指定对象最后一次出现处的索引。

       System.out.println(myList.lastIndexOf("C")); // 4

       // 删除指定下标位置的元素

       // 删除下标为0的元素

       myList.remove(0);

       System.out.println(myList.size()); // 5

       System.out.println("====================================");

       // 修改指定位置的元素

       myList.set(2, "Soft");

       // 遍历集合

       for(int i = 0; i < myList.size(); i++){

           Object obj = myList.get(i);

           System.out.println(obj);

       }

   }

}

ArrayList集合

   1、默认初始化容量10（底层先创建了一个长度为0的数组，当添加第一个元素的时候，初始化容量10。）

   2、集合底层是一个Object[]数组。

   3、构造方法：
       new ArrayList();
       new ArrayList(20);

   4、ArrayList集合的扩容：
       增长到原容量的1.5倍。
       ArrayList集合底层是数组，怎么优化？
           尽可能少的扩容。因为数组扩容效率比较低，建议在使用ArrayList集合的时候预估计元素的个数，给定一个初始化容量。

   5、数组优点：
       检索效率比较高。（每个元素占用空间大小相同，内存地址是连续的，知道首元素内存地址，
       然后知道下标，通过数学表达式计算出元素的内存地址，所以检索效率最高。）

   6、数组缺点：
      随机增删元素效率比较低。
       另外数组无法存储大数据量。（很难找到一块非常巨大的连续的内存空间。）

   7、向数组末尾添加元素，效率很高，不受影响。

   8、面试官经常问的一个问题？
       这么多的集合中，你用哪个集合最多？
           答：ArrayList集合，因为往数组末尾添加元素，效率不受影响。另外，我们检索/查找某个元素的操作比较多。

   9、ArrayList集合是非线程安全的。（不是线程安全的集合。）

案例如下：

public class ArrayListTest01 {

   public static void main(String[] args) {

       // 默认初始化容量是10

       // 数组的长度是10

       List list1 = new ArrayList();

       // 集合的size()方法是获取当前集合中元素的个数。不是获取集合的容量。

       System.out.println(list1.size()); // 0

       // 指定初始化容量

       // 数组的长度是20

       List list2 = new ArrayList(20);

       // 集合的size()方法是获取当前集合中元素的个数。不是获取集合的容量。

       System.out.println(list2.size()); // 0

       list1.add(1);

       list1.add(2);

       list1.add(3);

       list1.add(4);

       list1.add(5);

       list1.add(6);

       list1.add(7);

       list1.add(8);

       list1.add(9);

       list1.add(10);

       System.out.println(list1.size());

       // 再加一个元素

       list1.add(11);

       System.out.println(list1.size()); // 11个元素。

       /*

       int newCapacity = ArraysSupport.newLength(oldCapacity,minCapacity - oldCapacity,oldCapacity >> 1);

        */

       // 100 二进制转换成10进制： 00000100右移一位 00000010 （2）  【4 / 2】

       // 原先是4、现在增长：2，增长之后是6，增长之后的容量是之前容量的：1.5倍。

       // 6是4的1.5倍

   }

}

集合ArrayList的构造方法

案例如下：

public class ArrayListTest02 {

   public static void main(String[] args) {

       // 默认初始化容量10

       List myList1 = new ArrayList();

       // 指定初始化容量100

       List myList2 = new ArrayList(100);

       // 创建一个HashSet集合

       Collection c = new HashSet();

       // 添加元素到Set集合

       c.add(100);

       c.add(200);

       c.add(900);

       c.add(50);

通过这个构造方法就可以将HashSet集合转换成List集合。

       List myList3 = new ArrayList(c);

       for(int i = 0; i < myList3.size(); i++){

           System.out.println(myList3.get(i));

       }

   }

}

位运算符

1. 位运算符  >>

2. 案例如下：

public class BinaryTest {

   public static void main(String[] args) {

       // 5

       // >> 1 二进制右移1位。

       // >> 2 二进制右移2位。 就是除以两个二

       // 10的二进制位是：00001010  【10】

       // 10的二进制右移1位是：00000101  【5】

       System.out.println(10 >> 1); // 右移1位就是除以2

       // 二进制位左移1位

       // 10的二进制位是：00001010  【10】

       // 10的二进制左移1位：00010100 【20】

       System.out.println(10 << 1);

   }

}

LinkedList集合

链表

链表的优点：

由于链表上的元素在空间存储上内存地址不连续。所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高。 在以后的开发中，如果遇到随机增删集合中元素的业务比较多时，建议使用LinkedList。

链表的缺点：
   不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头节点开始遍历，直到找到为止。所以LinkedList集合检索/查找的效率较低。

  ArrayList：把检索发挥到极致。（末尾添加元素效率还是很高的。）
   LinkedList：把随机增删发挥到极致。
   加元素都是往末尾添加，所以ArrayList用的比LinkedList多。

2. 案例如下：

public class LinkedListTest01 {

   public static void main(String[] args) {

       // LinkedList集合底层也是有下标的。

       // 注意：ArrayList之所以检索效率比较高，不是单纯因为下标的原因。是因为底层数组发挥的作用。

       // LinkedList集合照样有下标，但是检索/查找某个元素的时候效率比较低，因为只能从头节点开始一个一个遍历。

       List list = new LinkedList();

       list.add("a");

       list.add("b");

       list.add("c");

       for(int i = 0; i <list.size(); i++){

           Object obj = list.get(i);

           System.out.println(obj);

       }

• LinkedList集合有初始化容量吗？

• 没有
• 最初这个链表中没有任何元素。first和last引用都是null

• 不管是 LinkedList 还是 ArrayList ，以后写代码时不需要关心具体是哪个集合，因为我们要面向接口编程，调用的方法都是接口中的方法。

  //List list2 = new ArrayList(); // 这样写表示底层你用了数组。

       List list2 = new LinkedList(); // 这样写表示底层你用了双向链表。

       // 以下这些方法你面向的都是接口编程。

       list2.add("123");

       list2.add("456");

       list2.add("789");

       for(int i = 0; i < list2.size(); i++){

           System.out.println(list2.get(i));

       }

   }

}

单向链表数据结构

linkedList集合

• 双向链表

• Linkedlist 内存图

vector集合

1. 底层也是一个数组，初始化容量：10

2. 怎么扩容的？
      扩容之后是原容量的2倍。
      10--> 20 --> 40 --> 80

3. ArrayList集合扩容特点：
     ArrayList集合扩容是原容量1.5倍。

4. Vector 中所有的方法都是线程同步的，都带有 synchronized 关键字，是线程安全的。效率比较低，使用较少了。

5. 怎么将一个线程不安全的ArrayList集合转换成线程安全的呢？
       使用集合工具类：  java.util.Collections;

6. 区别：
          java.util.Collection 是集合接口。
          java.util.Collections 是集合工具类。

7. 案例如下：

public class VectorTest {

   public static void main(String[] args) {

       // 创建一个Vector集合

       List vector = new Vector();

       //Vector vector = new Vector();

       // 添加元素

       // 默认容量10个。

       vector.add(1);

       vector.add(2);

       vector.add(3);

       vector.add(4);

       vector.add(5);

       vector.add(6);

       vector.add(7);

       vector.add(8);

       vector.add(9);

       vector.add(10);

       // 满了之后扩容（扩容之后的容量是20.）

       vector.add(11);

       Iterator it = vector.iterator();

       while(it.hasNext()){

           Object obj = it.next();

           System.out.println(obj);

       }

集合的工具类

java.util.Collection 集合接口
java.util.Collections 集合工具类，方便集合的操作

线程的转换

• 将非线程安全的变成线程安全的

// 这个可能以后要使用！！！！

       List myList = new ArrayList(); // 非线程安全的。

       // 变成线程安全的

       Collections.synchronizedList(myList); // 这里没有办法看效果，因为多线程没学，你记住先！

       // myList集合就是线程安全的了。

       myList.add("111");

       myList.add("222");

       myList.add("333");

   }

}

泛型

1. 基本概念

1、JDK5.0之后推出的新特性：泛型

2、泛型这种语法机制，只在程序编译阶段起作用，只是给编译器参考的。（运行阶段泛型没用！）

3、使用了泛型好处是什么？
   第一：集合中存储的元素类型统一了。
   第二：从集合中取出的元素类型是泛型指定的类型，不需要进行大量的“向下转型”！

4、泛型的缺点是什么？
   导致集合中存储的元素缺乏多样性！ 大多数业务中，集合中元素的类型还是统一的。所以这种泛型特性被大家所认可。

2. 案例：

public class GenericTest01 {

   public static void main(String[] args) {

       /*

       // 不使用泛型机制，分析程序存在缺点

       List myList = new ArrayList();

       // 准备对象

       Cat c = new Cat();

       Bird b = new Bird();

       // 将对象添加到集合当中

       myList.add(c);

       myList.add(b);

       // 遍历集合，取出每个Animal，让它move

       Iterator it = myList.iterator();

       while(it.hasNext()) {

           // 没有这个语法，通过迭代器取出的就是Object

           //Animal a = it.next();

           Object obj = it.next();

           //obj中没有move方法，无法调用，需要向下转型！

           if(obj instanceof Animal){

               Animal a = (Animal)obj;

               a.move();

           }

       }

        */

       // 使用JDK5之后的泛型机制

       // 使用泛型List<Animal>之后，表示List集合中只允许存储Animal类型的数据。

       // 用泛型来指定集合中存储的数据类型。

       List<Animal> myList = new ArrayList<Animal>();

       // 指定List集合中只能存储Animal，那么存储String就编译报错了。

       // 这样用了泛型之后，集合中元素的数据类型更加统一了。

       //myList.add("abc");

       Cat c = new Cat();

       Bird b = new Bird();

       myList.add(c);

       myList.add(b);

       // 获取迭代器

       // 这个表示迭代器迭代的是Animal类型。

       Iterator<Animal> it = myList.iterator();

       while(it.hasNext()){

           // 使用泛型之后，每一次迭代返回的数据都是Animal类型。

           //Animal a = it.next();

           // 这里不需要进行强制类型转换了。直接调用。

           //a.move();

           // 调用子类型特有的方法还是需要向下转换的！

           Animal a = it.next();

           if(a instanceof Cat) {

               Cat x = (Cat)a;

               x.catchMouse();

           }

           if(a instanceof Bird) {

               Bird y = (Bird)a;

               y.fly();

           }

       }

   }

}

class Animal {

   // 父类自带方法

   public void move(){

       System.out.println("动物在移动！");

   }

}

class Cat extends Animal {

   // 特有方法

   public void catchMouse(){

       System.out.println("猫抓老鼠！");

   }

}

class Bird extends Animal {

   // 特有方法

   public void fly(){

       System.out.println("鸟儿在飞翔！");

   }

}

钻石表达式

JDK8之后引入了：自动类型推断机制。（又称为钻石表达式）

public class GenericTest02 {

   public static void main(String[] args) {

       // ArrayList<这里的类型会自动推断>()，前提是JDK8之后才允许。

       // 自动类型推断，钻石表达式！

       List<Animal> myList = new ArrayList<>();

       myList.add(new Animal());

       myList.add(new Cat());

       myList.add(new Bird());

       // 遍历

       Iterator<Animal> it = myList.iterator();

       while(it.hasNext()){

           Animal a = it.next();

           a.move();

       }

       List<String> strList = new ArrayList<>();

       // 类型不匹配。

       //strList.add(new Cat());

       strList.add("http://www.126.com");

       strList.add("http://www.baidu.com");

       strList.add("http://www.bjpowernode.com");

       // 类型不匹配。

       //strList.add(123);

       //System.out.println(strList.size());

       // 遍历

       Iterator<String> it2 = strList.iterator();

       while(it2.hasNext()){

           // 如果没有使用泛型

           /*

           Object obj = it2.next();

           if(obj instanceof String){

               String ss = (String)obj;

               ss.substring(7);

           }

            */

           // 直接通过迭代器获取了String类型的数据

           String s = it2.next();

           // 直接调用String类的substring方法截取字符串。

           String newString = s.substring(7);

           System.out.println(newString);

       }

   }

}

自定义泛型

1. 自定义泛型可以吗？可以
      自定义泛型的时候，<> 尖括号中的是一个标识符，随便写。
      java源代码中经常出现的是：<E>和<T>
     E是Element单词首字母。
      T是Type单词首字母。

2. 案例如下：

public class GenericTest03<标识符随便写> {

   public void doSome(标识符随便写 o){

       System.out.println(o);

   }

   public static void main(String[] args) {

       // new对象的时候指定了泛型是：String类型

       GenericTest03<String> gt = new GenericTest03<>();

       // 类型不匹配

       //gt.doSome(100);

       gt.doSome("abc");

       // =============================================================

       GenericTest03<Integer> gt2 = new GenericTest03<>();

       gt2.doSome(100);

       // 类型不匹配

       //gt2.doSome("abc");

       MyIterator<String> mi = new MyIterator<>();

       String s1 = mi.get();

       MyIterator<Animal> mi2 = new MyIterator<>();

       Animal a = mi2.get();

       // 不用泛型就是Object类型。

       /*GenericTest03 gt3 = new GenericTest03();

       gt3.doSome(new Object());*/

   }

}

class MyIterator<T> {

   public T get(){

       return null;

   }

}

foreach

1. JDK5.0之后推出了一个新特性：叫做增强for循环，或者叫做foreach

2. 自己对forerch的一个理解：

语法：for（集合的数据类型  任意变量名称 ：集合的名称）

3. 案例如下

public class ForEachTest01 {

   public static void main(String[] args) {

       // int类型数组

       int[] arr = {432,4,65,46,54,76,54};

       // 遍历数组（普通for循环）

       for(int i = 0; i < arr.length; i++) {

           System.out.println(arr[i]);

       }

       // 增强for（foreach）

       // 以下是语法

       /*for(元素类型 变量名 : 数组或集合){

           System.out.println(变量名);

       }*/

       System.out.println("======================================");

       // foreach有一个缺点：没有下标。在需要使用下标的循环中，不建议使用增强for循环。

       for(int data : arr) {

           // data就是数组中的元素（数组中的每一个元素。）

           System.out.println(data);

       }

   }

}

3. 集合使用foreach

案例如下：

public class ForEachTest02 {

   public static void main(String[] args) {

       // 创建List集合

       List<String> strList = new ArrayList<>();

       // 添加元素

       strList.add("hello");

       strList.add("world!");

       strList.add("kitty!");

       // 遍历，使用迭代器方式

       Iterator<String> it = strList.iterator();

       while(it.hasNext()){

           String s = it.next();

           System.out.println(s);

       }

       // 使用下标方式（只针对于有下标的集合）

       for(int i = 0; i < strList.size(); i++){

           System.out.println(strList.get(i));

       }

       // 使用foreach

       for(String s : strList){ // 因为泛型使用的是String类型，所以是：String s

           System.out.println(s);

       }

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

       list.add(100);

       list.add(200);

       list.add(300);

       for(Integer i : list){ // i代表集合中的元素

           System.out.println(i);

       }

   }

}

HashSet集合

HashSet集合：无序不可重复。

public class HashSetTest01 {

   public static void main(String[] args) {

       // 演示一下HashSet集合特点

       Set<String> strs = new HashSet<>();

       // 添加元素

       strs.add("hello3");

       strs.add("hello4");

       strs.add("hello1");

       strs.add("hello2");

       strs.add("hello3");

       strs.add("hello3");

       strs.add("hello3");

       strs.add("hello3");

       // 遍历

       /*

       hello1

       hello4

       hello2

       hello3

       1、存储时顺序和取出的顺序不同。

       2、不可重复。

       3、放到HashSet集合中的元素实际上是放到HashMap集合的key部分了。

        */

       for(String s : strs){

           System.out.println(s);

       }

   }

}

TreeSet集合

1. TreeSet集合存储元素特点：
      1、无序不可重复的，但是存储的元素可以自动按照大小顺序排序！
      称为：可排序集合。
   
      2、无序：这里的无序指的是存进去的顺序和取出来的顺序不同。并且没有下标。

   3、案例如下：

public class TreeSetTest01 {

   public static void main(String[] args) {

       // 创建集合对象

       Set<String> strs = new TreeSet<>();

       // 添加元素

       strs.add("A");

       strs.add("B");

       strs.add("Z");

       strs.add("Y");

       strs.add("Z");

       strs.add("K");

       strs.add("M");

       // 遍历

       /*

           A

           B

           K

           M

           Y

           Z

       从小到大自动排序！

        */

       for(String s : strs){

           System.out.println(s);

       }

   }

}

day30

总结：

老杜画的建议自己画一遍

Collection、Map集合的Uml图

📎集合结构图.pdf

Map集合

java.util.Map接口中常用的方法

1. 基本概念
      1、Map和Collection没有继承关系。

  2、Map集合以key和value的方式存储数据：键值对key和value都是引用数据类型。
       key和value都是存储对象的内存地址。
       key起到主导的地位，value是key的一个附属品。

2. Map接口中常用方法：

  V put(K key, V value)    向Map集合中添加键值对

      V get(Object key) 通过key获取value

       void clear()    清空Map集合

       boolean containsKey(Object key) 判断Map中是否包含某个key

       boolean containsValue(Object value) 判断Map中是否包含某个value

       boolean isEmpty()   判断Map集合中元素个数是否为0

       V remove(Object key) 通过key删除键值对

       int size() 获取Map集合中键值对的个数。

       Collection<V> values() 获取Map集合中所有的value，返回一个Collection

      Set<K> keySet() 获取Map集合所有的key（所有的键是一个set集合）

       Set<Map.Entry<K,V>>         entrySet()
           将Map集合转换成Set集合
           假设现在有一个Map集合，如下所示：
               map1集合对象
               key             value
               ----------------------------
               1               zhangsan
               2               lisi
               3               wangwu
               4               zhaoliu

               Set set = map1.entrySet();
               set集合对象
               1=zhangsan 【注意：Map集合通过entrySet()方法转换成的这个Set集合，Set集合中元素的类型是 Map.Entry<K,V>】
               2=lisi     【Map.Entry和String一样，都是一种类型的名字，只不过：Map.Entry是静态内部类，是Map中的静态内部类】
               3=wangwu
               4=zhaoliu ---> 这个东西是个什么？Map.Entry

案例如下：

public class MapTest01 {

   public static void main(String[] args) {

       // 创建Map集合对象

       Map<Integer, String> map = new HashMap<>();

       // 向Map集合中添加键值对

       map.put(1, "zhangsan"); // 1在这里进行了自动装箱。

       map.put(2, "lisi");

       map.put(3, "wangwu");

       map.put(4, "zhaoliu");

       // 通过key获取value

       String value = map.get(2);

       System.out.println(value);

       // 获取键值对的数量

       System.out.println("键值对的数量：" + map.size());

       // 通过key删除key-value

       map.remove(2);

       System.out.println("键值对的数量：" + map.size());

       // 判断是否包含某个key

       // contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法。

       System.out.println(map.containsKey(new Integer(4))); // true

       // 判断是否包含某个value

       System.out.println(map.containsValue(new String("wangwu"))); // true

       // 获取所有的value

       Collection<String> values = map.values();

       // foreach

       for(String s : values){

           System.out.println(s);

       }

       // 清空map集合

       map.clear();

       System.out.println("键值对的数量：" + map.size());

       // 判断是否为空

       System.out.println(map.isEmpty()); // true

   }

}

Map集合的遍历 【非常重要】

public class MapTest02 {

   public static void main(String[] args) {

       // 第一种方式：获取所有的key，通过遍历key，来遍历value

       Map<Integer, String> map = new HashMap<>();

       map.put(1, "zhangsan");

       map.put(2, "lisi");

       map.put(3, "wangwu");

       map.put(4, "zhaoliu");

       // 遍历Map集合

       // 获取所有的key，所有的key是一个Set集合

       Set<Integer> keys = map.keySet();

       // 遍历key，通过key获取value

       // 迭代器可以

       /*Iterator<Integer> it = keys.iterator();

       while(it.hasNext()){

           // 取出其中一个key

           Integer key = it.next();

           // 通过key获取value

           String value = map.get(key);

           System.out.println(key + "=" + value);

       }*/

       // foreach也可以

       for(Integer key : keys){

           System.out.println(key + "=" + map.get(key));

       }

Map.Entry<K,V>

Map.Entry<K,V> 这是一个接口

看源码 里面有 getkey方法、getVaule方法

第二种遍历方式：

Set<Map.Entry<K,V>>      entrySet()    

• 以上这个方法是把Map集合直接全部转换成Set集合

• Set集合中元素的类型是：Map.Entry

       Set<Map.Entry<Integer,String>> set = map.entrySet();

       // 遍历Set集合，每一次取出一个Node

       // 迭代器

       /*Iterator<Map.Entry<Integer,String>> it2 = set.iterator();

       while(it2.hasNext()){

           Map.Entry<Integer,String> node = it2.next();

           Integer key = node.getKey();

           String value = node.getValue();

           System.out.println(key + "=" + value);

       }*/

       // foreach

       // 这种方式效率比较高，因为获取key和value都是直接从node对象中获取的属性值。

       // 这种方式比较适合于大数据量。

       for(Map.Entry<Integer,String> node : set){

           System.out.println(node.getKey() + "--->" + node.getValue());

       }

   }

}

HashMap集合

哈希表（散列结构图）

HashMap基本概念

1、HashMap 集合底层是 哈希表/散列表的数据结构。

2、哈希表是一个怎样的数据结构呢？
    哈希表是一个数组和单向链表的结合体。
    数组：在查询方面效率很高，随机增删方面效率很低。
    单向链表：在随机增删方面效率较高，在查询方面效率很低。
    哈希表将以上的两种数据结构融合在一起，充分发挥它们各自的优点。

3、HashMap集合底层的源代码：
   

public class HashMap{

       // HashMap底层实际上就是一个数组。（一维数组）

       Node<K,V>[] table;

       // 静态的内部类HashMap.Node

       static class Node<K,V> {

           final int hash; // 哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组的下标。）

           final K key; // 存储到Map集合中的那个key

           V value; // 存储到Map集合中的那个value

           Node<K,V> next; // 下一个节点的内存地址。

       }

   }

   哈希表/散列表：一维数组，这个数组中每一个元素是一个单向链表。（数组和链表的结合体。）

4、最主要掌握的是：
   map.put(k,v)
   v = map.get(k)
   以上这两个方法的实现原理，是必须掌握的。

5、HashMap集合的key部分特点：
   无序，不可重复。
   为什么无序？ 因为不一定挂到哪个单向链表上。
   不可重复是怎么保证的？ equals方法来保证HashMap集合的key不可重复。
   如果key重复了，value会覆盖。

   放在HashMap集合key部分的元素其实就是放到HashSet集合中了。
   所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。

6、哈希表HashMap使用不当时无法发挥性能！

   假设将所有的hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了纯单向链表。这种情况我们成为：散列分布不均匀

   什么是散列分布均匀？
       假设有100个元素，10个单向链表，那么每个单向链表上有10个节点，这是最好的， 是散列分布均匀的

   假设将所有的hashCode()方法返回值都设定为不一样的值，可以吗，有什么问题？
       不行，因为这样的话导致底层哈希表就成为一维数组了，没有链表的概念了。
       也是散列分布不均匀。
    散列分布均匀需要你重写hashCode()方法时有一定的技巧。

7、重点：放在HashMap集合key部分的元素，以及放在HashSet集合中的元素，需要同时重写hashCode和equals方法。

8、HashMap集合的默认初始化容量是16，默认加载因子是0.75
   这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组开始扩容。

   重点（记住）：HashMap集合初始化容量必须是2的倍数，这也是官方推荐的， 这是因为达到散列均匀，为了提高HashMap集合的存取效率，所必须的。

public class HashMapTest01 {

   public static void main(String[] args) {

       // 测试HashMap集合key部分的元素特点

       // Integer是key，它的hashCode和equals都重写了。

       Map<Integer,String> map = new HashMap<>();

       map.put(1111, "zhangsan");

       map.put(6666, "lisi");

       map.put(7777, "wangwu");

       map.put(2222, "zhaoliu");

       map.put(2222, "king"); //key重复的时候value会自动覆盖。

       System.out.println(map.size()); // 4

       // 遍历Map集合

       Set<Map.Entry<Integer,String>> set = map.entrySet();

       for(Map.Entry<Integer,String> entry : set){

           // 验证结果：HashMap集合key部分元素：无序不可重复。

           System.out.println(entry.getKey() + "=" + entry.getValue());

       }

   }

}

HashCode与equals

1、向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法！
equals方法有可能调用，也有可能不调用。

   拿put(k,v)举例，什么时候equals不会调用？
       k.hashCode()方法返回哈希值，哈希值经过哈希算法转换成数组下标。
       数组下标位置上如果是null，equals不需要执行。

   拿get(k)举例，什么时候equals不会调用？
       k.hashCode()方法返回哈希值，哈希值经过哈希算法转换成数组下标。
       数组下标位置上如果是null，equals不需要执行。

2、注意：如果一个类的equals方法重写了，那么hashCode()方法必须重写。并且equals方法返回如果是true，hashCode()方法返回的值必须一样。

   equals方法返回true表示两个对象相同，在同一个单向链表上比较。 那么对于同一个单向链表上的节点来说，他们的哈希值都是相同的。所以hashCode()方法的返回值也应该相同。

3、hashCode()方法和equals()方法不用研究了，直接使用IDEA工具生成，但是这两个方法需要同时生成。

4、终极结论：
   放在HashMap集合key部分的，以及放在HashSet集合中的元素，需要同时重写hashCode方法和equals方法。

5、对于哈希表数据结构来说：
   如果o1和o2的hash值相同，一定是放到同一个单向链表上。
   当然如果o1和o2的hash值不同，但由于哈希算法执行结束之后转换的数组下标可能相同，此时会发生“哈希碰撞”。

public class HashMapTest02 {

   public static void main(String[] args) {

       Student s1 = new Student("zhangsan");

       Student s2 = new Student("zhangsan");

       // 重写equals方法之前是false

       //System.out.println(s1.equals(s2)); // false

       // 重写equals方法之后是true

       System.out.println(s1.equals(s2)); //true （s1和s2表示相等）

       System.out.println("s1的hashCode=" + s1.hashCode()); //284720968 (重写hashCode之后-1432604525)

       System.out.println("s2的hashCode=" + s2.hashCode()); //122883338 (重写hashCode之后-1432604525)

       // s1.equals(s2)结果已经是true了，表示s1和s2是一样的，相同的，那么往HashSet集合中放的话，

       // 按说只能放进去1个。（HashSet集合特点：无序不可重复）

       Set<Student> students = new HashSet<>();

       students.add(s1);

       students.add(s2);

       System.out.println(students.size()); // 这个结果按说应该是1. 但是结果是2.显然不符合HashSet集合存储特点。怎么办？

   }

}

HashMap面试题目

HashMap集合key部分允许null吗？
    允许， 但是要注意：HashMap集合的key null值只能有一个。有可能面试的时候遇到这样的问题。

Hashtable

基本概念

Hashtable的key可以为null吗？
  Hashtable的key和value都是不能为null的。
  HashMap集合的key和value都是可以为null的。

  Hashtable方法都带有 synchronized ：线程安全的。

线程安全有其它的方案，这个Hashtable对线程的处理导致效率较低，使用较少了。

Hashtable和HashMap一样，底层都是哈希表数据结构。
Hashtable的初始化容量是11，默认加载因子是：0.75f
Hashtable的扩容是：原容量 * 2 + 1

public class HashtableTest01 {

   public static void main(String[] args) {

       Map map = new Hashtable();

       //map.put(null, "123");

       map.put(100, null);

   }

}

Properties

开发的时候点 看Properties中特有的方法

public class PropertiesTest {

   public static void main(String[] args) {

       // 创建对象

       Properties pro = new Properties();

       // 存

       pro.setProperty("username", "test");

       pro.setProperty("password", "test123");

       // 取

       String username = pro.getProperty("username");

       String password = pro.getProperty("password");

       System.out.println(username);

       System.out.println(password);

   }

}

TreeMap（TreeSet）

1. 基本概念

1、TreeSet集合底层实际上是一个TreeMap
2、TreeMap集合底层是一个二叉树。
3、放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了。
4、TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序。称为：可排序集合。

可排序集合

public class TreeSetTest02 {

   public static void main(String[] args) {

       // 创建一个TreeSet集合

       TreeSet<String> ts = new TreeSet<>();

       // 添加String

       ts.add("zhangsan");

       ts.add("lisi");

       ts.add("wangwu");

       ts.add("zhangsi");

       ts.add("wangliu");

       // 遍历

       for(String s : ts){

           // 按照字典顺序，升序！

           System.out.println(s);

       }

       TreeSet<Integer> ts2 = new TreeSet<>();

       ts2.add(100);

       ts2.add(200);

       ts2.add(900);

       ts2.add(800);

       ts2.add(600);

       ts2.add(10);

       for(Integer elt : ts2){

           // 升序！

           System.out.println(elt);

       }

   }

}

/*

数据库中有很多数据：

   userid  name     birth

   -------------------------------------

   1       zs          1980-11-11

   2       ls          1980-10-11

   3       ww          1981-11-11

   4       zl          1979-11-11

   编写程序从数据库当中取出数据，在页面展示用户信息的时候按照生日升序或者降序。

   这个时候可以使用TreeSet集合，因为TreeSet集合放进去，拿出来就是有顺序的。

*/

1. 对自定义的类型来说，TreeSet可以排序吗？
      以下程序中对于Person类型来说，无法排序。因为没有指定Person对象之间的比较规则。 谁大谁小并没有说明啊。
   
      以下程序运行的时候出现了这个异常：
           java.lang.ClassCastException:
                 class com.bjpowernode.javase.collection.Person
                 cannot be cast to class java.lang.Comparable

    出现这个异常的原因是：
      Person类没有实现java.lang.Comparable接口。

public class TreeSetTest03 {

   public static void main(String[] args) {

       Person p1 = new Person(32);

       //System.out.println(p1);

       Person p2 = new Person(20);

       Person p3 = new Person(30);

       Person p4 = new Person(25);

       // 创建TreeSet集合

       TreeSet<Person> persons = new TreeSet<>();

       // 添加元素

       persons.add(p1);

       persons.add(p2);

       persons.add(p3);

       persons.add(p4);

       // 遍历

       for (Person p : persons){

           System.out.println(p);

       }

   }

}

class Person {

   int age;

   public Person(int age){

       this.age = age;

   }

   // 重写toString()方法

   public String toString(){

       return "Person[age="+age+"]";

   }

}

对自定义的集合进行comparaTo（）方法重写

1. compareTo方法的返回值很重要：

返回0表示相同，value会覆盖。

返回>0，会继续在右子树上找。【10 - 9 = 1 ，1 > 0的说明左边这个数字比较大。所以在右子树上找。】

返回<0，会继续在左子树上找。

2.案例：

import java.util.TreeSet;

public class TreeSetTest04 {

   public static void main(String[] args) {

       Customer c1 = new Customer(32);

       Customer c2 = new Customer(20);

       Customer c3 = new Customer(30);

       Customer c4 = new Customer(25);

       // 创建TreeSet集合

       TreeSet<Customer> customers = new TreeSet<>();

       // 添加元素

       customers.add(c1);

       customers.add(c2);

       customers.add(c3);

       customers.add(c4);

       // 遍历

       for (Customer c : customers){

           System.out.println(c);

       }

   }

}

// 放在TreeSet集合中的元素需要实现java.lang.Comparable接口。

// 并且实现compareTo方法。equals可以不写。

class Customer implements Comparable<Customer>{

   int age;

   public Customer(int age){

       this.age = age;

   }

   // 需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较！

   // k.compareTo(t.key)

   // 拿着参数k和集合中的每一个k进行比较，返回值可能是>0 <0 =0

   // 比较规则最终还是由程序员指定的：例如按照年龄升序。或者按照年龄降序。

   @Override

   public int compareTo(Customer c) { // c1.compareTo(c2);

       // this是c1

       // c是c2

       // c1和c2比较的时候，就是this和c比较。

       /*int age1 = this.age;

       int age2 = c.age;

       if(age1 == age2){

           return 0;

       } else if(age1 > age2) {

           return 1;

       } else {

           return -1;

       }*/

       //return this.age - c.age; // =0 >0 <0

       return c.age - this.age;

   }

   public String toString(){

       return "Customer[age="+age+"]";

   }

}

import java.util.TreeSet;

/*

先按照年龄升序，如果年龄一样的再按照姓名升序。

*/

public class TreeSetTest05 {

   public static void main(String[] args) {

       TreeSet<Vip> vips = new TreeSet<>();

       vips.add(new Vip("zhangsi", 20));

       vips.add(new Vip("zhangsan", 20));

       vips.add(new Vip("king", 18));

       vips.add(new Vip("soft", 17));

       for(Vip vip : vips){

           System.out.println(vip);

       }

   }

}

class Vip implements Comparable<Vip>{

   String name;

   int age;

   public Vip(String name, int age) {

       this.name = name;

       this.age = age;

   }

   @Override

   public String toString() {

       return "Vip{" +

               "name='" + name + '\'' +

               ", age=" + age +

               '}';

   }

   @Override

   public int compareTo(Vip v) {

       // 写排序规则，按照什么进行比较。

       if(this.age == v.age){

           // 年龄相同时按照名字排序。

           // 姓名是String类型，可以直接比。调用compareTo来完成比较。

           return this.name.compareTo(v.name);

       } else {

           // 年龄不一样

           return this.age - v.age;

       }

   }

}

自平衡二叉树

比较器 new comparator（）

TreeSet集合中元素可排序的第二种方式：使用比较器的方式

1. 语法规则：

在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。

2. 两种排序怎么选择

Comparable和Comparator怎么选择呢？

当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。

    如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口。

3. 最终的结论：

   放到TreeSet或者TreeMap集合key部分的元素要想做到排序,包括两种方式：

第一种：放在集合中的元素实现java.lang.Comparable接口。

第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。

Comparator接口的设计符合OCP原则。

public class TreeSetTest06 {

   public static void main(String[] args) {

       // 创建TreeSet集合的时候，需要使用这个比较器。

       // TreeSet<WuGui> wuGuis = new TreeSet<>();//这样不行，没有通过构造方法传递一个比较器进去。

       // 给构造方法传递一个比较器。

       //TreeSet<WuGui> wuGuis = new TreeSet<>(new WuGuiComparator());

       // 大家可以使用匿名内部类的方式（这个类没有名字。直接new接口。）

       TreeSet<WuGui> wuGuis = new TreeSet<>(new Comparator<WuGui>() {

           @Override

           public int compare(WuGui o1, WuGui o2) {

               return o1.age - o2.age;

           }

       });

       wuGuis.add(new WuGui(1000));

       wuGuis.add(new WuGui(800));

       wuGuis.add(new WuGui(810));

       for(WuGui wuGui : wuGuis){

           System.out.println(wuGui);

       }

   }

}

// 乌龟

class WuGui{

   int age;

   public WuGui(int age){

       this.age = age;

   }

   @Override

   public String toString() {

       return "小乌龟[" +

               "age=" + age +

               ']';

   }

}

// 单独在这里编写一个比较器

// 比较器实现java.util.Comparator接口。（Comparable是java.lang包下的。Comparator是java.util包下的。）

/*

class WuGuiComparator implements Comparator<WuGui> {

   @Override

   public int compare(WuGui o1, WuGui o2) {

       // 指定比较规则

       // 按照年龄排序

       return o1.age - o2.age;

   }

}

*/

集合的总结

1、集合这块最主要掌握什么内容？

1.1、每个集合对象的创建（new）

1.2、向集合中添加元素

1.3、从集合中取出某个元素

1.4、遍历集合

1.5、主要的集合类：

ArrayList

LinkedList

HashSet (HashMap的key，存储在HashMap集合key的元素需要同时重写hashCode + equals)

TreeSet

HashMap

Properties

TreeMap