java基础2

六、数组

1. 定义

数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

数组是引用数据类型，引用数据类型在使用之前一定要做两件事情：声明和初始化。

2. 分类

一维数组

1、步骤1：声明一个数组

type[] arrayName;    // 数据类型[] 数组名;

2、步骤2：分配空间

3、步骤3：初始化一维数组

所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值。

1）使用 new 指定数组大小后进行初始化

type[] arrayName = new int[size];

2）使用 new 指定数组元素的值

type[] arrayName = new type[]{值 1,值 2,值 3,值 4,• • •,值 n};

3）直接指定数组元素的值

type[] arrayName = {值 1,值 2,值 3,...,值 n};

内存分析

1、堆

存放new的对象和数组
可以被所有的线程共享，不会存放别的对象引用

2、栈

存放基本变量类型
引用变量类型

3、方法区

可以被所有的线程共享
包含了所有的class和static变量

二维数组

1、步骤1：声明一个二维数组

type[][] arrayName;    // 数据类型[][] 数组名;

2、步骤2：初始化二维数组

type[][] arrayName = new type[][]{值 1,值 2,值 3,…,值 n};    // 在定义时初始化
type[][] arrayName = new type[size1][size2];    // 给定空间，在赋值
type[][] arrayName = new type[size][];    // 数组第二维长度为空，可变化

3、使用

1）获取全部数组元素

public static void main(String[] args) {
    int[][] arrays = new int[5][5];
    for (int i = 0; i < arrays.length; i++) {
        for (int j = 0; j < arrays[i].length; j++) {
            arrays[i][j] = (int)(Math.random() * 10);
        }
    }

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

要想快速地打印一个二维数组的数据元素列表，可以调用：
System.out.println(Arrays.deepToString(arrays));

2）获取整行元素

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int[][] arrays = {{5, 4, 7, 0, 7}, {7, 3, 0, 3, 7}, {0, 0, 2, 3, 7}, {8, 5, 3, 4, 2}, {9, 4, 7, 4, 6}};
    System.out.println("请输入行数：");
    int num = scanner.nextInt();
    for (int i = 0; i < arrays[num - 1].length; i++) {
        System.out.print(arrays[num-1][i] + " ");
    }
}

3）获取整列元素

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int[][] arrays = {{5, 4, 7, 0, 7}, {7, 3, 0, 3, 7}, {0, 0, 2, 3, 7}, {8, 5, 3, 4, 2}, {9, 4, 7, 4, 6}};
    System.out.println("请输入列数：");
    int num = scanner.nextInt();
    for (int i = 0; i < arrays.length; i++) {
        System.out.print(arrays[i][num] + " ");
    }
}

七、Arrays工具类

常用方法

1）int binarySearch(type[] a, type key)

使用二分法查询 key 元素值在 a 数组中出现的索引，如果 a 数组不包含 key 元素值，则返回负数。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。

2）int binarySearch(type[] a, int fromIndex, int toIndex, type key)

这个方法与前一个方法类似，但它只搜索 a 数组中 fromIndex 到 toIndex 索引的元素。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。

3）type[] copyOf(type[] original, int length)

这个方法将会把 original 数组复制成一个新数组，其中 length 是新数组的长度。如果 length 小于 original 数组的长度，则新数组就是原数组的前面 length 个元素，如果 length 大于 original 数组的长度，则新数组的前面元索就是原数组的所有元素，后面补充 0（数值类型）、false（布尔类型）或者 null（引用类型）。

4）type[] copyOfRange(type[] original, int from, int to)

这个方法与前面方法相似，但这个方法只复制 original 数组的 from 索引到 to 索引的元素。

5）boolean equals(type[] a, type[] a2)

如果 a 数组和 a2 数组的长度相等，而且 a 数组和 a2 数组的数组元素也一一相同，该方法将返回 true。

6）void fill(type[] a, type val)

该方法将会把 a 数组的所有元素都赋值为 val。

7）void fill(type[] a, int fromIndex, int toIndex, type val)

该方法与前一个方法的作用相同，区别只是该方法仅仅将 a 数组的 fromIndex 到 toIndex 索引的数组元素赋值为 val。

8）void sort(type[] a)

该方法对 a 数组的数组元素进行排序。

9）void sort(type[] a, int fromIndex, int toIndex)

该方法与前一个方法相似，区别是该方法仅仅对 fromIndex 到 toIndex 索引的元素进行排序。

10）String toString(type[] a)

该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。

八、冒泡排序法

冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

冒泡排序的算法比较简单，排序的结果稳定，但时间效率不太高。Java 中的冒泡排序在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int[] arrays = new int[5];
    for (int i = 0; i < arrays.length; i++) {
        arrays[i] = (int)(Math.random() * 10);
    }
    System.out.println("排序前的数：");
    for (int array : arrays) {
        System.out.print(array + "\t");
    }
    System.out.println();
    System.out.println("通过冒泡排序后的：");
    sort(arrays);
}

public static void sort(int[] arrays) {
    int temp = 0;
    //外层循环控制排序轮数，总循环次数为要排序数组的长度减 1
    for (int i = 0; i < arrays.length - 1; i++) {
        //内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少
        for (int j = 0; j < arrays.length - 1 - i; j++) {
            if (arrays[j] > arrays[j+1]){
                temp = arrays[j+1];
                arrays[j+1] = arrays[j];
                arrays[j] = temp;
            }
            System.out.print(arrays[j] + "\t");//对排列后的元素输出
        }
        System.out.print("[\t");
        for (int j = arrays.length - 1 - i; j < arrays.length; j++) {
            System.out.print(arrays[j] + "\t");
        }
        System.out.println("]");
    }
}

posted @ 2021-05-06 14:44 HXB_Blog 阅读(54) 评论(0) 收藏举报

刷新页面返回顶部

HXB_Blog