java从头开始-数组

数组

数组是一组数据元素相同的元素集合。

数组是引用数据类型即对象，数组中可以存储基本数据类型，也可以存储引用数据类型。

Java在创建数组是必须先给定数组的长度，长度一旦给定，不可变。

一维数组

数组的声明的两种方式

例如：

int a[];//数据类型 数组的名字 []
int[] b;//数据类型 []  数组名字

推荐使用第二种，避免混淆a的数据类型。

例如：

//      c为数组，d为变量
//      e，f均为数组        
		int c[], d;        
		int[] e, f;

创建数组的三种方式

例如：

//声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值
int a1 [] =new int[5]; 
//声明数组并分配内存，同时将其初始化
 int a2 [] =new int []{1,2,3,4,5,6,7,8}; 
//与前一种方式相同，仅仅只是语法相对简略
 int a3 [] ={1,2,3,4,5,6,7,8,9};

实例：

public static void main(String[] args) {
    
        System.out.println("**********各种数据类型的默认值如下***********");
        //int 类型的数组默认值为0
        int a1[] = new int[1];
        System.out.println("整型数据的默认值为："+Arrays.toString(a1));

        //byte 类型的数组默认值为0
        byte b1[] = new byte[1];
        System.out.println("字节型数据的默认值为："+Arrays.toString(b1));

        //short 类型的数组默认值为0
        short[]s = new short[1];
        System.out.println("short型数据的默认值为："+Arrays.toString(s));

        //long 类型的数组默认值为0
        long g[] = new long[1];
        System.out.println("long型数据的默认值为："+Arrays.toString(g));

        //float 类型的数组默认值为0.0
        float m[] = new float[1];
        System.out.println("单精度浮点数的默认值为："+Arrays.toString(m));

        //double 类型的数组默认值为0.0
        double [] n= new double[1];
        System.out.println("双精度浮点数的默认值为："+Arrays.toString(n));

        //String 类型的数组默认值为null
        String s1[]=new String[3];
        System.out.println("String类型数据的默认值为："+Arrays.toString(s1));

        //char 类型的数组默认值为0对应的字符
        char []c1 = new char[3];
        System.out.println("字符型数据的默认值为："+Arrays.toString(c1));

        //boolean 类型的数组默认值为false
        boolean []b2 = new boolean[2];
        System.out.println("布尔型数据的默认值为："+Arrays.toString(b2));

        int a2[] = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(Arrays.toString(a2));
        int a3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.out.println(Arrays.toString(a3));

        String s2[] =new String[]{"a","b","c"};
        System.out.println(Arrays.toString(s2));

        char c2[]= new char[]{'h','e','l','l','o'};
        System.out.println(Arrays.toString(c2));

    }

运行结果：

数组的遍历与迭代

数组元素的访问：数组名字[索引]

例如：a[0],a[1];

数组迭代的两种方式：
第一种：for循环

第二种：增强for循环

实例：

public static void main(String[] args) {
        //数组的访问
        int a[] = new int[]{1, 2, 3, 4, 5};
        System.out.println(a[1]);

        int b[] = new int[5];
        System.out.println(b[0]);
        b[0] = 3;
        b[1] = 4;
        System.out.println(b[0]);
        System.out.println(b[4]);

        boolean c[] = new boolean[6];
        System.out.println(c[1]);
        c[1] = true;
        System.out.println(c[1]);

        //数组的遍历
        //for循环遍历
        String s[] = new String[]{"h", "e", "l", "l", "o"};
        for (int i = 0; i < s.length; i++) {
            System.out.print(s[i]);
        }
        System.out.println();

        //foreach循环
        char c1[] = new char[]{'w', 'o', 'r', 'l', 'd'};
        for (char temp : c1) {
            System.out.print(temp);
        }
    }

运行结果：

注意

数组的索引(编号)从0开始。
索引的数据类型是整型
索引最大值和数组长度始终差1

二维数组

定义：数组的数组—二维数组的每一个元素是一个一维数组。

二维数组的声明

//建议使用第一种，不容易混淆a的数据类型
int [][]a ;
int a2[][];

二维数组的创建

		int [][] b = new int[4][5];
        int [][] c = new int[][]{{1,2,3},{1,2,3,4},{4,5,6,7}};
        int [][] d = {{4,5,6},{7,8,9}};
        int [][] e = new int[3][];

注意：

//定义了一个整型的二维数组 ,这个二维数组有3个一维数组,每一个一维数组包含5个元素.
int[][] arr = new int[3][5]；

二维数组的遍历与迭代

左索引决定行，右索引决定列。

实例：

 public static void main(String[] args) {
        //二维数组的声明
        int [][]a ;
        int a1[][];
        //二维数组的创建
        int [][] b = new int[4][5];
        int [][] c = new int[][]{{1,2,3},{1,2,3,4},{4,5,6,7}};
        int [][] d = {{4,5,6},{7,8,9}};
        int [][] e = new int[3][];
        System.out.println(e[0]);
        e[0]=new int[1];
        e[0][0]=5;
        System.out.println(e[0][0]);
       //二维数组的遍历
        for (int i = 0; i < c.length; i++) {
            for (int j = 0; j < c[i].length; j++) {
                System.out.print(c[i][j]+"\t");
            }
            System.out.println();
        }
     }

运行结果：

二维数组与稀疏数组相互转化

稀疏数组

定义：当一个数组中大部分元素是0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

特点：列数固定，3列。

行数为二维数组中非零元素的个数+1。

第一行依次记录二维数组的总行数，总列数以及非零元素的总个数。从第二行开始记录二维数组中非零元素所在行，列以及值。

如下图：

稀疏数组的处理方法是：

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

当一个二维数组里面大部分数是相同的值的时候可以转换为稀疏数组进行储存，这样起到压缩数据的作用。反过来，我们也可以使稀疏数组转化为二维数组。

实例：

 public static void main(String[] args) {
        //将二维数组转化为稀疏数组
        //1.创建一个二维数组，假使其中有三个非零元素
        int a[][] = new int[15][15];
        a[2][0] = 1;
        a[3][5] = 5;
        a[4][2] = 3;
        int sum = 0;
        //2.遍历二维数组，记录非零元素的个数sum，从而确定稀疏数组的行数为sum+1
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }
        //3.创建稀疏数组，并确定数组中元素的值
        int sqarse[][] = new int[sum + 1][3];
        sqarse[0][0] = a.length;
        sqarse[0][1] = a.length;
        sqarse[0][2] = sum;
        int index = 1;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    sqarse[index][0] = i;
                    sqarse[index][1] = j;
                    sqarse[index][2] = a[i][j];
                    index++;
                }
            }
        }
        //遍历并打印输出稀疏数组
        for (int i = 0; i < sqarse.length; i++) {
            for (int j = 0; j < sqarse[i].length; j++) {
                System.out.print(sqarse[i][j] + "\t");
            }
            System.out.println();
        }


        //将稀疏数组转化为二维数组
        //新建一个二维数组并为其赋值
        int[][] b = new int[sqarse[0][0]][sqarse[0][1]];
        for (int i = 1; i < sqarse.length; i++) {
            b[sqarse[i][0]][sqarse[i][1]] = sqarse[i][2];
        }
        //打印输出二维数组
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                System.out.print(b[i][j] + "\t");
            }
            System.out.println();
        }
    }