个人学习---Java数组

Java数组

数组定义

数组是相同类型数据的有序集合，为一种最简单的数据结构，按照一定的先后次序排列组合而成。其中，每一个数据称为数值元素，每个数组元素可通过索引(下标)来进行访问。

注：在Java中，数组索引从0开始。

数组的声明与创建

声明

在Java语言中，数组的声明有两种形式，如下式所示。

int[] array;
int arrays[];

两种定义方式效果相同，但一般采用前者作为首选方案。

注：

1. 声明数组时，数组并不存在。

2. 数组类型由变量类型 + "[ ]" 两部分组成。

创建

在Java语言中，使用new操作符来创建数组，如下图所示。

其中：数组尺寸表示数组的大小内容，即可以存放10个int类型的数字。

注：如果数组中最后的几个索引中没有赋值，则会赋默认值。Int类型赋0值，Sting类型赋null值，如下图所示。

Java内存分析

Java内存空间分为堆、栈、方法区等，如下表所示。

名称	功能
堆	用于存放new的对象和数组，可以被所有的线程所共享，不会存放其他的对象引用。
栈	存放基本变量类型(会包含这个基本类型的具体数值)。存放引用对象的变量(会存放这个引用在堆里的具体地址)。
方法区	可以被所有线程共享，包含了所有的class和static变量。

注：在声明数组时，将数组压入栈中；创建数组时，转入堆中创建，在堆中开辟了空间并对空间进行划分，在堆中实现对数组的赋值。

数组初始化

在Java中，数组具有三种初始化方法：

1. 静态初始化 ，如下式所示。

   int[] a = {1, 2, 3};

2. 动态初始化 ，如下式所示。

   int[] b = new int[10];

3. 默认初始化：数组也是一种引用类型，它的元素相当于类中的实例变量。因此，数组一经分配空间，其中每个元素也按照与实例变量相同的方式被隐式初始化，即赋默认值：int[ ]为0；String[ ]为null。

   关于实例变量，点击此处了解

注：数组基本特点包括以下四个方面：

1. 数组的长度是确定的，一旦创建，大小不允许改变。

2. 数组的元素必须是相同类型，元素类型不能混合。

3. 数组元素可以是任意数据类型。

4. 数组变量是一种引用类型，数组本身为对象，数组元素相当于对象的成员变量。在Java中，无论数组中存放基本类型还是其他对象类型，数组对象本身是在堆中存放的。

数组边界

下标的合法区间在 [0, length-1]，如果超过边界会报错，如下图所示。

注：可通过数组名 + "." + length 来获得数组的长度。

数组基础使用

1. 数组可通过循环语句来打印出全部元素并实现部分简单功能，如下图所示。

   

2. 使用加强for循环，更容易遍历输出数组元素，如下图所示。

   

   注：没有索引(下标)，不方便具体操作。

3. 数组可以作为方法的参数，如下图所示。

   

   注：当数组作为传入参数时，传递的是引用地址的拷贝，但是拷贝的地址和真实的地址都指向一个真实数据，因此改动形参，实参也会发生改动。

   补充：Java是值传递，当传递的是基本类型时，传得是值的拷贝，故修改形参并不影响实参；当传递的是引用类型时，传得是引用地址的拷贝，但拷贝地址和原始地址都指向一个真实的值，故修改形参会影响实参的结果；当传递封装类和String类时，虽然是它们是引用类型，但是由于其本质是由final修饰的，不能被修改，所以作为传参时实参是不会跟随形参发生改变的。

4. 数组可以作为方法返回值，如下图所示。

   

多维数组

多位数组可以看成数组的数组，本质为数组的嵌套。以二维数组为例，二维数组中的每一个元素都为一个一位数组，多维数组以此类推。

二维数组的创建，如下式所示。

        //静态初始化
        int[][] arrays = {{2,3},{4,5},{5,6}};
        //动态初始化
        int[][] arrays2 = new int[3][2];

结果，如下图所示。

注：图中的二维数组arrays_2可以看成一个三行两列的数组，与arrays_1表示相同。

补充：

arrays_1.length表示为二维数组的长度，即内部有多少个一维数组。arrays_1[0].length表示为在二维数组中，下标为0的一维数组中的元素个数。

二维数组的加强for循环输出，由下图所示。

Arrays类（数组工具类）

常用方法

1. 打印数组元素，使用Arrays.toString()方法，如下图所示。

   

2. 排序数组（升序），使用Arrays.sort()方法，如下图所示。

   

3. 给数组赋值，使用Arrays.fill()方法，如下图所示。

   

4. 比较数组中数值是否相等，使用Arrays.equals()方法，如下图所示。

   

5. 查找数组元素，能对排好序的数组来进行二分法查找，返回所查找数字的索引，使用Arrays.binarySearch()方法，如下图所示。

   

注：Arrays类中的方法都为static修饰的静态方法，直接用类名调用即可。（用对象来调用也行）

冒泡排序

冒泡算法为最出名的排序算法之一，它是通过元素之间两两比较，谁小或谁大就进行前移或后移。在冒泡算法中，外层为冒泡轮数，内层依次比较，如下图所示。

注：可以通过设置标志位来减少没有意义的比较，即若标志位没发生变化，则表示以及排好，退出即可,如下图所示。

稀疏算法

• 稀疏算法是一种压缩算法，用于处理数组中记录很多无意义的数据。

• 适用范围：当一个数组中大部分元素为0或者为同一元素值数组。

• 处理方式：**记录数组有几行几列，有多少不同的值，后将记录结果记录在一个小规模数组中。

  具体流程，如下图所示。

  

实现代码，如下所示。

import java.util.Scanner;
​
public class ArrayDemo5 {
    static int line = 4;
    static int col = 4;
    final static int sparseCol = 3;
​
    public static void main(String[] args) {
        int[][] nums = new int[line][col];
        int sum = 0;
        nums = inPut(line,col);
        outOldPut(nums);
​
        sum = count(nums);
        int[][] sparseNums = new int[sum+1][sparseCol];
        sparseNums = draw(nums, sum);
        outSparsePut(sparseNums);
​
        int[][] backNums = new int[line][col];
        backNums = back(sparseNums);
        outBackPut(backNums);
    }
    public static int[][] inPut(int line, int col){
        int[][] arrays2 = new int[line][col];
        System.out.println("请输入数组内容：");
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < arrays2.length; i++) {
            for (int j = 0; j < arrays2[i].length; j++) {
                if(scanner.hasNextInt()){
                    arrays2[i][j] = scanner.nextInt();
                }
            }
        }
        scanner.close();
        return arrays2;
    }
    public static void outOldPut(int[][] nums){
        System.out.println("输出原始数组为：");
        for (int i = 0; i < nums.length; i++) {
            for(int j = 0; j < nums[i].length ; j++) {
                System.out.print(nums[i][j] + "\t");
                if(j==nums[i].length-1){
                    System.out.println();
                }
            }
        }
        System.out.println("====================");
    }
    public static void outSparsePut(int[][] nums){
        System.out.println("输出稀疏数组为：");
        for (int i = 0; i < nums.length; i++) {
            for(int j = 0; j < nums[i].length ; j++) {
                System.out.print(nums[i][j] + "\t");
                if(j==nums[i].length-1){
                    System.out.println();
                }
            }
        }
        System.out.println("====================");
    }
    public static void outBackPut(int[][] nums){
        System.out.println("输出还原数组为：");
        //使用加强for循环输出二维数组。
        for (int[] i:nums) {
            for(int j :i) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
        System.out.println("====================");
    }
    public static int count(int[][] nums){
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                if (nums[i][j]!=0){
                    count++;
                }
            }
        }
        return count;
    }
    public static int[][] draw(int[][] nums, int sum){
        int[][] sparseNums = new int[sum+1][sparseCol];
        sparseNums[0][0] = line;
        sparseNums[0][1] = col;
        sparseNums[0][2] = sum;
        int count = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                if (nums[i][j]!=0){
                    sparseNums[count][0] = i;
                    sparseNums[count][1] = j;
                    sparseNums[count][2] = nums[i][j];
                    count++;
                }
            }
        }
        return sparseNums;
    }
    public static int[][] back(int[][] sparseNums){
        int[][] backNums = new int[line][col];
        for (int i = 1; i < sparseNums.length; i++) {
            backNums[sparseNums[i][0]][sparseNums[i][1]] = sparseNums[i][2];
        }
        return backNums;
    }
}