数组

数组描述

1. 相同类型数据的有序组合
2. 有先后次序
3. 每一个数据称作一个数组元素，并通过下标访问
4. 排序从0开始
5. 数据可以重复

---

数组的声明与创建

首先必须声明数组变量，才能在程序中使用数组

dataType[] arrayRefVar; //首选
dataType arrayRefVar[]; //效果相同，但是不推荐

Java语言使用new操作符来创建数组；

dataType[] arrayRefVar = new dataType[arraysize];

public class arrayDemo01 {
    //变量类型  变量名字 = 变量值；
    //数组类型  数组名字 = 元素值
    public static void main(String[] args) {
        int[] num1; //1.声明一个数组
       // int num2[];//C/C++写法
        num1 = new int[3]; //创建一个数组
        //3.给数组元素赋值
        num1[0] =2;
        num1[1] = 3;

        for (int i=0;i<num1.length;i++){	//遍历数组
            System.out.println(num1[i]);//2 3 0
        }
    }
}
//上面的声明与定义可以合在一起写：int[] num1 = new int[length] 

内存分析

​ 堆：存放new对象与数组
​ 栈：存放基本变量类型（包含具体数值）；引用对象变量（包含地址）

三种初始方式

​ 静态初始化：int[] a = {1,2,3,4,5,6}; 一开始值就是固定的

​ 动态初始化：int[] b = new int [2]; b[0]=2; b[1]=3; 包含默认初始化 先声明，后赋值

​ 默认初始化：数组是引用类型，它的元素相当于实例变量，因此数组被分配空间时，其中的每个元素

​ 也被按照实例变量同样的方式被隐式初始化，即赋值0；

四个基本特点

• 长度确定
• 类型相同
• 元素可以是任意类型，基本类型或引用类型 ，比如char/String
• 数组变量属于引用类型，数组也可以看成是对象，数组对象本生是在堆中的

数组越界：就是指定的范围超过了定义的范围，会报错：数组下标越界异常

---

数组的使用

For-Each循环

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

数组作方法入参

  //打印数组元素   数组可以封装成它的参数
    public static void printArray(int[] arrays){
     for (int i = 0;i<arrays.length;i++){
         System.out.println(arrays[i]+"");
     }

数组作返回值

  //翻转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];//定义数组
        for (int i=0,j=arrays.length-1;i<arrays.length;i++,j--){
             result[j]=arrays[i];

---

多维数组

很简单

 int[][] arrays= {{1,2},{3,4},{5,6},{7,8}};
        System.out.println(arrays[2]);//[I@1540e19d
        System.out.println(arrays[2][1]);//6
        System.out.println(arrays[0].length);//数组长度 ：2

---

Arrays类

工具类 java.util.Arrays

使用API帮助文档

Arrays类的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用，而
“不用”使用对象来调用，但是可以用对象调用

比如：

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

//toString 输出数组
int[] a = {1,2,4343,3424,12,3};
        System.out.println(a);//[I@1540e19d
        System.out.println(Arrays.toString(a));//[1, 2, 4343, 3424, 12, 3]

//可以自己造一个差不多的
//重复造轮子；不必再写一个已有的工具，但需要了解原理
public static void printArray(int[] a){
        for (int i=0;i<a.length;i++){
            if (i==0){
                System.out.print("[");
            }
            if(i==a.length-1){
                System.out.print("]");
            }else{
                System.out.print(a[i]+", ");
            }
        }

    }
//主类中调用，结果：[1, 2, 3, 12, 3424, 4343]

//冒泡排序
//比较相邻两个数，如果第一个数比第二个数大，就交换位置
//每次比较，都会产生一个最大或最小的数、
//下一轮则可以少一次排序
//依次循环，直到结束
public class arrayDemo07 {
    public static void main(String[] args) {
    int[] a= {1,4,2,6,4,34,87,13};
    int[] sort = sort(a);
        System.out.println(Arrays.toString(a));

    }
    public static int[] sort(int[] array){
        //借助第三个容器来换位
        int temp = 0;
        //外部循环
        for(int i = 0;i< array.length-1;i++){

            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;
    }

}

---

稀疏数组

压缩数据

数组中大部分元素为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();
        }

        //转换为稀疏素组保存保存
        //获取有效值个数
        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 i=0;i<array2.length;i++){
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"+array2[i][0]+"\t");
        }
        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++){
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        //3.打印
        System.out.println("输出还原的数组");
        for(int[] ints:array3){
            for (int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }


    }
}
//精简与还原