java数组

1. 什么是数组

数组是相同类型数据的有序集合

2. 2.数组的声明与创建

dataType[] arrayRefVar; // 首选的方法 
或 
dataType arrayRefVar[]; // 效果相同，但不是首选方法

建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。dataType arrayRefVar[] 风格是来自C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

public class Demo01 {
    public static void main(String[] args) {
        int[] nums;
        int sum=0;
        nums = new int[10];//里面可以存放10个int类型的数字
        for(int i=0;i<nums.length;i++){
            nums[i]=i+1;//把0-9的数字赋值给数组
            sum+=nums[i];//把数组中每个数字相加
        }
        System.out.println("sum="+sum);
    }
}

简单的数组

3. 三种初始化与简单内存分析

fb81e0b4f725f4483c12910d8ce527a6_MD5.png

  1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法
  2. 声明一个数组的时候并没有数组被真正的创建。
  3. 构造一个数组，必须指定长度
//1.声明一个数组 
int[] myList = null;

7a190088702685dbc11ea249a6d74c34_MD5.png

//2.创建一个数组 
myList = new int[10];

603e062e5e8664a334034cdd8e7ef07b_MD5.png

//3.像数组中存值 
myList[0] = 1; 
myList[1] = 2; 
myList[2] = 3; 
myList[3] = 4; 
myList[4] = 5; 
myList[5] = 6; 
myList[6] = 7; 
myList[7] = 8; 
myList[8] = 9; 
myList[9] = 10;

764579a76d8d82fd49943041516c3ecf_MD5.png

3.1. 静态初始化

除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] a = {1,2,3}; 
Man[] mans = {new Man(1,1),new Man(2,2)};

3.2. 动态初始化

数组定义、为数组元素分配空间、赋值的操作、分开进行。

int[] a = new int[2]; 
a[0]=1; 
a[1]=2;

3.3. 数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

4. 4、数组边界

下标合法区间 【0，length-1】

4.1. 小结

0249eec7986253ee5f0dd9449ae73bce_MD5.png

5. 5、数组使用

public class Demo02 {
    public static void main(String[] args) {
        int[] arr ={1,2,3,4,5};
        //遍历数组
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        //计算总和
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr[i];
        }
        System.out.println("sum="+sum);
        //找出最大的元素
        int max=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println("max="+max);
    }
}

6. 6、多维数组

int a[][] = new int[2][5];

7. 7、拓展 Arrays类

8. 8、拓展 冒泡排序

冒泡排序算法的原理如下：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

  3. 针对所有的元素重复以上的步骤，除了最后一个。

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

class Bubble {
    public int[] sort(int[] array) {
        int temp = 0;
// 外层循环，它决定一共走几趟 //-1为了防止溢出 
        for (int i = 0; i < array.length - 1; i++) {
            int flag = 0; //通过符号位可以减少无谓的比较，如果已经有序了，就退出循环
//内层循环，它决定每趟走一次 
            for (int j = 0; j < array.length - i - 1; j++) {
//如果后一个大于前一个,则换位 
                if (array[j + 1] > array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp; 
                    flag = 1;
                }
            }
            if (flag == 0) {
                break;
            }
        }
        return array;
    }
    public static void main(String[] args) {
        Bubble bubble = new Bubble();
        int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
        int[] sort = bubble.sort(array);
        for (int num : sort) {
            System.out.print(num + "\t");
        }
    }
}

9. 9、稀疏数组

9847e99817d1a6203dbe9252c49da5b9_MD5.png

先存入棋盘

public class Demo09 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11 0：没有棋子 1：黑棋 2：白棋
        int[] [] array1 =new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始数组
        System.out.println("原始数组");

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

b45f22442ef5ccf214bed4c147d04c32_MD5.png

public class Demo09 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11 0：没有棋子 1：黑棋 2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("原始数组");

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

        //转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数：" + sum);

        //创建一个稀疏数组的数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;//行
        array2[0][1] = 11;//列
        array2[0][2] = sum; //值

        //遍历二维数组，将非0的值存入到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;//行
                    array2[count][1] = j;//列
                    array2[count][2] = array1[i][j];//值
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.print(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\n");
        }
        //还原稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        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");
            }
        }
    }
}