目录

一、数组的定义

二、数组的声明创建

1.声明

2.数组的特性

 3.数组的创建（初始化）

（1）静态初始化

（2）动态初始化

三、数组的输出

四、二维数组 

1.定义

2.二维数组的遍历

 五、Arrays类

1.打印数组

2.Fill方法给数组赋值

3.equal方法判断两个数组是否相等

4.利用sort将数组排序

重点：冒泡排序

 六、稀疏数组

一、数组的定义

1.数组是相同类型数据的有序集合.
2.数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
3.其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们

二、数组的声明创建

1.声明

首先必须声明数组变量，才能在程序中使用数组。以下时声明数组变量的语法：

dataType[] arrayRefVar; //首选！

或

 dataType arrayRefVAR = new dateType[arraySize];//效果相同，但不是首选方法

Java语言使用操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

//获取数组长度
array.length

数组的元素通过索引访问，索引值都从0开始

2.数组的特性

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

b.其元素必须是相同类型,不允许出现混合类型。

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

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

数组对象本身是在堆中的。

3.内存分析

 栈——堆——元素

 

 3.数组的创建（初始化）

（1）静态初始化

静态初始化包括：创建+赋值

形式如下：

 int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
System.out.println(a[2]);

不使用new来进行声明，而是直接创建一个数组 

（2）动态初始化

动态初始化：包括默认初始化

 int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
 

若输出的索引值超出数组的长度，则会进行报错：如

int[] b = new int[10];
        b[0] = 10;
//元素赋值....
        System.out.println(b[11]);

报错： 

 意思为数组越界，索引值超过数组长度。

三、数组的输出

打印数组元素，使用下标索引值：

     //打印数组元素
        System.out.println(nums[10]);

遍历数组：

for(int n :nums){
            System.out.print(n+"t");
        }

计算数组所有元素的和：

 int sum = 0;
        for(int i = 0;i 
完整代码为：
 
public class Example01 {
    public static void main(String[] args){ 
        int[] nums = new int[10];
        nums[0] = 0;
        nums[1] = 1;
        nums[2] = 2;
        nums[3] = 3;
        nums[4] = 4;
        nums[5] = 5;
        nums[6] = 6;
        nums[7] = 7;
        nums[8] = 8;
        nums[9] = 9;
        
        //打印数组元素
        System.out.println(nums[2]);
        
        //遍历数组
        for(int n :nums){
            System.out.print(n+"t");
        }
       
        //计算数组所有元素的和
        int sum = 0;
        for(int i = 0;i 
四、二维数组  
1.定义 
二维数组同数学上的二维数组相同，定义式
 
int array[][] = { {a1,b1} ,{a2,b2} ,{a3,b3}, .....}
 
2.二维数组的遍历 
for(int[] n : array){ 
    for(int m : n){
    }
}
 
完整代码为： 
 
    public static void main(String[] args) {
        int[][] array = {{1, 2,}, {3, 4}, {5, 6}};
        for(int[] n : array){
            for(int m : n){
                System.out.print(m+"t");
            }
        }
    }

 
也可以使用for循环输出二维数组中的元素：
  
 
    public static void main(String[] args) {
        int array[][] = {{1, 2,}, {3, 4}, {5, 6}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                System.out.println(array[i][j]);

            }
        }
    }
 
 五、Arrays类 
1.打印数组 
    public static void main(String[] args) {
        int[] a = {156, 64, 87, 16, 155, 15};
        System.out.println(a);  //[I@10f87f48  只打印一个对象
        System.out.println("打印数组：");
        //数组格式打印出数组
        System.out.println(Arrays.toString(a));
        //利用方法
        printArray(a);
    }

    //构建方法，不利用工具包(重复造轮子)
    //Arrays.toString(a)
    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(a[i] + ",");
            } else {
                System.out.print(a[i] + "]");
            }
        }
    }
 
2.Fill方法给数组赋值 
public static void main(String[] args) {
        int[] a ={1,2,3,4,5,6};
        Arrays.fill(a,2,4,0);//将数组a的下标为2到下标为4的元素用0填充
        System.out.println(Arrays.toString(a));
    }
 
3.equal方法判断两个数组是否相等 
import java.util.Arrays;

public class EqualsArray {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5, 6};
        int[] b = {1, 2, 3, 4, 5, 7};
        if (Arrays.equals(a, b)) {
            System.out.println("a,b两个数组相等");
        } else {
            System.out.println("两个数组不相等");
        }
        equalsArray(a, b); //利用方法判断
    }


    //构建方法
    public static void equalsArray(int[] a, int[] b) {
        for (int i = 0, j = 0; i < a.length && j < a.length; i++, j++) {
            if (a[i] == b[j]) {
            } else {
                System.out.println("a,b两个数组不相等");
            }
        }
    }
}
 
4.利用sort将数组排序 
sort将对数组进行升序排序
 
import java.util.Arrays;

public class SortArray {
    public static void main(String[] args) {
        int[] a = {156, 64, 87, 16, 155, 15};
        System.out.println("n数组排序：");
        //sort：排序数组（升序）
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

    }
}
 
重点：冒泡排序 
也可以利用冒泡法对数组进行排序
 
import java.util.Arrays;

public class SortArray {
    public static void main(String[] args){
        int[] a = {156, 64, 87, 16, 155, 15};
        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，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
 
稀疏数组的处理方式是:
 记录数组一共有几行几列，有多少个不同值，把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模如下图:左边是原始数组，右边是稀疏数组
 
如存在下如所示二维数组：
 
 
 
则其稀疏数组表示为：
 
 
 
 
 a.建立并输出数组
 
int[][] array = new int[10][10];
        array[1][2] = 1;
        array[5][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组：");

        for (int[] ints : array) { //可以理解为：先将每一行赋给ints（作为一个一维数组）
            for (int anInt : ints) {  //再将ints数组中的每一个数赋给anInt
                System.out.print(anInt + "t"); //输出每个元素
            }
            System.out.println(); //在遍历完依次ints之后，在下一行继续遍历一下一个ints
 
 b.将数组转换为稀疏数组保存
 
//获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (array[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值个数：" + sum);

        //创建一个稀疏数组的数组
        int[][] array2 = new int[sum + 1][3];//稀疏数组，sum+1是因为起始行为0
        array2[0][0] = 10;//二维数组几行
        array2[0][1] = 10;//二维数组几列
        array2[0][2] = sum;//二维数组中有几个有效值
        //遍历二维数组，将非零的值存放到稀疏数组中
        int count = 0;//稀疏数组的行标
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[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][2] + "t");

        }
 
 c.将稀疏数组还原为原始数组
 
     System.out.println("还原数组");
        //读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];  //因为array2[0][0]储存的值为二维数组的行数，array2[0][1]储存的是二维数组的列
        //给元素还原值
        for (int i = 1; i < array2.length; i++) {  //遍历array2数组（i=1是因为array2的第0行是数组信息，从第一行还是为有效值坐标）
            array3[array2[i][0]][array2[i][1]] = array2[i][2]; //特殊赋值
        }
        //打印
        System.out.println("输出还原数组");
        for (int[] ints : array3) { //可以理解为：先将每一行赋给ints（作为一个一维数组）
            for (int anInt: ints) {  //再将ints数组中的每一个数赋给anInt
                System.out.print(anInt + "t"); //输出每个元素
            }
            System.out.println(); //在遍历完依次ints之后，在下一行继续遍历一下一个ints
        }
 
完整代码为：
 
import java.sql.SQLOutput;

public class SparseArray {
    public static void main(String[] args) {
        //创建二维数组10*10 0：没有棋子   1：白棋    2：黑棋
        int[][] array = new int[10][10];
        array[1][2] = 1;
        array[5][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组：");

        for (int[] ints : array) { //可以理解为：先将每一行赋给ints（作为一个一维数组）
            for (int anInt : ints) {  //再将ints数组中的每一个数赋给anInt
                System.out.print(anInt + "t"); //输出每个元素
            }
            System.out.println(); //在遍历完依次ints之后，在下一行继续遍历一下一个ints
        }

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (array[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值个数：" + sum);

        //创建一个稀疏数组的数组
        int[][] array2 = new int[sum + 1][3];//稀疏数组，sum+1是因为起始行为0
        array2[0][0] = 10;//二维数组几行
        array2[0][1] = 10;//二维数组几列
        array2[0][2] = sum;//二维数组中有几个有效值
        //遍历二维数组，将非零的值存放到稀疏数组中
        int count = 0;//稀疏数组的行标
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[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][2] + "t");

        }
         
        System.out.println("=========================");


        //还原数组
        System.out.println("还原数组");
        //读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];  //因为array2[0][0]储存的值为二维数组的行数，array2[0][1]储存的是二维数组的列
        //给元素还原值
        for (int i = 1; i < array2.length; i++) {  //遍历array2数组（i=1是因为array2的第0行是数组信息，从第一行还是为有效值坐标）
            array3[array2[i][0]][array2[i][1]] = array2[i][2]; //特殊赋值
        }
        //打印
        System.out.println("输出还原数组");
        for (int[] ints : array3) { //可以理解为：先将每一行赋给ints（作为一个一维数组）
            for (int anInt: ints) {  //再将ints数组中的每一个数赋给anInt
                System.out.print(anInt + "t"); //输出每个元素
            }
            System.out.println(); //在遍历完依次ints之后，在下一行继续遍历一下一个ints
        }

    }
}