Java数组和拓展

 

Java数组和拓展

什么是数组

• 数组是最简单的一种数据结构，是相同类型数据的有序集合。

• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。

• 每一个数据称作数组的元素，每一个元素可以通过一个下标来访问。

• 数组的下标与集合一样都是从0开始的。

 

声明数组

• Java风格

public class Demo1 {
    public static void main(String[] args) {
        int[] numbers;      //声明
        numbers = new int[10];      //定义
    }
}

• C/C++风格

public class Demo1 {
    public static void main(String[] args) {
        int numbers[];      //声明
        numbers = new int[10];      //定义
    }
}

以上两个示例代码定义了一个长度为10的数组，声明数组只会在栈中存放变量信息，定义数组长度后才会在堆中开放空间。

两种声明方式都可以声明一个数组，效果相同。

Java推荐使用第一种。

 

数组的使用

示例代码：

package com.rsp2012.array;
​
public class Demo1 {
    public static void main(String[] args) {
        int[] numbers;
        numbers = new int[10];
        
        //数组的赋值
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;
        numbers[5] = 6;
        numbers[6] = 7;
        numbers[7] = 8;
        numbers[8] = 9;
        numbers[9] = 10;
        
        //数组的取值
        System.out.println(numbers[9]);
        System.out.println(numbers[8]);
        System.out.println(numbers[7]);
        System.out.println(numbers[6]);
        System.out.println(numbers[5]);
        System.out.println(numbers[4]);
        System.out.println(numbers[3]);
        System.out.println(numbers[2]);
        System.out.println(numbers[1]);
        System.out.println(numbers[0]);
    }
}

以上代码为数组的基本使用方法，工作中一般使用for循环为数组赋值或者取值。

 

for循环赋值与取值

示例代码：

public class Demo1 {
    public static void main(String[] args) {
        int[] numbers = new int[10];
​
        //数组的赋值
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = i;
        }
​
        //数组的取值
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}

 

增强for循环的情况

示例代码：

public class Demo2 {
    public static void main(String[] args) {
        int[] numbers = new int[10];
​
        //数组的赋值
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = i;
        }
​
        //数组的取值
        for (int x : numbers) {
            System.out.println(x);
        }
    }
}

 

数组的特点

• 数组的长度是确定的，一旦被定义，则大小不可以被改变。

• 数组的元素必须是相同类型，不允许混合。

• 数组中的元素可以是任何类型。

• 数组变量属于引用类型，数组也可以看作对象，数组中的每个元素相当于该对象的成员变量。

• Java中的数组对象是保存在堆中的，因此数组无论保存什么类型的数据，数组对象本身是在堆中而不是在栈中。

 

数组的初始化

示例代码：

public class Demo3 {
    public static void main(String[] args) {
        int[] numbers;
        numbers = new int[10];
​
        //动态初始化
        numbers[0] = 1;
        numbers[1] = 2;
​
        //静态初始化
        int[] numbers2 = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    }
}

• 动态初始化

  声明数组，定义数组长度后进行赋值。

• 静态初始化

  声明数组时进行赋值，用来赋值的集合或数组的元素数决定数组的长度。

• 数组是引用类型的变量初始值为0，但数组类的元素是会按照相应的类型隐式初始化。

 

多维数组

• 多维数组可以看作数组的数组。

• 简单理解二维数组就是一个数组中的元素也是数组。

• 同理三维数组就是一个数组中的元素是数组并且该数组的元素也是数组。（禁止套娃）

示例代码①：

/**
 * 声明一个3行5列的多维数组，赋值0-14并遍历
 */
public class Demo6 {
    public static void main(String[] args) {
        //多维数组的静态声明
        int[][] numbers = {{0, 1, 2, 3, 4}, {5, 6, 7, 8, 9}, {10, 11, 12, 13, 14}};
​
        //多维数组的for-each遍历
        for (int[] number : numbers) {
            for (int i : number) {
                System.out.println(i);
            }
        }
    }
}

 

示例代码②：

/**
 * 声明一个3行5列的多维数组，依次赋值0-14并遍历
 */
public class Demo5 {
    public static void main(String[] args) {
        //多维数组的动态声明
        int[][] arrays = new int[3][5];
​
        //多维数组的赋值
        for (int i = 0, n = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                arrays[i][j] = n;
                n++;
            }
        }
​
        //多维数组的遍历
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.println(arrays[i][j]);
            }
        }
    }
}

 

拓展

数组练习

/**
 * 将数组的元素反转。
 */
public class Demo4 {
    public static void main(String[] args) {
        int[] array = new int[10];
        for (int i = 0; i < array.length; i++) {
            array[i]=i;
        }
        for (int i : array) {
            System.out.println(i);
        }
        System.out.println("********************************");
        for (int i : reversal(array)) {
            System.out.println(i);
        }
    }
​
    public static int[] reversal (int[] a){
        int[] value = new int [a.length];
        for (int i = 0; i < value.length; i++) {
            value[a.length-1-i]=a[i];
        }
        return value;
    }
}

 

 

Arrays类

工具类，java.util.Arrays，包含一系列关于数组的使用方法。

示例代码：

import java.util.Arrays;
​
public class Demo7 {
    public static void main(String[] args) {
        int[] array = {15, 1, 123, 5777, 12367, 23, 656, 11};
​
        //将元素重新整理并升序排列数组中的元素
        Arrays.sort(array);
        //打印数组中的元素
        System.out.println(Arrays.toString(array));
    }
}

Arrays类有很多关于数组的使用方法，以上只是简单例举了两个，其他还有例如填充数组，比对数组中的元素等等。

 

冒泡排序

示例代码：

/**
 * 冒泡排序
 */
public class Demo8 {
    public static void main(String[] args) {
        int[] array = {33, 123, 5, 325, 166, 72, 41, 341, 41, 4232, 1245, 33, 41, 14, 72, 34};
        int temp = 0;
        //外循环决定比较次数
        for (int i = 0; i < array.length - 1; i++) {
            //内循环判断大小后交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                //判断当前循环到的元素是否大于之后的元素
                if (array[j] > array[j + 1]) {
                    //如果大于则交换两个数
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        //遍历数组查看结果
        for (int i : array) {
            System.out.print(i + ", ");
        }
    }
}

 

稀疏数组

当一个多维数组中有大量的0或者相同的元素，和少量需要的元素时，可以通过稀疏数组来存储。

稀疏数组其实就是记录数组中有效值的坐标和值，来压缩存储空间。

创建

public class Demo9 {
    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
​
        //遍历原始数组
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }
}

 

转换

public class Demo10 {
    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
​
        //获取该数组中有效元素的值
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array[i][j] != 0) {
                    sum += 1;
                }
            }
        }
​
        //创建一个稀疏数组,行为目标数组有效元素数+1，固定3列
        int[][] list = new int[sum + 1][3];
​
        //创建表头数据
        //稀疏数组的Index[0][0]存储目标数组的行数
        list[0][0] = 11;
        //稀疏数组的Index[0][1]存储目标数组的列数
        list[0][1] = 11;
        //稀疏数组的Index[0][2]存储目标数组的有效元素个数
        list[0][2] = sum;
​
        //将目标数组的有效元素的坐标系和值赋值给稀疏数组中的元素
        int count = 1;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    list[count][0] = i;
                    list[count][1] = j;
                    list[count][2] = array[i][j];
                    count++;
                }
            }
        }
        //遍历得到的稀疏数组
        for (int[] ints : list) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

 

还原（到底还是自己太笨了）

//为了方便展示代码，新建了一个Demo。
public class Demo11 {
    public static void main(String[] args) {
        //就不引用了，直接抄过来了。
        int[][] list = {{11, 11, 2}, {1, 2, 1}, {2, 3, 2}};
        //声明一个对应的数组用来接收稀疏数组的数据。
        int[][] array = new int[list[0][0]][list[0][1]];
​
        //还原稀疏数组
        int count = 1;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                //判断当前行的当前列是否与稀疏数组中的坐标相等
                if (i == list[count][0] && j == list[count][1]) {
                    //把坐标对应的值赋给对应元素
                    array[i][j] = list[count][2];
                    //如果索引值小于数组长度-1，则索引+1
                    if (count < list.length - 1) {
                        count++;
                    }
                }
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}

 

还原（正确的打开方式）

也是不知道自己在那里瞎琢磨个啥，自己写了一堆代码人家老师一句话就带过了，这就是我和大佬的差距吗？ QAQ

//为了方便展示代码，新建了一个Demo。
public class Demo12 {
    public static void main(String[] args) {
        //就不引用了，直接抄过来了。
        int[][] list = {{11, 11, 2}, {1, 2, 1}, {2, 3, 2}};
        //声明一个对应的数组用来接收稀疏数组的数据。
        int[][] array = new int[list[0][0]][list[0][1]];
​
        //还原的正确打开方式 呜呜
        for (int i = 1; i < list.length; i++) {
            array[list[i][0]][list[i][1]]=list[i][2];
        }
        
        //遍历还原出来的数组
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
    }
}