1、昨日复习

  1. 什么是枚举类？枚举类的对象声明的修饰符都有哪些？
    枚举类：类中的对象的个数是确定的，有限个。
    private final (No)
    public static final (Yes)
    2. 什么是元注解？说说Retention和Target元注解的作用
    元注解：对现有的注解进行解释说明的注解。
    Retention：指明所修饰的注解的生命周期。SOURCE CLASS RUNTIME
    3. 说说你所理解的集合框架都有哪些接口，存储数据的特点是什么

  2. 比较throw 和 throws 的异同
    同：
    throw:生成一个异常对象，并抛出。使用在方法内部<-> 自动抛出异常对象
    throws:处理异常的方式。使用在方法声明处的末尾<->try-catch-finally
    “上游排污，下游治污”
    5. 谈谈你对同步代码块中同步监视器和共享数据的理解及各自要求。
    同步监视器：俗称锁。①任何一个类的对象都可以充当锁。②多个线程共用同一把锁。
    共享数据：多个线程共同操作的数据，即为共享数据。
    需要使用同步机制将操作共享数据的代码包起来。不能包多了，也不能包少了。

    2、java集合

    Java 集合可分为 Collection 和 Map 两种体系
    QQ截图20220117212845.png
    QQ截图20220117213001.png ```java package com.atguigu.java3;

import com.sun.tracing.dtrace.ArgsAttributes; import org.junit.Test;

import java.lang.annotation.Target; import java.util.ArrayList; import java.util.Collection; import java.util.Date;

/**

  • 一、集合框架的概述
  • 1、集合、数组都是对多个数据进行存储操作的结构，简称java容器。
  • 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi,数据库中） *
  • 2.1、数组在存储多个数据方面的特点：

  • 一旦初始化以后，其长度就确定了。

  • 数组一旦定义好，其元素类型也就确定了。我们也就只能操作指定类型的数据了。

  • 比如：String[] arr;int[] arr1;Object[] arr2;
  • 2.2、数组在存储多个数据方面的缺点：

  • 一旦初始化以后，其长度就不可修改。

  • 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，效率不高。

  • 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。

  • 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。 *

  • 二、集合框架
  • |——Collection接口：单列集合，用来存储一个一个的对象
  • |——List接口：存储有序的、可重复的数据。——>“动态”数组
  • |——ArrayList、LinkedList、Vector
  • |——Set接口：存储无序的、不可重复的数据。——>高中讲的“集合”
  • |——HashSet、LinkedHashSet、TreeSet
  • |——Map接口：双列集合，用来存储一对（“key-value对”）一对的数据——>高中函数：y=f(x)
  • |——HashMap、LinkedHashMap、TreeMap、Hashtable、Properties *

  • 三、Collection接口中的方法的使用 */ public class CollectionTest { @Test public void test1(){

    1. Collection coll = new ArrayList();
    2. //add(Object e)：将元素e添加到集合coll中
    3. coll.add("AA");
    4. coll.add("BB");
    5. coll.add(123);
    6. coll.add(new Date());
    7. //size()：获取添加的元素的个数
    8. System.out.println(coll.size());
    10. //addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中
    11. Collection coll1 = new ArrayList();
    12. coll1.add(456);
    13. coll1.add("CC");
    14. coll.addAll(coll1);
    15. System.out.println(coll.size());
    16. System.out.println(coll);
    17. //clear()：清空集合元素
    18. coll.clear();
    19. //isEmpty()：判断当前集合是否为空
    20. System.out.println(coll.isEmpty());

    }

}

  1. ```java
  2. package com.atguigu.java1;
  4. import java.util.Objects;
  6. public class Person {
  7.     private String name;
  8.     private int age;
  10.     public Person() {
  11.     }
  13.     public Person(String name, int age) {
  14.         this.name = name;
  15.         this.age = age;
  16.     }
  18.     public String getName() {
  19.         return name;
  20.     }
  22.     public void setName(String name) {
  23.         this.name = name;
  24.     }
  26.     public int getAge() {
  27.         return age;
  28.     }
  30.     public void setAge(int age) {
  31.         this.age = age;
  32.     }
  34.     @Override
  35.     public String toString() {
  36.         return "Person{" +
  37.                 "name='" + name + '\'' +
  38.                 ", age=" + age +
  39.                 '}';
  40.     }
  42.     @Override
  43.     public boolean equals(Object o) {
  44.         System.out.println("person.equals");
  45.         if (this == o) return true;
  46.         if (o == null || getClass() != o.getClass()) return false;
  47.         Person person = (Person) o;
  48.         return age == person.age && Objects.equals(name, person.name);
  49.     }
  51. /*    @Override
  52.     public int hashCode() {
  53.         return Objects.hash(name, age);
  54.     }*/
  55. }
  1. package com.atguigu.java1;
  3. import org.junit.Test;
  5. import java.util.ArrayList;
  6. import java.util.Arrays;
  7. import java.util.Collection;
  8. import java.util.List;
  10. /**
  11.  * Collection接口中声明的方法的测试
  12.  * 想CollectionTest接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()。
  13.  */
  14. public class CollectionTest {
  15.     @Test
  16.     public void test1() {
  17.         Collection coll = new ArrayList();
  18.         coll.add(123);//此处123被自动装箱为Integer
  19.         coll.add(456);
  20.         coll.add(new String("Tom"));
  21.         coll.add(false);
  22.         /*Person p = new Person("Jerry",20);
  23.         coll.add(p);*/
  24.         coll.add(new Person("Jerry",20));
  25.         //1、contains(Object obj)：判断当前集合是否包含obj
  26.         //我们在判断时会调用obj对象所在类的equals方法()。
  27.         boolean contains = coll.contains(123);
  28.         System.out.println(contains);
  29.         System.out.println(coll.contains(new String("Tom")));//true
  30. //        System.out.println(coll.contains(p));//true
  31.         System.out.println(coll.contains(new Person("Jerry",20)));//false-->true
  33.         //2、containsAll(Collection coll1)：判断形参coll1中的所有元素是否都存在当前集合中
  34.         Collection coll1 = Arrays.asList(123,456);
  35.         System.out.println(coll.containsAll(coll1));//true
  36.     }
  38.     @Test
  39.     public void test2(){
  40.         //3、remove(Object obj)：从当前集合中移除obj元素
  41.         Collection coll = new ArrayList();
  42.         coll.add(123);//此处123被自动装箱为Integer
  43.         coll.add(456);
  44.         coll.add(new String("Tom"));
  45.         coll.add(false);
  46.         coll.add(new Person("Jerry",20));
  48.         coll.remove(123);
  49.         System.out.println(coll);
  51.         coll.remove(new Person("Jerry",20));
  52.         System.out.println(coll);
  54.         //4、removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素
  55.         Collection coll1 = Arrays.asList(123,4567);
  56.         coll.removeAll(coll1);
  57.         System.out.println(coll);
  58.     }
  60.     @Test
  61.     public void test3(){
  62.         Collection coll = new ArrayList();
  63.         coll.add(123);//此处123被自动装箱为Integer
  64.         coll.add(456);
  65.         coll.add(new String("Tom"));
  66.         coll.add(false);
  67.         coll.add(new Person("Jerry",20));
  69.         //5、retainAll(Collection coll1)：获取当前集合与coll1集合的交集，并返回给当前集合
  70.         /*Collection coll1 = Arrays.asList(123,456,789);
  71.         coll.retainAll(coll1);
  72.         System.out.println(coll);*/
  74.         //6、equals(Object obj)：要想返回true，需要当前集合与形参集合的元素都相同
  75.         Collection coll1 = new ArrayList();
  76.         coll1.add(123);//此处123被自动装箱为Integer
  77.         coll1.add(456);
  78.         coll1.add(new String("Tom"));
  79.         coll1.add(false);
  80.         coll1.add(new Person("Jerry",20));
  81.         System.out.println(coll1.equals(coll));
  82.     }
  84.     @Test
  85.     public void test4(){
  86.         Collection coll = new ArrayList();
  87.         coll.add(123);//此处123被自动装箱为Integer
  88.         coll.add(456);
  89.         coll.add(new String("Tom"));
  90.         coll.add(false);
  91.         coll.add(new Person("Jerry",20));
  93.         //7、hashCode()：返回当前对象的哈希值
  94.         System.out.println(coll.hashCode());
  96.         //8、toArray() ：集合--->数组
  97.         Object[] arr = coll.toArray();
  98.         for (int i = 0; i < arr.length; i++) {
  99.             System.out.println(arr[i]);
  100.         }
  102.         //拓展：数组--->集合:调用Arrays类的静态方法asList(T... a)
  103.         List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
  104.         System.out.println(list);
  106.         List arr1 = Arrays.asList(new int[]{123, 456});
  107.         System.out.println(arr1.size());//1
  109.         List arr2 = Arrays.asList(new Integer[]{123, 456});
  110.         System.out.println(arr2.size());//2
  112.         //9、iterator()：返回Iterator接口中的实例，用于遍历集合元素。放在IteratorTest.java中测试
  114.     }
  115. }
  1. package com.atguigu.java1;
  3. import org.junit.Test;
  5. import java.util.ArrayList;
  6. import java.util.Collection;
  7. import java.util.Iterator;
  9. /**
  10.  * 集合元素的遍历，使用迭代器Iterator接口（Map不用该迭代器）
  11.  * 1、内部方法：hasNext() 和next()
  12.  * 2、集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
  13.  * 默认游标都在集合的第一个元素之前。
  14.  * 3、内部定义了remove()，可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove方法
  15.  * 4、如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，
  16.  * 再调用remove都会报IllegalStateException。
  17.  */
  18. public class IteratorTest {
  19.     @Test
  20.     public void test1(){
  21.         Collection coll = new ArrayList();
  22.         coll.add(123);//此处123被自动装箱为Integer
  23.         coll.add(456);
  24.         coll.add(new Person("Jerry",20));
  25.         coll.add(new String("Tom"));
  26.         coll.add(false);
  28.         Iterator iterator = coll.iterator();
  29.         //方式一：
  30.         /*System.out.println(iterator.next());
  31.         System.out.println(iterator.next());
  32.         System.out.println(iterator.next());
  33.         System.out.println(iterator.next());
  34.         System.out.println(iterator.next());*/
  35.         //报异常：NoSuchElementException
  36.         //System.out.println(iterator.next());
  38.         //方式二：不推荐
  39.         /*for (int i = 0; i < coll.size(); i++) {
  40.             System.out.println(iterator.next());
  41.         }*/
  42.         //方式三：推荐
  43.         while(iterator.hasNext()){
  44.             //next():①指针下移 ②将下移以后集合位置上的元素返回
  45.             System.out.println(iterator.next());
  46.         }
  47.     }
  49.     @Test
  50.     public void test2(){
  51.         Collection coll = new ArrayList();
  52.         coll.add(123);//此处123被自动装箱为Integer
  53.         coll.add(456);
  54.         coll.add(new Person("Jerry",20));
  55.         coll.add(new String("Tom"));
  56.         coll.add(false);
  58.         //Iterator iterator = coll.iterator();
  59.         //错误方式一：
  60.        /* while(iterator.next() != null){
  61.             System.out.println(iterator.next());
  62.         }*/
  64.         //错误方式二：
  65. /*        while(coll.iterator().hasNext()){
  66.             System.out.println(coll.iterator().next());
  67.         }*/
  69.     }
  71.     //测试Iterator中的remove()方法
  72.     @Test
  73.     public void test3(){
  74.         Collection coll = new ArrayList();
  75.         coll.add(123);//此处123被自动装箱为Integer
  76.         coll.add(456);
  77.         coll.add(new Person("Jerry",20));
  78.         coll.add(new String("Tom"));
  79.         coll.add(false);
  81.         //删除集合中"Tom"
  82.         Iterator iterator = coll.iterator();
  83.         while (iterator.hasNext()){
  84.             Object obj = iterator.next();
  85.             if ("Tom".equals(obj)){
  86.                 iterator.remove();
  87.             }
  88.         }
  90.         //遍历集合
  91.         iterator = coll.iterator();
  92.         while (iterator.hasNext()){
  93.             System.out.println(iterator.next());
  94.         }
  95.     }
  96. }
  1. package com.atguigu.java1;
  3. import org.junit.Test;
  5. import java.util.ArrayList;
  6. import java.util.Collection;
  8. /**
  9.  * jdk 5.0新增了foreach循环，用于遍历集合、数组
  10.  */
  11. public class ForTest {
  12.     @Test
  13.     public void test1(){
  14.         Collection coll = new ArrayList();
  15.         coll.add(123);//此处123被自动装箱为Integer
  16.         coll.add(456);
  17.         coll.add(new Person("Jerry",20));
  18.         coll.add(new String("Tom"));
  19.         coll.add(false);
  22.         //for(集合中元素的类型  局部变量 : 集合对象)
  23.         //内部任然调用了迭代器
  24.         for(Object obj:coll){
  25.             System.out.println(obj);
  26.         }
  27.     }
  29.     @Test
  30.     public void test2(){
  31.         int[] arr = new int[]{1,2,3,4,5,6};
  33.         for (int i:arr){
  34.             System.out.println(i);
  35.         }
  36.     }
  38.     //练习题
  39.     @Test
  40.     public void test3(){
  41.         String[] arr = new String[]{"MM","MM","MM"};
  43.         //方式一：普通for赋值
  44. /*        for (int i = 0; i < arr.length; i++) {
  45.             arr[i] = "GG";
  46.         }*/
  48.         //方式二：增强for循环
  49.         for (String s : arr){
  50.             s = "GG";
  51.         }
  52.         for (int i = 0; i < arr.length; i++) {
  53.             System.out.println(arr[i]);
  54.         }
  55.     }
  57. }

3、Collection子接口之一：List接口

  1. package com.atguigu.java1;
  3. import org.junit.Test;
  5. import java.util.*;
  7. /*      1、接口框架
  8.  *          |----Collection接口：单列集合，用来存储一个一个的对象
  9.  *  *              |----List接口：存储有序的、可重复的数据。---->“动态”数组，替换原有的数组
  10.  *  *                  |----ArrayList：作为List接口的主要实现类；线程不安全，效率高；底层使用Object[]存储 elementData存储
  11.                        |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
  12.                        |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[]存储 elementData存储
  13.         2、源码分析
  14.         *
  15. *           2.1、ArrayList的源码分析：jdk7.0的情况下
  16. *               ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组 elementData
  17. *               list.add(123);//elementData[0] = new Integer(123);
  18. *               ....
  19. *               list.add(11);//如果此次的添加导致底层的elementData数组容量不够，则扩容。
  20. *               默认情况下，扩容为原来的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
  21. *
  22. *               结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
  23. *
  24. *           2.2、jdk 8.0中ArrayList的变化：
  25. *               ArrayList list = new ArrayList();//底层Object[]数组 elementData初始化为{}，并没有创建长度为10的数组
  26. *               list.add(123);//第一次调用add()时，底层才创建了长度为10得到数组，并将数组123添加到elementData[0]
  27. *               ....
  28. *               后续的添加和扩容操作与jkd 7.0无异。
  29. *
  30. *           2.3、小结：jkd 7.0中的ArrayList的对象的创建类似于单例的饿汉式，
  31. *                       而jdk 8.0中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
  32. *
  33. *       3、LinkedList的源码分析：
  34. *           LinkedList list = new LinkedList();内部声明了Node类型的first和last属性，默认值为null，
  35. *           list.add;//将123封装到Node中，创建了Node对象。
  36. *
  37. *           其中，Node定义为：
  38. *               private static class Node<E> {
  39.                     E item;
  40.                     Node<E> next;
  41.                     Node<E> prev;
  43.                     Node(Node<E> prev, E element, Node<E> next) {
  44.                         this.item = element;
  45.                         this.next = next;
  46.                         this.prev = prev;
  47.                     }
  49. *       4、Vector源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组，
  50. *           在扩容方面，默认扩容为原来的数组长度的2倍。
  51. *
  52.  面试题：ArrayList、LinkedList、Vector三者的异同？
  53.  同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
  54.  不同：见上
  55.         5、List接口中的常用方法
  56.         *
  58.  */
  59. public class ListTest {
  60.     /*
  61. void add(int index, Object ele):在index位置插入ele元素
  62. boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
  63. Object get(int index):获取指定index位置的元素
  64. int indexOf(Object obj):返回obj在集合中首次出现的位置
  65. int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
  66. Object remove(int index):移除指定index位置的元素，并返回此元素
  67. Object set(int index, Object ele):设置指定index位置的元素为ele
  68. List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
  70. 总结：常用方法
  71. 增：add(Object obj)
  72. 删：remove(int index)/remove(Object obj)
  73. 改：set(int index, Object ele)
  74. 查：get(int index)
  75. 插：add(int index, Object ele)
  76. 长度：size()
  77. 遍历：① Iterator迭代器
  78.       ② 增强for循环
  79.       ③ 普通的循环
  80.      */
  81.     @Test
  82.     public void test1(){
  83.         ArrayList list = new ArrayList();
  84.         list.add(123);
  85.         list.add(456);
  86.         list.add("AA");
  87.         list.add(new Person("Tom",12));
  88.         list.add(456);
  89.         System.out.println(list.toString());
  90.         //void add(int index, Object ele):在index位置插入ele元素
  91.         list.add(1,"BB");
  92.         System.out.println(list);
  94.         //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
  95.         List list1 = Arrays.asList(1, 2, 3);
  96.         list.addAll(list1);
  97.         System.out.println(list.size());//9
  99.         //Object get(int index):获取指定index位置的元素
  100.         System.out.println(list.get(0));
  101.     }
  103.     @Test
  104.     public void test2(){
  105.         ArrayList list = new ArrayList();
  106.         list.add(123);
  107.         list.add(456);
  108.         list.add("AA");
  109.         list.add(new Person("Tom",12));
  110.         list.add(456);
  111.         //int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在,返回-1。
  112.         int index = list.indexOf(456);
  113.         System.out.println(index);
  115.         //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置.如果不存在,返回-1。
  116.         System.out.println(list.lastIndexOf(456));
  117.         Object obj = list.remove(0);
  118.         System.out.println(obj);
  119.         System.out.println(list);
  121.         //Object set(int index, Object ele):设置指定index位置的元素为ele
  122.         list.set(1,"CC");
  123.         System.out.println(list);
  125.         //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
  126.         List subList = list.subList(2, 4);
  127.         System.out.println(subList);
  128.         System.out.println(list);
  129.     }
  131.     @Test
  132.     public void test3(){
  133.         ArrayList list = new ArrayList();
  134.         list.add(123);
  135.         list.add(456);
  136.         list.add("AA");
  137.         //方式一：Iterator迭代器
  138.         Iterator iterator = list.iterator();
  139.         while (iterator.hasNext()){
  140.             System.out.println(iterator.next());
  141.         }
  142.         System.out.println("****************************");
  143.         //方式二：增强for循环
  144.         for (Object obj:list){
  145.             System.out.println(obj);
  146.         }
  147.         System.out.println("****************************");
  148.         //方式三：普通的循环
  149.         for (int i = 0; i < list.size(); i++) {
  150.             System.out.println(list.get(i));
  151.         }
  152.     }
  153. }
  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. import java.util.ArrayList;
  6. import java.util.List;
  7. /*
  8. 区分List中的remove(int index)和remove(Object obj)
  9.  */
  10. public class ListExer {
  11.     @Test
  12.     public void testListRemove() {
  13.         List list = new ArrayList();
  14.         list.add(1);
  15.         list.add(2);
  16.         list.add(3);
  17.         updateList(list);
  18.         System.out.println(list);//
  19.     }
  20.     private static void updateList(List list) {
  21.         //list.remove(2);//[1, 2]
  22.         list.remove(new Integer(2));//[1, 3]
  23.     }
  24. }

4、Collection子接口之二：Set接口

  1. package com.atguigu.java2;
  3. import com.atguigu.java1.Person;
  4. import org.junit.Test;
  6. import java.util.*;
  8. /**
  9.  * 1、Set接口的框架结构：
  10.  * |----Collection接口：单列集合，用来存储一个一个的对象
  11.  *          |----Set接口：存储无序的、不可重复的数据。---->高中讲的“集合”
  12.  *  *            |----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
  13.  *                  |----LinkedHashSet：作为HashSet子类，遍历其内部数据时，可以按照添加的顺序遍历
  14.  *                                      对于频繁的遍历操作，LinkedHashSet效率高于HashSet
  15.  *               |----TreeSet：可以按照添加对象的指定属性，进行排序
  16.  *
  17.  * 1、Set接口中没有额外的定义新的方法，使用的都是Collection中声明过的方法。
  18.  * 2、要求：向Set（HashSet、LinkedHashSet）中添加的数据，其所在的类一定要重写hashCode()和equals()
  19.  *    要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码
  20.  *    重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。
  21.  */
  22. public class SetTest {
  23.     /*
  24.     一、Set接口：存储无序的、不可重复的
  25.     以HashSet为例说明：
  26.     1、无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值来添加的
  28.     2、不可重复性：保证添加的元素按照equals方法判断时，不能返回true。即相同的元素只能添加一个。
  30.     二、添加元素的过程：以HashSet为例：
  31.     我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a哈希值，
  32.     此哈希值接着通过某种计算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断
  33.     数组此位置上是否已经有元素：
  34.         如果此位置上没有其他元素，则元素a添加成功。----->情况1
  35.         如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的哈希值：
  36.             如果哈希值不相同，则元素a添加成功。----->情况2
  37.             如果哈希值相同，进而需要调用元素a所在类的equals()方法：
  38.                 equals()返回true，元素a添加失败
  39.                 equals()返回false，元素a添加成功----->情况3
  41.     对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上数据一链表的方式存储。
  42.     jdk7：元素a放到数组中，指向原来的元素。反客为主。
  43.     jdk8：原来的元素放在数组中，指向元素a。先来后到。
  44.     总结：七上八下。
  45.     HashSet底层：数组+链表的结构 前提：jdk7.0
  46.      */
  47.     @Test
  48.     public void test1(){
  49.         Set set = new HashSet();
  50.         set.add(456);
  51.         set.add(123);
  52.         set.add("AA");
  53.         set.add("CC");
  54.         set.add(new User("Tom",12));
  55.         set.add(new User("Tom",12));
  56.         set.add(129);
  58.         Iterator iterator = set.iterator();
  59.         while(iterator.hasNext()){
  60.             System.out.println(iterator.next());
  61.         }
  64.     }
  66.     //LinkedHashSet的使用
  67.     //LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个
  68.     //数据和后一个数据。
  69.     //优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
  70.     @Test
  71.     public void test2(){
  72.         Set set = new LinkedHashSet();
  73.         set.add(456);
  74.         set.add(123);
  75.         set.add("AA");
  76.         set.add("CC");
  77.         set.add(new User("Tom",12));
  78.         set.add(new User("Tom",12));
  79.         set.add(129);
  81.         Iterator iterator = set.iterator();
  82.         while(iterator.hasNext()){
  83.             System.out.println(iterator.next());
  84.         }
  87.     }
  88. }
  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. import java.util.Comparator;
  6. import java.util.Iterator;
  7. import java.util.TreeSet;
  9. public class TreeSetTest {
  10.     /*
  11.     1、向TreeSet中添加的数据，要求是相同类的对象
  12.     2、两种排序方式：自然排序和定制排序
  13.     3、自然排序中，比较两个对象是否相同的标椎为：compareTo()返回0。不再是equals().
  14.     4、定制排序中，比较两个对象是否相同的标椎为：compare()返回0。不再是equals().
  15.      */
  16.     @Test
  17.     public void test1(){
  18.         TreeSet set = new TreeSet();
  19.         //失败：不能添加不同类的对象
  20.         /*
  21.         set.add(123);
  22.         set.add(456);
  23.         set.add("AA");
  24.         set.add(new User("Tom",12));*/
  25.         /*set.add(34);
  26.         set.add(-34);
  27.         set.add(43);
  28.         set.add(1);
  29.         set.add(8);*/
  30.         set.add(new User("Tom",12));
  31.         set.add(new User("Jerry",32));
  32.         set.add(new User("Jim",2));
  33.         set.add(new User("Mike",65));
  34.         set.add(new User("Jack",33));
  35.         set.add(new User("Jack",56));
  38.         Iterator iterator = set.iterator();
  39.         while (iterator.hasNext()){
  40.             System.out.println(iterator.next());
  41.         }
  42.     }
  44.     @Test
  45.     public void test2(){
  46.         //按照年龄从小到大排序
  47.         TreeSet set = new TreeSet(new Comparator() {
  48.             @Override
  49.             public int compare(Object o1, Object o2) {
  50.                 if (o1 instanceof User && o2 instanceof User){
  51.                     User user1 = (User) o1;
  52.                     User user2 = (User) o2;
  53.                     return Integer.compare(user1.getAge(),user2.getAge());
  54.                 }else {
  55.                     throw new RuntimeException("输入的数据类型不匹配");
  56.                 }
  57.             }
  58.         });
  59.         set.add(new User("Tom",12));
  60.         set.add(new User("Jerry",32));
  61.         set.add(new User("Jim",2));
  62.         set.add(new User("Mike",65));
  63.         set.add(new User("Jack",33));
  64.         set.add(new User("Marry",33));
  65.         set.add(new User("Jack",56));
  68.         Iterator iterator = set.iterator();
  69.         while (iterator.hasNext()){
  70.             System.out.println(iterator.next());
  71.         }
  73.     }
  74. }

尚硅谷宋红康第11章_Java集合.pdf