数组

1.数组的创建

• 声明：

   数据类型[] 变量名   //方法1
   数据类型  变量名[]  //方法2

   

• 创建：

  • 动态初始化

   变量名 = new 数据类型[数组大小]
   数据类型[] 变量名 = new 数据类型[数据大小]   //数组声明加创建

  • 静态初始化

   int 变量名[] = {数值，数值，...}  //数组创建加赋值

   

• 赋值：

   变量名[元素下标] = 数值

冒泡排序

定义：用于一维数组的排序，可使数组中数字按一定顺序排列

 package Array;
 ?
 import java.lang.reflect.Array;
 import java.util.Arrays;
 ?
 public class Main2 {
     public static void main(String[] args) {
         int array[] ={10,5,6,45,7,8};
         int a = 0;
         for(int i = 0;i<array.length-1;i++){
             for (int j = 0;j<array.length-1-i;j++){
                 if(array[j+1]<array[j]){
                     a = array[j+1];
                     array[j+1] = array[j];
                     array[j] = a;
                 }
             }
         }
         System.out.println(Arrays.toString(array));
     }
 }

稀疏数组

定义：稀疏数组用于记录数组中的有效数字并存储，可以使用稀疏数组还原数组

 import java.util.Scanner;
 ?
 public class main {
     public static void main(String[] args) {
         int [][] array1= new int[11][11];                 //新建一个二维数组
         array1[2][1] = 1;
         array1[2][3] = 1;
         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 <array1.length ; i++) {
             for (int j = 0; j < array1[i].length; j++) {
                 if(array1[i][j]!=0){
                     sum++;
                 }
             }
         }
         System.out.println("有效数字的个数为："+sum);
         System.out.println("稀疏数组为：");
         int [][] array2 = new int[sum+1][3];                        //建立一个稀疏数组
         array2 [0][0] = array1.length;                              //第零行储存数组行列长度与有效数字数
         array2 [0][1] = array1.length;
         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];
                 }
             }
         }
         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]];       //还原数组
         for (int i = 1; i < array2.length; i++) {
             array3[array2[i][0]][array2[i][1]] = array2[i][2];
         }
         for (int[] ints : array3) {                                 //打印还原数组
             for (int anInt : ints) {
                 System.out.print(anInt+"\t");
             }
             System.out.println(" ");
         }
     }
 }
 ?