Java笔记高级篇

关联链接

Java笔记	地址
基础篇	https://blog.csdn.net/weixin_46585199/article/details/128447004
高级篇	https://blog.csdn.net/weixin_46585199/article/details/128879787

第七章 IDEA的使用

第八章 多线程

8.1 程序、进程、线程、并发、并行概念

（1）进程

1. 定义：进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程。

2. 进程作为资源分配的基本单位，系统在运行时会为每一个进程分配不同的内存区域。

（2）线程

1. 定义：线程是程序内部的一条执行路径。

2. 若一个进程同一时间并行执行多个线程，就是支持多线程的

3. 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小

4. 一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象，可以访问相同的变量和对象，这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

（3）并行与并发

1. 多个CPU同时执行多个任务。
2. 一个CPU同时执行多个任务。

8.2 线程创建的两种方式

（1）方式一：继承于Thread类

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
3. 创建Thread类的子类的对象
4. 通过此对象调用start()
   例子：

//遍历100以内的所有的偶数

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2. 重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建Thread类的子类的对象
        MyThread t1 = new MyThread();

        //4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
        t1.start();
        //问题一：我们不能通过直接调用run()的方式启动线程。
//        t1.run();

        //问题二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
//        t1.start();
        //我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();

        //如下操作仍然是在main线程中执行的。
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i + "***********main()************");
            }
        }
    }

}

/**
 * 练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数
 *
 *
 * @author shkstart
 * @create 2019-02-13 下午 2:16
 */
public class ThreadDemo {
    public static void main(String[] args) {
//-------------------法一---------------------
//        MyThread1 m1 = new MyThread1();
//        MyThread2 m2 = new MyThread2();
//
//        m1.start();
//        m2.start();
//----------------------------------------
//*******************法2匿名*********************
        //创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if(i % 2 == 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);

                    }
                }
            }
        }.start();


        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if(i % 2 != 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);

                    }
                }
            }
        }.start();

    }
}
//****************************************

//---------------法一接上-------------------------
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);

            }
        }

    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);

            }
        }

    }
}

（2）Thread类中的常用方法：

1. start():启动当前线程；调用当前线程的run()

2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

3. currentThread():静态方法，返回执行当前代码的线程

4. getName():获取当前线程的名字

5. setName():设置当前线程的名字

6. yield():释放当前cpu的执行权

7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。

8. stop():已过时。当执行此方法时，强制结束当前线程。

9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。

10. isAlive():判断当前线程是否存活

线程的优先级：

MAX_PRIORITY：10

MIN _PRIORITY：1

NORM_PRIORITY：5  -->默认优先级

2.如何获取和设置当前线程的优先级：
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级

说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。

（3）方式二：实现Runnable接口

1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start()

（4）比较创建线程的两种方式。

1. 开发中：优先选择：实现Runnable接口的方式

原因：

• 实现的方式没有类的单继承性的局限性
• 实现的方式更适合来处理多个线程有共享数据的情况。

2. 联系：public class Thread implements Runnable
3. 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

package com.atguigu.day01.src.atguigu.java;

//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{

    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

        }
    }
}


public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5. 通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }

}

8.3 线程生命周期

8.4 线程同步机制

8.5 线程通信

8.6 JDK5.0 新增创建线程的方式

第九章 常用类

String类

1. String类的理解(以JDK8为例说明)
   1.1 类的声明

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence

final:String是不可被继承的
Serializable:可序列化的接口。凡是实现此接口的类的对象就可以通过网络或本地流进行数据的传输。
Comparable:凡是实现此接口的类，其对象都可以比较大小。

1.2 内部声明的属性：
jdk8中：

private final char value[]; //存储字符串数据的容器

final : 指明此value数组一旦初始化，其地址就不可变。

jdk9开始：为了节省内存空间，做了优化

private final byte[] value; //存储字符串数据的容器。

2. 字符串常量的存储位置
   字符串常量都存储在字符串常量池(StringTable)中
   字符串常量池不允许存放两个相同的字符串常量。
   字符串常量池，在不同的jdk版本中，存放位置不同。
   jdk7之前：字符串常量池存放在方法区
   jdk7及之后：字符串常量池存放在堆空间。
   
   
   

3. String的不可变性的理解
   ① 当对字符串变量重新赋值时，需要重新指定一个字符串常量的位置进行赋值，不能在原有的位置修改

    @Test
    public void test1(){
        String s1 = "hello";    //字面量的定义方式
        String s2 = "hello";

        System.out.println(s1 == s2);//true

    }

② 当对现有的字符串进行拼接操作时，需要重新开辟空间保存拼接以后的字符串，不能在原有的位置修改

 @Test
    public void test3(){
        String s1 = "hello";
        String s2 = "hello";

        s2 += "world";

        System.out.println(s1); //hello
        System.out.println(s2);//helloworld
    }

③ 当调用字符串的replace()替换现有的某个字符时，需要重新开辟空间保存修改以后的字符串，不能在原有的位置修改

public void test4(){
        String s1 = "hello";
        String s2 = "hello";

        String s3 = s2.replace('l', 'w');

        System.out.println(s1);//hello
        System.out.println(s2);//hello
        System.out.println(s3);//hewwo
    }

4. String实例化的两种方式
   第1种方式：String s1 = "hello";
   第2种方式：String s2 = new String("hello");

 @Test
    public void test1(){
        String s1 = "hello";
        String s2 = "hello";

        String s3 = new String("hello");
        String s4 = new String("hello");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false

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

    }

【面试题】
问：
String s = new String("hello");的内存解析？
或：
String s = new String("hello");在内存中创建了几个对象？
答：这需要分情况来说，如果常量池中已经有了相应的对象，则只需要在堆里面创建一个对象，然后将指向共同的char数组。如果常量池中没有相应的对象，则会在常量池中创建一个对象0x3344，在堆里创建一个对象0x1122，然后将指向共同的char数组。

【面试题】
问：
画出下列代码的的内存解析？

    @Test
    public void test2(){
        Person p1 = new Person();
        Person p2 = new Person();
        p1.name = "Tom";
        p2.name = "Tom";

        p1.name = "Jerry";

        System.out.println(p2.name);//Tom
    }

5. String的连接操作:+
   情况1：常量 + 常量: 结果仍然存储在字符串常量池中，返回此字面量的地址。
   注：此时的常量可能是字面量，也可能是final修饰的常量
   情况2：常量 + 变量 或 变量 + 变量 ：都会通过new的方式创建一个新的字符串，返回堆空间中此字符串对象的地址
   情况3：调用字符串的intern():返回的是字符串常量池中字面量的地址
   情况4(了解)：concat(xxx):不管是常量调用此方法，还是变量调用，同样不管参数是常量还是变量，总之，调用完concat()方法
   都返回一个新new的对象。

    /*
    * 测试String的连接符：+
    * */
    @Test
    public void test3(){
        String s1 = "hello";
        String s2 = "world";

        String s3 = "helloworld";
        String s4 = "hello" + "world";
        String s5 = s1 + "world"; //通过查看字节码文件发现调用了StringBuilder的toString()---> new String()
        String s6 = "hello" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println();

        String s8 = s5.intern(); //intern():返回的是字符串常量池中字面量的地址
        System.out.println(s3 == s8);//true

    }

    @Test
    public void test4(){
        final String s1 = "hello";
        final String s2 = "world";

        String s3 = "helloworld";
        String s4 = "hello" + "world";
        String s5 = s1 + "world";
        String s6 = "hello" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s5);//true
        System.out.println(s3 == s6);//true
        System.out.println(s3 == s7);//true
    }

    @Test
    public void test5(){
        String s1 = "hello";
        String s2 = "world";

        String s3 = s1.concat(s2);
        String s4 = "hello".concat("world");
        String s5 = s1.concat("world");

        System.out.println(s3 == s4);//false
        System.out.println(s3 == s5);//false
        System.out.println(s4 == s5);//false

    }
}

6. String的构造器和常用方法

6.1 构造器

• public String() ：初始化新创建的 String对象，以使其表示空字符序列。
• public String(String original)： 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
• public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
• public String(char[] value,int offset, int count) ：通过字符数组的一部分来构造新的String。
• public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
• public String(byte[] bytes,String charsetName) ：通过使用指定的字符集解码当前参数中的字节数组来构造新的String。

6.2 常用方法

public class StringMethodTest1 {
    /*
    *   （1）boolean isEmpty()：字符串是否为空
        （2）int length()：返回字符串的长度
        （3）String concat(xx)：拼接
        （4）boolean equals(Object obj)：比较字符串是否相等，区分大小写
        （5）boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写
        （6）int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小
        （7）int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写
        （8）String toLowerCase()：将字符串中大写字母转为小写
        （9）String toUpperCase()：将字符串中小写字母转为大写
        （10）String trim()：去掉字符串前后空白符
        （11）public String intern()：结果在常量池中共享
    *
    * */
    @Test
    public void test1(){
        String s1 = "";
        String s2 = new String();
        String s3 = new String("");

        System.out.println(s1.isEmpty());
        System.out.println(s2.isEmpty());
        System.out.println(s3.isEmpty());

        String s4 = null;
        System.out.println(s4.isEmpty());//报空指针异常

        String s5 = "hello";
        System.out.println(s5.length());//5
    }

    @Test
    public void test2(){
        String s1 = "hello";
        String s2 = "HellO";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));

        String s3 = "abcd";
        String s4 = "adef";
        System.out.println(s3.compareTo(s4));

        String s5 = "abcd";
        String s6 = "aBcd";
        System.out.println(s5.compareTo(s6));
        System.out.println(s5.compareToIgnoreCase(s6));

        String s7 = "张ab";
        String s8 = "李cd";
        System.out.println(s7.compareTo(s8));

        String s9 = " he  llo   ";
        System.out.println("****" + s9.trim() + "*****");
    }

    /*
    *   （11）boolean contains(xx)：是否包含xx
        （12）int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1
        （13）int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
        （14）int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1
        （15）int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
    *
    * */
    @Test
    public void test3(){
        String s1 = "教育尚硅谷教育";
        System.out.println(s1.contains("硅谷"));

        System.out.println(s1.indexOf("教育"));
        System.out.println(s1.indexOf("教育",1));

        System.out.println(s1.lastIndexOf("教育"));
        System.out.println(s1.lastIndexOf("教育",4));
    }
    /*
    *   （16）String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
        （17）String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
    * */
    @Test
    public void test4(){
        String s1 = "教育尚硅谷教育";
        System.out.println(s1.substring(2));
        System.out.println(s1.substring(2,5));//[2,5)
    }

    /*
    * （18）char charAt(index)：返回[index]位置的字符
    （19）char[] toCharArray()： 将此字符串转换为一个新的字符数组返回
    （20）static String valueOf(char[] data)  ：返回指定数组中表示该字符序列的 String
    （21）static String valueOf(char[] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String
    （22）static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String
    （23）static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String
    * （24）boolean startsWith(xx)：测试此字符串是否以指定的前缀开始
      （25）boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
     （26）boolean endsWith(xx)：测试此字符串是否以指定的后缀结束
    * */
    @Test
    public void test5(){
        String s1 = "教育尚硅谷教育";
        System.out.println(s1.charAt(2));

        String s2 = String.valueOf(new char[]{'a', 'b', 'c'});
        String s3 = String.copyValueOf(new char[]{'a', 'b', 'c'});
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s2 == s3);

        System.out.println(s1.startsWith("教育a"));
        System.out.println(s1.startsWith("教育",5));

    }

    /*
    * （27）String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 不支持正则。
    （28）String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
    （29）String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
    （30）String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
    * */
    @Test
    public void test6(){
        String s1 = "hello";
        String s2 = s1.replace('l', 'w');
        System.out.println(s1);
        System.out.println(s2);

        String s3 = s1.replace("ll", "wwww");
        System.out.println(s3);

    }
}

StringBuffer与StringBuilder

1. 三个类的对比:String、StringBuffer、StringBuilder

String:不可变的字符序列;底层使用char[] （jdk8及之前），底层使用byte[] （jdk9及之后）
StringBuffer:可变的字符序列;JDK1.0声明，线程安全的，效率低;底层使用char[] （jdk8及之前），底层使用byte[] （jdk9及之后）
StringBuilder:可变的字符序列;JDK5.0声明，线程不安全的,效率高;底层使用char[] （jdk8及之前），底层使用byte[] （jdk9及之后）

2. StringBuffer/StringBuilder的可变性分析（源码分析）：
   回顾：

String s1 = new String(); //char[] value = new char[0];
String s2 = new String("abc");// char[] value = new char[]{'a','b','c'};

针对于StringBuilder来说：
内部的属性有：

char[] value; //存储字符序列
int count; //实际存储的字符的个数
StringBuilder sBuffer1 = new StringBuilder();//char[] value = new char[16];
StringBuilder sBuffer1 = new StringBuilder("abc"); //char[] value = new char[16 + "abc".length()];

sBuffer1.append("ac");//value[0] = 'a'; value[1] = 'c';
sBuffer1.append("b");//value[2] = 'b';

…不断的添加，一旦count要超过value.length时，就需要扩容：默认扩容为原有容量的2倍+2。
并将原有value数组中的元素复制到新的数组中。

3. 源码启示：

如果开发中需要频繁的针对于字符串进行增、删、改等操作，建议使用StringBuffer或StringBuilder替换String.
因为使用String效率低。
如果开发中，不涉及到线程安全问题，建议使用StringBuilder替换StringBuffer。因为使用StringBuilder效率高
如果开发中大体确定要操作的字符的个数，建议使用带int capacity参数的构造器。因为可以避免底层多次扩容操作，性能更高。

4. StringBuffer和StringBuilder中的常用方法

//增：
    append(xx)
//删：
    delete(int start, int end)
    deleteCharAt(int index)
//改：
    replace(int start, int end, String str)
    setCharAt(int index, char c)
//查：
    charAt(int index)
//插：
    insert(int index, xx)
//长度：
    length()

5. 对比三者的执行效率

StringBuilder > StringBuffer > String

日期时间API

一、JDK8之前的API:

1. System类的currentTimeMillis()

   获取当前时间对应的毫秒数，long类型，时间戳
   当前时间与1970年1月1日0时0分0秒之间的毫秒数
   常用来计算时间差

2. 两个Date类

public class DateTimeTest {
    /*
    * 两个Date类的使用
    *//第一个Date类
    * |--java.util.Date
    *   > 两个构造器的使用
    *   > 两个方法的使用：①toString() ② long getTime()
    * 		//第二个Date类
    *       |----java.sql.Date: 对应着数据库中的date类型
    *
    * */
    @Test
    public void test1(){
        Date date1 = new Date(); //创建一个基于当前系统时间的Date的实例
        System.out.println(date1.toString());//Mon Dec 05 11:56:26 CST 2022

        long milliTimes = date1.getTime();
        System.out.println("对应的毫秒数为：" + milliTimes); //1670212256045

        Date date2 = new Date(1370202256045L); //创建一个基于指定时间戳的Date的实例
        System.out.println(date2.toString());
    }
    
    @Test
    public void test2(){
        java.sql.Date date1 = new java.sql.Date(1370202256045L);
        System.out.println(date1.toString());//2013-06-03

        System.out.println(date1.getTime());//1370202256045
    }

3. SimpleDateFormat类
   SimpleDateFormat类：用于日期时间的格式化和解析

   格式化：日期—>字符串
   解析：字符串 —> 日期

    @Test
    public void test3() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat();
        //格式化：日期--->字符串
        Date date1 = new Date();
        String strDate = sdf.format(date1);
        System.out.println(strDate);//22-12-5 下午2:21

        //解析：字符串 ---> 日期
        Date date2 = sdf.parse("22-12-5 下午3:21");
        System.out.println(date2);
    }

    @Test
    public void test4() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss Z");
        sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //格式化：日期--->字符串
        Date date1 = new Date();
        String strDate = sdf.format(date1);
        System.out.println(strDate);//2022-12-05 14:27:19

        //解析：字符串 ---> 日期
        Date date2 = sdf.parse("2022-12-05 14:27:19");
        System.out.println(date2);

        //解析失败。因为参数的字符串不满足SimpleDateFormat可以识别的格式。
//        Date date3 = sdf.parse("22-12-5 下午2:21");
//        System.out.println(date2);
    }

4. Calendar类（日历类）：抽象类
   Calendar:日历类
   ① 实例化 由于Calendar是一个抽象类，所以我们需要创建其子类的实例。这里我们通过Calendar的静态方法getInstance()即可获取
   ②常用方法：get(int field) / set(int field,xx) / add(int field,xx) / getTime() / setTime()

    @Test
    public void test5(){
        Calendar calendar = Calendar.getInstance();

        //测试方法
        //get(int field)
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));

        //set(int field,xx)
        calendar.set(Calendar.DAY_OF_MONTH,23);
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));

        //add(int field,xx)
        calendar.add(Calendar.DAY_OF_MONTH,3);
        calendar.add(Calendar.DAY_OF_MONTH,-5);
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));

        //getTime():Calender --> Date
        Date date = calendar.getTime();
        System.out.println(date);

        //setTime():使用指定Date重置Calendar
        Date date1 = new Date();
        calendar.setTime(date1);
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
    }
}

【面试题】
1.如何将一个java.util.Date的实例转换为java.sql.Date的实例
2.将控制台获取的年月日（比如：2022-12-13）的字符串数据，保存在数据库中。
（简化为得到java.sql.Date的对象，此对象对应的时间为2022-12-13）。

public class Exer01 {
    /*
    * 1：
    如何将一个java.util.Date的实例转换为java.sql.Date的实例
    * */
    @Test
    public void test1(){
        Date date1 = new Date();
        //错误的：
//        java.sql.Date date2 = (java.sql.Date) date1;
//        System.out.println(date2);

        //正确的：
        java.sql.Date date2 = new java.sql.Date(date1.getTime());
        System.out.println(date2);
    }

    /*
    * 2：
        将控制台获取的年月日（比如：2022-12-13）的字符串数据，保存在数据库中。
        （简化为得到java.sql.Date的对象，此对象对应的时间为2022-12-13）。
        *
        * 字符串 ---> java.util.Date ---> java.sql.Date
    * */
    @Test
    public void test2() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String pattern = "2022-12-13";
        //得到java.util.Date
        Date date1 = sdf.parse(pattern);
        //转换为java.sql.Date
        java.sql.Date date2 = new java.sql.Date(date1.getTime());
        System.out.println(date2);
    }
}

二、JDK8中的API:

1. LocalDate,LocalTime,LocalDateTime —>类似于Calendar

实例化：now() / of(xxx,xx,xx)
方法：get() / withXxx() / plusXxx() / minusXxx() …

@Test
    public void test3(){
        //now():获取当前日期和时间对应的实例
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println(localDate);//2022-12-05
        System.out.println(localTime);//15:43:51.474
        System.out.println(localDateTime); //2022-12-05T15:43:51.475

        //of():获取指定的日期、时间对应的实例
        LocalDate localDate1 = LocalDate.of(2021, 5, 23);
        LocalDateTime localDateTime1 = LocalDateTime.of(2022, 12, 5, 11, 23, 45);
        System.out.println(localDate1);
        System.out.println(localDateTime1);

        //getXXX()
        LocalDateTime localDateTime2 = LocalDateTime.now();
        System.out.println(localDateTime2.getDayOfMonth());
        //体现不可变性
        //withXxx()
        LocalDateTime localDateTime3 = localDateTime2.withDayOfMonth(15);
        System.out.println(localDateTime2);//2022-12-05T15:48:48.399
        System.out.println(localDateTime3);//2022-12-15T15:48:48.399
        //plusXxx()
        LocalDateTime localDateTime4 = localDateTime2.plusDays(5);
        System.out.println(localDateTime2);//2022-12-05T15:50:21.864
        System.out.println(localDateTime4);//2022-12-10T15:50:21.864

    }

2. Instant:瞬时 —>类似于Date

实例化：now() / ofEpochMilli()
方法：toEpochMilli()

3. DateTimeFormatter —> 类似于SimpleDateFormat
   用于格式化和解析LocalDate,LocalTime,LocalDateTime

Java比较器

其他类

枚举类和注解

第十章 枚举类与注解

第十一章 集合

1.集合概述

1. 内存层面需要针对于多个数据进行存储。此时，可以考虑的容器有：数组、集合类

2. 数组存储多个数据方面的特点：

   数组一旦初始化，其长度就是确定的。
   数组中的多个元素是依次紧密排列的，有序的，可重复的
   (优点) 数组一旦初始化完成，其元素的类型就是确定的。不是此类型的元素，就不能添加到此数组中。

      int[] arr = new int[10];
      arr[0] = 1;
      arr[1] = "AA";//编译报错
      
      Object[] arr1 = new Object[10];
      arr1[0] = new String();
      arr1[1] = new Date();

(优点)元素的类型既可以是基本数据类型，也可以是引用数据类型。

数组存储多个数据方面的弊端：

数组一旦初始化，其长度就不可变了。
数组中存储数据特点的单一性。对于无序的、不可重复的场景的多个数据就无能为力了。
数组中可用的方法、属性都极少。具体的需求，都需要自己来组织相关的代码逻辑。
针对于数组中元素的删除、插入操作，性能较差。

3. Java集合框架体系（java.util包下）

java.util.Collection:存储一个一个的数据
|-----子接口：List:存储有序的、可重复的数据 ("动态"数组)
        |---- ArrayList(主要实现类)、LinkedList、Vector
|-----子接口：Set:存储无序的、不可重复的数据(高中学习的集合)
        |---- HashSet(主要实现类)、LinkedHashSet、TreeSet

java.util.Map:存储一对一对的数据(key-value键值对。
|---- HashMap(主要实现类)、LinkedHashMap、TreeMap、Hashtable、Properties

4. 学习的程度把握：
   层次1：针对于具体特点的多个数据，知道选择相应的适合的接口的主要实现类，会实例化，会调用常用的方法。
   层次2：区分接口中不同的实现类的区别。
   层次3：① 针对于常用的实现类，需要熟悉底层的源码 ② 熟悉常见的数据结构 （第14章讲）

Collection接口及方法

• JDK不提供此接口的任何直接实现，而是提供更具体的子接口（如：Set和List）去实现。
• Collection 接口是 List和Set接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 集合。
  方法如下：

2.1 添加

（1）add(E obj)：添加元素对象到当前集合中
（2）addAll(Collection other)：添加other集合中的所有元素对象到当前集合中，即this = this ∪ other

注意：add和addAll的区别

package com.atguigu.collection;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

public class TestCollectionAdd {
    @Test
    public void testAdd(){
        //ArrayList是Collection的子接口List的实现类之一。
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        System.out.println(coll);
    }

    @Test
    public void testAddAll(){
        Collection c1 = new ArrayList();
        c1.add(1);
        c1.add(2);
        System.out.println("c1集合元素的个数：" + c1.size());//2
        System.out.println("c1 = " + c1);

        Collection c2 = new ArrayList();
        c2.add(1);
        c2.add(2);
        System.out.println("c2集合元素的个数：" + c2.size());//2
        System.out.println("c2 = " + c2);

        Collection other = new ArrayList();
        other.add(1);
        other.add(2);
        other.add(3);
        System.out.println("other集合元素的个数：" + other.size());//3
        System.out.println("other = " + other);
        System.out.println();

        c1.addAll(other);
        System.out.println("c1集合元素的个数：" + c1.size());//5
        System.out.println("c1.addAll(other) = " + c1);

        c2.add(other);
        System.out.println("c2集合元素的个数：" + c2.size());//3
        System.out.println("c2.add(other) = " + c2);
    }
}

注意：coll.addAll(other);与coll.add(other);

2.2 判断

（3）int size()：获取当前集合中实际存储的元素个数
（4）boolean isEmpty()：判断当前集合是否为空集合
（5）boolean contains(Object obj)：判断当前集合中是否存在一个与obj对象equals返回true的元素
（6）boolean containsAll(Collection coll)：判断coll集合中的元素是否在当前集合中都存在。即coll集合是否是当前集合的“子集”
（7）boolean equals(Object obj)：判断当前集合与obj是否相等

   @Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add("AA");
        Person p1 = new Person("Tom",12);
        coll.add(p1);
        coll.add(128);//自动装箱
        coll.add(new String("尚硅谷"));

        //isEmpty()
        System.out.println(coll.isEmpty());

        //contains(Object obj)
        System.out.println(coll.contains("AA"));//true
        System.out.println(coll.contains(128));//true
        System.out.println(coll.contains(new String("尚硅谷")));//true,因为String重写过equals方法论
        System.out.println(coll.contains(new Person("Tom",12)));//false,因为Person类没有重写equals方法，重写后会变成true。

        //containsAll(Collection coll)
        Collection coll1 = new ArrayList();
        coll1.add("AA");
        coll1.add(128);
        
        System.out.println(coll.containsAll(coll1));
    }

2.3 删除

（8）void clear()：清空集合元素
（9） boolean remove(Object obj) ：从当前集合中删除第一个找到的与obj对象equals返回true的元素。
（10）boolean removeAll(Collection coll)：从当前集合中删除所有与coll集合中相同的元素。即this = this - this ∩ coll
（11）boolean retainAll(Collection coll)：从当前集合中删除两个集合中不同的元素，使得当前集合仅保留与coll集合中的元素相同的元素，即当前集合中仅保留两个集合的交集，即this = this ∩ coll；

注意几种删除方法的区别

@Test
    public void test3(){
        Collection coll = new ArrayList();

        coll.add("AA");
        coll.add("AA");
        Person p1 = new Person("Tom",12);
        coll.add(p1);
        coll.add(128);//自动装箱
        coll.add(new String("尚硅谷"));
        System.out.println(coll);
//        coll.clear();
//        System.out.println(coll);
//        System.out.println(coll.size());//0

        //remove(Object obj)
        coll.remove(new Person("Tom",12));

        coll.remove("AA");
        System.out.println(coll);

    }

2.4 其它

（12）Object[] toArray()：返回包含当前集合中所有元素的数组
（13）hashCode()：获取集合对象的哈希值
（14）iterator()：返回迭代器对象，用于集合遍历

	@Test
    public void test4(){
        Collection coll = new ArrayList();

        coll.add("AA");
        coll.add("AA");
        Person p1 = new Person("Tom",12);
        coll.add(p1);
        coll.add(128);//自动装箱
        coll.add(new String("尚硅谷"));

        //集合 ---> 数组
        Object[] arr = coll.toArray();
        System.out.println(Arrays.toString(arr));

        //hashCode():
        System.out.println(coll.hashCode());

    }

    @Test
    public void test5(){
        String[] arr = new String[]{"AA","BB","CC"};
        Collection list = Arrays.asList(arr);
        System.out.println(list);

        List list1 = Arrays.asList("AA", "BB", "CC", "DD");
        System.out.println(list1);
    }

    @Test
    public void test6(){
        Integer[] arr = new Integer[]{1,2,3};
        List list = Arrays.asList(arr);
        System.out.println(list.size());//3
        System.out.println(list);


        int[] arr1 = new int[]{1,2,3};
        List list1 = Arrays.asList(arr1);
        System.out.println(list1.size());//1
        System.out.println(list1);

    }

3. Iterator(迭代器)接口

3.1 Iterator接口

• 在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同。

  • Collection接口与Map接口主要用于存储元素
  • Iterator，被称为迭代器接口，本身并不提供存储对象的能力，主要用于遍历Collection中的元素

• Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。

  • public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
  • 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

• Iterator接口的常用方法如下：

  • public E next():返回迭代的下一个元素。
  • public boolean hasNext():如果仍有元素可以迭代，则返回 true。

• 注意：在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。

public class IteratorTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();

        coll.add("AA");
        coll.add("AA");
        Person p1 = new Person("Tom",12);
        coll.add(p1);
        coll.add(128);//自动装箱
        coll.add(new String("尚硅谷"));

        //获取迭代器对象
        Iterator iterator = coll.iterator();//多态

        //方式1：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());

//        System.out.println(iterator.next());//如果超出了集合中元素的个数，会报NoSuchElementException异常

        //方式2：
//        for(int i = 0;i < coll.size();i++){
//            System.out.println(iterator.next());
//        }

        //方式3：推荐
        //hasNext():当下一个元素存在的时候，才取元素
        //next():返回集合中的下一个元素。
        while(iterator.hasNext()){//当下一个元素存在的时候，才取元素
            System.out.println(iterator.next());
        }
    }

3.2 迭代器的执行原理

Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，接下来通过一个图例来演示Iterator对象迭代元素的过程：
使用Iterator迭代器删除元素：java.util.Iterator迭代器中有一个方法：void remove() ;

Iterator iter = coll.iterator();//回到起点
while(iter.hasNext()){
    Object obj = iter.next();
    if(obj.equals("Tom")){
        iter.remove();
    }
}

注意：

• Iterator可以删除集合的元素，但是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。

• 如果还未调用next()或在上一次调用 next() 方法之后已经调用了 remove() 方法，再调用remove()都会报IllegalStateException。

• Collection已经有remove(xx)方法了，为什么Iterator迭代器还要提供删除方法呢？因为迭代器的remove()可以按指定的条件进行删除。

例如：要删除以下集合元素中的偶数

package com.atguigu.iterator;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class TestIteratorRemove {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add(1);
        coll.add(2);
        coll.add(3);
        coll.add(4);
        coll.add(5);
        coll.add(6);

        Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            Integer element = (Integer) iterator.next();
            if(element % 2 == 0){
                iterator.remove();
            }
        }
        System.out.println(coll);
    }
}

在JDK8.0时，Collection接口有了removeIf 方法，即可以根据条件删除。（第18章中再讲）

package com.atguigu.collection;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Predicate;

public class TestCollectionRemoveIf {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);

        coll.removeIf(new Predicate() {
            @Override
            public boolean test(Object o) {
                String str = (String) o;
                return str.contains("地");
            }
        });
        System.out.println("删除包含\"地\"字的元素之后coll = " + coll);
    }
}

3.3 foreach循环

• foreach循环（也称增强for循环）是 JDK5.0 中定义的一个高级for循环，专门用来遍历数组和集合的。

• foreach循环的语法格式：

for(元素的数据类型 局部变量 : Collection集合或数组){ 
  	//操作局部变量的输出操作
}
//这里局部变量就是一个临时变量，自己命名就可以

• 举例：

package com.atguigu.iterator;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

public class TestForeach {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
		//foreach循环其实就是使用Iterator迭代器来完成元素的遍历的。
        for (Object o : coll) {
            System.out.println(o);
        }
    }
    @Test
    public void test02(){
        int[] nums = {1,2,3,4,5};
        for (int num : nums) {
            System.out.println(num);
        }
        System.out.println("-----------------");
        String[] names = {"张三","李四","王五"};
        for (String name : names) {
            System.out.println(name);
        }
    }
}

• 对于集合的遍历，增强for的内部原理其实是个Iterator迭代器。
• 它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

4. Collection子接口1：List

4.1 List接口特点

• 鉴于Java中数组用来存储数据的局限性，我们通常使用java.util.List替代数组
• List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
• JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

4.2 List接口方法

List的方法包括从Collection集合继承的方法（共有15个方法），但是List是有序的，进而就有索引，所以List集合里添加了一些根据索引来操作集合元素的方法。

• 插入元素
  • void add(int index, Object ele):在index位置插入ele元素
  • boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
• 获取元素
  • Object get(int index):获取指定index位置的元素
  • List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
• 获取元素索引
  • int indexOf(Object obj):返回obj在集合中首次出现的位置
  • int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
• 删除和替换元素

  • Object remove(int index):移除指定index位置的元素，并返回此元素

  • Object set(int index, Object ele):设置指定index位置的元素为ele

举例：

package com.atguigu.list;

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

public class TestListMethod {
    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);
        }
    }
}

注意：在JavaSE中List名称的类型有两个，一个是java.util.List集合接口，一个是java.awt.List图形界面的组件，别导错包了。

4.3 List接口主要实现类：ArrayList

• ArrayList 是 List 接口的主要实现类

• 本质上，ArrayList是对象引用的一个”变长”数组

• Arrays.asList(…) 方法返回的 List 集合，既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LsbEo4q9-1677635622890)(images/image-20220408210743342.png)]

4.4 List的实现类之二：LinkedList

• 对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高。这是由底层采用链表（双向链表）结构存储数据决定的。
• 特有方法：
  • void addFirst(Object obj)
  • void addLast(Object obj)
  • Object getFirst()
  • Object getLast()
  • Object removeFirst()
  • Object removeLast()

4.5 List的实现类之三：Vector

• Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
• 在各种List中，最好把ArrayList作为默认选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。
• 特有方法：
  • void addElement(Object obj)
  • void insertElementAt(Object obj,int index)
  • void setElementAt(Object obj,int index)
  • void removeElement(Object obj)
  • void removeAllElements()

4.6 练习

面试题：

@Test
public void testListRemove() {
    List list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    updateList(list);
    System.out.println(list);//[1,2]
}

private static void updateList(List list) {
    list.remove(2);  
}

练习1：

• 定义学生类，属性为姓名、年龄，提供必要的getter、setter方法，构造器，toString()，equals()方法。
• 使用ArrayList集合，保存录入的多个学生对象。
• 循环录入的方式，1：继续录入，0：结束录入。
• 录入结束后，用foreach遍历集合。

• 代码实现，效果如图所示：

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XtvTU6FU-1677635622892)(images/1559890098509.png)]

package com.atguigu.test01;

import java.util.ArrayList;
import java.util.Scanner;

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

        Scanner scanner = new Scanner(System.in);
        ArrayList stuList = new ArrayList();

        for (;;) {

            System.out.println("选择（录入 1 ；结束 0）");
            int x = scanner.nextInt();//根据x的值，判断是否需要继续循环

            if (x == 1) {
                System.out.println("姓名");
                String name = scanner.next();
                System.out.println("年龄");
                int age = scanner.nextInt();
                Student stu = new Student(age, name);
                stuList.add(stu);

            } else if (x == 0) {
                break;

            } else {

                System.out.println("输入有误，请重新输入");
            }
        }

        for (Object stu : stuList) {
            System.out.println(stu);
        }
    }
}

public class Student {

    private int age;
    private String name;

    public Student() {
    }

    
    public Student(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}


	public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;

    }

	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}

}

练习2：

​ 1、请定义方法public static int listTest(Collection list,String s)统计集合中指定元素出现的次数

​ 2、创建集合，集合存放随机生成的30个小写字母

​ 3、用listTest统计，a、b、c、x元素的出现次数

​ 4、效果如下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tnsh1jCK-1677635622893)(images/1559896150606.png)]

package com.atguigu.test02;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Random;

public class Test02 {
	public static void main(String[] args) {
		Collection list = new ArrayList();
		Random rand = new Random();
		for (int i = 0; i < 30; i++) {
			list.add((char)(rand.nextInt(26)+97)+"");
		}
		System.out.println(list);
		System.out.println("a:"+listTest(list, "a"));	
		System.out.println("b:"+listTest(list, "b"));	
		System.out.println("c:"+listTest(list, "c"));
		System.out.println("x:"+listTest(list, "x"));	
	}

	public static int listTest(Collection list, String string) {
		int count = 0;
		for (Object object : list) {
			if(string.equals(object)){
				count++;
			}
		}
		return count;
	}
}

练习3：KTV点歌系统

描述

分别使用ArrayList和LinkedList集合，编写一个**KTV点歌系统**的程序。在程序中：

• 指令1代表添加歌曲
• 指令2代表将所选歌曲置顶
• 指令3代表将所选歌曲提前一位
• 指令4代表退出该系统

要求根据用户输入的指令和歌曲名展现歌曲列表。例如输入指令1，输入歌曲名"爱你一万年"，则输出“当前歌曲列表：[爱你一万年]”。

提示

• 为了指引用户操作，首先要将各个指令所表示的含义打印到控制台

  System.out.println("-------------欢迎来到点歌系统------------");
  System.out.println("1.添加歌曲至列表");
  System.out.println("2.将歌曲置顶");
  System.out.println("3.将歌曲前移一位");
  System.out.println("4.退出");
  

• 程序中需要创建一个集合作为歌曲列表，并向其添加一部分歌曲

• 通过ArrayList或LinkedList集合定义的方法操作歌曲列表

代码

• 使用ArrayList集合模拟点歌系统的实现代码，如下所示：

  /**
   * @author 尚硅谷-宋红康
   * @create 20:26
   */
  public class KTVByArrayList {
      private static ArrayList musicList = new ArrayList();// 创建歌曲列表
      private static Scanner sc = new Scanner(System.in);
  
      public static void main(String[] args) {
          addMusicList();// 添加一部分歌曲至歌曲列表
          boolean flag = true;
          while (flag) {
              System.out.println("当前歌曲列表：" + musicList);
              System.out.println("-------------欢迎来到点歌系统------------");
              System.out.println("1.添加歌曲至列表");
              System.out.println("2.将歌曲置顶");
              System.out.println("3.将歌曲前移一位");
              System.out.println("4.退出");
              System.out.print("请输入操作序号：");
              int key = sc.nextInt();// //接收键盘输入的功能选项序号
              // 执行序号对应的功能
              switch (key) {
                  case 1:// 添加歌曲至列表
                      addMusic();
                      break;
                  case 2:// 将歌曲置顶
                      setTop();
                      break;
                  case 3:// 将歌曲前移一位
                      setBefore();
                      break;
                  case 4:// 退出
                      System.out.println("----------------退出---------------");
                      System.out.println("您已退出系统");
                      flag = false;
                      break;
                  default:
                      System.out.println("----------------------------------");
                      System.out.println("功能选择有误，请输入正确的功能序号!");
                      break;
              }
  
          }
      }
  
      // 初始时添加歌曲名称
      private static void addMusicList() {
          musicList.add("本草纲目");
          musicList.add("你是我的眼");
          musicList.add("老男孩");
          musicList.add("白月光与朱砂痣");
          musicList.add("不谓侠");
          musicList.add("爱你");
      }
  
      // 执行添加歌曲
      private static void addMusic() {
          System.out.print("请输入要添加的歌曲名称：");
          String musicName = sc.next();// 获取键盘输入内容
          musicList.add(musicName);// 添加歌曲到列表的最后
          System.out.println("已添加歌曲：" + musicName);
      }
  
      // 执行将歌曲置顶
      private static void setTop() {
          System.out.print("请输入要置顶的歌曲名称：");
          String musicName = sc.next();// 获取键盘输入内容
          int musicIndex = musicList.indexOf(musicName);// 查找指定歌曲位置
          if (musicIndex < 0) {// 判断输入歌曲是否存在
              System.out.println("当前列表中没有输入的歌曲！");
          }else if(musicIndex == 0){
              System.out.println("当前歌曲默认已置顶！");
          }else {
              musicList.remove(musicName);// 移除指定的歌曲
              musicList.add(0, musicName);// 将指定的歌曲放到第一位
              System.out.println("已将歌曲《" + musicName + "》置顶");
          }
      }
  
      // 执行将歌曲置前一位
      private static void setBefore() {
          System.out.print("请输入要置前的歌曲名称：");
          String musicName = sc.next();// 获取键盘输入内容
          int musicIndex = musicList.indexOf(musicName);// 查找指定歌曲位置
          if (musicIndex < 0) {// 判断输入歌曲是否存在
              System.out.println("当前列表中没有输入的歌曲！");
          } else if (musicIndex == 0) {// 判断歌曲是否已在第一位
              System.out.println("当前歌曲已在最顶部！");
          } else {
              musicList.remove(musicName);// 移除指定的歌曲
              musicList.add(musicIndex - 1, musicName);// 将指定的歌曲放到前一位
              System.out.println("已将歌曲《" + musicName + "》置前一位");
          }
      }
  }
  

5. Collection子接口2：Set

5.1 Set接口概述

• Set接口是Collection的子接口，Set接口相较于Collection接口没有提供额外的方法
• Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
• Set集合支持的遍历方式和Collection集合一样：foreach和Iterator。
• Set的常用实现类有：HashSet、TreeSet、LinkedHashSet。

5.2 Set主要实现类：HashSet

5.2.1 HashSet概述

• HashSet 是 Set 接口的主要实现类，大多数时候使用 Set 集合时都使用这个实现类。

• HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存储、查找、删除性能。

• HashSet 具有以下特点：

  • 不能保证元素的排列顺序
  • HashSet 不是线程安全的
  • 集合元素可以是 null

• HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法得到的哈希值相等，并且两个对象的 equals() 方法返回值为true。

• 对于存放在Set容器中的对象，对应的类一定要重写hashCode()和equals(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。

• HashSet集合中元素的无序性，不等同于随机性。这里的无序性与元素的添加位置有关。具体来说：我们在添加每一个元素到数组中时，具体的存储位置是由元素的hashCode()调用后返回的hash值决定的。导致在数组中每个元素不是依次紧密存放的，表现出一定的无序性。

5.2.2 HashSet中添加元素的过程：

• 第1步：当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法得到该对象的 hashCode值，然后根据 hashCode值，通过某个散列函数决定该对象在 HashSet 底层数组中的存储位置。

• 第2步：如果要在数组中存储的位置上没有元素，则直接添加成功。

• 第3步：如果要在数组中存储的位置上有元素，则继续比较：

  • 如果两个元素的hashCode值不相等，则添加成功；
  • 如果两个元素的hashCode()值相等，则会继续调用equals()方法：
    • 如果equals()方法结果为false，则添加成功。
    • 如果equals()方法结果为true，则添加失败。

  第2步添加成功，元素会保存在底层数组中。

  第3步两种添加成功的操作，由于该底层数组的位置已经有元素了，则会通过链表的方式继续链接，存储。

举例：

package com.atguigu.set;

import java.util.Objects;

public class MyDate {
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyDate myDate = (MyDate) o;
        return year == myDate.year &&
                month == myDate.month &&
                day == myDate.day;
    }

    @Override
    public int hashCode() {
        return Objects.hash(year, month, day);
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

package com.atguigu.set;

import org.junit.Test;

import java.util.HashSet;

public class TestHashSet {
    @Test
    public void test01(){
        HashSet set = new HashSet();
        set.add("张三");
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("王五");
        set.add("赵六");

        System.out.println("set = " + set);//不允许重复，无序
    }

    @Test
    public void test02(){
        HashSet set = new HashSet();
        set.add(new MyDate(2021,1,1));
        set.add(new MyDate(2021,1,1));
        set.add(new MyDate(2022,2,4));
        set.add(new MyDate(2022,2,4));


        System.out.println("set = " + set);//不允许重复，无序
    }
}

5.2.3 重写 hashCode() 方法的基本原则

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

注意：如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。

5.2.4 重写equals()方法的基本原则

• 重写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。

• 推荐：开发中直接调用Eclipse/IDEA里的快捷键自动重写equals()和hashCode()方法即可。

  • 为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？

  首先，选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
  
  其次，31只占用5bits,相乘造成数据溢出的概率较小。
  
  再次，31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）
  
  最后，31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！(减少冲突)
  

5.2.5 练习

**练习1：**在List内去除重复数字值，要求尽量简单

public static List duplicateList(List list) {
      HashSet set = new HashSet();
      set.addAll(list);
      return new ArrayList(set);
}
public static void main(String[] args) {
      List list = new ArrayList();
      list.add(new Integer(1));
      list.add(new Integer(2));
      list.add(new Integer(2));
      list.add(new Integer(4));
      list.add(new Integer(4));
      List list2 = duplicateList(list);
      for (Object integer : list2) {
          System.out.println(integer);
      }
}

**练习2：**获取随机数

编写一个程序，获取10个1至20的随机数，要求随机数不能重复。并把最终的随机数输出到控制台。

/**
 * 
 * @Description 
 * @author 尚硅谷-宋红康
 * @date 2022年5月7日上午12:43:01
 *
 */
public class RandomValueTest {
	public static void main(String[] args) {
		HashSet hs = new HashSet(); // 创建集合对象
		Random r = new Random();
		while (hs.size() < 10) {
			int num = r.nextInt(20) + 1; // 生成1到20的随机数
			hs.add(num);
		}

		for (Integer integer : hs) { // 遍历集合
			System.out.println(integer); // 打印每一个元素
		}
	}
}

**练习3：**去重

使用Scanner从键盘读取一行输入，去掉其中重复字符，打印出不同的那些字符。比如：aaaabbbcccddd

/**
 * 
 * @Description 
 * @author 尚硅谷-宋红康
 * @date 2022年5月7日上午12:44:01
 *
 */
public class DistinctTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in); // 创建键盘录入对象
		System.out.println("请输入一行字符串:");
		String line = sc.nextLine(); // 将键盘录入的字符串存储在line中
		char[] arr = line.toCharArray(); // 将字符串转换成字符数组
        
		HashSet hs = new HashSet(); // 创建HashSet集合对象

		for (Object c : arr) { // 遍历字符数组
			hs.add(c); // 将字符数组中的字符添加到集合中
		}

		for (Object ch : hs) { // 遍历集合
			System.out.print(ch);
		}
	}
}

**练习4：**面试题

HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");

set.add(p1);
set.add(p2);
p1.name = "CC";
set.remove(p1);
System.out.println(set);

set.add(new Person(1001,"CC"));
System.out.println(set);

set.add(new Person(1001,"AA"));
System.out.println(set);

//其中Person类中重写了hashCode()和equal()方法

5.3 Set实现类之二：LinkedHashSet

• LinkedHashSet 是 HashSet 的子类，不允许集合元素重复。

• LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以添加顺序保存的。

• LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。

举例：

package com.atguigu.set;

import org.junit.Test;

import java.util.LinkedHashSet;

public class TestLinkedHashSet {
    @Test
    public void test01(){
        LinkedHashSet set = new LinkedHashSet();
        set.add("张三");
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("王五");
        set.add("赵六");

        System.out.println("set = " + set);//不允许重复，体现添加顺序
    }
}

5.4 Set实现类之三：TreeSet

5.4.1 TreeSet概述

• TreeSet 是 SortedSet 接口的实现类，TreeSet 可以按照添加的元素的指定的属性的大小顺序进行遍历。
• TreeSet底层使用红黑树结构存储数据
• 新增的方法如下： (了解)
  • Comparator comparator()
  • Object first()
  • Object last()
  • Object lower(Object e)
  • Object higher(Object e)
  • SortedSet subSet(fromElement, toElement)
  • SortedSet headSet(toElement)
  • SortedSet tailSet(fromElement)
• TreeSet特点：不允许重复、实现排序（自然排序或定制排序）
• TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。
  • 自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列。
    • 如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
    • 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
  • 定制排序：如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。
    • 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
    • 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
• 因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象。
• 对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 或compare(Object o1,Object o2)方法比较返回值。返回值为0，则认为两个对象相等。

5.4.2 举例

举例1：

package com.atguigu.set;


import org.junit.Test;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * @author 尚硅谷-宋红康
 * @create 14:22
 */
public class TreeSetTest {
    /*
    * 自然排序：针对String类的对象
    * */
    @Test
    public void test1(){
        TreeSet set = new TreeSet();

        set.add("MM");
        set.add("CC");
        set.add("AA");
        set.add("DD");
        set.add("ZZ");
        //set.add(123);  //报ClassCastException的异常

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    /*
    * 自然排序：针对User类的对象
    * */
    @Test
    public void test2(){
        TreeSet set = new TreeSet();

        set.add(new User("Tom",12));
        set.add(new User("Rose",23));
        set.add(new User("Jerry",2));
        set.add(new User("Eric",18));
        set.add(new User("Tommy",44));
        set.add(new User("Jim",23));
        set.add(new User("Maria",18));
        //set.add("Tom");

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println(set.contains(new User("Jack", 23))); //true
    }
}

其中，User类定义如下：

/**
 * @author 尚硅谷-宋红康
 * @create 14:22
 */
public class User implements Comparable{
    String name;
    int age;
    
	public User() {
    }
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    /*
    举例：按照age从小到大的顺序排列，如果age相同，则按照name从大到小的顺序排列
    * */
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }

        if(o instanceof User){
            User user = (User)o;
            int value = this.age - user.age;
            if(value != 0){
                return value;
            }
            return -this.name.compareTo(user.name);
        }
        throw new RuntimeException("输入的类型不匹配");
    }
}

举例2：

/*
 * 定制排序
 * */
@Test
public void test3(){
    //按照User的姓名的从小到大的顺序排列
    Comparator comparator = new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof User && o2 instanceof User){
                User u1 = (User)o1;
                User u2 = (User)o2;

                return u1.name.compareTo(u2.name);
            }
            throw new RuntimeException("输入的类型不匹配");
        }
    };
    TreeSet set = new TreeSet(comparator);

    set.add(new User("Tom",12));
    set.add(new User("Rose",23));
    set.add(new User("Jerry",2));
    set.add(new User("Eric",18));
    set.add(new User("Tommy",44));
    set.add(new User("Jim",23));
    set.add(new User("Maria",18));
    //set.add(new User("Maria",28));

    Iterator iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

5.4.3 练习

**练习1：**在一个List集合中存储了多个无大小顺序并且有重复的字符串，定义一个方法，让其有序(从小到大排序)，并且不能去除重复元素。

提示：考查ArrayList、TreeSet

/**
 * 
 * @Description
 * @author 尚硅谷-宋红康
 * @date 2022年4月7日上午12:50:46
 *
 */
public class SortTest {
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add("ccc");
		list.add("ccc");
		list.add("aaa");
		list.add("aaa");
		list.add("bbb");
		list.add("ddd");
		list.add("ddd");
		sort(list);
		System.out.println(list);
	}

	/*
	 * 对集合中的元素排序,并保留重复
	 */
	public static void sort(List list) {
		TreeSet ts = new TreeSet(new Comparator() { 
			@Override
			public int compare(Object o1, Object o2) { // 重写compare方法
                String s1 = (String)o1;
                String s2 = (String)o2;
				int num = s1.compareTo(s2); // 比较内容
				return num == 0 ? 1 : num; // 如果内容一样返回一个不为0的数字即可
			}
		});

		ts.addAll(list); // 将list集合中的所有元素添加到ts中
		list.clear(); // 清空list
		list.addAll(ts); // 将ts中排序并保留重复的结果在添加到list中
	}
}

**练习2：**TreeSet的自然排序和定制排序

1. 定义一个Employee类。
   该类包含：private成员变量name,age,birthday，其中 birthday 为 MyDate 类的对象；
   并为每一个属性定义 getter, setter 方法；
   并重写 toString 方法输出 name, age, birthday

2. MyDate类包含:
   private成员变量year,month,day；并为每一个属性定义 getter, setter 方法；

3. 创建该类的 5 个对象，并把这些对象放入 TreeSet 集合中（下一章：TreeSet 需使用泛型来定义）

4. 分别按以下两种方式对集合中的元素进行排序，并遍历输出：

   1). 使Employee 实现 Comparable 接口，并按 name 排序
   2). 创建 TreeSet 时传入 Comparator对象，按生日日期的先后排序。

代码实现：

public class MyDate implements Comparable{
    private int year;
    private int month;
    private int day;

    public MyDate() {
    }

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
//        return "MyDate{" +
//                "year=" + year +
//                ", month=" + month +
//                ", day=" + day +
//                '}';
        return year + "年" + month + "月" + day + "日";
    }

    @Override
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }
        if(o instanceof MyDate){
            MyDate myDate = (MyDate) o;
            int yearDistance = this.getYear() - myDate.getYear();
            if(yearDistance != 0){
                return yearDistance;
            }
            int monthDistance = this.getMonth() - myDate.getMonth();
            if(monthDistance != 0){
                return monthDistance;
            }

            return this.getDay() - myDate.getDay();
        }
        throw new RuntimeException("输入的类型不匹配");
    }
}

public class Employee implements Comparable{
    private String name;
    private int age;
    private MyDate birthday;


    public Employee() {
    }

    public Employee(String name, int age, MyDate birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    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;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", birthday=" + birthday +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if(o == this){
            return 0;
        }
        if(o instanceof Employee){
            Employee emp = (Employee) o;
            return this.name.compareTo(emp.name);
        }
        throw new RuntimeException("传入的类型不匹配");
    }
}

public class EmployeeTest {
    /*
    自然排序：
    创建该类的 5 个对象，并把这些对象放入 TreeSet 集合中
    * 需求1：使Employee 实现 Comparable 接口，并按 name 排序
    * */
    @Test
    public void test1(){
        TreeSet set = new TreeSet();

        Employee e1 = new Employee("Tom",23,new MyDate(1999,7,9));
        Employee e2 = new Employee("Rose",43,new MyDate(1999,7,19));
        Employee e3 = new Employee("Jack",54,new MyDate(1998,12,21));
        Employee e4 = new Employee("Jerry",12,new MyDate(2002,4,21));
        Employee e5 = new Employee("Tony",22,new MyDate(2001,9,12));

        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);

        //遍历
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    /*
    * 定制排序：
    * 创建 TreeSet 时传入 Comparator对象，按生日日期的先后排序。
    * */
    @Test
    public void test2(){
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Employee && o2 instanceof Employee){
                    Employee e1 = (Employee) o1;
                    Employee e2 = (Employee) o2;
                    //对比两个employee的生日的大小
                    MyDate birth1 = e1.getBirthday();
                    MyDate birth2 = e2.getBirthday();
                    //方式1：
//                    int yearDistance = birth1.getYear() - birth2.getYear();
//                    if(yearDistance != 0){
//                        return yearDistance;
//                    }
//                    int monthDistance = birth1.getMonth() - birth2.getMonth();
//                    if(monthDistance != 0){
//                        return monthDistance;
//                    }
//
//                    return birth1.getDay() - birth2.getDay();

                    //方式2：
                    return birth1.compareTo(birth2);
                }

                throw new RuntimeException("输入的类型不匹配");

            }
        };
        TreeSet set = new TreeSet(comparator);

        Employee e1 = new Employee("Tom",23,new MyDate(1999,7,9));
        Employee e2 = new Employee("Rose",43,new MyDate(1999,7,19));
        Employee e3 = new Employee("Jack",54,new MyDate(1998,12,21));
        Employee e4 = new Employee("Jerry",12,new MyDate(2002,4,21));
        Employee e5 = new Employee("Tony",22,new MyDate(2001,9,12));

        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);

        //遍历
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

6. Map接口

现实生活与开发中，我们常会看到这样的一类集合：用户ID与账户信息、学生姓名与考试成绩、IP地址与主机名等，这种一一对应的关系，就称作映射。Java提供了专门的集合框架用来存储这种映射关系的对象，即java.util.Map接口。

6.1 Map接口概述

• Map与Collection并列存在。用于保存具有映射关系的数据：key-value

  • Collection集合称为单列集合，元素是孤立存在的（理解为单身）。
  • Map集合称为双列集合，元素是成对存在的(理解为夫妻)。

• Map 中的 key 和 value 都可以是任何引用类型的数据。但常用String类作为Map的“键”。

• Map接口的常用实现类：HashMap、LinkedHashMap、TreeMap和``Properties。其中，HashMap是 Map 接口使用频率最高`的实现类。

6.2 Map中key-value特点

这里主要以HashMap为例说明。HashMap中存储的key、value的特点如下：

• Map 中的 key用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法

• key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value，不同key对应的value可以重复。value所在的类要重写equals()方法。

• key和value构成一个entry。所有的entry彼此之间是无序的、不可重复的。

6.2 Map接口的常用方法

• 添加、修改操作：
  • Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
  • void putAll(Map m):将m中的所有key-value对存放到当前map中
• 删除操作：
  • Object remove(Object key)：移除指定key的key-value对，并返回value
  • void clear()：清空当前map中的所有数据
• 元素查询的操作：
  • Object get(Object key)：获取指定key对应的value
  • boolean containsKey(Object key)：是否包含指定的key
  • boolean containsValue(Object value)：是否包含指定的value
  • int size()：返回map中key-value对的个数
  • boolean isEmpty()：判断当前map是否为空
  • boolean equals(Object obj)：判断当前map和参数对象obj是否相等
• 元视图操作的方法：
  • Set keySet()：返回所有key构成的Set集合
  • Collection values()：返回所有value构成的Collection集合
  • Set entrySet()：返回所有key-value对构成的Set集合

举例：

package com.atguigu.map;

import java.util.HashMap;

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

        //添加元素到集合
        map.put("黄晓明", "杨颖");
        map.put("李晨", "李小璐");
        map.put("李晨", "范冰冰");
        map.put("邓超", "孙俪");
        System.out.println(map);

        //删除指定的key-value
        System.out.println(map.remove("黄晓明"));
        System.out.println(map);

        //查询指定key对应的value
        System.out.println(map.get("邓超"));
        System.out.println(map.get("黄晓明"));

    }
}

举例：

public static void main(String[] args) {
    HashMap map = new HashMap();
    map.put("许仙", "白娘子");
    map.put("董永", "七仙女");
    map.put("牛郎", "织女");
    map.put("许仙", "小青");

    System.out.println("所有的key:");
    Set keySet = map.keySet();
    for (Object key : keySet) {
        System.out.println(key);
    }

    System.out.println("所有的value:");
    Collection values = map.values();
    for (Object value : values) {
        System.out.println(value);
    }

    System.out.println("所有的映射关系:");
    Set entrySet = map.entrySet();
    for (Object mapping : entrySet) {
        //System.out.println(entry);
        Map.Entry entry = (Map.Entry) mapping;
        System.out.println(entry.getKey() + "->" + entry.getValue());
    }
}

6.3 Map的主要实现类：HashMap

6.3.1 HashMap概述

• HashMap是 Map 接口使用频率最高的实现类。
• HashMap是线程不安全的。允许添加 null 键和 null 值。
• 存储数据采用的哈希表结构，底层使用一维数组+单向链表+红黑树进行key-value数据的存储。与HashSet一样，元素的存取顺序不能保证一致。
• HashMap 判断两个key相等的标准是：两个 key 的hashCode值相等，通过 equals() 方法返回 true。
• HashMap 判断两个value相等的标准是：两个 value 通过 equals() 方法返回 true。

6.3.2 练习

**练习1：**添加你喜欢的歌手以及你喜欢他唱过的歌曲

例如：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p0l0W7Gx-1677635622894)(images/image-20220914190805362.png)]

//方式1
/**
 * @author 尚硅谷-宋红康
 * @create 9:03
 */
public class SingerTest1 {
    public static void main(String[] args) {

        //创建一个HashMap用于保存歌手和其歌曲集

        HashMap singers = new HashMap();
        //声明一组key,value
        String singer1 = "周杰伦";

        ArrayList songs1 = new ArrayList();
        songs1.add("双节棍");
        songs1.add("本草纲目");
        songs1.add("夜曲");
        songs1.add("稻香");
        //添加到map中
        singers.put(singer1,songs1);
        //声明一组key,value
        String singer2 = "陈奕迅";
        List songs2 = Arrays.asList("浮夸", "十年", "红玫瑰", "好久不见", "孤勇者");
        //添加到map中
        singers.put(singer2,songs2);

        //遍历map
        Set entrySet = singers.entrySet();
        for(Object obj : entrySet){
            Map.Entry entry = (Map.Entry)obj;
            String singer = (String) entry.getKey();
            List songs = (List) entry.getValue();

            System.out.println("歌手：" + singer);
            System.out.println("歌曲有：" + songs);
        }

    }
}

//方式2：改为HashSet实现
public class SingerTest2 {
	@Test
	public void test1() {

		Singer singer1 = new Singer("周杰伦");
		Singer singer2 = new Singer("陈奕迅");

		Song song1 = new Song("双节棍");
		Song song2 = new Song("本草纲目");
		Song song3 = new Song("夜曲");
		Song song4 = new Song("浮夸");
		Song song5 = new Song("十年");
		Song song6 = new Song("孤勇者");

		HashSet h1 = new HashSet();// 放歌手一的歌曲
		h1.add(song1);
		h1.add(song2);
		h1.add(song3);

		HashSet h2 = new HashSet();// 放歌手二的歌曲
		h2.add(song4);
		h2.add(song5);
		h2.add(song6);

		HashMap hashMap = new HashMap();// 放歌手和他对应的歌曲
		hashMap.put(singer1, h1);
		hashMap.put(singer2, h2);

		for (Object obj : hashMap.keySet()) {
			System.out.println(obj + "=" + hashMap.get(obj));
		}

	}
}

//歌曲
public class Song implements Comparable{
	private String songName;//歌名

	public Song() {
		super();
	}

	public Song(String songName) {
		super();
		this.songName = songName;
	}

	public String getSongName() {
		return songName;
	}

	public void setSongName(String songName) {
		this.songName = songName;
	}

	@Override
	public String toString() {
		return "《" + songName + "》";
	}

	@Override
	public int compareTo(Object o) {
		if(o == this){
			return 0;
		}
		if(o instanceof Song){
			Song song = (Song)o;
			return songName.compareTo(song.getSongName());
		}
		return 0;
	}
	
	
}
//歌手
public class Singer implements Comparable{
	private String name;
	private Song song;
	
	public Singer() {
		super();
	}

	public Singer(String name) {
		super();
		this.name = name;
		
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Song getSong() {
		return song;
	}

	public void setSong(Song song) {
		this.song = song;
	}

	@Override
	public String toString() {
		return name;
	}

	@Override
	public int compareTo(Object o) {
		if(o == this){
			return 0;
		}
		if(o instanceof Singer){
			Singer singer = (Singer)o;
			return name.compareTo(singer.getName());
		}
		return 0;
	}
}

练习2：二级联动

将省份和城市的名称保存在集合中，当用户选择省份以后，二级联动，显示对应省份的地级市供用户选择。

效果演示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dxc2uiAp-1677635622895)(images/clip_image001.png)]

/**
 * 
 * @Description 
 * @author 尚硅谷-宋红康  Email:shkstart@126.com
 * @version 
 * @date 2021年5月7日上午12:26:59
 *
 */
class CityMap{
	
	public static Map model = new HashMap();
	
	static {
		model.put("北京", new String[] {"北京"});
		model.put("上海", new String[] {"上海"});
		model.put("天津", new String[] {"天津"});
		model.put("重庆", new String[] {"重庆"});
		model.put("黑龙江", new String[] {"哈尔滨","齐齐哈尔","牡丹江","大庆","伊春","双鸭山","绥化"});
		model.put("吉林", new String[] {"长春","延边","吉林","白山","白城","四平","松原"});
		model.put("河北", new String[] {"石家庄","张家口","邯郸","邢台","唐山","保定","秦皇岛"});
	}
	
}

public class ProvinceTest {
	public static void main(String[] args) {
		
		Set keySet = CityMap.model.keySet();
		for(Object s : keySet) {
			System.out.print(s + "\t");
		}
		System.out.println();
		System.out.println("请选择你所在的省份：");
		Scanner scan = new Scanner(System.in);
		String province = scan.next();
		
		String[] citys = (String[])CityMap.model.get(province);
		for(String city : citys) {
			System.out.print(city + "\t");
		}
		System.out.println();
		System.out.println("请选择你所在的城市：");
		String city = scan.next();
		
		System.out.println("信息登记完毕");
	}
	
}

练习3：WordCount统计

需求：统计字符串中每个字符出现的次数

String str = “aaaabbbcccccccccc”;

提示：

char[] arr = str.toCharArray(); //将字符串转换成字符数组

HashMap hm = new HashMap(); //创建双列集合存储键和值，键放字符，值放次数

/**
 * 
 * @author 尚硅谷-宋红康 
 * @date 2022年5月7日上午12:26:59
 *
 */
public class WordCountTest {
	public static void main(String[] args) {
        String str = "aaaabbbcccccccccc";
        char[] arr = str.toCharArray(); // 将字符串转换成字符数组
        HashMap map = new HashMap(); // 创建双列集合存储键和值

        for (char c : arr) { // 遍历字符数组
            if (!map.containsKey(c)) { // 如果不包含这个键
                map.put(c, 1); // 就将键和值为1添加
            } else { // 如果包含这个键
                map.put(c, (int)map.get(c) + 1); // 就将键和值再加1添加进来
            }

        }

        for (Object key : map.keySet()) { // 遍历双列集合
            System.out.println(key + "=" + map.get(key));
        }

    }
}

6.4 Map实现类之二：LinkedHashMap

• LinkedHashMap 是 HashMap 的子类
• 存储数据采用的哈希表结构+链表结构，在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的先后顺序，可以保证遍历元素时，与添加的顺序一致。
• 通过哈希表结构可以保证键的唯一、不重复，需要键所在类重写hashCode()方法、equals()方法。

public class TestLinkedHashMap {
    public static void main(String[] args) {
        LinkedHashMap map = new LinkedHashMap();
        map.put("王五", 13000.0);
        map.put("张三", 10000.0);
        //key相同，新的value会覆盖原来的value
        //因为String重写了hashCode和equals方法
        map.put("张三", 12000.0);
        map.put("李四", 14000.0);
        //HashMap支持key和value为null值
        String name = null;
        Double salary = null;
        map.put(name, salary);

        Set entrySet = map.entrySet();
        for (Object obj : entrySet) {
        	Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry);
        }
    }
}

6.5 Map实现类之三：TreeMap

• TreeMap存储 key-value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 key-value 对处于有序状态。
• TreeSet底层使用红黑树结构存储数据
• TreeMap 的 Key 的排序：
  • 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
  • 定制排序：创建 TreeMap 时，构造器传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口
• TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

/**
 * @author 尚硅谷-宋红康
 * @create 1:23
 */
public class TestTreeMap {
    /*
    * 自然排序举例
    * */
    @Test
    public void test1(){
        TreeMap map = new TreeMap();

        map.put("CC",45);
        map.put("MM",78);
        map.put("DD",56);
        map.put("GG",89);
        map.put("JJ",99);

        Set entrySet = map.entrySet();
        for(Object entry : entrySet){
            System.out.println(entry);
        }

    }

    /*
    * 定制排序
    *
    * */
    @Test
    public void test2(){
        //按照User的姓名的从小到大的顺序排列

        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;

                    return u1.name.compareTo(u2.name);
                }
                throw new RuntimeException("输入的类型不匹配");
            }
        });

        map.put(new User("Tom",12),67);
        map.put(new User("Rose",23),"87");
        map.put(new User("Jerry",2),88);
        map.put(new User("Eric",18),45);
        map.put(new User("Tommy",44),77);
        map.put(new User("Jim",23),88);
        map.put(new User("Maria",18),34);

        Set entrySet = map.entrySet();
        for(Object entry : entrySet){
            System.out.println(entry);
        }
    }
}

class User implements Comparable{
    String name;
    int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public User() {
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    /*
    举例：按照age从小到大的顺序排列，如果age相同，则按照name从大到小的顺序排列
    * */
    @Override
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }

        if(o instanceof User){
            User user = (User)o;
            int value = this.age - user.age;
            if(value != 0){
                return value;
            }
            return -this.name.compareTo(user.name);
        }
        throw new RuntimeException("输入的类型不匹配");
    }
}

6.6 Map实现类之四：Hashtable

• Hashtable是Map接口的古老实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。
• Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构（数组+单向链表），查询速度快。
• 与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序
• Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。
• 与HashMap不同，Hashtable 不允许使用 null 作为 key 或 value。

面试题：Hashtable和HashMap的区别

HashMap:底层是一个哈希表（jdk7:数组+链表;jdk8:数组+链表+红黑树）,是一个线程不安全的集合,执行效率高
Hashtable:底层也是一个哈希表（数组+链表）,是一个线程安全的集合,执行效率低

HashMap集合:可以存储null的键、null的值
Hashtable集合,不能存储null的键、null的值

Hashtable和Vector集合一样,在jdk1.2版本之后被更先进的集合(HashMap,ArrayList)取代了。所以HashMap是Map的主要实现类，Hashtable是Map的古老实现类。

Hashtable的子类Properties（配置文件）依然活跃在历史舞台
Properties集合是一个唯一和IO流相结合的集合

6.7 Map实现类之五：Properties

• Properties 类是 Hashtable 的子类，该对象用于处理属性文件

• 由于属性文件里的 key、value 都是字符串类型，所以 Properties 中要求 key 和 value 都是字符串类型

• 存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法

@Test
public void test01() {
    Properties properties = System.getProperties();
    String fileEncoding = properties.getProperty("file.encoding");//当前源文件字符编码
    System.out.println("fileEncoding = " + fileEncoding);
}
@Test
public void test02() {
    Properties properties = new Properties();
    properties.setProperty("user","songhk");
    properties.setProperty("password","123456");
    System.out.println(properties);
}

@Test
public void test03() throws IOException {
    Properties pros = new Properties();
    pros.load(new FileInputStream("jdbc.properties"));
    String user = pros.getProperty("user");
    System.out.println(user);
}

7. Collections工具类

参考操作数组的工具类：Arrays，Collections 是一个操作 Set、List 和 Map 等集合的工具类。

7.1 常用方法

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法（均为static方法）：

排序操作：

• reverse(List)：反转 List 中元素的顺序
• shuffle(List)：对 List 集合元素进行随机排序
• sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
• sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
• swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

查找

• Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
• Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
• Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素
• Object min(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最小元素
• int binarySearch(List list,T key)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且必须是可比较大小的，即支持自然排序的。而且集合也事先必须是有序的，否则结果不确定。
• int binarySearch(List list,T key,Comparator c)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且集合也事先必须是按照c比较器规则进行排序过的，否则结果不确定。
• int frequency(Collection c，Object o)：返回指定集合中指定元素的出现次数

复制、替换

• void copy(List dest,List src)：将src中的内容复制到dest中
• boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
• 提供了多个unmodifiableXxx()方法，该方法返回指定 Xxx的不可修改的视图。

添加

• boolean addAll(Collection c,T… elements)将所有指定元素添加到指定 collection 中。

同步

• Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ij99169D-1677635622896)(images/image-20220409003002526.png)]

7.2 举例

package com.atguigu.collections;

import org.junit.Test;

import java.text.Collator;
import java.util.*;

public class TestCollections {
    @Test
    public void test01(){
        /*
        public static <T> boolean addAll(Collection<? super T> c,T... elements)
        将所有指定元素添加到指定 collection 中。Collection的集合的元素类型必须>=T类型
        */
        Collection<Object> coll = new ArrayList<>();
        Collections.addAll(coll, "hello","java");
        Collections.addAll(coll, 1,2,3,4);

        Collection<String> coll2 = new ArrayList<>();
        Collections.addAll(coll2, "hello","java");
        //Collections.addAll(coll2, 1,2,3,4);//String和Integer之间没有父子类关系
    }

	@Test
    public void test02(){
/*
 * public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
 * 在coll集合中找出最大的元素，集合中的对象必须是T或T的子类对象，而且支持自然排序
*  
*  public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp)
*  在coll集合中找出最大的元素，集合中的对象必须是T或T的子类对象，按照比较器comp找出最大者
*
*/
        List<Man> list = new ArrayList<>();
        list.add(new Man("张三",23));
        list.add(new Man("李四",24));
        list.add(new Man("王五",25));

        /*
         * Man max = Collections.max(list);//要求Man实现Comparable接口，或者父类实现
         * System.out.println(max);
         */

        Man max = Collections.max(list, new Comparator<Man>() {
            @Override
            public int compare(Man o1, Man o2) {
                return o2.getAge()-o2.getAge();
            }
        });
        System.out.println(max);
    }

	@Test
    public void test03(){
        /*
         * public static void reverse(List<?> list)
         * 反转指定列表List中元素的顺序。
         */
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"hello","java","world");
        System.out.println(list);

        Collections.reverse(list);
        System.out.println(list);
    }
	@Test
    public void test04(){
        /*
         * public static void shuffle(List<?> list) 
         * List 集合元素进行随机排序，类似洗牌，打乱顺序
         */
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"hello","java","world");

        Collections.shuffle(list);
        System.out.println(list);
    }
	@Test
    public void test05() {
        /*
         * public static <T extends Comparable<? super T>> void sort(List<T> list)
         * 根据元素的自然顺序对指定 List 集合元素按升序排序
         *
         * public static <T> void sort(List<T> list,Comparator<? super T> c)
         * 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
         */
        List<Man> list = new ArrayList<>();
        list.add(new Man("张三",23));
        list.add(new Man("李四",24));
        list.add(new Man("王五",25));

        Collections.sort(list);
        System.out.println(list);

        Collections.sort(list, new Comparator<Man>() {
            @Override
            public int compare(Man o1, Man o2) {
                return Collator.getInstance(Locale.CHINA).compare(o1.getName(),o2.getName());
            }
        });
        System.out.println(list);
    }
	@Test
    public void test06(){
        /*
         * public static void swap(List<?> list,int i,int j)
         * 将指定 list 集合中的 i 处元素和 j 处元素进行交换
         */
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"hello","java","world");

        Collections.swap(list,0,2);
        System.out.println(list);
    }
	@Test
    public void test07(){
        /*
         * public static int frequency(Collection<?> c,Object o)
         * 返回指定集合中指定元素的出现次数
         */
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"hello","java","world","hello","hello");
        int count = Collections.frequency(list, "hello");
        System.out.println("count = " + count);
    }
	@Test
    public void test08(){
        /*
         * public static <T> void copy(List<? super T> dest,List<? extends T> src)
         * 将src中的内容复制到dest中
         */
        List<Integer> list = new ArrayList<>();
        for(int i=1; i<=5; i++){//1-5
            list.add(i);
        }

        List<Integer> list2 = new ArrayList<>();
        for(int i=11; i<=13; i++){//11-13
            list2.add(i);
        }

        Collections.copy(list, list2);
        System.out.println(list);

        List<Integer> list3 = new ArrayList<>();
        for(int i=11; i<=20; i++){//11-20
            list3.add(i);
        }
		//java.lang.IndexOutOfBoundsException: Source does not fit in dest
        //Collections.copy(list, list3);
        //System.out.println(list);

    }
	
	@Test
    public void test09(){
        /*
         * public static <T> boolean replaceAll(List<T> list，T oldVal，T newVal)
         * 使用新值替换 List 对象的所有旧值
         */
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"hello","java","world","hello","hello");

        Collections.replaceAll(list, "hello","song");
        System.out.println(list);
    }
}

7.3 练习

练习1：

请从键盘随机输入10个整数保存到List中，并按倒序、从大到小的顺序显示出来

**练习2：**模拟斗地主洗牌和发牌，牌没有排序

效果演示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r8H93zSH-1677635622897)(images/image-20220409011625061.png)]

提示：

String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

String[] color = {"方片","梅花","红桃","黑桃"};

ArrayList<String> poker = new ArrayList<>();

代码示例：

/**
 * 
 * @author 尚硅谷-宋红康
 * @date 2022年5月7日上午12:26:59
 *
 */
public class PokerTest {
	
	public static void main(String[] args) {
		String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
		String[] color = {"方片","梅花","红桃","黑桃"};
		ArrayList poker = new ArrayList();
		//1. 生成54张扑克牌
		for (String s1 : color) {
			for (String s2 : num) {
				poker.add(s1.concat(" " + s2));
			}
		}

		poker.add("小王");
		poker.add("大王");
		//2. 洗牌
		Collections.shuffle(poker);
		//3. 发牌
		ArrayList tomCards = new ArrayList();
        ArrayList jerryCards = new ArrayList();
        ArrayList meCards = new ArrayList();
        ArrayList lastCards = new ArrayList();

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

            if(i >= poker.size() - 3){
                lastCards.add(poker.get(i));
            }else if(i % 3 == 0){
                tomCards.add(poker.get(i));
            }else if(i % 3 == 1){
                jerryCards.add(poker.get(i));
            }else {
                meCards.add(poker.get(i));
            }

        }

		//4. 看牌
		System.out.println("Tom:\n" + tomCards);
        System.out.println("Jerry:\n" + jerryCards);
        System.out.println("me:\n" + meCards);
        System.out.println("底牌:\n" + lastCards);
	}
}

**练习3：**模拟斗地主洗牌和发牌并对牌进行排序的代码实现。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vcbTrS0o-1677635622898)(images/image-20220915002714578.png)]

提示：考查HashMap、TreeSet、ArrayList、Collections

代码示例：

/**
 * @author 尚硅谷-宋红康
 * @create 0:23
 */
public class PokerTest1 {
    public static void main(String[] args) {
        String[] num = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        String[] color = {"方片", "梅花", "红桃", "黑桃"};
        HashMap map = new HashMap(); // 存储索引和扑克牌
        ArrayList list = new ArrayList(); // 存储索引
        int index = 0; // 索引的开始值
        for (String s1 : num) {
            for (String s2 : color) {
                map.put(index, s2.concat(s1)); // 将索引和扑克牌添加到HashMap中
                list.add(index); // 将索引添加到ArrayList集合中
                index++;
            }
        }
        map.put(index, "小王");
        list.add(index);
        index++;
        map.put(index, "大王");
        list.add(index);
        // 洗牌
        Collections.shuffle(list);
        // 发牌
        TreeSet Tom = new TreeSet();
        TreeSet Jerry = new TreeSet();
        TreeSet me = new TreeSet();
        TreeSet lastCards = new TreeSet();

        for (int i = 0; i < list.size(); i++) {
            if (i >= list.size() - 3) {
                lastCards.add(list.get(i)); // 将list集合中的索引添加到TreeSet集合中会自动排序
            } else if (i % 3 == 0) {
                Tom.add(list.get(i));
            } else if (i % 3 == 1) {
                Jerry.add(list.get(i));
            } else {
                me.add(list.get(i));
            }
        }

        // 看牌
        lookPoker("Tom", Tom, map);
        lookPoker("Jerry", Jerry, map);
        lookPoker("康师傅", me, map);
        lookPoker("底牌", lastCards, map);

    }

    public static void lookPoker(String name, TreeSet ts, HashMap map) {
        System.out.println(name + "的牌是:");
        for (Object index : ts) {
            System.out.print(map.get(index) + " ");
        }

        System.out.println();
    }
}

第十二章 泛型和File

第十三章 IO流

第十四章 反射