Java全栈JavaSE：9.Java数组详解

Posted 2021-09-03 new nm个对象

声明：本节内容为本人观看“遇见狂神说”Java教学视频后总结，仅供学习参考。

1.什么是Java数组

2.如何声明创建数组

package com.oy.arrays;

public class Demo1 {
    public static void main(String[] args) {
        // 1.声明数组
        int[] num1; //方式1，推荐这种方式
        int[] num2; //c++中的语法，不推荐
        // 2.定义数组长度，会在内存中开辟对应大小的空间
        num1 = new int[10]; //设置数组长度为10，即下标为0-9
        // 3.设置数组值
        num1[0] = 0;
        num1[1] = 10;
        num1[2] = 20;
        num1[3] = 30;
        num1[4] = 40;
        num1[5] = 50;
        num1[6] = 60;
        num1[7] = 70;
        num1[8] = 80;
        num1[9] = 90;

    }
}

3.数组的三种初始方法及内存分析

（1）数组初始化方式

（2）内存分析

4.下标越界

5.数组的使用

普通for循环遍历数组

package com.oy.arrays;

public class Demo2 {
    public static void main(String[] args) {
        int[] nums = {10,20,30,40,50};
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
}

运行结果如下：

10
20
30
40
50

for-each循环遍历数组

package com.oy.arrays;

public class Demo2 {
    public static void main(String[] args) {
        int[] nums = {10,20,30,40,50};
        for(int num:nums){
            System.out.println(num);
        }
    }
}

运行结果如下：

10
20
30
40
50

数组作为方法的入参

package com.oy.arrays;

public class Demo3 {
    public static void main(String[] args) {
        int[] nums = {5,22,65,99,44,15};
        int max = maxArray(nums); //将数组作为参数，传入方法中
        System.out.println(max);
    }

    // 定义方法：输出int数组中的最大值
    public static int maxArray(int[] arrays){
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (arrays[i]>max){
                max = arrays[i];
            }
        }
        return max;
    }
}

数组作为方法的返回值

package com.oy.arrays;

public class Demo4 {
    public static void main(String[] args) {
        int[] nums = {5,22,36,88,75};
        for (int x:resArray(nums)){
            System.out.print(x+" ");
        }
    }

    //定义方法：返回反转后的数组
    public static int[] resArray(int[] array){
        int[] result = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            result[array.length-(i+1)] = array[i];
        }
        return result; //返回数组
    }
}

运行结果如下：

75 88 36 22 5

6.多维数组

package com.oy.arrays;

public class Demo5 {
    public static void main(String[] args) {
        //定义二维数组.方式一
        /**
         * 1(array[0][0]) 2(array[0][1])
         * 3(array[1][0]) 4(array[1][1])
         * 5(array[2][0]) 6(array[2][1])
         */
        int[][] nums1 = new int[3][2];
        nums1[0][0] = 1;
        nums1[0][1] = 2;
        nums1[1][0] = 3;
        nums1[1][1] = 4;
        nums1[2][0] = 5;
        nums1[2][1] = 6;

        //定义二维数组.方式二
        int[][] nums2 = {{1,2},{3,4},{5,6}};

        //获取二维数组值
        printArray(nums1[1]);

        System.out.println(nums1[2][0]);
    }



    //定义打印数组的方法
    public static void printArray(int[] array){
        for(int x:array){
            System.out.print(x + " ");
        }
        System.out.println();
    }
}

运行结果如下：

3 4 
5

7.Arrays类操作数组

（1）扩展：使用IDEA查看某个类下的所有方法

（2）Arrays类的常用方法

• Arrays.toString(数组名)：将数组变为字符串

package com.oy.arrays;

import java.util.Arrays;

public class Dem6 {
    public static void main(String[] args) {
        int[] num = {10,55,32,95,68,75,42,65,88};
        System.out.println(Arrays.toString(num));
    }
}

效果如下：

[10, 55, 32, 95, 68, 75, 42, 65, 88]

• Arrays.sort(数组名)：将数组排序，升序

package com.oy.arrays;

import java.util.Arrays;

public class Dem6 {
    public static void main(String[] args) {
        int[] num = {10,55,32,95,68,75,42,65,88};
        Arrays.sort(num); //排序，升序
        System.out.println(Arrays.toString(num));
    }
}

效果如下：

[10, 32, 42, 55, 65, 68, 75, 88, 95]

Arrays类下有许多方法，可以通过jdk文档来查看。这里不一一讲解。

8.冒泡排序

原理图：

• 冒泡排序就是将数组中相邻的两个元素做比较，如果大小不符合排序要求，则交换位置
• 每一轮遍历都会产生一个最大值或最小值，且下一轮遍历就不需要比较该值。
• 每一轮遍历都可以减少一次比较
• 依次循环，直到结束。

代码实现：

package com.oy.arrays;

import java.util.Arrays;

public class Demo7 {
    public static void main(String[] args) {
        int[] num = {5,22,36,12,99,45,26,68,71};

        int tmp = 0;
        //第一个for循环，确定最多需要遍历的轮数(数组长度-1次)
        for (int i = 1; i < num.length; i++) {
            boolean flag = true;
            //第二个for循环，确定每一轮需要两两比较的次数。每完成一轮都会减1
            for (int j = 0; j < num.length-i; j++) {
                //如果大小不符合，则交换位置
                if (num[j]>num[j+1]){
                    tmp = num[j];
                    num[j] = num[j+1];
                    num[j+1] = tmp;
                    flag = false;
                }
            }

            //如果一轮遍历下来，都没有发生位置交换，则表示顺序已经ok。不需要继续遍历了
            if (flag){
                break;
            }
        }
        System.out.println(Arrays.toString(num));
    }
}

运行结果如下：

[5, 12, 22, 26, 36, 45, 68, 71, 99]

9.稀疏数组（扩展）