学习日记（数组内容下篇）

学习日记（数组）

六、数组的使用

1. 数组的遍历：for 循环、增强型 for 循环

举例 1：用 for 循环给数组元素赋值、打印全部的数组元素、计算和、查找最大元素

package com.Sun3285.array;

public class PracticeThree {
    public static void main(String[] args) {
        int[] nums = new int[5];

        //用循环的方法给数组元素赋值
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i + 1;
        }

        //打印全部的数组元素
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }

        System.out.print("\n");
        System.out.println("===========================");

        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            //sum = sum + nums[i];
        }
        System.out.println("数组的元素和为：" + sum);

        System.out.println("===========================");

        //查找最大元素
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
        }
        System.out.println("数组中的最大元素为：" + max);
    }
}

运行结果

举例 2：增强型 for 循环（省去了数组的下标，适合打印输出，不能对数组中的元素进行操作）

package com.Sun3285.array;

public class PracticeFour {
    public static void main(String[] args) {
        int[] array = {5, 4, 3, 2, 1, 0};

        //计算数组元素的和
        int sum = 0;
        for (int a : array) {
            System.out.print(a + "\t");
            sum += a;
        }
        System.out.println();
        System.out.println("数组元素的和为：" + sum);
    }
}

运行结果

2. 数组作方法入参

举例：编写方法，打印数组元素

package com.Sun3285.array;

public class PracticeFour {
    public static void main(String[] args) {
        int[] array = {5, 4, 3, 2, 1, 0};
        printArray(array);
    }
    
    //打印数组元素
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println("array[" + i + "] = " + array[i]);
        }
    }
}

运行结果

详细分析

3. 数组作返回值

举例：反转数组

package com.Sun3285.array;

public class PracticeFive {
    public static void main(String[] args) {
        char[] symbol = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};

        for (int i = 0; i < symbol.length; i++) {   //输出原数组
            System.out.print(symbol[i] + "\t");
        }

        System.out.println();
        System.out.println("==============================");

        char[] finSymbol = reverse(symbol);

        for (int i = 0; i < finSymbol.length; i++) {   //输出翻转后的数组
            System.out.print(finSymbol[i] + "\t");
        }

    }

    //反转数组
    public static char[] reverse(char[] symbol) {
        char[] finSymbol = new char[symbol.length]; //定义一个新数组作为反转后的结果

        for (int i = 0; i < symbol.length; i++) {
            finSymbol[i] = symbol[symbol.length - i - 1];  //反转过程
        }

        return finSymbol;  //返回反转后的数组
    }
}

运行结果

详细分析

---

七、二维数组（多维数组）

多维数组可以看成是数组的数组，如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

• 定义一个二维数组

int[][] array = {{1, 2}, {3, 4}, {5, 6}};

• 画图理解
  

• 打印二维数组

package com.Sun3285.array;

public class PracticeSix {
    public static void main(String[] args) {
        //多维数组
        int[][] array = {{1, 2}, {3, 4}, {5, 6}};

        System.out.println("数组长度为：" + array.length);

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

运行结果

---

八、Arrays 类

1. 数组的工具类：java.util.Arrays。API 中提供了一个工具类供我们使用，从而可以对数组对象进行一些基本的操作。
   

2. Arrays 类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名（eg. Arrays.sort()）进行调用，而”不用“使用对象来调用（注意是”不用“，而不是”不能“）。

3. 学习过程可以点进类，看源码。
   
   

4. 使用 Arrays 类举例

package com.Sun3285.array;

import java.util.Arrays;

public class PracticeSeven {
    public static void main(String[] args) {

        int[] nums = {1, 2, 89, -9, 1006, 78, 3, -78};

        //打印数组元素
        System.out.println(Arrays.toString(nums));

        System.out.println("=============================");

        //排序：升序
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

        System.out.println("=============================");

        //填充
        Arrays.fill(nums, 5, 7, 2);
        System.out.println(Arrays.toString(nums));
    }
}

运行结果

详细分析

---

九、选择排序和冒泡排序

• 选择排序

package com.Sun3285.array;

import java.util.Arrays;

public class PracticeEight {
    public static void main(String[] args) {
        int[] nums = {2, 1, -98, 58, 24, 100, 6, -5};

        System.out.println(Arrays.toString(nums));

        int[] sortNum = sort(nums);  //同时改变了数组 nums 中元素的值

        System.out.println("=====================================");
        System.out.println(Arrays.toString(nums));
        System.out.println(Arrays.toString(sortNum));
    }

    //选择排序：每次选择出待排序列的最小值
    public static int[] sort(int[] nums) {
        int[] sortNum = new int[nums.length];

        for (int i = 0; i < nums.length; i++) {
            int temp = nums[i];     //存放元素数值
            for (int j = (i + 1); j < nums.length; j++) {  //每一次大循环结束，都会产生一个当前最小值，放在前面
                if (nums[j] < nums[i]) {
                    nums[i] = nums[j];
                    nums[j] = temp;
                    temp = nums[i];
                }
            }
            sortNum[i] = nums[i];
        }
        return sortNum;
    }
}

运行结果

详细分析

• 冒泡排序

两层循环，外层冒泡轮数，里层依次比较，嵌套循环，立马可以得出这个算法的时间复杂度为 O(n2)。

package com.Sun3285.array;

import java.util.Arrays;

public class PracticeNine {
    public static void main(String[] args) {
        double[] array = {2.1, -9.24, 10, 85.1, -7.11, 1, 100, 0};

        double[] finArray = sort(array);

        System.out.println(Arrays.toString(finArray));
    }

    //冒泡排序
    public static double[] sort(double[] array) {
        double temp = 0;

        for (int i = 0; i < (array.length - 1); i++) {
            for (int j = 0; j < (array.length - i - 1); j++) {  //每次循环结束产生一个最大值，放在最后
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;     //交换两者的值
                }
            }
        }
        return array;
    }
}

运行结果及详细分析

思路：先写一轮比较的过程 -> 用 for 循环得到所有比较的结果

优化：通过 flag 标识位减少没有意义的比较

---

十、稀疏数组

介绍：当一个数组中大部分元素为 0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

处理方式：

• 记录数组一共有几行几列，有多少个不同值；
• 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小数组的规模（压缩）。

1. 把普通数组表示出来
   

2. 把普通数组变为稀疏数组
   
   

3. 把稀疏数组变为普通数组
   

所有代码：

package com.Sun3285.array;

public class PracticeTen {
    public static void main(String[] args) {
        //把普通数组表示出来
        int[][] array1 = new int[6][6];

        array1[0][5] = 7;
        array1[1][1] = 1;
        array1[2][2] = 2;

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }


        //把普通数组变为稀疏数组
        int num = 0;

        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j] != 0) {
                    num++;   //计数：不同值的个数
                }
            }
        }

        int[][] array2 = new int[num + 1][3];  //稀疏数组 array2

        array2[0][0] = array1.length;
        array2[0][1] = array1[0].length;
        array2[0][2] = num;               //给稀疏数组 array2 的第一行元素赋值

        int count = 1;

        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j] != 0) {
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];  //给稀疏数组 array2 的其余行元素赋值
                    count++;
                }
            }
        }

        System.out.println("========================================");
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }


        //把稀疏数组变为普通数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //给特殊元素赋值
        //array3[array2[1][0]][array2[1][1]] = array2[1][2];      array3[0][5] = 7;
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //输出
        System.out.println("========================================");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

    }
}

运行结果

---

注意：

1. 数组 array 增强型 for 循环的快捷操作：array.for。

2. 不能用增强型 for 循环给数组赋初值。
   

3. 在线 API 帮助文档：JDK 帮助文档。

4. 调用方法给数组排序，原数组中元素的顺序也会发生改变。