排序算法、异常、多线程基础 总结

大家好，欢迎来到IT知识分享网。

冒泡排序

一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次 对所有的数据进行操作，直至所有数据按要求完成排序 如果有n个数据进行排序，总共需要比较n-1次 每一次比较完毕，下一次的比较就会少一个数据参与

选择排序

另外一种排序的方式，选中数组的某个元素,其后面的元素依次和选中的元素进行两两比较，将较 大的数据放在后面，依次从前到后选中每个元素，直至所有数据按要求完成排序 如果有n个数据进行排序，总共需要比较n-1次 每一次比较完毕，下一次的比较就会少一个数据参与

二分查找

普通查找

原理：遍历数组，获取每一个元素，然后判断当前遍历的元素是否和要查找的元素相同，如果相同就返 回该元素的索引。如果没有找到，就返回一个负数作为标识(一般是-1)

二分查找

原理: 每一次都去获取数组的中间索引所对应的元素，然后和要查找的元素进行比对，如果相同就返回 索引；
如果不相同，就比较中间元素和要查找的元素的值；
如果中间元素的值大于要查找的元素，说明要查找的元素在左侧，那么就从左侧按照上述思想继续查询 (忽略右侧数据)；
如果中间元素的值小于要查找的元素，说明要查找的元素在右侧，那么就从右侧按照上述思想继续查询 (忽略左侧数据)；
二分查找对数组是有要求的,数组必须已经排好序

 public static void main(String[] args) { 
    int[] arr = { 
   10, 14, 21, 38, 45, 47, 53, 81, 87, 99}; int index = binarySerach(arr, 38); System.out.println(index); } / * 二分查找方法 * * @param arr 查找的目标数组 * * @param number 查找的目标值 * * @return 找到的索引,如果没有找到返回-1 * */ public static int binarySerach(int[] arr, int number) { 
    int start = 0; int end = arr.length - 1; while (start <= end) { 
    int mid = (start + end) / 2; if (number == arr[mid]) { 
    return mid ; } else if (number < arr[mid]) { 
    end = mid - 1; } else if (number > arr[mid]) { 
    start = mid + 1; } } return -1; //如果数组中有这个元素，则返回  } 

异常

异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部 位的功能将受影响.在程序中的意思就是：
异常 ：
指的是程序在执行过程中，出现的非正常的情况，终会导致JVM的非正常停止。 在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对 象。Java处理异常的方式是中断处理。
异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

Java异常处理的五个关键字：try、catch、finally、throw、throws

声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处 理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常 (抛出异常).
声明异常格式：
修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{ }
声明异常的代码演示

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异 常类，用逗号隔开。

捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常: 1. 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。 2. 在方法中使用try-catch的语句块来处理异常。
try-catch的方式就是捕获异常。 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
捕获异常语法如下：

try：该代码块中编写可能产生异常的代码。
catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。 注意:try和catch都不能单独使用,必须连用。
演示如下：

如何获取异常信息：
Throwable类中定义了一些查看方法:

public String getMessage() :获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
public String toString() :获取异常的类型和异常描述信息(不用)。
public void printStackTrace() :打印异常的跟踪栈信息并输出到控制台。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。 在开发中呢也可以在catch将编译期异常转换成运行期异常处理

finally 代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有 些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
什么时候的代码必须终执行？
当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后, 终关闭打开的资源。
finally的语法:
try…catch…finally:自身需要处理异常,终还得关闭资源。
注意:finally不能单独使用。
比如在我们之后学习的IO流中，当打开了一个关联文件的资源，后程序不管结果如何，都需要把这个 资源关闭掉。
finally代码参考如下：

异常注意事项

运行时异常被抛出可以不处理。即不捕获也不声明抛出。 如果父类的方法抛出了多个异常,子类覆盖(重写)父类方法时,只能抛出相同的异常或者是他的子 集。 父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获 处理，不能声明抛出 当多异常分别处理时，捕获处理，前边的类不能是后边类的父类 在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。 多个异常使用捕获又该如何处理呢？

1. 多个异常分别处理。
2. 多个异常一次捕获，多次处理。
3. 多个异常一次捕获一次处理。

一般我们是使用一次捕获多次处理方式，格式如下：

try{ 
    编写可能会出现异常的代码 }catch(异常类型A e){ 
    当try中出现A类型异常,就用该catch来捕获. 处理异常的代码 //记录日志/打印异常信息/继续抛出异常  }catch(异常类型B e){ 
    当try中出现B类型异常,就用该catch来捕获. 处理异常的代码 //记录日志/打印异常信息/继续抛出异常 } 

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间 有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

多线程基础

并发与并行

并行：指两个或多个事件在同一时刻发生（同时执行）。
并发：指两个或多个事件在同一个时间段内发生(交替执行)。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并 发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却 是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行 多个线程，我们把这种情况称之为线程调度。

线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同 时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序 即是一个进程从创建、运行到消亡的过程。
线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个 进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

进程

线程

进程与线程的区别

进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线 程。
线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。

注意：下面内容为了解知识点

1:因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执 行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。

2:Java 程序的进程里面至少包含两个线程，主进程也就是 main()方法线程，另外一个是垃圾回收 机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就 是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启 动两个线程。

3:由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候， 通常考虑创建多线程，而不是创建多进程。

线程调度:

分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)， Java使用的为抢占式调度。

Thread类

线程开启我们需要用到了 java.lang.Thread 类，API中该类中定义了有关线程的一些方法，具体如 下：
构造方法：
public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定 名字。

常用方法：
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时 停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

翻阅API后得知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式

创建线程方式一_继承方式

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线 程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体 来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

1. 定义Thread类的子类,并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任 务,因此把run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象
3. 调用线程对象的start()方法来启动该线程
4.
代码如下：

方式一
测试类：

自定义线程类：

创建线程的方式二_实现方式

采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线 程执行体
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对 象才是真正的线程对象。
3. 调用线程对象的start()方法来启动线程。

代码如下:

tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线 程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源 共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

匿名内部类

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：