Java数组

Java数组

声明数组（2种）

int[] nums;    //首选
int nums[];    //为了便于C/C++程序员快速上手

创建数组

int[] = nums;    //声明一个数组  但没分配空间
nums = new int[10];    //创建一个数组

int[] nums = new int[10]        /声明创建一起写
System.out.println(nums.length)    //获取长度

int的变量没赋值默认值就是0

内存分析

• step1: int[] array = null;

  声明数组时，并没有new对象，所以只在栈里面有一个array的名字

• step2:array = new int[10];

  创建数组，此时在栈里面得到10个空间

  

• step3:给数组元素中赋值

三种初始化(静态、动态、默认)

• 静态初始化：使用{} 创建+赋值

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

• 动态初始化(其中包含默认初始化 没有赋值的就会默认初始化) 创建之后，再手动赋值

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

• 默认初始化

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

数组的四个基本特点

• 其长度是确定的，数组一旦被创建，它的大小是不可以被改变的

• 其元素必须是相同类型，不允许出现混合类型

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

• 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量(Java的对象是在堆中的)，因此无论数组保存原始对象还是其他对象类型，数组对象本身是在堆中的

JDK5新特性( for each循环 没有下标 一般用来打印数组元素比较方便)

int[] arrays = {1,2,3,4,5};
for (int array : arrays){
    System.out.println(array);
}

数组反转

public static int[] reverse(int[] arrays){
    int[] result = new int[arrays.lengh];
    for (int i=0,j=result.length-1; i<arrays.length; i++ j--){
         result[j] = arrays[i];
    }
    return result;
}

多维数组

int[][] array = {{1,2},{2,,3},{3,4},{4,5}};
System.out.println(array[0])        //此时打印的是一个对象  因为JAVA里面数组就是个对象

Arrays类

    public static void main(String[] args) {
        int[] a = {1,32,3,4,45,65,6,7,6,67,656};
        //打印数组元素：  Arrays.toString
        System.out.println(Arrays.toString(a));

        //对数组排序
        Arrays.sort(a); //默认是升序
        System.out.println(Arrays.toString(a));

        //填充元素
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));  //全为0了
    }

冒泡排序

    public static void main(String[] args) {
        int[] arrs = {123,4,5,6,76,23,4,232,2445,2,33};
        arrs = sort(arrs);
        System.out.println(Arrays.toString(arrs));
    }

    public static int[] sort(int[] arr){
        int temp;
        boolean flag = false;       //用于判断一轮是否进行了交换  如果已经排好了就跳出
        for (int i = 0; i < arr.length - 1; i++){            //外层循环  n个数 一层外循环排好一个数，最后一次会排好两个数
            for (int j = 0; j < arr.length - 1 - i; j++){   //内层循环  n个数 每次只用比较n-1次 而n会每次减1
                if(arr[j] > arr[j+1]){
                    temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                    flag = true;
                }
            }
            if(!flag){
                break;
            }
        }
        return arr;
    }

稀疏数组

    public static void main(String[] args) {
        //1.创建一个二维数组 11*11  0:没有棋子  1: 黑棋  2:白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        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 += 1;
                }
            }
        }
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;  //第一行分别为: 行数、列数、有效值个数
        array2[0][1] = 11;
        array2[0][2] = sum;
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;   //第i行存第i个有效值,分别为:有效值所在的行、列、值
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < sum+1; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }
        //还原稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i <= array2[0][2]; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印恢复数组
        for (int i = 0; i < array2[0][0]; i++) {
            for (int j = 0; j < array2[0][1]; j++) {
                System.out.print(array3[i][j]+"\t");
            }
            System.out.println();
        }
    }