java数组

Java数组

数组的概述

• 数组时相同类型数据的有序集合。
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
• 其中，每一个数据称作为一个数组元素，每个数组元素可以通过一个下标太访问他们。

数组的声明

• 首先必须声明数组变量，才能在程序中使用数组。下面是声明

  • dataType[] arrayRefVar;
    dataType arrayRefVar[];
    

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

  • dataType[] arrayRefVar = new dataType[arraySize];
    

• 数组的元素是通过索引访问的，数组索引从 0 开始。

• 获取数组长度

  • arrays.length;
    

使用案例

package com.yanxun;

public class Demo07 {
    public static void main(String[] args) {
        int[] arrays = new int[100];
        for(int i = 0; i < 100; ++ i){
            arrays[i] = i + 1;
        }
        for(int i = 0; i < arrays.length; ++ i)
            System.out.print(arrays[i] + " ");
    }
}

数据初始化的三种方式

静态初始化

int[] a = {1, 2, 3};
Man[] mans = {new Man(1, 1), new Man(2,  2)};

动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

数组默认初始化

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

package com.yanxun;

public class Demo08 {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};// 
        for(int i : a) {
            System.out.print(i + " ");
        }
        System.out.println();
        int[] b = new int[4];
        b[0] = 1;//动态初始化
        b[1] = 2;
        b[2] = 3;
        b[3] = 3;
        for(int i : b){
            System.out.print(i + " ");
        }
        System.out.println();
        int[] c = new int[4];//默认初始化
        for(int i : c) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

数组的四个基本特点

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

多维数组

二维数组

int[][] array = {{1, 2}, {2, 3}, {3, 4}};

Arrays 类

• 数组的工具类java.util.Arrays
• 由于数组本身并没有声明方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以堆数据对象进行一些基本操作。
• 查看Jdk文档
• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用。
• 具有以下常用功能：
  • 给数组赋值： 通过fill方法。
  • 对数组排序：通过sort方法，按升序。
  • 比较数组：通过equals方法比较数组中的元素值是否相等。
  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找和操作。

package com.yanxun;

import java.util.Arrays;

public class Demo09 {
    public static void main(String[] args) {
        int[] a = {213,3121,2211,221,1,234,12,321,221,121};
        Arrays.sort(a);//排序
        System.out.println(Arrays.toString(a));//打印
        Arrays.fill(a, 0);//填充
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2, 4, 1);//2 - 4不包括全变为1
        System.out.println(Arrays.toString(a));
    }
}

稀疏数组

• 当一个数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组。
• 稀疏数组得处理方式是：
  • 记录数组一共有几行几列，有多少个不同得值。
  • 把具有不同值得元素和行列及值记录在一个小规模得数组中，从而缩小程序得规模。
• 如下图：
  • 

用稀疏矩阵编写五子棋中的，存盘退出和续上盘的功能

• 分析问题：

  • 因为该二维数组的很多值是默认为0，因此记录了很多没有意义的数据。

• 解决：稀疏数组

• 代码

  • package com.yanxun;
    
    public class Demo10 {
        public static void main(String[] args) {
            //创建一个二维数组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 + "	");
                }
                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);
    
            //创建稀疏数组
            int[][] arrays2 = new  int[sum+1][3];
            arrays2[0][0] = 11;
            arrays2[0][1] = 11;
            arrays2[0][2] = sum;
    
            //遍历二维数组将非零的值存放到数组
            int count = 0;
            for (int i = 0; i < 11; ++ i) {
                for(int j = 0; j < 11; ++ j) {
                    if (array1[i][j] != 0) {
                        count ++;
                        arrays2[count][0] = i;
                        arrays2[count][1] = j;
                        arrays2[count][2] = array1[i][j];
                    }
                }
            }
    
            //输出稀疏数组
            for (int i = 0; i < arrays2.length; ++ i) {
                System.out.println(arrays2[i][0] + "	" + arrays2[i][1] + "	" + arrays2[i][2]);
            }
    
    
            //还原稀疏数组
            int[][] array3 = new int[arrays2[0][0]][arrays2[0][1]];
    
            for (int i = 1; i < arrays2.length; ++ i) {
                array3[arrays2[i][0]][arrays2[i][1]] = arrays2[i][2];
            }
    
            //打印还原的值
            for(int[] ints : array1) {
                for(int anInt : ints){
                    System.out.print(anInt + "	");
                }
                System.out.println();
            }
        }
    }