4. JAVA学习 数组（冒泡排序法、直接排序法）

JAVA学习 数组

为了更方便的管理变量元素，将几个变量聚到一起，组成数组。有时也会用到二维数组，通过循环遍历数组元素

1. 一维数组

数组类型是由基本的变量类型扩展的。
在java中声明数组变量有两种形式：
1.变量后面加 [ ]，如 int numbers [ ]
2.在类型后面添加[ ]，如 int [ ] numbers
声明完数组变量，需要分配存储空间

public static void main(String[] args) {
        int numbers[];//第一种声明数组方法：变量类型+数组名称[]
        numbers = new int[4];//分配数组空间，方括号内添加入数字，表示数字有多大
        numbers[0] = 2;
        numbers[1] = 3;
        numbers[2] = 5;
        numbers[3] = 7;
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("number="+numbers[i]);//依次遍历打印数组元素
        }
    }

以斐波那锲数列为例，java代码可以帮助我们求解斐波那锲数列。先声明一个大小为12的整形数组，接着用循环遍历。代码如下：

 public static void main(String[] args) {
        int[] rabbitnumbers; //声明数组变量
        rabbitnumbers = new int[12];  //一年有12个月
        for (int i = 0; i < rabbitnumbers.length; i++) {
            if (i < 2) {  //数列的前两个元素都是1
                rabbitnumbers[i] = 1;
            } else {  //从第三个元素开始。每个元素都是前两个元素的和
                rabbitnumbers[i] = rabbitnumbers[i - 1] + rabbitnumbers[i - 2];
            }
            System.out.println(rabbitnumbers[i]);  //打印输出当前结果
        }

2. 二维数组

一维数组可以联想一维平面，二维数组就相当于是二维平面，一张坐标系了，二维数组也有两种声明方式：

变量名称后面加两个方括号：double triangle [ ] [ ]
类型后面加两个方括号：double [ ] [ ] triangle

 public static void main(String[] args) {
        double triangle [] [];  //声明二维数组
        triangle= new double[3][2];  //分配二维数组空间：2*3
        triangle[0][0] = -2.0;  //赋值
        triangle[0][1] = 0.0;
        triangle[1][0] = 0.0;
        triangle[1][1] = -1.0;
        triangle[2][0] = 2.0;
        triangle[2][1] = 1.0;
        for (int i = 0; i < triangle.length; i++) {  //循环遍历输出
            for (int j = 0; j < triangle[i].length; j++) {
                System.out.println("二维数组第"+i+"行，第"+j+"列的元素为："+triangle[i][j]);
            }
        }
    }

3. 数组工具 Arrays

java专门设计了一些Arrays工具，包含一些常用功能：

Arrays.equals(a1,a2);//判断两个数组是否相等，也就是里面对应元素是否相等
Arrays.fill(a,val);//往数组a里面加入指定的val
dest = Arrays.copyOf(src,newLength);//把数组src的内容赋值给dest，且长度为newLength
Arrays.sort(a);//对数组a内部元素排序，默认升序

3.1 填充替换数组元素

public static void main(String[] args) {
        int arr[] = new int[]{5,2,1,5};//创建int数组
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);//输出本来的赋值元素
        }
       Arrays.fill(arr,8);  //将arr数组里面元素全部替换为8
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);  //再次打印输出观察结果
        }
    }

3.2 对数组进行排序

public static void main(String[] args) {
        int arr[] = new int[]{6, 8, 4, 25, 5, 2};
        System.out.print("数组原本输出为");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.print("排序后的数组输出为：");
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }

3.3 复制数组

public static void main(String[] args) {
        int arr[] = new int[]{2, 3, 5, 6};
        int newarr[] = Arrays.copyOf(arr, 5);
        for (int i = 0; i < newarr.length; i++) {
            System.out.println(newarr[i]);
        }
    }

如果新数组的长度超出会用0来填充

4. 实战

4.1 冒泡排序法

public static void main(String[] args) {
        int[] array = new int[]{0, 8, 6, 4, 9, 2, 5, 3, 7};
        int temp;  //中间变量
        System.out.println("原来数组输出为：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"\t");
        }
        System.out.println('\n'+"从小到大排序结果为：");
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1; j++) {  //比较相邻元素，大的往后排
                if (array[j] > array[j + 1]) {   //交换元素
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"\t");
        }
        System.out.println('\n'+"从大到小排序结果为：");
        for (int i = 0; i < array.length; i++) {  //比较相邻元素，小的往后排
            for (int j = 0; j < array.length - 1; j++) {
                if (array[j] < array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"\t");
        }
    }

运行结果：

原来数组输出为：
0 8 6 4 9 2 5 3 7
从小到大排序结果为：
0 2 3 4 5 6 7 8 9
从大到小排序结果为：
9 8 7 6 5 4 3 2 0

4.2 直接排序法

直接排序法交换次数要比冒泡排序少得多，具体概念见直接排序与冒泡排序区别

public static void main(String[] args) {
        int[] array = new int[]{5, 1, 7, 9, 6, 3, 8};
        int index;
        int temp;
        System.out.println("原来数组输出如下：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(+ array[i]+"\t");
        }
        System.out.println('\n'+"直接排序法排序如下");
        for (int i = 1; i < array.length; i++) {
            index = 0;
            for (int j = 1; j < array.length - i; j++) {
                if (array[j] > array[index]) {
                    index = j;
                }
            }
            temp = array[array.length - i];
            array[array.length - i] = array[index];
            array[index] = temp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"\t");
        }
    }

下次将Java的方法与包装。

Java逻辑控制