数组

数组的定义、赋值和输出

public class Demo1 {
    public static void main(String[] args) {
        int[] nums;//首选定义
        int nums2[];
        nums = new int[10];
        //从键盘输入十个数据
        for(int i=0;i<10;i++){
            System.out.println("请输入第"+(i+1)+"个数据:");
            Scanner scanner = new Scanner(System.in);
            if(scanner.hasNextInt()){
                nums[i]=scanner.nextInt();
            }
        }
        //打印数组中的元素
        for (int i=0;i<10;i++){
            System.out.println(nums[i]);
        }
    }
}

Java内存

在声明时，数组并没有产生。在栈中会存放基本变量类型以及引用对象的变量(会存放这个引用在堆里面的具体地址)。在堆中会存放new的对象和数组(数组的本身就是对象)，可以被所有的线程共享，不会存放别的对象引用。

初始化

public class Demo2 {
    public static void main(String[] args) {
        //静态初始化：创建+赋值
        int[] array = {1,2,3,4,5};
       //动态初始化：包含默认初始化
        int[] array2;
        array2 = new int[20];
        array2[5]=1;
        System.out.println(array2[5]);
        System.out.println(array2[0]);//没赋值的默认为0
        Man[] men = {new Man(),new Man()};//引用类型数组，有Man类
    }
}

使用

public class Demo3 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3};
        //增强型for循环遍历，无法获取下标
        for (int array:arrays) {
            System.out.println(array);
        }
        printArrays(arrays);
        int[] reverse=reverseArrays(arrays);
        printArrays(reverse);
    }
    //打印数组
    public static void printArrays(int[] arrays){
        for(int i=0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }
    }
    //反转数组
    public static int[] reverseArrays(int[] arrays){// 返回值类型应该设置成数组类型 int[]
       int[] result = new int[arrays.length];
        for (int i=0,j=arrays.length-1;i< arrays.length;i++,j--){
            result[i]=arrays[j];
        }
        return result;
​
    }
}

注意点：

• 当数组作为返回值时，需要将返回值类型设置成数组类型

   

Arrays类

public class Demo4 {
    public static void main(String[] args) {
        int[] a={5,9,7,8,10,20};
        System.out.println(a);//[I@1b6d3586 哈希值
        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));//[5, 9, 7, 8, 10, 20]
        //数组排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //赋值  0~3之间的元素全为4  0包括3不包括
        Arrays.fill(a,0,3,4);
        System.out.println(Arrays.toString(a));
    }
}

其它方法可以去帮助文档查看

稀疏数组

当一个数组中大部分元素都是同一个数值时，用稀疏数组来保存该数组。

处理方式：

1. 记录数组的行列数和不同数值的个数

2. 把不同数值和所在的行列坐标放到另一个小规模的数组中

   public class Demo6 {
       public static void main(String[] args) {
           //定义一个棋盘 12x12    1表示白棋 2表示黑棋
           int[][] arrays1;
           arrays1 = new int[12][12];
           arrays1[2][2]=1;
           arrays1[3][3]=2;
           printChessBoard(arrays1);
           //记录不同值的个数
           int count=0;
           for(int i=0;i<arrays1.length;i++){
               for(int j=0;j<arrays1[i].length;j++){
                    if(arrays1[i][j]!=0)
                       count++;
               }
           }
           //声明一个稀疏数组
           int[][] arrays2;
           arrays2 = new int[count+1][3];
           arrays2[0][0]=12;
           arrays2[0][1]=12;
           arrays2[0][2]=count;
           //遍历棋盘找到不同值的行列值
           int sum=0;
           for(int i=0;i<arrays1.length;i++){
               for(int j=0;j<arrays1[i].length;j++){
                   if(arrays1[i][j]!=0){
                       sum++;
                   arrays2[sum][0]=i;
                   arrays2[sum][1]=j;
                   arrays2[sum][2]=arrays1[i][j];
                   }
               }
           }
           printArray(arrays2);
           int[][] result;
           result = recover(arrays2);
           printArray(result);
   ​
       }
       //打印棋盘
       public static void printChessBoard(int[][] array){
           for(int i=0;i<array.length;i++){
               for(int j=0;j<array[i].length;j++){
                   System.out.print(array[i][j]+" ");
               }
               System.out.println("\n");
           }
       }
       //输出稀疏数组
       public static void printArray(int[][] array){
           for(int i=0;i<array.length;i++){
               for(int j=0;j<array[i].length;j++){
                   System.out.print(array[i][j]+" ");
               }
               System.out.println("\n");
           }
       }
       //根据稀疏数组还原棋盘
       public static int[][] recover(int[][] array){
           //建立一个数组来存放棋盘
           int[][] result ;
           result = new int[array[0][0]][array[0][1]];
           //定义一个row变量，用来给与稀疏数组中所表示非零值的行列值相同位置赋非零值
           int row=1;
           //稀疏数组的具体行数无法得知，但是可以通过稀疏数组第一行第三个元素来判断，总行数就是不同元素个数再加1。
           //稀疏数组的最后一行的行数就是给棋盘数组赋值的外循环次数，列数同理。这样可以防止在给棋盘赋值是出现数组下标越界的问题
           for(int i=0;i<=array[array[0][2]][0];i++){
               for(int j=0;j<=array[array[0][2]][1];j++){
                   if(i==array[row][0]&&j==array[row][1]){
                       result[i][j]=array[row][2];
                       row++;
                   }else{
                       result[i][j]=0;
                   }
               }
           }
           return result;
       }
   }