一.选择排序
public class TestSelectionSort {
public static void main(String[] args) {
//1.数组
int[] arr = {5, 4, 7, 1, 8, 2, 3, 6, 9};
//2.使用选择排序
//外层循环,控制你选中的那个元素
for(int i = 0;i < arr.length - 1;i++){
//内层循环,控制和那个元素进行比较
for(int j = i+1;j < arr.length;j++){
//比较 arr[i] arr[j]
if (arr[i] > arr[j]){
//交换
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
//3.打印
System.out.println(Arrays.toString(arr));
}
} public static void main(String[] args) {
int[] ab ={2,3,12,23,43,15,11,12,14};
int index = 0;
int temp =0;
for (int i=0;i<ab.length-1;i++){
index = i;
for (int j = i+1;j<ab.length;j++){
if (ab[index]>ab[j]){
index=j;
}
}
if (index!=i){
temp = ab[i];
ab[i] = ab[index];
ab[index] =temp;
}
}
System.out.println(Arrays.toString(ab));
}二.二分查找
普通查找: 给定数组,从数组中找到某个元素的索引
int[] arr = {4,5,6,1,7,2,8,9}; 找出 7出现的索引,我们只能从前到后依次遍历
二分查找: 给定的数组,必须是有自然顺序的(比如,从小到大), 从数组中找到某个元素的索引
int[] arr = {1,3,5,6,8,9,10,12}; 找出3出现的索引,我们可以依然从前到后遍历
但是效率很低,我们从中间开始,根据中间值的大小瞬间可以让查找访问缩小一半
图解：
public class TestBinarySearch {
public static void main(String[] args) {
//1.定义数组
int[] arr = {10,20,30,40,50,60,70,88,90};
//2.查找元素
int key = 55;
//3.调用方法
int index = binarySearch(arr, key);
System.out.println(index);
}
//二分查找
public static int binarySearch(int[] arr,int key){
//1.开始和结束索引
int left = 0;
int right = arr.length - 1;
//2.循环
while (left <= right){
//3.获取中间索引
int middle = (left + right) / 2;
//4.比较中间索引的元素和key
if (arr[middle] > key){
right = middle - 1;
}else if(arr[middle] < key){
left = middle + 1;
}else{
return middle;
}
}
return -1;
}
}三.异常处理
程序在运行过程中发生错误或异常情况是不可避免的，如果每一个运行时错误都由程序员手动处理，其工作量是不可想象的。
Java语言中的异常处理机制就解决了上述问题，把错误与异常的管理带到了面向对象的世界。
public void printStackTrace() :以红色打印异常的详细信息(包括异常类型,异常原因,异常位置)【最常用】
打印的效果如下:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at com.itheima.demo03_exception01.TestException.main(TestException.java:6)
public String getMessage() :获取发生异常的原因。
public String toString(); 获取异常的类型和异常描述信息(不用)
异常的分类”
编译时异常，
写好代码之后,运行代码之前出现的异常
编译时异常是Exception以及Exception的子类(RuntimeException除外) 运行时异常
运行代码时出现的异常
运行时异常是RuntimeException以及其子类 java语言定义了很多异常类，将运行错误和异常的信息和处理方法封装在了异常类中，帮助程序员检查和控制异常。
Throwable 是 Java 语言中所有错误或异常的超类，在 Java 中只有 Throwable 类型的实例才可以被抛出（throw）或者捕获（catch），它是异常处理机制的基本组成类型。
实例分为 Error 和 Exception 两种。
Error 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果
出现了这样的错误，除了告知用户，剩下的就是尽力使程序安全的终止。
Exception 又有两个分支 ， 一个是运行时异常 RuntimeException ， 一 个是检查异常 CheckedException。
RuntimeException 如 ：NullPointerException 、 ClassCastException ；
CheckedException 如： I/O 错误导致的 IOException、SQLException。
RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。 如果出现 RuntimeException，那么一
定是程序员代码书写导致的错误.
CheckedException：一般是外部错误，这种异常都发生在编译阶段，Java 编译器会强
制程序去捕获此类异常，即会出现要求你把这段可能出现异常的程序进行 try catch，该类异常一
般包括几个方面：
- 试图在文件尾部读取数据
- 试图打开一个错误格式的 URL
- 试图根据给定的字符串查找 class 对象，而这个字符串表示的类并不存在
常见的异常种类：
输入输出异常：IOException
算术异常类：ArithmeticExecption
空指针异常类：NullPointerException
类型强制转换异常：ClassCastException
操作数据库异常：SQLException
文件未找到异常：FileNotFoundException
数组负下标异常：NegativeArrayException
数组下标越界异常：ArrayIndexOutOfBoundsException
违背安全原则异常：SecturityException
文件已结束异常：EOFException
字符串转换为数字异常：NumberFormatException
方法未找到异常：NoSuchMethodException
Objects中非空判断方法
Objects类是什么?? 工具类
public static <T> T requireNonNull(T obj); 方法内部帮助我们判断是否为null
查看源码:
该方法也称为 空指针容忍方法
public static <T> T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
} Java中异常的分类：
Error
Error 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果出现了这样的错误，除了告知用户，剩下的就是尽力使程序安全的终止。
Exception（RuntimeException、CheckedException）
Exception 又有两个分支，一个是运行时异常 RuntimeException ，一个是CheckedException。RuntimeException 如 ： NullPointerException 、 ClassCastException ；一个是检查异常CheckedException，如 I/O 错误导致的 IOException、SQLException。 RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。 如果出现 RuntimeException，那么一定是程序员的错误检查异常 CheckedException：一般是外部错误，这种异常都发生在编译阶段，Java 编译器会强制程序去捕获此类异常，即会出现要求你把这段可能出现异常的程序进行 try catch，该类异常一般包括几个方面：
试图在文件尾部读取数据试图打开一个错误格式的 URL试图根据给定的字符串查找 class 对象，而这个字符串表示的类并不存在
Java中的异常处理
在Java中如果需要处理异常，必须先对异常进行捕获，然后再对异常情况进行处理。
如何对可能发生异常的代码进行异常捕获和处理呢？
两种异常处理方式：
1使用try和catch关键字即可，被try块包围的代码说明这段代码可能会发生异常，一旦发生异常，异常便会被catch捕获到，然后需要在catch块中进行异常处理。
2在Java中还提供了另一种异常处理方式即抛出异常，顾名思义，也就是说一旦发生异常，我把这个异常抛出去，让调用者去进行处理，自己不进行具体的处理，此时需要用到throw和throws关键字。
Throw 和 throws 的区别：
位置不同
throws 用在函数上，后面跟的是异常类，可以跟多个；而 throw 用在函数内，后面跟的是异常对象。
功能不同：
throws 用来声明异常，让调用者只知道该功能可能出现的问题，可以给出预先的处理方式；throw 抛出具体的问题对象，执行到 throw，功能就已经结束了，跳转到调用者，并将具体的问题对象抛给调用者。也就是说 throw 语句独立存在时，下面不要定义其他语句，因为执行不到。throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw 则是抛出了异常，执行 throw 则一定抛出了某种异常对象。两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
throws 表示出现异常的一种可能性，并不一定会发生这些异常；
throw 则是抛出了异常，执行 throw 则一定抛出了某种异常对象。
自定义异常：
Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是没有定义好的,此时我们根据自己业务的异常情况来定义异常类。
一些异常都是 Java 内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题，这时就需要我们自定义异常。
在开发中根据自己业务的异常情况来定义异常类。
（1）自定义一个编译器异常：自定义类 并继承 java.lang.Exception
（2）自定义一个运行时期的异常类：自定义类，并继承于 java.lang.RuntimeException。
建议：保留两种构造器的形式
①无参构造
②带给父类的message属性赋值的构造器
自定义异常有固定步骤:
a.创建一个类,类名必须叫XxxException
b.继承Exception或者RuntimeException
c.一般来说需要提供两个构造,无参构造+带有String参数的构造
//a.创建一个类,类名必须叫XxxException
public class MyException extends /*Exception*/RuntimeException{
//b.继承Exception或者RuntimeException
//c.一般来说需要提供两个构造,无参构造+带有String参数的构造
//无参构造
public MyException(){
}
//带有异常信息的构造
public MyException(String message){
//一定要把message把保存起来
//super(参数) 表示调用父类的构造方法
super(message);
}
} 语法格式：
public class XXXExcepiton extends Exception | RuntimeException{
添加一个空参数的构造方法
添加一个带异常信息的构造方法
}（1）自定义异常类一般都是以Exception结尾,说明该类是一个异常类
（2）自定义异常类,必须的继承Exception或者RuntimeException
继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try...catch
继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)
// 自定义异常类
public class xxxException extends /*Exception*/ RuntimeException{
//添加一个空参数的构造方法
public xxxException(){
super();
}
/*
添加一个带异常信息的构造方法
查看源码发现,所有的异常类都会有一个带异常信息的构造方法,方法内部会调用父类带异常信息的构造方法,让父类来处理这个异常信息
*/
public xxxException(String message){
super(message);
}
}throws声明抛出异常
a.声明异常的格式
throws关键字是给方法使用的,为该方法做出声明,声明该方法内部有编译时异常,调用者需要处理该异常
格式:
public void 方法名(参数列表)throws XxxException{
一堆代码(如果这堆代码有编译时异常)
}
b.案例演示
public class TestException03 {
public static void main(String[] args) throws FileNotFoundException{
//调用方法
readFile("1.txt");
}
//定义方法:读取硬盘上某个文件
//throws关键字是给方法使用的,为该方法做出声明,声明该方法内部有编译时异常,调用者需要处理该异常
public static void readFile(String name) throws FileNotFoundException{
//假设硬盘上有一个叫1.txt的文件
if ("1.txt".equals(name)) {
//可以读
System.out.println("读取文件成功...");
}else{
//抛出异常
throw new FileNotFoundException("没有找到你要的文件:"+name);
}
}
}
try --- catch 捕获异常
a.捕获异常的格式
格式:
try{
可能出现异常的代码
}catch(XxxExcption e){
//处理异常
e.printStackTrace(); //直接打印(开发阶段)
save(e);//将异常保存到异常日志(异常数据库)
}
b.案例演示
public class TestException04 {
public static void main(String[] args) {
//调用方法
try {
readFile("11.txt");
}catch (FileNotFoundException e){
//处理
System.out.println("有异常啦!!!");
e.printStackTrace();
}
System.out.println("程序继续执行...");// 有异常的情况下 这句代码能否执行???
}
//定义方法:读取硬盘上某个文件
//throws关键字是给方法使用的,为该方法做出声明,声明该方法内部有编译时异常,调用者需要处理该异常
public static void readFile(String name) throws FileNotFoundException{
//假设硬盘上有一个叫1.txt的文件
if ("1.txt".equals(name)) {
//可以读
System.out.println("读取文件成功...");
}else{
//抛出异常
throw new FileNotFoundException("没有找到你要的文件:"+name);
}
}
}
c.捕获到异常之后,如何查看异常的信息
i.直接打印出来 调用 e.printStackTrace(); 一般开发阶段
ii.可以先保存起来 比如保存到异常日志,异常系统之类 finally代码块
a.finally代码块的格式
finally一般不能单独使用,配合try..catch使用
try{
可能有异常的代码
}catch(XxxException e){
e.printStackTrace();
}finally{
写在finally中的代码,无论是否有异常,都会执行!!
}
b.finally代码块的作用
写在finally中的代码,无论是否有异常,都会执行!!
一般用于写释放资源,关闭连接等代码(后期我们会在IO流,数据库等方面使用到)
c.案例演示
try{
readFile(文件名);
}catch(Exception e){
打印出异常信息
}finally{
释放文件这个资源
xxx.close();
}异常的注意事项：
a.运行时异常被抛出可以不处理,不需要throws声明,也不需要trycatch捕获
b.如果父类的方法抛出了多个异常,子类覆盖(重写)父类方法时,只能抛出相同的异常或者是他的子集。
假设父类的方法抛出100个异常,子类在重写该方法时,只能抛出这个100个或者这100个中的一部分
c.如果父类的方法没有抛出异常,那么子类在重写该方法时,必须也不能抛出异常
d.如果我们的异常有多个,我们该如何处理呢???
方法1(); 可能抛出 One异常
方法2(); 可能抛出 Two异常
方法3(); 可能抛出 Three异常
i.每个异常单独trycatch【一般人都不使用】
try{
方法1();
}catch(One e){
处理
}
try{
方法2();
}catch(One e){
处理
}
try{
方法3();
}catch(One e){
处理
}
ii.所有异常一起try,但是分开catch【偶尔使用】
try{
方法1(); 可能抛出 One异常 假设 One extends Two
方法2(); 可能抛出 Two异常
方法3(); 可能抛出 Three异常
}catch(One e1){
立刻处理打印
}catch(Two e2){
稍后处理,保存起来
}catch(Three e3){
不处理
}
"注意事项": 要求 前面的异常必须是子类异常 后面的异常必须是父类
iii.所有异常一起try,一个catch【经常使用】
try{
方法1(); 可能抛出 One异常
方法2(); 可能抛出 Two异常
方法3(); 可能抛出 Three异常
}catch(Exception e1){
处理
}
e.多个异常有三种方式处理:
i.一个异常,一个trycatch
ii.多个异常,一个try多个catch
iii.多个异常,一个try一个catch
