一.选择排序
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