java se 进阶_08-08总结(JavaSE进阶 上)

1、常见算法

1. 冒泡排序(随笔/经典排序算法)

2. 选择排序(随笔/经典排序算法)

3.二分查找

前提

数组是有序的

原理

1.每一次都去获取数组的中间索引所对应的元素，然后和要查找的元素进行比对，如果相同就返回索引；

2.如果不相同，就比较中间元素和要查找的元素的值；

3.如果中间元素的值大于要查找的元素，说明要查找的元素在左侧，那么就从左侧按照上述思想继续查询 (忽略右侧数据)；如果中间元素的值小于要查找的元素，说明要查找的元素在右侧，那么就从右侧按照上述思想继续查询(忽略左侧数据)；

代码实现

2、异常

1.概述

异常

指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM非正常停止。在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

2.异常类的体系

异常的根类是java.lang.Throwable。

Throwable体系：

Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。

Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。

3. 异常的处理

throw(抛出异常)

在方法中用来抛出异常对象，一次只能抛出一个异常对象。

格式：throw new 异常类名(参数)；例如：

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

throws(声明异常)

在方法声明上(参数列表后面, 大括号前面)声明有异常，throws后面可以跟多个异常类名。(throws把异常交给调用者处理)。

格式：修饰符  返回值类型  方法名(参数)  throws  异常类名1,异常类名2…{ }

try…catch(捕获异常)

格式：

try {    可能出现异常的代码(有编译时异常的代码)    }

catch (异常的声明) {    出现异常之后你的处理方式    }

try-catch注意事项

try和catch都不能单独使用,必须连用

如果try中有多个异常出现, 我们可以写多个catch

如果多个catch中有子父类关系, 子类放在前面, 父类放在后面

e.printStackTrace();可以将异常类名,信息和位置打印到控制台

try中如果出现异常, 被catch捕捉起来, try中异常下面的代码不会执行, 而是直接执行catch中的语句

throws抛出异常, 抛出给调用者处理, 如果最终抛给虚拟机, 虚拟机会将程序终止运行，而try-catch自己处理异常, 程序可以继续执行

finally语句体

有一些特定的代码无论异常是否发生，都需要执行。在finally代码块中存放的代码都是一定会被执行的。

try...catch....finally：这种语法通常用在自身需要处理异常,最终还得关闭资源的场景。

3、多线程

1.基本概念

并发和并行

并行: 同一个时间点上, 多个任务同时执行, 需要多核CPU

并发: 同一个时间段中, 多个任务同时请求执行, 而在一个时间点上执行的任务只有一个， CPU会切换执行权

线程和进程

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

线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

进程与线程的区别

进程有独立的内存空间，进程中的数据存放空间(堆空间和栈空间)是独立的，至少有一个线程。

线程的堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。

2.多线程的实现方式

创建线程方式一：继承Thread类

1.定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。

2.创建Thread子类的实例，即创建了线程对象

3.调用线程对象的start()方法来启动该线程

创建线程方式二：实现Runnable接口

1.定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

2.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

3.调用线程对象的start()方法来启动线程。

注意：使用Thread方式开启多条线程, Thread的子类对象需要创建多次；使用Runnable方法开启多条线程, Runnable接口的实现类对象只需要创建一次.

实现Runnable接口的好处

解决了单继承的局限性

继承Thread类的方式, 共享数据需要加上static修饰；实现Runnable接口的方式, 共享数据不需要加static

实现Runnable方式, 降低代码的耦合度

线程池中只允许Runnable/Callable, 不能添加Thread

匿名对象开启线程

new MyThread().start();

*************************************

MyRunnable mr = new MyRunnable();

new Thread(mr).start();

匿名内部类开启线程

new Thread() {

@Override

public void run() {

System.out.println("开启了一条新线程!~111");

}

}.start();

****************************************************************

Runnable r = new Runnable() {

@Override

public void run() {

System.out.println("开启了一条新线程!~222");

}

};

new Thread(r).start();

3.Thread中的其他方法

构造方法                                                                        描述

public Thread(String name)                                           指定线程名

public Thread(Runnable r, String name)                        先传入Runnale, 再执行线程名

其他方法                                                                         描述

public final String getName()                                          获取线程的名字

public final synchronized void setName(String name)    修改线程的名字

public static Thread currentThread()                               获取当前正在执行的线程对象

public static void sleep(long millis)                                  让当前线程休眠指定的毫秒数

注意：异常不能抛, 只能try-catch。异常出现的方法是一个重写的方法, 父类的方法没有异常抛出, 子类重写的方法也不能抛出异常。

4、线程安全

1. 同步代码块

目的: 让程序在某一段代码的执行过程中, 不被抢走执行权

位置：方法中

格式

synchronized(锁对象) {

要同步的代码;

}

锁的注意事项

锁对象可以是任意对象

想保证同步, 必须使用同一把锁

常用的锁对象

this: 要保证只有一个当前类的对象

字节码对象: Xxx.class  每个类只有一个字节码对象, 不会出现问题

2.线程安全问题

线程安全问题产生的原因:

多线程环境下

有共享数据

有多条语句操作共享数据

如何解决线程安全问题:

只要将操作共享数据的代码都放在同步中

**多窗口卖票案例

3.其他同步方式

同步方法

public synchronized void fun1( ) { }    // 普通的同步方法, 默认锁对象是: this

public staticsynchronized void fun2( ) { }    // 静态同步方法, 默认锁对象是 :  类名.class

5、线程状态

1.线程的6种状态

2.等待唤醒机制(线程间通信)

方法                                                        描述

wait()                                                       让当前线程进入无限等待的状态

notify()                                                     随机唤醒一条等待的线程

notifyAll()                                                 唤醒所有等待的线程

使用时的注意事项

3个方法必须由锁对象来调用

3个方法必须写在同步中

3个方法都是定义在Object类中

wait和sleep的区别

wait会释放锁(wait的时候会被抢走执行权)

sleep不会释放锁(sleep的时候锁还在，不会被抢走执行权)

**生产者消费者案例(包子案例)