Java基础入门（下）

二、Java语言基础（下） 2.1 多线程

关于多线程，首先需要理解三个基本概念：

什么是程序？

程序是为完成特定任务、用某种语言编写的一组指令的集合。
什么是进程？

进程是程序的一次执行过程。进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。
什么是线程？

进程可进一步细化为线程，是一个程序内部的一条执行路径。线程是调度和执行的单位。

每个线程拥独立的运行栈和程序计数器(pc)；多个线程，共享同一个进程中的方法区、堆。

线程切换的开销小，进程切换开销大，一个进程中可以有多个线程。
单核CPU与多核CPU的理解
- 单核CPU：其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费。）但是因为CPU时间单元特别短，因此感觉不出来。
- 如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）。
- 一个Java应用程序java.exe，其实至少三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
并行与并发的理解
- 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
- 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事

2.1.1 创建多线程的方式

继承Thread类
实现Runnable接口

JDK5新增-实现Callable接口

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

相较于实现Runnable接口，实现Callable接口的方式更加强大，具体体现在：

call()可以返回值的。
call()可以抛出异常，被外面的操作捕获，获取异常的信息
Callable是支持泛型的

JDK5新增-使用线程池

class NumberThread implements Runnable{

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

class NumberThread1 implements Runnable{

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

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

线程池的优点：

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没任务时最多保持多长时间后会终止

2.1.2 Thread类中的常用的方法

start():启动当前线程；调用当前线程的run()。
run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
currentThread():静态方法，返回执行当前代码的线程。
getName():获取当前线程的名字。
setName():设置当前线程的名字。
yield():释放当前cpu的执行权，不会释放锁。
join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
stop():已过时。当执行此方法时，强制结束当前线程。
sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
isAlive():判断当前线程是否存活。
getPriority():获取线程的优先级。
setPriority(int p):设置线程的优先级。

线程的优先级：

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 -->默认优先级
高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行，并不意味着只当高优先级的线程执行完以后，低优先级的线程才执行。

2.1.3 线程的生命周期

2.1.4 线程的同步机制

背景

例子：创建个窗口卖票，总票数为100张.使用实现Runnable接口的方式
- 问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
- 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
- 如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
Java解决方案：同步机制
- 同步代码块
```
synchronized(同步监视器){
    //需要被同步的代码
}
```
- 同步方法
  
  如果操作共享数据的代码完整的声明在一个方法中，我们可以将此方法声明同步的。
  
  同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  
  非静态的同步方法，同步监视器是：this。
  
  静态的同步方法，同步监视器是：当前类本身。
- Lock锁 — JDK5.0新增
  
  synchronized 与 Lock的异同？
  - 相同：二者都可以解决线程安全问题
  - 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器；Lock需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()）。

使用的优先顺序：

Lock —> 同步代码块（已经进入了方法体，分配了相应资源 ) —> 同步方法（在方法体之外)

线程安全的单例模式：

public class SingleInstance {
    private volatile static SingleInstance uniqueInstance = null;
    public static SingleInstance getInstance() {
        if (uniqueInstance == null) {
            synchronized (SingleInstance.class) {
            	if (uniqueInstance == null) {
                	uniqueInstance = new SingleInstance();
                }
            }
        }
        return uniqueInstance;
    }
}

避免出现死锁

死锁，即不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。如下：

public static void main(String[] args) {

    StringBuffer s1 = new StringBuffer();
    StringBuffer s2 = new StringBuffer();

    new Thread(){
        @Override
        public void run() {
            synchronized (s1){
                s1.append("a");
                s2.append("1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (s2){
                    s1.append("b");
                    s2.append("2");
                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }
    }.start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (s2){
                s1.append("c");
                s2.append("3");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (s1){
                    s1.append("d");
                    s2.append("4");
                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }
    }).start();
}

2.1.5 线程通信

wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。

notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

备注：

wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常。
wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
sleep() 和 wait()的异同？
- 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
- 不同点：
  
  1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
  
  2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中。
  
  3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
yield 和 sleep 的异同
1）yield, sleep 都能暂停当前线程，sleep 可以指定具体休眠的时间，而 yield 则依赖 CPU 的时间片划分。

2）yield, sleep 两个在暂停过程中，如已经持有锁，则都不会释放锁资源。

3）yield 不能被中断，而 sleep 则可以接受中断。
问题：yield()不会释放锁，只释放cpu的执行权，有啥意义，不是只有拿到锁的线程才能执行么？

答：谁告诉你只有一把锁了？？？共用一把锁的其他线程不能执行，但是用别的锁的线程可以执行！

2.2 Java常用类 2.2.1 java.lang.String类的使用

String声明为final的，不可被继承
String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小。
String内部定义了final char[] value用于存储字符串数据。
通过字面量的方式（区别于new给一个字符串赋值，此时的字符串值声明在字符串常量池中)。
字符串常量池中是不会存储相同内容(使用String类的equals()比较，返回true)的字符串的。

String的不可变性

当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
当对现的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

String类实例化方式

通过字面量定义的方式

此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
```
String s1 = "javaEE";
String s2 = "javaEE";
```

通过new + 构造器的方式

通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。

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

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

问题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？
两个；一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”。

字符串拼接方式赋值的对比

常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
只要其中一个是变量，结果就在堆中。
如果拼接的结果调用intern()方法，返回值就在常量池中

String s1 = "javaEE";
String s2 = "hadoop";

String s3 = "javaEEhadoop";
String s4 = "javaEE" + "hadoop";
String s5 = s1 + "hadoop";
String s6 = "javaEE" + 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(s6 == s7);//false

String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
System.out.println(s3 == s8);//true
****************************
String s1 = "javaEEhadoop";
String s2 = "javaEE";
String s3 = s2 + "hadoop";
System.out.println(s1 == s3);//false

final String s4 = "javaEE";//s4:常量
String s5 = s4 + "hadoop";
System.out.println(s1 == s5);//true

JVM中字符串常量池存放位置

jdk 1.6 (jdk 6.0 ,java 6.0):方法区（永久区）
jdk 1.7:堆空间
jdk 1.8:方法区（元空间）

StringBuffer

初始化为一个长度为16的char[]，扩容策略：2*原容量+2

2.2.2 时间API 2.2.2.1 获取系统当前时间

想获取系统当前时间，System类中的静态方法currentTimeMillis()想必大家都不会陌生，它返回的是当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差，也被称为时间戳。

java.util.Date类与java.sql.Date类

关于这两个类，很多人可能不是特别清楚两者之间的区别与联系，接下来我们对此进行简单的梳理。

区别：

首先，从包名可以看出java.sql.Date类是与数据库相关的类，更准确地来说，它与数据库中的日期类型变量相对应。而java.util.Date类，就是我们平时使用的类了（事实上开发中也很少会用它，具体后面再说）。

那么除了根据包名能判断出的这些外，两者之间有什么联系呢？

联系：

通过查阅jdk源码可知：java.sql.Date继承了java.util.Date类，也就是说，java.sql.Date类是java.util.Date类的子类。

搞清楚了两者之间的区别和联系后，我们来回答两个问题：
- 第一个问题：如何将java.sql.Date对象转换为java.util.Date对象呢？
  
  熟悉面向对象的读者肯定知道，子类对象可直接向上转型成父类对象（多态性）。据此，我们可以直接将java.sql.Date类的对象赋给java.util.Date对象，代码如下：
```
java.util.Date date = new java.sql.Date(136513463156L); //向java.sql.Date的构造器中传入时间戳
```
- 第二个问题：如何将java.util.Date对象转换为java.sql.Date对象呢？
  
  进行强制类型转换？当然不可行。事实上，如果我们将父类对象强制转化为子类对象，将会抛出Exception in thread "main" java.lang.ClassCastException: java.util.Date cannot be cast to java.sql.Date异常。那么就只能从两者之间的联系下手，代码如下：
```
java.util.Date date = new java.util.Date();// 创建java.util.Date对象
java.sql.Date sqlDate = new java.sql.Date(date.getTime());//getTime()方法会返回当前Date对象对应的毫秒数。（时间戳）
```

补充说明（了解即可）：

java.text.SimpleDataFormat类：主要用来格式化日期时间。简单介绍一下用法：

Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//格式化
String format = sdf.format(date);
System.out.println(format);//2019-02-18 11:48:27
//解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),
//否则，抛异常
Date date1 = sdf1.parse("2020-02-18 11:48:27");
System.out.println(date1);

Calendar类：该类是日历类，也是一个抽象类。简单介绍一下用法：

//1.创建Calendar类的对象有两种方式：
//方式一：创建其子类（GregorianCalendar的对象）
//方式二：调用其静态方法getInstance()
Calendar calendar = Calendar.getInstance();

//2.常用方法
//get()
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//获取本月内的第几天，从1开始
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//获取一年内的第几天，从1开始

//set()
//calendar可变性
calendar.set(Calendar.DAY_OF_MONTH,22); // 设置日期为本月内的第22天
System.out.println(calendar.get(Calendar.DAY_OF_MONTH)); //输出22

//add()
calendar.add(Calendar.DAY_OF_MONTH,-3); // 设置日期为今天的日期-3天；
System.out.println(calendar.get(Calendar.DAY_OF_MONTH)); // 今天是11月8号，所以输出5

//getTime():日历类---> Date
Date date = calendar.getTime(); // 返回Date对象
System.out.println(date);//输出Sun Nov 08 17:49:57 CST 2020

//setTime():Date ---> 日历类
Date date = new Date();
calendar.setTime(date);
System.out.println(calendar.get(Calendar.YEAR)); // 输出2020
System.out.println(date.getYear()); // 输出120，此方法输出的是今年与1900年之差

Calendar类本意是为了弥补了Date类的缺陷而生的，但是随着在开发中的使用，渐渐的暴露出它们的不足。比如糟糕的可变性、偏移性等等。下面，我们一起来看看jdk1.8之后，关于日期的处理。

2.2.2.2 jdk1.8引入的关于时间处理的API

回顾Java对日期时间的迭代：

第一代：jdk 1.0 Date类
第二代：jdk 1.1 Calendar类，一定程度上替换Date类
第三代：jdk 1.8 提出了新的一套API

前两代存在的问题举例：

可变性：像日期和时间这样的类应该是不可变的。
偏移性：Date中的年份是从1900开始的，而月份都从0开始。
格式化：格式化只对Date用，Calendar则不行。
此外，它们也不是线程安全的；不能处理闰秒等。

java 8 中新的日期时间API涉及到的包：

本地日期、本地时间、本地日期时间的使用：LocalDate / LocalTime / LocalDateTime

简介

① 分别表示使用 ISO-8601日历系统的日期、时间、日期时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。
② LocalDateTime相较于LocalDate、LocalTime，使用频率要高
③ 类似于Calendar
常用方法：

时间点：Instant

简介

① 时间线上的一个瞬时点。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC开始的秒数。）
② 类似于 java.util.Date类
常用方法：

日期时间格式化类：DateTimeFormatter

简介

① 格式化或解析日期、时间
② 类似于SimpleDateFormat
实例化方式：
- 预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
- 本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
- 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

常用方法：

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
//格式化
String str = formatter.format(LocalDateTime.now());
System.out.println(str);//2020-11-08 06:48:13

//解析
TemporalAccessor accessor = formatter.parse("2020-11-08 06:48:13");
System.out.println(accessor);
//输出{SecondOfMinute=13, MinuteOfHour=48, MicroOfSecond=0, MilliOfSecond=0, NanoOfSecond=0, HourOfAmPm=6},ISO resolved to 2020-11-08

其他API

带时区的日期时间：ZonedDateTime / ZoneId

//获取“Asia/Tokyo”时区对应的时间
LocalDateTime localDateTime = LocalDateTime.now(ZoneId.of("Asia/Tokyo"));
System.out.println(localDateTime);//2020-11-08T19:57:38.479
//now()/now(ZoneId id):获取当前时区/指定时区的ZonedDateTime对象
ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
System.out.println(zonedDateTime);//2020-11-08T19:58:45.084+09:00[Asia/Tokyo]

时间间隔：Duration–用于计算两个“时间”间隔，以秒和纳秒为基准

//设置起始日期时间，获取当前日期时间
LocalDateTime localDateTime = LocalDateTime.of(2016, 11, 8, 19, 2, 00);
LocalDateTime localDateTime1 = LocalDateTime.now();

Duration duration = Duration.between(localDateTime, localDateTime1);//返回间隔对象
System.out.println(duration.toDays()); //输出1461

日期间隔：Period --用于计算两个“日期”间隔，以年、月、日衡量

LocalDate localDate = LocalDate.now();
LocalDate localDate1 = LocalDate.of(2030, 11, 8);

Period period = Period.between(localDate, localDate1);
System.out.println(period); //P10Y
System.out.println(period.getYears()); // 10
System.out.println(period.getMonths()); // 0
System.out.println(period.getDays()); // 0

日期时间校正器：TemporalAdjuster

//获取当前日期的下一个周日是哪天？
TemporalAdjuster temporalAdjuster = TemporalAdjusters.next(DayOfWeek.SUNDAY);
LocalDateTime localDateTime = LocalDateTime.now().with(temporalAdjuster);
System.out.println(localDateTime); //2020-11-15T19:15:51.426
//获取下一个工作日是哪天？今天是2020-11-08
LocalDate localDate = LocalDate.now().with(new TemporalAdjuster(){
    @Override
    public Temporal adjustInto(Temporal temporal) {
        LocalDate date = (LocalDate)temporal;
        if(date.getDayOfWeek().equals(DayOfWeek.FRIDAY)){
            return date.plusDays(3);//如果是周五，则+3
        }else if(date.getDayOfWeek().equals(DayOfWeek.SATURDAY)){
            return date.plusDays(2);//如果是周六，则+2
        }else{
            return date.plusDays(1);//其他情况，则+1
        }
    }
});
System.out.println("下一个工作日是：" + localDate); //下一个工作日是：2020-11-09

2.2.3 比较器

引子

在比较Java对象时，正常情况下，我们只能使用==或!=进行比较，而不能使用>或者<这样的运算符。

那么问题来了，开发过程中我们经常要对多个对象排序，排序必然需要比较，那么如何实现呢？

其实实现也很简单，使用Comparable或者Comparator两个接口中的一个即可。

Comparable接口的使用

先来看一段代码：

public static void main(String[] args) {
    String[] arr = new String[] {"dd","aa","xx","cc"};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr)); // 输出[aa, cc, dd, xx]
}

执行上面的代码，输出结果为：[aa, cc, dd, xx]。

为什么呢？查阅String类的源码可知，String类实现了Comparable接口的compareTo(obj)方法。

在重写compareTo(obj)方法时，我们需要满足三个规则：

如果当前对象this大于形参对象obj，则返回正整数，
如果当前对象this小于形参对象obj，则返回负整数，
如果当前对象this等于形参对象obj，则返回零。

那么让我们自定义的类实现比较就很简单了，只需要按照上面三个规则实现Comparable接口中的compareTo(obj)方法，再调用Arrays.sort(arr)或者Collections.sort(list)即可。

那么什么情况下都能够以实现Comparable接口的方式来定义对象的比较方式吗？

当然不是！实际上，虽然Comparable接口可以解决一部分业务需求，但是当我们无法使某个类实现Comparable接口时（比如第三方Jar包中的类），我们通常会使用另一种方式—实现Comparator接口。

Comparator接口的使用

与实现Comparable接口类似，使用Comparator接口同样需要我们实现一个方法—compare（obj1,obj2）。

在重写compare(Object o1,Object o2)方法时，我们同样需要满足三个规则：

如果方法返回正整数，则表示o1大于o2；
如果返回0，表示相等；
返回负整数，表示o1小于o2。

示例代码如下：

public static void main(String[] args) {
    Comparator comparator = (o1, o2) -> {
        if (o1 instanceof Person && o2 instanceof Person) {
            Person preson1 = (Person) o1;
            Person preson2 = (Person) o1;
            return Integer.compare(preson1.getAge(),preson2.getAge());
        }
        throw new RuntimeException("输入的数据类型不一致");
    };
    Person p1 = new Person();
    p1.setAge(18);
    Person p2 = new Person();
    p2.setAge(20);
    Person[] people = new Person[]{p1, p2};
    Arrays.sort(people,comparator);
    System.out.println(Arrays.toString(people)); // 输出[Person{age=18}, Person{age=20}]
}

2.2.4 枚举类

使用

//使用enum关键字枚举类
enum Season1 {
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    //2.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2.私化类的构造器,并给对象属性赋值

    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
}

常用方法

Season1 summer = Season1.SUMMER;
//toString():返回枚举类对象的名称
System.out.println(summer.toString());

//System.out.println(Season1.class.getSuperclass());
System.out.println("****************");
//values():返回所的枚举类对象构成的数组
Season1[] values = Season1.values();
for(int i = 0;i < values.length;i++){
    System.out.println(values[i]);
}
System.out.println("****************");
Thread.State[] values1 = Thread.State.values();
for (int i = 0; i < values1.length; i++) {
    System.out.println(values1[i]);
}

//valueOf(String objName):返回枚举类中对象名是objName的对象。
Season1 winter = Season1.valueOf("WINTER");
//如果没objName的枚举类对象，则抛异常：IllegalArgumentException
//        Season1 winter = Season1.valueOf("WINTER1");
System.out.println(winter);

枚举类对象分别实现接口

interface Info{
    void show();
}

//使用enum关键字枚举类
enum Season1 implements Info{
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    SPRING("春天","春暖花开"){
        @Override
        public void show() {
            System.out.println("春天在哪里？");
        }
    },
    SUMMER("夏天","夏日炎炎"){
        @Override
        public void show() {
            System.out.println("宁夏");
        }
    },
    AUTUMN("秋天","秋高气爽"){
        @Override
        public void show() {
            System.out.println("秋天不回来");
        }
    },
    WINTER("冬天","冰天雪地"){
        @Override
        public void show() {
            System.out.println("大约在冬季");
        }
    };
}

2.2.5 注解

注解是什么？

Java注解是附加在代码中的一些元信息 ，简单来说，注解就算一个辅助工具，可以让我们的代码更加简洁等。

为什么要学习注解

首先，我们平时使用的框架，就是靠着注解才得以使我们开发更加方便。框架=注解+反射+设计模式

通过注解你可以将你的某个方法以注解的形式调用，就像Spring中的@Controller、@Component等注解一样。

首先说明一些概念：

什么是元注解？

元注解就是对现有注解进行说明的注解。

为此，我们接下来来了解一下JDK5.0提供的四个元注解：

@Retention：指定所修饰的 Annotation 的生命周期。参数：
- RetentionPolicy.SOURCE—注解只在源文件中有效
- RetentionPolicy.CLASS—注解在class文件中有效，当运行Java程序时，该注解不会被保留。默认值。
- RetentionPolicy.RUNTIME—运行时有效。程序可以通过反射来获取该注解。
@Target:用于指定被修饰的注解能用于修饰哪些程序元素
@documented:表示所修饰的注解在被javadoc解析时，保留下来。
@Inherited:被它修饰的注解将具继承性。

怎么使用注解

了解了上面的概念后，我们可以来实现一个简单的注解，代码如下：

@Retention(RetentionPolicy.RUNTIME) // 注解在运行时有效，即可通过反射获取
@Target({ElementType.METHOD,ElementType.PARAMETER})  // 注解可用在方法和参数上。
@Inherited // 注解可继承
@documented // javadoc解析时保留
@interface HelloAnnotation {
    String value() default "hello";
}

@HelloAnnotation
public void setAge() {
    
}

注解只是提供一个辅助信息，要跟反射结合在一起使用才可以实现某项功能！

补充知识：Java8中注解的新特性

可重复注解：(当需要在一个方法上使用多次注解时使用)

① 在HelloAnnotation上声明@Repeatable，成员值为HelloAnnotations.class

② HelloAnnotation的Target和Retention等元注解与HelloAnnotations相同。

代码示例如下：

@Retention(RetentionPolicy.RUNTIME) // 注解在运行时有效，即可通过反射获取
@Target(ElementType.METHOD) // 注解可用在方法上
@Inherited // 注解可继承
@Repeatable(HelloAnnotations.class)//可重复
@documented // javadoc解析时保留
@interface HelloAnnotation {
    String value() default "hello";
}
@Retention(RetentionPolicy.RUNTIME) // 注解在运行时有效，即可通过反射获取
@Target(ElementType.METHOD) // 注解可用在方法上
@Inherited // 注解可继承
@documented // javadoc解析时保留
@interface HelloAnnotations {
    HelloAnnotation value()[];
}


//使用如下：
@HelloAnnotation
@HelloAnnotation
public static void main(String[] args) {
}

类型注解：
①ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中，如：泛型声明。

示例代码如下：

@Retention(RetentionPolicy.RUNTIME) // 注解在运行时有效，即可通过反射获取
@Target({ElementType.TYPE_PARAMETER }) // 注解可用在方法上
@interface HelloAnnotation {
    String value() default "hello";
}

class TestAnnotation<@HelloAnnotation T> {

}

②ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

示例代码如下：

@Retention(RetentionPolicy.RUNTIME) // 注解在运行时有效，即可通过反射获取
@Target({ElementType.TYPE_USE}) // 注解可用在方法上
@interface HelloAnnotation {
    String value() default "hello";
}

public static void main(String[] args) throws @HelloAnnotation RuntimeException{
        @HelloAnnotation int i = 0;
        List<@HelloAnnotation String> list = null;
}

2.3 Java集合 2.3.1 Collection接口

|----Collection接口：单列集合，用来存储一个一个的对象

|----List接口：存储有序的、可重复的数据。 -->“动态”数组

|----ArrayList、linkedList、Vector

|----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”

|----HashSet、linkedHashSet、TreeSet

向Collection接口的实现类的对象中添加对象obj时，要求obj所在类要重写equals()。

遍历Collection的两种方式：

使用迭代器Iterator
foreach循环（或增强for循环）

使用集合的remove()方法时需要注意：

如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。因为“指针”还没有下移。

2.3.2 Collection子接口：List接口

List存储有序的、可重复的数据。

2.3.2.1 List接口常用实现类

|----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储

|----linkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储，线程不安全的

|----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

2.3.2.2 源码分析

ArrayList

jdk 7情况下

ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData

list.add(123);//elementData[0] = new Integer(123);

...

list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。

扩容机制：扩容为原来容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)。

jdk8情况下

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组

list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]

扩容机制：与jdk 7 相同。

总结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

linkedList

linkedList list = new linkedList(); //内部声明了Node类型的first和last属性，默认值为null
list.add(123);//将123封装到Node中，创建了Node对象。
//Node：linkedList的双向链表的一个节点
private static class Node {
    E item;
    Node next;
    Node prev;

    Node(Node prev, E element, Node next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

Vector

jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。

扩容机制：默认扩容为原来的数组长度的2倍。

2.3.3 Collection子接口：Set接口

Set存储无序的、不可重复的元素。存储顺序是根据数据的哈希值确定的。

以HashSet为例，描述元素添加过程：

我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即索引位置）；
判断数组此位置上是否已经元素：
- 如果此位置上没其他元素，则元素a添加成功。
- 如果此位置上其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
  - 如果hash值不相同，则元素a添加成功。
  - 如果hash值相同，进而需要调用元素a所在类的equals()方法：
    equals()返回true,元素a添加失败
    equals()返回false,则元素a添加成功。

在此位置已有元素的情况下，元素添加成功：元素a 与已经存在指定索引位置上数据以链表的方式存储。

jdk 7 :元素a放到数组中，指向原来的元素。

jdk 8 :原来的元素在数组中，指向元素a
总结：七上八下，如下图

在JDK7中，HashSet底层的数据结构是“数组+链表”；

在JDK8中，HashSet底层的数据结构仍然是“数组+链表”，不过，当链表长度大于8时，链表会转换为红黑树，即数据结构变为了“数组+红黑树”。

2.3.3.1 Set接口常用实现类

|----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值

|----linkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历

在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。

对于频繁的遍历操作，linkedHashSet效率高于HashSet.

|----TreeSet：可以照添加对象的指定属性，进行排序。

2.3.3.2 存储对象所在类的要求

HashSet/linkedHashSet:

要求向Set(主要指：HashSet、linkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()方法。
重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。

重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。
TreeSet:
- 在自然排序中，比较两个对象是否相同的标准为compareTo()返回0。（不再是equals()）
- 在定制排序中，比较两个对象是否相同的标准为compare()返回0。（不再是equals()）

2.3.3.3 TreeSet的使用

//方式一：自然排序
@Test
    public void test1(){
        TreeSet set = new TreeSet();

        //失败：不能添加不同类的对象
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add(new User("Tom",12));

            //举例一：
//        set.add(34);
//        set.add(-34);
//        set.add(43);
//        set.add(11);
//        set.add(8);

        //举例二：
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));


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

    }

//方式二：定制排序
    @Test
    public void test2(){
        Comparator com = 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 Integer.compare(u1.getAge(),u2.getAge());
                }else{
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };

        TreeSet set = new TreeSet(com);
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Mary",33));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));


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

2.3.4 Map接口 2.3.4.1 常用实现类

|----Map:双列数据，存储key-value对的数据

|----HashMap:作为Map的主要实现类；线程不安全的，效率高；可以存储null的key和value

|----linkedHashMap:保证在遍历map元素时，可以照添加的顺序实现遍历。

原因：在原的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。

|----TreeMap:保证照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序。底层使用红黑树

|----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value

|----Properties:常用来处理配置文件。key和value都是String类型

2.3.4.2 存储结构的理解

Map中的key:无序的、不可重复的，使用Set存储的key —> key所在的类要重写equals()和hashCode() （以HashMap为例)

Map中的value:无序的、可重复的，使用Collection存储的value —>value所在的类要重写equals()

一个键值对：key-value构成了一个Entry对象。

Map中的entry:无序的、不可重复的，使用Set存储所的entry

2.3.4.3 HashMap的实现原理

JDK7中：
```
HashMap map = new HashMap()://在实例化以后，底层创建了长度是16的一维数组Entry[] table。
//...可能已经执行过多次put...

map.put(key1,value1);
```
- 首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置;
- 如果此位置上的数据为空，此时的key1-value1添加成功。
- 如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：
  - 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。
  - 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：
    
    如果equals()返回false:此时key1-value1添加成功。
    
    如果equals()返回true:使用value1替换value2。
在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原的数据复制过来。
JDK8中：
- new HashMap():底层没创建一个长度为16的数组
- jdk 8底层的数组是：Node[],而非Entry[]
- 首次调用put()方法时，底层创建长度为16的数组
- jdk7底层结构只：数组+链表。jdk8中底层结构：数组+链表+红黑树。
  - 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
  - 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

HashMap底层典型属性的属性的说明：

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

2.3.5 linkedHashMap的底层实现原理

linkedHashMap底层使用的结构与HashMap相同，因为linkedHashMap继承于HashMap.
区别在于：linkedHashMap内部提供了Entry，替换HashMap中的Node.

2.3.6 TreeMap的使用

向TreeMap中添加key-value，要求key必须是由同一个类创建的对象。因为要根据key进行排序：自然排序、定制排序

2.3.7 Collections工具类

常用方法

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)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值

ArrayList和HashMap都是线程不安全的，如果程序要求线程安全，我们可以使用synchronizedList(List list）和 synchronizedMap(Map map）将ArrayList、HashMap转换为线程安全的。

2.4 泛型

1.举例:
【Order.java】

public class Order {

    String orderName;
    int orderId;
    //类的内部结构就可以使用类的泛型
    T orderT;
    public Order(){
        //编译不通过
//        T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

    public Order(String orderName,int orderId,T orderT){
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //如下的个方法都不是泛型方法
    public T getOrderT(){
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;
    }

    //静态方法中不能使用类的泛型。
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }

    public void show(){
        //编译不通过
//        try{
//        }catch(T t){
//        }
    }

    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没任何关系。
    //换句话说，泛型方法所属的类是不是泛型类都没关系。
    //泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
    public static   List copyFromArrayToList(E[] arr){

        ArrayList list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }
}

【SubOrder.java】
public class SubOrder extends Order {//SubOrder:不是泛型类

    public static  List copyFromArrayToList(E[] arr){
        ArrayList list = new ArrayList<>();
        for(E e : arr){
            list.add(e);
        }
        return list;
    }

}

//实例化时，如下的代码是错误的
SubOrder o = new SubOrder<>();

【SubOrder1.java】
public class SubOrder1 extends Order {//SubOrder1:仍然是泛型类

}

备注：

泛型类的构造方法是public Person() {}而不是public Person(){}
异常类不能是泛型的；
泛型不能使用new T[]，但是可以T[] data = (T[]) Object[length]

类A是类B的父类，则A 是 B 的父类。但G 和G二者不具备子父类关系，二者是并列关系。

2.4.1 通配符：?

类A是类B的父类，G和G是没关系的，二者共同的父类是G

 @Test
    public void test3(){
        List

Java基础入门（下）

Java相关栏目本月热门文章