选择排序（重点）
/*
选择排序
*/
public class Demo01SelectSort{
public static void main(Strings[] args){
int[] arr = {5, 1, 8, 3};
System.Out.Println("排序前的数组元素" + Arrays.toString(arr));
selectSort(arr);
System.Out.Println("排序后的数组元素" + Arrays.toString(arr));
}
/*
定义一个选择排序的方法
1.方法的参数传递一个数组，方法中对数组中的元素进行排序
2.定义一个循环嵌套:
外层循环：控制比较的次数 数据长度-1
内层循环：控制每次比较几对元素
为防止重复的比较 索引+1
为控制每次比较的对数依次减少，索引+i
3.在循环中依次比较arr[i]和arr[j]的值，每次选出最小的
比较两个元素，使用第三方变量交换位置
*/
public static void selectSort(int[] arr){
//2.定义一个循环嵌套
for(int i = 0; i < arr.length - 1; i++){//外层循环：控制比较的次数，数组长度-1 for(int j = 1 + i； j < arr.length; j++){//内层循环：控制每次比较几对元素
//在循环中依次比较arr[i]和arr[j]的值，选出最小的
if(arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
}
冒泡排序
/*
冒泡排序
*/
public class Demo01BubbleSort {
public static void main(String[] args) {
int[] arr = {5,1,8,3};
System.out.println("排序前数组中的元素:"+ Arrays.toString(arr));
bubbleSort(arr);
System.out.println("排序后数组中的元素:"+ Arrays.toString(arr));
}
/*
定义一个冒泡排序的方法
1.方法的参数传递一个数组,对数组进行冒泡排序
2.定义一个循环嵌套:
外层循环:控制比较的次数,数组的索引arr.length-1
内层循环:控制每次比较几对元素
为了防止索引越界异常 arr.length-1
为了每次比较的对数依次减少 arr.length-1-i
3.在循环中依次比较的是arr[j]和arr[j+1]的值,选择最大的
比较两个元素,使用第三方变量交换位置
*/
public static void bubbleSort(int[] arr){
//定义一个循环嵌套
for(int i = 0; i < arr.length-1; i++){//控制比较次数
for(int j = 0; j < arr.length-1-i; j++){//控制每次比对几对元素
//在循环中依次比较的是arr[j]和arr[j+1]的值,选择最大的
if(arr[j]>arr[j+1]){
//比较两个元素,使用第三方变量交换位置
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}
二分法查找
/*
二分(折半)查找:
前提:数组|集合必须是有序的(小-->大)
*/
public class Demo01BinarySearch {
public static void main(String[] args) {
int[] arr = {-10,0,11,30,66,88};
//int index = binarySearch(0, arr);//1
//int index = binarySearch(88, arr);//5
//int index = binarySearch(100, arr);//-1
/*
java.util.Arrays:数组工具类
static int binarySearch(Object[] a, Object key) 二分查找
如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
找到了,返回元素的索引,找不到返回-(插入点) - 1
插入点:被查找的元素在数组中的插入的位置
22就在11和30之间,位置就是3索引
*/
//int index = Arrays.binarySearch(arr, 88);//5
int index = Arrays.binarySearch(arr, 22);//-4 -3-1=-4
System.out.println(index);
}
/*
定义一个方法实现二分查找
1.方法的参数传递要查找的值和被查找的数组
2.定义3个指针(min,mid,max)
3.遍历数组,使用被查找的元素和中间索引指向的元素比较,循环执行的条件 min<=max
被查找的元素>中间指针执行的元素 min = mid +1;
被查找的元素<中间指针执行的元素 max = mid -1;
被查找的元素==中间指针执行的元素 找到了,返回mid
4.循环结束了,还没有找到返回-1
*/
public static int binarySearch(int number,int[] arr){
//2.定义3个指针(min,mid,max)
int min = 0;
int max = arr.length-1;
int mid = 0;
//3.遍历数组,使用被查找的元素和中间索引指向的元素比较,循环执行的条件 min<=max
while (min<=max){
//使用公式计算mid的值,每次循环值都必须重新计算
mid = (min+max)/2;
if(number>arr[mid]){
//被查找的元素>中间指针执行的元素 min = mid +1;
min = mid +1;
}else if(number<arr[mid]){
//被查找的元素<中间指针执行的元素 max = mid -1;
max = mid-1;
}else{
//被查找的元素==中间指针执行的元素 找到了,返回mid
return mid;
}
}
//4.循环结束了,还没有找到返回-1
return -1;
}
}
异常
概念
指在程序执行过程中出现非正常情况，最终会导致JVM非正常的停止。
在Java等面向对象的语言中，异常本身是一个类，产生异常就是创建了异常对象并抛出了一个异常对象。Java的处理方式是停止Java虚拟机
异常的体系:
-- java.lang.Throwable:异常和错误的最顶层的父类
Throwable 类是 Java 语言中所有错误或异常的超类。
异常:不正常,身体出现了小毛病,感冒,发烧,是可以治愈的
在程序中异常是可以解决的,解决了异常之后程序可以继续执行
-- java.lang.Exception extends Throwable:编译期异常,写代码的时候(编译),出现的异常
-- java.lang.RuntimeException extends Exception: 运行期异常:程序运行的时候,出现的异常
错误:非常严重的问题,得了艾滋,癌症,无药可救等死
在程序中错误是不能解决的,必须的修改源代码,才能解决
-- java.lang.Error extends Throwable:错误
异常产生的过程（重点）
throw关键字
/*
throw关键字(重点)
作用:可以在方法中抛出指定的异常对象
格式:
修饰符 返回值类型 方法名(参数){
throw new Exception("异常信息");
throw new RuntimeException("异常信息");
}
注意:
1.throw关键字必须写在方法中使用
2.throw关键字后边创建的异常对象,必须使用Exception或者Exception的子类对象
3.在方法中使用throw关键字抛出了编译异常,我们就必须处理这个编译异常
在方法中使用throw关键字抛出了运行期异常,我们可以不用处理这个异常,最终交给JVM处理(中断)
*/
public class Demo03throw {
public static void main(String[] args) {
int[] arr = {1,2,3};
int element = getElement(arr, 3);
System.out.println(element);
System.out.println("后续代码!");
System.out.println("后续代码!");
System.out.println("后续代码!");
}
/*
定义一个方法,参数传递数组和数组的索引
在方法中根据索引查找元素并返回
在工作中:必须对传递到方法中的参数进行一些合法性的判断
如果参数合法,那么就正常运行方法
如果参数不合法:可以使用抛出异常对象的方式,告之方法的调用者,传递的参数有问题
*/
public static int getElement(int[] arr,int index){
/*
对数组arr进行合法性判断,判断arr是否为null
arr是null,那么就抛出空指针异常对象,告之方法的调用者:您传递的数组的值是null
*/
if(arr==null){
throw new NullPointerException("您传递的数组的值是null");
}
/*
对index数组的索引进行合法性判断,判断index是否超出了数组索引的范围
如果index超出了数组索引的范围,那么就抛出索引越界异常,告之方法的调用者
"您传递的参数index超出了数组的使用范围"
*/
if(index<0 || index>arr.length-1){
throw new ArrayIndexOutOfBoundsException("您传递的参数index:"+index+"超出了数组的使用范围");
}
int ele = arr[index];
return ele;
}
}
throws关键字
/*
throws关键字(重点)
异常处理的第一种方式,抛出指定的异常对象
作用:
方法内部抛出了指定的异常对象,我们就必须的处理这个异常对象
可以使用throws来来处理这个异常对象,可以使用throws继续把这个异常对象抛出给方法的调用者处理
最终会抛出给JVM处理,JVM就会以红色的字体把异常对象打印到控制台,中断正在执行的程序
弊端:
程序中如果有后续的代码,执行不到的,程序已经停止了
格式:
修饰符 返回值类型 方法名(参数) throws xxxException,...,yyyException{
throw new xxxException("异常的信息");
...
throw new yyyException("异常的信息");
}
注意:
1.throws关键字必须写在方法的声明处
2.一般在方法内部抛出了什么异常对象,就使用throws关键字在方法上声明什么异常对象
a.在方法内部抛出了多个异常对象,就需要使用throws关键字在方法上声明多个异常对象
b.在方法内部抛出的多个异常对象,有子父类关系,在方法上使用throws关键字抛出父类异常对象即可
3.调用了一个抛出异常对象的方法,那么我们就必须处理这个异常
a.可以使用throws关键字继续抛出这个异常对象,最终会抛出给JVM处理
b.可以使用try...catch来处理这个异常对象
*/
public class Demo04throws {
//main(String[] args) throws Exception:把异常对象抛出给main方法的调用者JVM处理
public static void main(String[] args) throws Exception {
int[] arr = {1,2,3};
int element = getElement(arr, 3);
System.out.println(element);
System.out.println("后续代码!");
System.out.println("后续代码!");
System.out.println("后续代码!");
}
//getElement(int[] arr,int index)throws Exception:把异常对象抛出给方法的调用者main方法处理
public static int getElement(int[] arr,int index)throws Exception{
if(arr==null){
throw new Exception("您传递的数组的值是null");
}
if(index<0 || index>arr.length-1){
throw new Exception("您传递的参数index:"+index+"超出了数组的使用范围");
}
int ele = arr[index];
return ele;
}
}
throws抛出子父类异常
/*
throws关键字的使用
*/
public class Demo05throws {
public static void main(String[] args) throws IOException{
/*
调用了一个抛出异常对象的方法,那么我们就必须处理这个异常
在方法内部抛出的多个异常对象,有子父类关系,在方法上使用throws关键字抛出父类异常对象即可
FileNotFoundException extends IOException extends Exception
*/
readFile("d:\\a.txt");
}
/*
定义一个方法,传递一个文件的路径,在方法中根据文件的路径读取文件
*/
public static void readFile(String path) throws FileNotFoundException,IOException{
//对路径进行合法性判断,判断路径是否为null,是null抛出IO异常
if(path==null){
throw new IOException("您传递的文件路径是null!");
}
//对路径进行合法性判断,判断路径是否为d:\\a.txt,不是指定的路径,抛出文件找不到异常
if(!"d:\\a.txt".equals(path)){
throw new FileNotFoundException("您传递的文件路径不是d:\\a.txt");
}
}
}
try…catch关键字
/*
try...catch关键字:异常处理的第二种方式,建议工作中使用
方法内部抛出了指定的异常对象,我们就必须的处理这个异常对象
可以使用try..catch关键字捕获处理异常,自定义定义处理异常的方式
好处:
处理了异常对象之后,后续如果有代码,可以继续执行
格式:
try{
可能产生异常的代码
}catch(定义异常相关的变量){ 变量的作用是用来接收差生的异常对象
异常的处理逻辑
}
...
catch(){
异常的处理逻辑
}
注意:
1.try中可能产生什么异常对象,catch中就定义什么异常变量来接收这个异常对象
2.如果try中的代码产生了异常,就会执行catch中异常的处理逻辑,执行完catch中的代码,继续执行try...catch之后的代码
3.如果try中的代码没有产生异常,就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try...catch之后的代码
4.如果try中产生了多个异常对象,就需要定义多个catch来捕获这些异常对象
*/
public class Demo06TryCatch {
public static void main(String[] args) {
try {
//可能产生异常的代码
readFile(null);
} catch (FileNotFoundException e) {
//异常的处理逻辑
System.out.println("传递的文件路径不是d:\\a.txt");
}catch (IOException e) {
//异常的处理逻辑
System.out.println("传递的文件路径是null");
}
System.out.println("后续代码!");
System.out.println("后续代码!");
System.out.println("后续代码!");
System.out.println("后续代码!");
}
/*
定义一个方法,传递一个文件的路径,在方法中根据文件的路径读取文件
*/
public static void readFile(String path)throws FileNotFoundException,IOException{
//对路径进行合法性判断,判断路径是否为null,是null抛出IO异常
if(path==null){
throw new IOException("您传递的文件路径是null!");
}
//对路径进行合法性判断,判断路径是否为d:\\a.txt,不是指定的路径,抛出文件找不到异常
if(!"d:\\a.txt".equals(path)){
throw new FileNotFoundException("您传递的文件路径不是d:\\a.txt");
}
System.out.println("成功的读取到了d:\\a.txt文件");
}
}
521
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
