冒泡排序

概念：冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
算法描述:
（1）比较相邻的元素。如果第一个比第二个大，就交换它们两个；
（2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一（3）对，这样在最后的元素应该会是最大的数；
（4）针对所有的元素重复以上的步骤，除了最后一个；
（5）重复步骤1~3，直到排序完成。
动画演示：

案例分析：
示例一：

import java.util.Arrays;
public class Demo1 {
    public static void main(String[] args) {
        int[] a = {121, 100, 98, 78, 89, 45, 22, 75, 33};
        //定义循环次数
        for (int i = 0; i < a.length - 1; i++) {
            //循环比较的过程
            boolean isChange=false;
            for (int j = 0; j < a.length - 1-i; j++) {
                if (a[j] > a[j + 1]) {//前一个比后一个大，则不满足升序
                    //需要进行交换
                    int tmp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = tmp;
                    isChange=true;
                }
            }
            System.out.print("经过" + (i + 1) + "轮比较，数组变为：");
            System.out.println(Arrays.toString(a));
            if(!isChange){//本轮没有任何交换
                System.out.print("经过" + (i + 1) + "轮比较，数组已有序：");
                break;
        }
        System.out.println(Arrays.toString(a));
    }
}
}

输出结果：

示例二：使用冒泡排序对输入的5名学员成绩进行降序排列

import java.util.Arrays;
import java.util.Scanner;
public class Text1 {
    public static void main(String[] args) {
        int[]a=new int[5];
        for (int i = 0; i < a.length; i++) {
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入第"+(i+1)+"学员成绩");
            a[i]=sc.nextInt();
                }for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j <a.length-1-i ; j++) {
                if(a[j]<a[j+1]){
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                }
            }
        }//Arrays.sort(a);//直接排序
        System.out.println(Arrays.toString(a));
    }
}

输出结果：

示例三：
升序排列学生成绩。

import java.util.Arrays;
import java.util.Scanner;
public class Text1 {
    public static void main(String[] args) {
        int[]a=new int[5];
        for (int i = 0; i < a.length; i++) {
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入第"+(i+1)+"学员成绩");
            a[i]=sc.nextInt();
                }for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j <a.length-1-i ; j++) {
                if(a[j]>a[j+1]){
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                }
            }
        }//Arrays.sort(a);//直接排序
        System.out.println(Arrays.toString(a));
    }
}

输出结果：

二维数组

定义

Java中定义和操作多维数组的语法与一堆数组类似。在实际应用中，三维及以上数组很少使用，主要使用二维数组。
定义二维数组的语法格式如下：
数据类型[][]数组名；
或者：
数据类型 数组名[][];
数据类型为数组元素的类型。
“[][]”用于表明定义一个二维数组，通过多个下标进行数据访问。
定义一个整型二维数组：
关键代码：

int[][] scores;  //定义二维数组
scores=new int[5][50]  //分配内存空间
//或者
int[][] scores=new int[5][50];

需要强调的是，虽然从语法上看Java支持多维数组，但从内存分配原理的角度看，Java中只有一维数组，没有多维数组。或者说，表面上是多维数组，实质上都是一维数组。
二维数组存储方式示意图：

二维数组实际上是一个一维数组，它的每一个元素又是一个一维数组。

初始化二维数组

二维数组也可以进行初始化操作，与一维数组类似，同样可采用两种方式，请注意大括号的结构及书写顺序。
定义二维数组并初始化数组元素的两种方法：
关键代码：

int[][] scores=new int[][]{{90,85,92,78,54},{76,63,80},{87}};
//或者
int scores[][]={{90,85,92,78,54},{76,63,80},{87}};

二位数组的遍历

（1）初始化整型二维数组。
（2）定义保存总成绩的变量。
（3）使用for循环遍历二维数组。
示例一：
有5个班各5名学生某门课程的成绩，如何计算5个班各自的总成绩。

import java.util.Arrays;
public class Demo5 {
    public static void main(String[] args) {
        int[][] a=new int[5][5];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                a[i][j] = (int) (Math.random() * 100);
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println(Arrays.toString(a[i]));
        }int total=0;
        for (int i = 0; i < a.length; i++) {
            int sum=0;
            for (int j = 0; j <a[i].length ; j++) {
                sum+=a[i][j];
                total+=sum;
            }
            System.out.println((i+1)+"班级的总分为："+sum);
        } System.out.println("全年级总分为："+total);
    }
}

输出结果：

示例二：已知有3个班级各5名学员，请使用二维数组计算各个班级的总成绩。

import java.util.Scanner;
public class Text2 {
    public static void main(String[] args) {
        int[][] a=new int[3][5];
        for (int i = 0; i <a.length ; i++) {
            System.out.println("第"+(i+1)+"个班");
            for (int  j = 0;  j <a[i].length ;  j++) {
                Scanner sc=new Scanner(System.in);
                System.out.print("请输入第"+(j+1)+"个学生的成绩："+"\t");
                a[i][j]=sc.nextInt();
            }
            }for (int i = 0; i < a.length; i++) {
            int sum=0;
            for (int j = 0; j <a[i].length ; j++) {
                sum+=a[i][j];
            }
            System.out.println((i+1)+"班总成绩："+sum);
        }
    }
}

输出结果：
示例三：公鸡2文，母鸡1文，小鸡半文，每种至少一只，100文买100只鸡有多少种可能。请使用循环获得所有可能并插入数组，使用遍历数组的方式输出

public class Text13 {
    public static void main(String[] args) {
       /* for (int gong = 1; gong <50 ; gong++) {
            for (int mu = 1; mu <100 ; mu++) {
                int xiao=100-gong-mu;
                if(gong*2+mu+xiao/2==100&&xiao%2==0){
                    System.out.println("公鸡："+gong+",母鸡："+mu+",小鸡："+xiao);
                }
            }
        }*/
       int[][] a=new int[100][3];
       int count=0;
        for (int coke = 1; coke <50 ; coke++) {
            for (int hen = 1; hen <100 ; hen++) {
                int chick=100-coke-hen;
                if(coke*2+hen+chick/2==100&&chick%2==0){
                    a[count][0]=coke;
                    a[count][1]=hen;
                    a[count][2]=chick;
                    count++;
                }
            }
        }int[][]rst;
        rst= Arrays.copyOf(a,count);
        for(int[] r:rst){
            System.out.println(Arrays.toString(r));
        }
    }
}

输出结果：

升序排列

（1）初始化一个整型二维数组。
（2）使用for循环遍历二维数组。
（3）使用Arrays类的sort()方法对二维数组的元素进行升序排列。
（4）使用for循环遍历二维数组的元素并输出。

Arrays类

JDK中提供了一个专门用于操作数组的工具类，即Arrays类，位于java.util包中。该类提供了一系列方法来操作数组，如排序、复制、比较、填充等，用户直接调用这些方法即可，不需自己编码实现，降低了开发难度。
Arrays类的常用方法如表：

方法	返回类型	说明
equals(array1,array2)	boolean	比较两个数是否相等
sort(array)	void	对数组array的元素进行升序排列
toString	String	将一个数组array转换成一个字符串
fill(array,val)	void	把数组array的所有元素都赋值为val
copyOf(array,length)	与array数据类型一致	把数组array复制成一个长度为length的新数组
binarySearch(array,val)	int	查询元素值val在数组array的下标

比较两个数组是否相等

Arrays类的equals()方法用于比较两个数组是否相等。只有当两个数组长度相等对应位置的元素也一一相等，该方法返回true；否则返回false。

对数组的元素进行升序排列

Arrays类的sort()方法对数组的元素进行升序排列，即从小到大的顺序排列。

将数组转换成字符串

Arrays类中提供了专门输出数组内容的方法——toString()方法。该方法用于将一个数组转换成一个字符串。它的顺序把多个数组元素连在一起，多个数组元素之间使用英文逗号和空格隔开。利用这种方法可以很清楚地观察到各个数组元素的值。

将数组所有元素赋值为相同的值

初始化一个整型一维数组，使用
Arrays类的fill()方法替换数组的所有元素为相同的元素。

将数组复制成一个长度为设定值的新数组

初始化一个整型一维数组，使用Arrays类的copy()方法把数组复制成一个长度为设定值的新数组。

查询元素在数组中的下标

Arrays类的binarySearch()方法用于查询数组元素在数组中的下标。调用该方法时要求数值中的元素已经按升序排序，这样才能得到正确的结果。

二分法

算法：二分法查找适用于数据量较大时，但是数据需要先排好顺序。主要思想是：（设查找的数组区间为array[low, high]）
（1）确定该区间的中间位置K（2）将查找的值T与array[k]比较。若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。区域确定如下：a.array[k]>T 由数组的有序性可知array[k,k+1,……,high]>T;故新的区间为array[low,……，K-1]b.array[k]<T 类似上面查找区间为array[k+1,……，high]。每一次查找与中间值比较，可以确定是否查找成功，不成功当前查找区间将缩小一半，递归查找即可。
案例：

//二分查找的前提条件，数组要有序
import java.util.Arrays;
import java.util.Scanner;
public class Test19 {
    public static void main(String[] args) {
        int[] a=new int[10];
        for (int i = 0; i < a.length; i++) {
            a[i]=(int)(Math.random()*100);
            Arrays.sort(a);
        }
        System.out.println(Arrays.toString(a));
        int start=0;
        int end=a.length-1;
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num=sc.nextInt();
        while(true){
            int mid=(start+end)/2;
            if(start>end){
                System.out.println("没有找到这个数");
                break;
            }if(num==a[mid]){
                System.out.println("找到这个数了");
                break;
            }else if(a[mid]<num){
                start=mid+1;
            }else {
                end=mid-1;
            }
            }
        }
    }

输出结果：