Update Java Notes

Seazean · Seazean · commit 98dc35823fae · 2021-04-24T22:18:37.000+08:00
diff --git a/Java.md b/Java.md
@@ -111,17 +111,27 @@ G[float]
 G-->H[double]
 ```
 
+##### 上下转型
+
 * float 与 double：
 
-  Java 不能隐式执行向下转型，因为这会使得精度降低
+  Java 不能隐式执行**向下转型**，因为这会使得精度降低
 
   ```java
   //1.1字面量属于double类型，不能直接将1.1直接赋值给 float 变量，因为这是向下转型
-  float f = 1.1;
+  float f = 1.1;//报错
   //1.1f 字面量才是 float 类型
   float f = 1.1f;
   ```
 
+  ```java
+  float f1 = 1.234f;
+  double d1 = f1;
+  
+  double d2 = 1.23;
+  float f2 = (float) d2;//向下转型需要强转
+  ```
+
 * 隐式类型转换：
 
   字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型向下转型为 short 类型
@@ -134,6 +144,16 @@ G-->H[double]
   s1 = (short) (s1 + 1);
   ```
 
+  ```java
+  int i1 = 1245;
+  long l1 = i1;
+  
+  long l2 = 1234;
+  int i2 = (int) l2;
+  ```
+  
+  
+  
   
 
 ***
@@ -3237,20 +3257,20 @@ public static void main(String[] args){
 
 常用API：
 
-| 方法名                                                       | 说明                                                        |
-| ------------------------------------------------------------ | ----------------------------------------------------------- |
-| public int getYear()                                         | 获取年                                                      |
-| public int getMonthValue()                                   | 获取月份（1-12）                                            |
-| public int getDayOfMonth()                                   | 获取月份中的第几天（1-31）                                  |
-| public int getDayOfYear()                                    | 获取一年中的第几天（1-366）                                 |
-| public DayOfWeek getDayOfWeek()                              | 获取星期                                                    |
-| public int getMinute()                                       | 获取分钟                                                    |
-| public int getHour()                                         | 获取小时                                                    |
-| public LocalDate  toLocalDate ()                             | 转换成为一个LocalDate对象（年月日）                         |
-| public LocalTime toLocalTime ()                              | 转换成为一个LocalTime对象（时分秒）                         |
-| public String format (指定格式)                              | 把一个LocalDateTime格式化成为一个字符串                     |
-| public LocalDateTime parse (准备解析的字符串, 解析格式)      | 把一个日期字符串解析成为一个LocalDateTime对象               |
-| **public static DateTimeFormatter ofPattern(String pattern)** | 使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象 |
+| 方法名                                                    | 说明                                                        |
+| --------------------------------------------------------- | ----------------------------------------------------------- |
+| public int getYear()                                      | 获取年                                                      |
+| public int getMonthValue()                                | 获取月份（1-12）                                            |
+| public int getDayOfMonth()                                | 获取月份中的第几天（1-31）                                  |
+| public int getDayOfYear()                                 | 获取一年中的第几天（1-366）                                 |
+| public DayOfWeek getDayOfWeek()                           | 获取星期                                                    |
+| public int getMinute()                                    | 获取分钟                                                    |
+| public int getHour()                                      | 获取小时                                                    |
+| public LocalDate  toLocalDate()                           | 转换成为一个LocalDate对象（年月日）                         |
+| public LocalTime toLocalTime()                            | 转换成为一个LocalTime对象（时分秒）                         |
+| public String format(指定格式)                            | 把一个LocalDateTime格式化成为一个字符串                     |
+| public LocalDateTime parse(准备解析的字符串, 解析格式)    | 把一个日期字符串解析成为一个LocalDateTime对象               |
+| public static DateTimeFormatter ofPattern(String pattern) | 使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象 |
 
 ```java
 public class JDK8DateDemo2 {
@@ -3262,7 +3282,7 @@ public class JDK8DateDemo2 {
         System.out.println(localDateTime);
         DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
         String s = localDateTime.format(pattern);
-         LocalDateTime parse = LocalDateTime.parse(s, pattern);
+		LocalDateTime parse = LocalDateTime.parse(s, pattern);
     }
 }
 ```
@@ -3289,6 +3309,8 @@ public class JDK8DateDemo2 {
 
 **时间间隔**
 
+Duration类API：
+
 | 方法名                                           | 说明                 |
 | ------------------------------------------------ | -------------------- |
 | public static Period between(开始时间,结束时间)  | 计算两个“时间"的间隔 |
@@ -3298,14 +3320,12 @@ public class JDK8DateDemo2 {
 | public long toTotalMonths()                      | 获取此期间的总月数   |
 | public static Durationbetween(开始时间,结束时间) | 计算两个“时间"的间隔 |
 | public long toSeconds()                          | 获得此时间间隔的秒   |
-| public int toMillis()                            | 获得此时间间隔的毫秒 |
-| public int toNanos()                             | 获得此时间间隔的纳秒 |
+| public long toMillis()                           | 获得此时间间隔的毫秒 |
+| public long toNanos()                            | 获得此时间间隔的纳秒 |
 
 ```java
-//计算两个时间的间隔
 public class JDK8DateDemo9 {
     public static void main(String[] args) {
-        //public static Period between(开始时间,结束时间)  计算两个"时间"的间隔
         LocalDate localDate1 = LocalDate.of(2020, 1, 1);
         LocalDate localDate2 = LocalDate.of(2048, 12, 12);
         Period period = Period.between(localDate1, localDate2);
@@ -6662,7 +6682,11 @@ public class FileDemo{
 
 
 
-#### API
+***
+
+
+
+#### 常用API
 
 ##### 常用方法
 
@@ -6722,7 +6746,7 @@ System.out.println(f.isDirectory()); // false
 
 
 
-##### 创建和删除方法
+##### 创建删除
 
 `public boolean createNewFile()` : 当且仅当具有该名称的文件尚不存在时， 创建一个新的空文件。
 															（几乎不用的，因为以后文件都是自动创建的！）
@@ -6756,6 +6780,10 @@ public class FileDemo {
 
 
 
+***
+
+
+
 #### 遍历目录
 
 - `public String[] list()`：
@@ -6791,6 +6819,10 @@ public class FileDemo {
 
 
 
+***
+
+
+
 #### 文件搜索
 
 递归实现文件搜索(非规律递归)
@@ -6841,7 +6873,7 @@ public static void searchFiles(File dir , String fileName){
 
 
 
-### 字符集
+### Character
 
 字符集：各个国家为自己国家的字符取的一套编号规则。
 	计算机的底层是不能直接存储字符的，只能存储二进制，010101。
@@ -6884,7 +6916,7 @@ public static void searchFiles(File dir , String fileName){
 
 
 
-### IO流
+### IOStream
 
 #### 概述
 
@@ -11953,11 +11985,11 @@ Java语言提供了对象终止（finalization）机制来允许开发人员提
 - 可复活的：对象的所有引用都被释放，但是对象有可能在finalize() 中复活
 - 不可触及的：对象的 finalize() 被调用，并且没有复活，那么就会进入不可触及状态，不可触及的对象不可能被复活。因为**finalize()只会被调用一次**，等到这个对象再被标记为可回收时就必须回收
 
-注意：永远不要主动调用某个对象的finalize()方法，应该交给垃圾回收机制调用
+注意：永远不要主动调用某个对象的finalize()方法，应该交给垃圾回收机制调用，原因：
 
-* finalize() 时可能会导致对象复活。
+* finalize() 时可能会导致对象复活
 * finalize() 方法的执行时间是没有保障的，它完全由GC线程决定，极端情况下，若不发生GC，则finalize()方法将没有执行机会。因为优先级比较低，即使主动调用该方法，也不会因此就直接进行回收
-* 一个糟糕的finalize() 会严重影响GC的性能。
+* 一个糟糕的finalize() 会严重影响GC的性能
 
 
 
@@ -14951,7 +14983,7 @@ System.out.println("unpark...");//和上一个unpark同时执行
 
 `public final void setDaemon(boolean on)`：如果是 true ，将此线程标记为守护线程 
 
-线程启动前调用此方法：
+线程**启动前**调用此方法：
 
 ```java
 Thread t = new Thread() {
@@ -14961,15 +14993,15 @@ Thread t = new Thread() {
     }
 };
 // 设置该线程为守护线程
-t1.setDaemon(true);
-t1.start();
+t.setDaemon(true);
+t.start();
 ```
 
 用户线程：平常创建的普通线程
 
 守护线程：服务于用户线程，只要其它非守护线程运行结束了，即使守护线程代码没有执行完，也会强制结束
 
-面试：当运行的线程都是守护线程，Java虚拟机将退出，因为普通线程执行完后，守护线程也不会继续运行下去
+说明：当运行的线程都是守护线程，Java虚拟机将退出，因为普通线程执行完后，守护线程不会继续运行下去
 
 常见的守护线程：
 
@@ -15728,9 +15760,42 @@ public class ThreadDead {
 }
 ```
 
-定位死锁：
+**定位死锁**：
+
+* 检测死锁可以使用 jconsole工具，或者使用 jps 定位进程 id，再用 `jstack id`定位死锁
+
+  ```sh
+  "Thread-1" #12 prio=5 os_prio=0 tid=0x000000001eb69000 nid=0xd40 waiting formonitor entry [0x000000001f54f000]
+  	java.lang.Thread.State: BLOCKED (on object monitor)
+  #省略    
+  "Thread-1" #12 prio=5 os_prio=0 tid=0x000000001eb69000 nid=0xd40 waiting for monitor entry [0x000000001f54f000]
+  	java.lang.Thread.State: BLOCKED (on object monitor)
+  #省略
+  
+  Found one Java-level deadlock:
+  ===================================================
+  "Thread-1":
+      waiting to lock monitor 0x000000000361d378 (object 0x000000076b5bf1c0, a java.lang.Object),
+      which is held by "Thread-0"
+  "Thread-0":
+      waiting to lock monitor 0x000000000361e768 (object 0x000000076b5bf1d0, a java.lang.Object),
+      which is held by "Thread-1"
+      
+  Java stack information for the threads listed above:
+  ===================================================
+  "Thread-1":
+      at thread.TestDeadLock.lambda$main$1(TestDeadLock.java:28)
+      - waiting to lock <0x000000076b5bf1c0> (a java.lang.Object)
+      - locked <0x000000076b5bf1d0> (a java.lang.Object)
+      at thread.TestDeadLock$$Lambda$2/883049899.run(Unknown Source)
+      at java.lang.Thread.run(Thread.java:745)
+  "Thread-0":
+      at thread.TestDeadLock.lambda$main$0(TestDeadLock.java:15)
+      - waiting to lock <0x000000076b5bf1d0> (a java.lang.Object)
+      - locked <0x000000076b5bf1c0> (a java.lang.Object)
+      at thread.TestDeadLock$$Lambda$1/495053715
+  ```
 
-* 检测死锁可以使用 jconsole工具，或者使用 jps 定位进程 id，再用 jstack 定位死锁
 * linux 下可以通过 top 先定位到CPU 占用高的 Java 进程，再利用 `top -Hp 进程id` 来定位是哪个线程，最后再用 jstack 排查
 
 避免死锁：避免死锁要注意加锁顺序
@@ -17448,15 +17513,14 @@ public final class Singleton {
 CAS的全称是Compare-And-Swap，是**CPU并发原语**
 
 * CAS并发原语体现在Java语言中就是sun.misc.Unsafe类的各个方法，调用UnSafe类中的CAS方法，JVM会实现出CAS汇编指令，这是一种完全依赖于硬件的功能，通过它实现了原子操作
-* CAS是一种系统原语，原语属于操作系统范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致的问题，也就是说CAS是线程安全的
+* CAS是一种系统原语，原语属于操作系统范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且**原语的执行必须是连续的，执行过程中不允许被中断**，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致的问题，也就是说CAS是线程安全的
 * CAS 的底层是 lock cmpxchg 指令(X86 架构)，在单核 CPU 和多核 CPU 下都能够保证比较交换的原子性。在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再开启总线，这个过程不会被线程的调度机制所打断，保证了多个线程对内存操作的原子性
 
 作用：比较当前工作内存中的值和主物理内存中的值，如果相同则执行规定操作，否者继续比较直到主内存和工作内存的值一致为止
 
 CAS特点：
 
-* CAS 体现的是**无锁并发、无阻塞并发**
-* 没有使用 synchronized，所以线程不会陷入阻塞，线程不需要频繁切换状态（上下文切换）
+* CAS 体现的是**无锁并发、无阻塞并发**，没有使用 synchronized，所以线程不会陷入阻塞，线程不需要频繁切换状态（上下文切换，系统调用）
 * CAS 是基于乐观锁的思想
 
 CAS缺点：
