2022/4/21 JavaDay13

多维数组

数组嵌套数组

 package com.sundada.array;
 ​
 public class ArrayDemo05 {
     public static void main(String[] args) {
         int[][]array={{1,2},{2,3},{3,4},{4,5}};
         //[4][2]
         /*1,2
         *2,3
         *3,4
         * 4,5
         * */
 ​
         for (int i = 0; i < array.length; i++) {
             for (int j = 0; j < array[i].length; j++) {
                 System.out.println(array[i][j]);
 ​
             }
 ​
         }
 //        printArray(array[0]);
 //        System.out.println(array[0][1]);
     }
 //    public static void printArray(int[]arrays){
 //        for (int i = 0; i < arrays.length; i++) {
 //            System.out.println(arrays[i]);
 //        }
 //    }
 ​
 }

Arrays类

 package com.sundada.array;
 ​
 import java.util.Arrays;
 ​
 public class ArrayDemo06 {
     public static void main(String[] args) {
         int[]a={1,2,3,4,999,123,324,534,6,34};
         System.out.println(a);//hashcode-[I@1b6d3586
 ​
         Arrays.sort(a);//升序
         System.out.println(Arrays.toString(a)); //打印数组
         Arrays.fill(a,2,4,0);//数组填充
         System.out.println(Arrays.toString(a));
 ​
        //printArray(a);
 ​
     }
     public static void printArray(int[]a)
     {
         for (int i = 0; i < a.length; i++) {
             if ( i==0 ) System.out.print("[");
 ​
             else if ( i==a.length-1 ) System.out.println(a[i]+"]");
             else System.out.print(a[i]+",");
         }
     }
 }

冒泡排序

 package com.sundada.array;
 ​
 import java.util.Arrays;
 ​
 public class ArrayDemo07 {
 ​
     public static void main(String[] args) {
          int[]a={1,2,3,4,5,6,7};
          int[]sort=sort(a);
         System.out.println(Arrays.toString(sort));
     }
     //冒泡排序
     public static int[] sort(int[]array){
         int temp=0;
         //外层循环判断次数
         for (int i = 0; i < array.length-1; i++) {
             for (int j = 0; j < array.length-1; j++) {
                 if ( array[j+1]<array[j] ){
                     temp=array[j];
                     array[j]=array[j+1];
                     array[j+1]=temp;
                 }
 ​
             }
         }
         return array;
     }
 }

优化

 package com.sundada.array;
 ​
 import java.util.Arrays;
 ​
 public class ArrayDemo07 {
 ​
     public static void main(String[] args) {
          int[]a={1,2,3,4,5,6,7};
          int[]sort=sort(a);
         System.out.println(Arrays.toString(sort));
     }
     //冒泡排序
     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; 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;
     }
 }

稀疏数组

行 列 值

 package com.sundada.array;
 ​
 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();
 ​
         }
         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[][]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[] ints : array2) {
             for (int anInt : ints) {
                 System.out.print(anInt+"\t");
 ​
             }
             System.out.println();
 ​
         }
         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];
         }
         System.out.println("输出还原的数组");
         for (int[] ints : array3) {
             for (int anInt : ints) {
                 System.out.print(anInt+"\t");
 ​
             }
             System.out.println();
 ​
         }
 ​
     }
 }