java 数组 构建 get java,数组

第一节：数组概念

• 数组：是一个变量，相同类型数据的有序集合
• 数组是用来存储固定大小的同类型元素
• 数组是在内存空间划出一串连续的空间

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

1. 标识符：和变量名一样，即数组的名字称为标识符，用于区分不同的数组
2. 数组元素：数组标识符后要向数组中存放数据，这些数据就被称为数组元素
3. 数组下标：数据的有序编号
5. 元素类型：即数据类型（BYTE, SHORT, INT, LONG,CHAR,FLOAT, DOUBLE ... ）



6. 获取数组长度：数组名.length

第二节：声明创建

1. 声明数组

数据类型[] 数组名; //建议使用
 或 
 数据类型 数组名[];int[]scores; //存储学生的成绩，类型为int
 double heigth[]; //存储学生的身高，类型为double

        2. 分配空间

数据类型[] 数组名 = new 数据类型 [数组长度];   //长度必须写
 int scores[] = new int[30]; //存储30位学生的成绩

        3. 赋值

数组名[下标值];
或者
数据类型[] 数组名 = {值1，值2，值3，…… ，值n}

scores[0] = 80;
scores[1] = 78;
scores[2] = 99;
scores[3] = 58;
//......

int[] scores = {60,78,88,92}; //创建一个长度为4的数组
//等价于
int[] scores = new int []{60,78,88,92}; //注意不能给数组定义长度
//注意

        4. 对数据进行处理

int[]scores = new int[]{56,78,97,100,42,85}; //定义一个成绩数组
int sum = 0; //成绩总和
for (int i = 0; i < scores.length; i++) {
//成绩累加
sum+=scores[i];
}
System.out.println("成绩的总和："+sum); //输出 458
/*错误示例
int[] score;
score = {56,78,97,100,42,85}; //报错
注意：在赋值情况下，必须在一条语句完成，不能分行拆分写
*/

第三节：内存分析

第四节：初始化

• 静态初始化

//静态初始化 声明+赋值
int[] num = {12,33,56,88};
System.out.println(num[2]);

• 动态初始化

//动态初始化 包含默认初始化
int[]score = new int[4];
score[0] = 12;
score[1] = 32;
score[2] = 45;
System.out.println(score[1]);
//默认值初始化
System.out.println(score[3]);

• 默认初始化

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

第五节：数组小结

• 数组的四个基本特点：

• 其长度是确定的，数组一旦被创建它的大小就不可以改变
• 元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属于引用类型，数组也可以看做对象，数组的每一个元素相当于该对象的成员变量。数组本身就是对象，Java中对象在堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中

• 数组边界

• 下标的合法区间：[0,length - 1],若越界就会报错

int[] num = new int[2];
System.out.println(num[2]);

• java.lang.ArrayIndexOutOfBoundsException:数组下标越界异常

第六节：数组使用

• for-each

// forEach遍历数据(无法取下标)
int[] arrays = {12,33,56,88};
for (int array : arrays) {
    System.out.println(array);//输出 12 33 56 88
}

• 数组作为方法入参

public static void main(String[] args) {
        int[] arrays = {12,33,56,88};
        printArray(arrays); //输出 12 33 56 88
    }
    //打印数组元素
    public static void printArray(int[]arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
     }
 }

第七节：多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其中每一个元素都是一个一维数组
• 二维数组

int a[][] = new int [4][2]

• 解析：以上二维数组a可以看成一个四行两列的数组
• 图解：

第八节：Array类

• 数组的工具类：java.util.Array
• Array类中的方法都是static修饰的静态方法，在使用时可以直接通过类名进行调用
• 常用功能：

• 给数组赋值：通过fill()方法
• 对数组排序：通过sort()方法
• 比较数组：通过equals()方法比较数组中元素值是否相等
• 查找数组元素：通过binarySearch()方法能对排序好的数组进行二分查找法操作

第九节：冒泡排序

• 图解：

• 示例：

public static void main(String[] args) {
        //冒泡排序法
        /*
        1.比较数组中两个相邻的元素，若第一个元素比第二个元素大，则交换位置
        2.每一次比较都会产生一个最大/最小的元素
        3.下一轮比较时将减少一次排序
        4.依次循环排序，直到结束！
         */
        int[] arr = {12,143,565,88,14,6,78};
    		//调用冒泡排序法
        int[] sort = sort(arr);
        System.out.println(Arrays.toString(sort)); 
        //输出 [565, 143, 88, 78, 14, 12, 6]
    }
    //冒泡排序法
    public static int[]sort(int[]array){
        int temp = 0; //临时存放元素
        boolean flag = false; //通过flag标志，减少无意义的比较
        //外层循环，判断执行几次循环
        for (int i = 0; i < array.length-1; i++) {
            //内层循环 比较判断两个元素大小，若第一个元素比第二个元素大，则交换位置
            for (int j = 0; j < array.length-1; j++) {
                if (array[j+1] > array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if(flag == false){
                break;
            }
        }
        return array;
    }

第十节：稀疏数组

• 当一个数组中大部分元素为0，或为同一值的数组时，可以使用稀疏数组来保存该数组的数据
• 稀疏数组的处理方式

• 记录数组中一共有几行几列，有多少个不同的值
• 把具有不同元素的行列及值记录在一个小规模的数组中 ，从而缩小程序的规模

• 下图中左边为原始数组，右边为稀疏数组



• 示例：

public static void main(String[] args) {
        //稀疏数组 棋盘数据
        //1.创建一个二维数组 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+" ");
            }
            System.out.println();
        }
        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);
        //2.创建一个稀疏数组
        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 < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i; //行
                    array2[count][1] = j; //列
                    array2[count][2] = array1[i][j]; //值
                }
            }
        }
        //3.输出稀疏数组
        System.out.println("稀疏数组数据：");
        System.out.println("行"+"\t"+"列"+"\t"+"值");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]);
        }

        //还原稀疏数组的数据
        //1.读取稀疏数组数据
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的初始值
        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+" ");
            }
            System.out.println();
        }
    }