JAVA进阶级开发之（Array工具类）

常见的算法：

1、排序算法：

2、查找算法：

3、算法：

4、冒泡排序算法（理论）

4、选择排序算法（理论）

5、数组的元素查找：

6、介绍一下java.util.Arrays工具类

我们学习数组的时候，需要对数组的数据进行一下处理，例如排序和查找这种简单的原理我们需要去学会怎么去用自己写的代码去运行，

但是呢！JAVA的类库里面其实已经封装好了一个叫做Array的工具类，需要用到的时候就进行调用，因此不用我们太过于去了解工具类里面的源码，

程序员只需要知道如何调用工具类为自己服务就行，效率会提高很多！，接下来先了解一下常见的数组算法和Array工具类

数组：

常见的算法：

1、排序算法：

冒泡排序算法

选择排序算法

2、查找算法：

二分法查找

3、算法：

实际上在java中不需要精通算法，因为java中已经封装好了算法，要排序的时候就进行调用方法就行

例如：

java中提供了一个数组工具类

java.util.Arrays

Array工具类

既然是工具类，意味着java已经帮助程序员完成了封装等工作，这个工具类是带有static关键字的，因此调用的时候不需要频繁的new对象，直接类名.进行调用即可

可以在idea中双敲shift键位，调出搜索框后输入 Arrarys 找到此类即可

其中有一个sort() 方法，可以排序

这个方法是静态方法，直接使用类名调用就行

注意：工具类中的方法大部分是静态方法

4、冒泡排序算法（理论）

参与比较的数据：9 8 10 7 6 0 11

第一次循环：

8 9 10 7 6 0 11（1次比较：交换）

8 9 10 7 6 0 11（2次比较：不交换）

8 9 7 10 6 0 11（3次比较：交换）

8 9 7 6 10 0 11（4次比较：交换）

8 9 7 6 0 10 11（5次比较：不交换）

8 9 7 6 0 10 11（6次比较：交换）

最终冒出最大数据在右边：11

此时参与比较的数据：8 9 7 6 0 10

第二次循环：

8 9 7 6 0 10（1次比较：不交换）

8 7 9 6 0 10（2次比较：交换）

8 7 6 9 0 10（3次比较：交换）

8 7 6 0 9 10（4次比较：交换）

8 7 6 0 9 10（5次比较：不交换）

此时参与比较的数据：8 7 6 0 9

第三次循环：

7 8 6 0 9（1次比较：交换）

7 6 8 0 9（2次比较：交换）

7 6 0 8 9（3次比较：交换）

7 6 0 8 9（4次比较：不交换）

此时参与比较的数据：7 6 0 8

第四次循环：

6 7 0 8（1次比较：交换）

6 0 7 8（2次比较：交换）

6 0 7 8（3次比较：不交换）

此时参与比较的数据：6 0 7

第五次循环：

0 6 7（1次比较：交换）

0 6 7（2次比较：不交换）

此时参与比较的数据：0 6

第六次循环：

0 6（1次比较：不交换）

演示冒泡算法的代码：

package com.lbj.javase.array;/*** @author LBJ* @version V1.0* @Package com.lbj.javase.array* @date 2021/2/23 22:08* @Copyright 公司*/
public class BubbleSort {public static void main(String[] args) {int[] array1={9,8,10,7,6,0,11};//使用冒泡算法进行排序
//        for (int i = 0; i <array1.length-1;i++) {
//
//        }//上面使用的循环体不如下面使用的效果，其实原理是一样的//外层控制循环次数，内层控制比较次数for (int i = array1.length-1; i >0; i--) {for (int j = 0; j <i; j++) {if (array1[j]>array1[j+1]){//用一个临时数据保存交换数据int temp;temp=array1[j];array1[j]=array1[j+1];array1[j+1]=temp;}}}//完成循环后，遍历输出冒泡算法排序好的数组for (int i = 0; i <array1.length; i++) {System.out.println(array1[i]);}}
}

4、选择排序算法（理论）

选择排序比冒泡排序的效率高

高在交换位置的次数上

选择排序的交换位置是有意义的

循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和最前面的数据交换位置

参与比较的数据：3 1 6 2 5（这一堆参与比较的数据中最左边的元素下标是0）

第一次循环之后的结果是：

1 3 6 2 5

参与比较的数据：3 6 2 5（这一堆参与比较的数据中最左边的元素下标是1）

第二次循环之后的结果是：

2 6 3 5

参与比较的数据：3 6 5（这一堆参与比较的数据中最左边的元素下标是2）

第三次循环之后的结果是：

3 6 5

参与比较的数据：6 5（这一堆参与比较的数据中最左边的元素下标是3）

第四次循环之后的结果是：

5 6

注意：5条数据，循环4次

上机演示：

package com.lbj.javase.array;/*** @author LBJ* @version V1.0* @Package com.lbj.javase.array* @date 2021/3/2 16:09* @Copyright 公司* 关键点：选择排序的关键在于，你怎么找出一堆数据中最小的*/
public class SelectSort {public static void main(String[] args) {int[] array1={3,1,6,2,5};//count用来计算比较次数int count=0;int count2=0;//选择排序//5条数据循环4次（外层循环4次）for (int i = 0; i <array1.length-1; i++) {//i的值是0 1 2 3//i正好是参加比较的这堆数据中，最左边那个元素的下标//i是一个参与比较的这堆数据中心的起点下标//假设起点i下标位置上的元素是最小的(关键点)，这一步是为了把min最小值确定下来int min = i;for (int j = i + 1; j < array1.length; j++) {//count是用来计算元素的比较次数count++;if (array1[j] < array1[min]) {//如果if()里面的内容成立，那么此时最小值的元素是jmin = j;}}//当i和min相等时，表示最初猜测是对的//当i和min不相等时，表示最初猜测是错的，有比这个元素更小的元素//需要拿着这个更小的元素和左边的元素交换位置if (min != i) {//表示存在更小的数据//arrary1[min] 最小的数据//arrary1[i]   最前面的数据int temp;temp = array1[min];array1[min] = array1[i];array1[i] = temp;//统计交换位置的次数count2++;}}//冒泡排序和选择排序比较的次数没变//交换位置的次数减少了System.out.println("比较次数"+count);System.out.println("交换次数"+count2);//遍历输出排序好的数组for (int j = 0; j < array1.length; j++) {System.out.println(array1[j]);}}}

结果：

5、数组的元素查找：

数组的元素查找有两种方式：

第一种方式：一个一个找，直到找到为止

第二种方式：二分法算法查找，效率较高

第一种方式示例：

package com.lbj.javase.array;public class ArraySearch {public static void main(String[] args) {int[] arr={1,2,3,4,5,6};//需求，要求找出数组元素为5的下标//用第一种方式，一个个找for (int i = 0; i <arr.length; i++) {if (arr[i]==5){System.out.println("找到数据5的下标为"+i);return;}}System.out.println("找不到数据为5");}
}

第一种方法改进（封装成为方法）：

package com.lbj.javase.array;/*** @author LBJ* @version V1.0* @Package com.lbj.javase.array* @date 2021/3/2 20:43* @Copyright 公司** 数组的元素查找*      数组的元素查找有两种方式：*          第一种方式：一个一个找，直到找到为止*          第二种方式：二分法算法查找，效率较高*/
public class ArraySearch {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5, 6};//需求，要求找出数组元素为5的下标//用第一种方式，一个个找
//        for (int i = 0; i <arr.length; i++) {
//            if (arr[i]==5){
//                System.out.println("找到数据5的下标为"+i);
//                return;
//            }
//        }
//        System.out.println("找不到数据为5");//改进：最好以上的程序封装一个方法//思考：传什么参数？返回什么值？//传什么：第一个参数是数组，第二个参数是被查找的元素//返回值：返回被查找这个元素的下标，如果找不到就返回-1表示不存在int index = arraySearch(arr, 5);System.out.println("你想找的元素5下标为"+index);if (index == -1) {System.out.println("你想找的数组不存在");}}/*** 从数组中检索某个元素的下标* @param arr 被检索的数组* @param ele 被检索的元素* @return 大于等于0的数表示元素的下标，-1表示该元素不存在*/public static int arraySearch(int[] arr, int ele) {for (int i = 0; i < arr.length; i++) {if (ele == arr[i]) {return i;}}return -1;}
}

第二种方式（二分法查找）：

一维数组int[ ] arr={10(下标0),11,12,13,14,15,16,17,18,19,20(下标10)}; 伪代码

要求：通过二分法查找，找出18这个元素的下标

(0+10)/2 --> 算出中间元素的下标：5

拿着中间这个元素和目标要查找的元素进行对比：

中间元素是：arr[5] --> 15

由于：15<18 18是被查找的元素

被查找的元素18在目前中间元素15的右边

所以开始元素的下标从0变成（5+1）

再重新计算一个中间元素的下标：

开始下标是：5+1

结束下标是：10

计算：（6+10）/2 --> 8

8下标对应的元素arr[8]刚好是18

找到的中间元素正好和被找的元素18相等，表示找到了，下标为8

注意：

二分法查找算法是基于排序的基础上的（没有排序好的数组不能用二分法查找）

二分法查找终止条件：

一直折半，直到中间的那个元素恰好是被查找的元素

缺点：

如果一个元素刚好一直在最后一个，二分法会很浪费系统资源查找

上机演示：

package com.lbj.javase.array;/*** @author LBJ* @version V1.0* @Package com.lbj.javase.array* @date 2021/3/4 20:32* @Copyright 公司*/
public class ArrayUtil {public static void main(String[] args) {int[] arr={2,5,6,8,9,12,23,45,56,78,89};//使用二分法查找元素5的下标int index=binarySearch1(arr,6);System.out.println(index==-1?"该元素不存在":"该元素6的下标为"+index);}public static int binarySearch1(int[] arr, int ele) {//开始元素的下标int begin=0;//结束元素的下标int end=arr.length-1;//开始元素下标只要在结束元素下标的左边，就有机会继续循环while (begin<=end){//中间元素的下标int mid=(begin+end)/2;if (arr[mid]<ele){//目标元素在中间元素右边//重新赋值begin=mid+1;}else if (arr[mid]==ele){//目标元素和中间元素相等return mid;}else if (ele<arr[mid]){//目标元素在中间元素左边end=mid-1;}}return -1;}
}

实验结果：

6、介绍一下java.util.Arrays工具类

工具类里面所有方法都是静态方法，直接类名.工具类方法，进行调用

主要使用的是两个方法：二分法查找，排序

以后要学会自己看开发文档，不要死记硬背

上机演示：

package com.lbj.javase.array;import java.util.Arrays;/*** @author LBJ* @version V1.0* @Package com.lbj.javase.array* @date 2021/3/5 12:08* @Copyright 公司*/
public class ArrayTest12 {public static void main(String[] args) {int[] arr={3,5,6,9,12,32,54,4,8,9};//使用工具类对数组进行排序Arrays.sort(arr);//遍历输出for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}//使用工具类对数组进行二分法查找(建立在已经排序完成的基础上)int index=Arrays.binarySearch(arr,8);System.out.println(index==-1?"数组中没有此数据":"数组中元素8的下标是"+index);}}

演示结果：