Java基础：数组

• 学习来源遇见狂神说)

定义

public class arrays {
    public static void main(String[] args) {
        int array[]; //声明一个数组
        array = new int[10]; //创建一个数组

        int[] array1 = new int[10]; //声明并创建一个数组
    }
}

内存分析

• 堆

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

• 栈

  • 存放基本变量类型（会包含基本类型的具体数值）
  • 引用对象的变量（会存放这个引用在堆里面的具地址）

• 方法区

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

三种初始化

public class arrays {
    public static void main(String[] args) {
        //静态初始化
        int[] a ={1,2,3,4,5};
        
        //动态初始化
        int[] b = new int[2];
        b[0] = 1;
        b[1] = 2;
        
        //默认初始化
        /*
        数组是引用类型，他的元素相当于类的实例变量，以此数组空间一经分配，
        其中的每个元素也按照实例变量同样的方式被隐式初始化
        */
    }
}

基本特点

• 长度确定，创建后大小不能改变

• 元素类型必须相同

• 元素可是是任何类型，包括基本数据类型和引用类型

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

  数组对象本身是在堆中的

for-Each循环

public class arrays {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        for (int array : arrays){
            System.out.println(array);
        }
    }
}`

多维数组

public class arrays {
    public static void main(String[] args) {
        int[][] array = {{1, 2}, {2, 3}, {3, 4}};
        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array[i].length; j++){
                System.out.println(array[i][j]);
            }
        }
    }
}

Arrays类示例

• 查看jdk帮助文档学习更多类与方法

import java.lang.reflect.Array;
import java.util.Arrays;
public class arrays {
    public static void main(String[] args) {
        int[] array = {1, 6, 43, 7};
        System.out.println(Arrays.toString(array));
        Arrays.sort(array);  //排序
        System.out.println(Arrays.toString(array));
    }
}

冒泡排序

import java.lang.reflect.Array;
import java.util.Arrays;
public class arrays {
    public static void main(String[] args) {
        int[] a = {2,6,4,27,1};
        int[] b = bubbleSort(a);
        System.out.println(Arrays.toString(b));
    }

    /*冒泡排序
    1.比较数组中两个相邻元素，如果第一个比第二个大，交换位置
    2.每一轮比较，都会产生一个最大的数放在arrays[arrays.length-1-i] i为第i次比较，初始值为0
    3.下一轮可以少一次比较
    4.循环至结束
     */
     public static int[] bubbleSort(int[] arrays){
         int tem = 0;
         for (int i = 0; i < arrays.length-1; i++) {
             boolean flag = false;
             for (int j = 0; j < arrays.length-i-1; j++) {
                 if(arrays[j] > arrays[j+1]){
                     tem = arrays[j];
                     arrays[j] = arrays[j+1];
                     arrays[j+1] = tem;
                     flag = true;
                 }
             }
             if(!flag){    //如果第i轮没有发生过交换，结束循环
                 break;
             }
         }
         return arrays;
    }
}

稀疏数组

• 第一行：记录数组一共有几行几列，有多少个不等于0的值
• 把不等于0的元素的行列位置和值记录在小规模数组中，缩小程序的规模

public class arrays {
    public static void main(String[] args) {
        //创建原数组
        int count = 0;
        int[][] array1 = new int[10][10];
        array1[2][3] = 9;
        array1[5][7] = 2;

        System.out.println("打印原数组：");
        for (int[] array : array1) {
            for (int elem : array) {
                if (elem != 0) {
                    count++;
                }
                System.out.print(elem + " ");
            }
            System.out.println();

        }
        System.out.println("不为零的元素个数：" + count);

        //稀疏数组
        int[][] array2 = new int[count + 1][3];
        array2[0][0] = 10;
        array2[0][1] = 10;
        array2[0][2] = count;
        int index = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    index++;
                    array2[index][0] = i;
                    array2[index][1] = j;
                    array2[index][2] = array1[i][j];
                }
            }
        }
        System.out.println("================="+"\n打印稀疏数组");
        for (int[] array : array2) {
            for (int elem : array) {
                System.out.print(elem + "\t");
            }
            System.out.println();
        }

        //稀疏数组还原为数组
        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("======================"+"\n稀疏数组还原为数组：");
        for (int[] array : array3) {
            for (int elem : array) {
                System.out.print(elem + " ");
            }
            System.out.println();
        }
    }
}