死锁、常用类之数学、日期时间API、数组的算法升华、数组的工具类

一.死锁：

1.当两个或者更多隔线程互相持有对象想要的资源不放手，就会死锁

2.当同步代码快或同步方法中出现了嵌套使用

（1）同步代码快中，出现了另一个同步代码快，或调用了另一个同步方法

（2）同步方法中，出现了同步代码快，或者调用了另一个同步方法，而且两者之间有使用对象要的锁对象等资源时，就有可能出现死锁状态，尽量避免

如果出现了，要么手动停止，或者说我们要制造异常，让线程从死锁状态出来，然后再去抢夺资源。

2.sleep方法和wait方法有什么区别？

（1）sleep方法在Thread类中声明，是静态方法，通过Thread类.sleep（）调用

（2）wait方法在Object类中声明，是非静态方法,通过锁对象.wait() 调用

wait方法和notify为什么要在Object中声明“

因为wait方法必须是对象调用，但是锁对象是任意类型的对象

那么意味着任意类型的对象都必须具备wait方法，这样的方法只能放在根父类中声明

（2）sleep方法是必须制定时间，等待时间到了，或中途被interrupt了，就会自动醒来

wait方法，一种是指定时间，一种是无限时等待如果无限时等待必须notify唤醒之后才能继续

（3）当前线程遇到了sleep方法不会释放锁得，一直要等当前线程结束，才会释放锁

public class TestSleepWait { public static void main(String[] args) { MyThread m1 = new MyThread(); MyThread m2 = new MyThread(); m1.start(); m2.start(); } } class MyThread extends Thread{ private int num = 1; public void run(){ synchronized (MyThread.class) { System.out.println(num++); /* try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); }*/ try { MyThread.class.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } }

二、常用类之数学

1.java.long,math类

（1）public static double sqrt(double a):求x的平方根

（2）public static double random)(): 返回带正号的double 值，大于等于0.0且小于1.0

（3）public static double pow (double a, double b):返回第一个参数的第二个参数次幂,即a的b次方

（4）public static double abs (double a ) 返回绝对值

（5）public static double max(double a, double b)：求a和b的最大值

（6）public static double min(double a, double b)：求a和b的最小值

（7）public static double floor (double a);向下取整

​ public static double ceil (double a);向上取整

​ public static long round (double a);四舍五入取整(最接近的整数)

​ -x.5比较特殊

2.java.math包

java.math,BigDecimal:定点小数和大的小数,可以精确到小数点后n位，如果可以整除，可以用该方法，如果不能整除，说明保留小数点后多少位

float 和double ：浮点数,不精确.

java.math.BigInerger:表示大整数

用法 BigInteger ig1 =new Big Integer(参数);

3.java.util,Random类：产生随机数

可以产生随机的整数、小数、boolean等所有数据类型

Math.random只能产生【0,1】之间的随机小数

Random random = new Random();

三、日期时间API

1.jdk中的日期时间API经历了三代

第一代：java.util.Date等

第二代：java.util.Calendar等

第三代：java.time包及其子包的类型

2.java.util.Date类

（1）Date() 获取当前系统时间

（2）Date(long time),根据指定的毫秒值，获取对应的日期时间

(2)Long getTime()获取当前系统时间距离1970-1-1凌晨的毫秒值

等同于 System.currentTimeMillis()

问题：为什么开始于1970年

Unix操作系统在1970年设计数来，把1970-1-1凌晨作为计算机时间的原始起点

Date类型大部分都是已过时的方法

3.java.util.Calendar类

他是一个抽象类，

如何创建对象：

（1）创建它子类对象

(2)在Calendar类中提供静态方法

Date和Calendar：

（1）使用麻烦

无法获取满足本地人阅读习惯的日期时间对象

需要借助DateFormat，它是抽象类，他有一非常

（2）可变对象：在开发中，日期对象，某个对象某个瞬间的日期时间，是不应该变的

(3)没有考虑闰秒

4.java8引入，java.time包：包含值对象的基础包

（1）本地的日期类型的API

LocalDate:日期、

Localtime：时间

LocalDateTime:日期和时间

LocalDateTime.now（）方法指当前时间

LocalDateTime.of（）方法可以指定时间

.isLeapYear():判断指定时间是不是闰年

修改日期或时间对象会返回一个新的对象结果，必须接受

5.java.long.System

(1)System.out 对象

（2）System.in 对象

（3）public static long currenTimeMillis():获取距离1970年的时间

(4)public static void arraycopy(Object src,int srcPos,Object,destPos,int length)

src:原数组

srcPos:原数组的起始位置

dest:目标数组

destPos:目标数组的起始位置

length:要挪动的元素的长度

total个元素, arr.length长度 假设length = 10, total = 7, 元素的下标[0,6] i=2 移动[3],[4],[5],[6] 删除arr数组的[i] 元素： System.arraycopy(arr, i+1, arr, i, total-i-1) i=2 移动[2],[3],[4],[5],[6] 插入arr数组的[i]元素： System.arraycopy(arr, i, arr, i+1, total-i)

(5)public static void gc()：通知GC工作，进行垃圾回收，通知后，不代表GC线程立刻工作。 (6)public static void exit(int status)：终止当前运行的Java虚拟机。 该参数作为状态代码; 按照惯例，非零状态码表示异常终止。 （7）public static Properties getProperties()：获取所有的系统数属性

6.java.lang.Runtiam类

runtime.getRrntime()代表JVM的运行环境

四、数组的算法升华

1.数组的反转

方案一：

先新建一个数组，然后把元素按照反转之后的正确的顺序放进去，指向新的数组

缺点：浪费空间

方案二：

首尾交换

public class TestArray { @Test public void test01(){ int[] arr = {1,2,3,4,5}; //反转之后：arr中{5,4,3,2,1} //方案一：先新建一个数组，然后把元素按照反转之后的正确的顺序放到新数组中，让arr指向新数组 int[] newArr = new int[arr.length]; //把arr中的元素逆序放到newArr for (int i = 0; i < newArr.length; i++) { /*newArr[0] = arr[arr.length-1]; newArr[1] = arr[arr.length-2];*/ newArr[i] = arr[arr.length-1-i]; } //让arr指向新的数组 arr = newArr; //遍历 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } @Test public void test02(){ int[] arr = {1,2,3,4,5}; //首尾交换 /* 1 2 3 4 5 1和5换 2和4换 5个元素换2次 10个元素：5次 交换的次数 = 数组的长度/2（整数与整数相除只保留整数部分） */ //循环的次数 = 交换的次数 for (int i = 0; i < arr.length/2; i++) { //交换的过程 int temp = arr[i]; arr[i] = arr[arr.length-1-i]; arr[arr.length-1-i] = temp; } //遍历 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }

2.数组的扩容

public class TestArray2 { @Test public void test01(){ int[] arr = {1,2,3,4,5}; //我想要在当前数组的基础上，增加一个元素6，放在最后 /* 思路： （1）创建新数组 （2）把原来的元素复制过程 （3）把新元素放进去 （4）让arr指向新数组 */ int[] newArr = new int[arr.length+1]; for (int i=0; i <arr.length; i++){ newArr[i] = arr[i]; } // newArr[newArr.length-1] = 6; arr = newArr; arr[arr.length-1] = 6; } }

3、数组的插入

ublic class TestArray3 { @Test public void test01(){ int[] arr = {1,2,3,4,5}; //需求：要在arr[1]的位置插入6，结果{1,6,2,3,4,5} /* （1）先创建一个新数组newArr，新数组的长度 > 旧数组 （2）把arr中[0,index-1]的元素放到newArr中 （3）把新元素放到newArr中[index] （4）把arr中[index,arr.length-1]放到newArr中 （5）最后arr指向newArr */ int[] newArr = new int[arr.length+1]; int index = 1;//插入的位置 int value = 6;//插入的值 for (int i=0; i<index; i++){ newArr[i] = arr[i]; } newArr[index] = value; for(int i=index; i<arr.length; i++){ newArr[i+1] = arr[i]; } arr = newArr; //遍历 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } @Test public void test02(){ String[] arr = {"hello","java","world",null,null}; /* 要在index=1的位置插入"atguigu"，结果{"hello","atguigu","java","world",null}; 思路： （1）把index及其后面的元素后移 （2）然后把新元素放到[index] */ int total = 3; int index = 1;//插入的位置 System.arraycopy(arr, index, arr, index+1, total-index); arr[index] = "atguigu"; total++; //遍历 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } /* 在arr[index]位置插入value */ public int[] insert(int[] arr,int index, int value){ /* 方案一： （1）先创建新数组，扩容 (2)把arr的所有元素，原封不动的赋值到新数组newArr （3）再把index位置及其后面的元素后移 （4）把value放到index位置 （5）返回新数组 */ int[] newArr = new int[arr.length+1]; for (int i = 0; i < arr.length; i++) { newArr[i] = arr[i]; } System.arraycopy(newArr, index, newArr, index+1, arr.length-index); newArr[index]=value; return newArr; } @Test public void test03(){ int[] arr = {1,2,3,4,5}; int index = 1; int value = 6; arr = insert(arr, index, value); for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }

4、数组的元素删除

public class TestArray4 { @Test public void test01(){ String[] all = {"hello","java","world",null,null}; //删除index=1位置的元素 int index = 1; int total = 3; //把index+1后面的元素往前移动 System.arraycopy(all, index+1, all, index, total-index-1); all[total-1] = null; //遍历 for (int i = 0; i < all.length; i++) { System.out.println(all[i]); } } }

5.数组的二分查找

之前：数组的查找，是顺序查找，从[0]开始，挨个比较是否目标对象，如果是，找到了，如果不是，一直找到最后 现在：二分查找，又称为折半查找 二分查找有要求，数组必须是有序的

public class TestArray5 { @Test public void test01(){ int[] arr = {2,5,7,8,10,15,18,20,22,25,28};//数组是有序的 int value = 18; //查找value是否在arr中，如果在，打印下标，如果不在，说明不在 int left = 0; int right = arr.length-1; int mid = (left +right)/2; int index = -1; while(left <= right){ if(arr[mid] == value){ index = mid; break; }else if(value > arr[mid]){ left = mid +1; }else{ right = mid - 1; } mid = (left + right) / 2; } if(index==-1){ System.out.println("没找到"); }else{ System.out.println("找到了，下标是：" + index); } } }

6.数组的直接排序=冒泡

public class TestArray6 { @Test public void test01(){ int[] arr = {49,38,65,97,76,13,27,49}; /* 直接选择排序： 思路：每一轮，找出本轮未排序元素中的最小/最大值，看它是否在正确的位置，如果不在，就与该正确位置的元素交换，这样经过多轮之后，实现排序 最坏的情况：arr.length-1轮 {49,38,65,97,76,13,27,49} 从小到大 第一轮：在[0,arr.length-1]范围的最小值 arr[5]=13是最小的，它应该在arr[0]，所以要arr[0]与arr[5] {13,38,65,97,76,49,27,49} 第二轮：在[1, arr.length-1]范围找最小值 arr[6]=27是最小的，它应该在arr[1]，所以要arr[1]与arr[6] {13,27,65,97,76,49,38,49} 。。。。 */ for (int i=0; i<arr.length-1; i++){ //第1轮：i=0, j=0到arr.length-1 //第2轮：i=1, j=1到arr.length-1 //第3轮：i=2, j=2到arr.length-1 //... //第n轮：i=arr.length-2, j=arr.length-2到arr.length-1 //j=i int min = arr[i];//假设本轮的第一个元素最小 int index = i;//本轮最小值的下标 for(int j=i; j<=arr.length-1; j++){ if(arr[j] < min){ min = arr[j]; index = j; } } if(index != i){ //交换 arr[index] 和 arr[i] int temp = arr[index]; arr[index] = arr[i]; arr[i] = temp; } } //结果 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } @Test public void test02() { int[] arr = {49, 38, 65, 97, 76, 13, 27, 49}; /* 第一轮：拿所有元素与arr[0]位置的元素比较，有比它小的，就交换 第一次：{38, 49, 65, 97, 76, 13, 27, 49}; 第二次： 第三次： 第四次： 第五次：{13, 49, 65, 97, 76, 38, 27, 49}; 第六次： 第七次： 第二轮：拿所有元素与arr[1]位置的元素比较，有比它小的，就交换 。。。 */ for(int i=0; i<arr.length-1; i++){ for(int j=i; j<=arr.length-1; j++){ if(arr[j] < arr[i]){ int temp = arr[j]; arr[j] = arr[i]; arr[i] = temp; } } } } @Test public void test03(){ int[] arr = {49,38,65,97,76,13,27,49}; for (int i=0; i<arr.length-1; i++){ int index = i;//本轮最小值的下标 for(int j=i; j<=arr.length-1; j++){ if(arr[j] < arr[index]){ index = j; } } if(index != i){ //交换 arr[index] 和 arr[i] int temp = arr[index]; arr[index] = arr[i]; arr[i] = temp; } } //结果 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }

五、数组的工具类

java.util.Arrays工具类：此类包含用来操作数组（比如排序和搜索）的各种方法。 开发中：能够用API的方法，肯定是最简洁的， 面试中，需要知道底层是如何实现的，甚至有些算法要手动会实现。

System.arraycopy这个方法和数组关系，为啥在System类中，不在Arrays类？ 因为版本的问题。JDK1.0时候，还没有Arrays工具类，但是arraycopy这个方法已经在使用了， 当时没地方放这个方法，只好放在系统类中。后期所有和数组有关的方法都在Arrays类中。

（1）public static int binarySearch(int[] a, int key)：二分查找 如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点： 它有很多重载形式，形参的类型不同

（2）public static int[] copyOf(int[] original,int newLength)：复制数组 它有很多重载形式，形参的类型不同

（3）public static int[] copyOfRange(int[] original,int from, int to) 它有很多重载形式，形参的类型不同

（4）public static boolean equals(int[] a, int[] a2)：比较两个数组是否相同 它有很多重载形式，形参的类型不同

（5）public static void fill(int[] a,int val)：用val填充整个数组 它有很多重载形式，形参的类型不同

（6）public static void sort(int[] a) :对指定的 int 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法 它有很多重载形式，形参的类型不同

（7）public static void sort(Object[] a)：给对象数组排序，按升序排列，要求元素必须是java.lang.Comparable public static void sort(Object[] a, Comparator c)：按升序排列，需要一个Comparator实现类对象

（8）public static String toString(int[] a) 它有很多重载形式，形参的类型不同