数组（入门最后一课）

数组概述

数组声明创建

• 数据类型加上一个[]代表这个数据类型的一个数组，然后new一个这样类型的数组，并给它分配一个初始的大小。（必须分配大小，不然无限存就乱套了）
  

数组的声明和创建可以合并为一句话：

int[] nums = new int[10];

• 获取数组的长度：arrays.length
  

内存分析

• java内存有堆、栈和方法区（当然远不止这三个）
  

• 分配过程示意图
  

• 数组下标越界： ArrayIndexOutOfBoundsException
  

三种初始化

数组的四个基本特点

数组边界

• Ctrl+/：快速注释！！！
• Alt+Enter：生成对象快捷键！！！ 打出后面的，然后按住就会生成!!!
• fori + Enter ：会自动生成 for循环 ，for (int i = 0; i < ; i++) { }

数组使用（重点）

（1）普通for循环

（2）For-Each循环：一般用于打印结果

• 后面的参数是数组，前面的参数相当于遍历出来的具体的值
• 直接遍历输出数组中的元素~
• 但是没有下标，不适合对数组元素进行操作

public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //jdk1.5以后有，增强型for循环，省去了数组的下标。适合打印输出，不适合对元素进行操作
        for (int array : arrays) {
            System.out.println(array);
        }
    }

（3）数组作方法入参：对数组进行一些操作

• 打印数组元素
  

（4）数组作返回值：比如说反转数组，返回一个新的数组

• 反转数组
• 注意：必须定义一个新数组，然后调用reverse方法，最后打印输出。
  如果只是单纯调用reverse方法，不会打印输出结果的！！！！
  
  

多维数组（eg：二维数组）

• 多维数组其实就是数组里面嵌数组，数组里面嵌数组
• 其实二维数组就完全够用了，不会定义多维数组
  
  
  
  
• 多维数组中的一个下标其实是一个对象（还是看作数组）
  
  
• 循环遍历所有元素
  

Arrays类

（1）打印数组元素：Arrays.toString()方法

• 也可以点进toString方法去查看它的源码
  

（2）排序：Arrays.sort()方法（升序排序）

（3）数组填充：Arrays.fill()方法

• 将指定的字节值分配给指点字节数组的每个元素
  
• 注意：是左闭右开区间！！！！！
• eg：2~4之间，是下标为2和3的元素
  

冒泡排序

（1）冒泡排序

1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
2. 每一次比较，都会产生出一个最大，或者最小的数字；
3. 下一轮就可以少一次排序
4. 依次循环，直到结束！
   

• 若想要降序，即小的在前面的话，修改>为<即可

（2）冒泡排序的优化（即原先已经有序了）

• 没理解为啥优化了，学一下思想吧
• 加了一个flag来判断

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {1,4,5,6,72,2,2,2,25,6,7};
        //调用完我们自己写的排序方法以后，返回一个排序后的数组
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {//用length-1是为了防止溢出
            //通过flag标识位减少没有意义的比较
            boolean flag = false;
            //内存循环：比较判断两个数，如果第一个比第二个大，则交换位置
            for (int j = 0; j < array.length-1-i; 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;
    }
}

稀疏数组（是一种数据结构）：为了压缩，节省空间

• 6，7，8的意思：6行7列的数组，其中里面有8个有效数字
• 下面八个元素记录了这8个数字的有效坐标：几行几列，它的值是多少
• 注意：行、列的下标都是从0开始的

转化为稀疏数组以及稀疏数组的还原

public class ArrayDemo08 {
    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;
        //一、输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        System.out.println("====================");
        //二、转换为稀疏数组保存
        //1.获取有效值的个数
        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];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        
        
        System.out.println("====================");
        //三、还原数组
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {//注意 i=1开始，因为第一行存的是数组的大小和有效值的个数
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.打印还原后的数组
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}