day09-Java 数组

Java 数组

1.数组创建

datatype[] arryName = new dataType[size]

int[] numbers = new int[10];//创建一个大小为10 的int数组

1.2.数组内存分析

1.3.三种初始化方式

1.数组是引用类型，元素相当于类的实例变量，一经分配，每个元素也按实例变量同样的方式被隐式初始化

//静态初始化数组
int[] num1 = {1,2,3,4};
Man[] mans = {new Man(1,1),new Man(2,2)}//引用
//动态初始化；包含默认值（int为0，String为null）
int[] num2 = new int[10];
for (int i = 0; i <num2.length ; i++) {
    num2[i] = i;
} 

1.4数组特点

1.**长度确定，**大小不可变

2.元素是相同类型，不能混类型，可看成任意类型的有序集合

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

4.**数组变量属于引用类型，**数组可看成对象，每个元素相当于该对象的成员变量

5.数组本身就是对象，java中对象在堆中，因此，无论保存原始类型还是其他对象类型，数组对象本身在堆中。

2.数组使用

int[] num1 = {1,2,3,4};
//。for/for-each循环,num1.for(增强型for循环)
for (int i : num1) {
    System.out.println(i);
}
//当作参数传递
printArry(num2);
}
public static void printArry(int[] arry){
    for (int i : arry) {
        System.out.println(i);
    }
}
//数组作返回值
public static int[] reverse(int[] arry){
    int[] arry1 = new int[arry.length];
    for (int i = 0,j = arry.length-1; i < arry1.length; i++,j--) {
        arry1[i] = arry[j];
    }
    return arry1;
}

3.多维数组

//二维数组
int[][] arry= {{1,2},{2,3},{3,4},{4,5}};
for (int i = 0; i <arry.length ; i++) {
    for (int j = 0; j <arry[i].length ; j++) {
        System.out.print(arry[i][j]);
    }
    System.out.println();
}
int[][] num = new int[4][2];
for (int i = 0; i <num.length ; i++) {
    for (int j = 0; j < num[i].length; j++) {
        num[i][j] = i+j;
    }
}
for (int i = 0; i <num.length ; i++) {
    for (int j = 0; j <num[i].length ; j++) {
        System.out.print(num[i][j]);
    }
    System.out.println();
}

4.Arrys类

里面有很多关于数组常用的静态方法，直接调用即可

查看JDK帮助文档：E:\Setup_Java\jdk api 1.8_China

//常用方法
//给数组赋值:fill()
//对数组排序升序：sort()
//比较数组元素值是否相等：equals()
//查找数组元素：binarySearch()堆排序好的数组二分查找
public static void main(String[] args) {
    int[] a = {1,4,5,7,90,55,33,100};
    Arrays.sort(a);
    System.out.println(Arrays.toString(a));//[1, 4, 5, 7, 33, 55, 90, 100]
    printArry(a);//1 4 5 7 33 55 90 100 a[]数组本身变了
    Arrays.fill(a,0);//用0填充数组
    System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0, 0, 0, 0]
    printArry(a);//0 0 0 0 0 0 0 0 a[]数组本身变了
    int[] b = {1,4,5,7,90,55,33,100};
    System.out.println(Arrays.equals(a,b));//判断a,b数组元素是否相等  false
    System.out.println(Arrays.binarySearch(b,90));//-8未排序
    Arrays.sort(b);//排序[1, 4, 5, 7, 33, 55, 90, 100]
    System.out.println(Arrays.binarySearch(b,90));//6
}
public static void printArry(int[] a){
    for (int i = 0; i < a.length; i++) {
        System.out.print(a[i]+" ");
    }
    System.out.println();
}

4.1冒泡排序

public static int[] sort(int[] arry){
    //外层循环,控制比较趟数，每循环一次确定一个位置，故共需要leng-1次即可
    //内层循环，两两比较，每次循环比较次数length-1-i。
    //优化一下{1,2,3,4,5}这种情况
    int temp = 0;
    boolean flag = false;//标志
    for (int i = 0; i <arry.length-1 ; i++) {
        for (int j = 0; j <arry.length-1-i ; j++) {
            if (arry[j+1]<arry[j]){
                temp= arry[j+1];
                arry[j+1] = arry[j];
                arry[j] = temp;
                flag = true;
            }
        }
        if (flag==false) break;
    }
    return arry;
}

5.稀疏数组

public class Xishu {
    public static void main(String[] args) {

        //    创建棋盘
        int[][] checkerBoard = new int[11][11];
        checkerBoard[1][3] = 1;
        checkerBoard[2][4] = 2;
        System.out.println("= = = = = = =初始的棋盘= = = = = = = = = =");
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                System.out.print(checkerBoard[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("= = = = = = = = = = = = = = = = = = = = = =");
        System.out.println("= = = = = = = =  稀疏数组=  = = = = = = = =");
        //有效数字+1行，3列
        //第一行：棋盘行 棋盘列 有效数字个数
        //第二行：所在行 所在列 第一个有效数字值
        //以此类推
        int sum = count(checkerBoard);
        int[][] sparseArray = new int[sum+1][3];//稀疏数组
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = sum;
        //创建稀疏数组
        int cot = 0;
        for (int i = 0; i <checkerBoard.length ; i++) {
            for (int j = 0; j <checkerBoard[i].length ; j++) {
                if (checkerBoard[i][j]!=0){
                    cot++;
                    sparseArray[cot][0] = i;
                    sparseArray[cot][1] = j;
                    sparseArray[cot][2] = checkerBoard[i][j];
                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i <sparseArray.length ; i++) {
            for (int j = 0; j <sparseArray[i].length ; j++) {
                System.out.print(sparseArray[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("= = = = = = = = = = = = = = = = = = = = = =");
        System.out.println("= = = = = =  =  还原稀疏数组=  = = = == = =");
        int[][] recheckerBoard = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
            recheckerBoard[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        for (int i = 0; i < recheckerBoard.length; i++) {
            for (int j = 0; j < recheckerBoard[i].length; j++) {
                System.out.print(recheckerBoard[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("= = = = = = = = = = = = = = = = = = = = = =");
    }
    public static int count(int[][] arry){
        /**
         * 计算初始棋盘有效数字
         */
        int sum = 0;
        for (int i = 0; i <arry.length ; i++) {
            for (int j = 0; j <arry.length ; j++) {
                if (arry[i][j] != 0){
                    sum++;
                }
            }
        }
        return sum;
    }
}