2021-8-26~28 数组（已经补充）

数组

• 格式

• 变量类型 变量名字 = 变量的值;
  

• int[]初始化都是0

• 实例

  public static void main(String[] args) {
          int[] nums;//声明一个数组
          nums = new int[10];//创建了一个数组
          nums[0]=1;
          nums[1]=2;
          nums[2]=3;
          nums[3]=4;
          nums[4]=5;
          nums[5]=6;
          nums[6]=7;
          nums[7]=8;
          nums[8]=9;
          nums[9]=10;
          int sum = 0;
          for (int x = 0; x < nums.length; x++) {
              sum=nums[x]+sum;
          }
          System.out.println(sum);//数组总和：55
  
  
         /*
         //懒人快速生成      nums[0]=1;赋值
         for (int i = 0; i < 10; i++) {
              System.out.println("nums["+i+"]="+(i+1)+";");
          }*/
  
      }
  

• 动态，静态数组

        //动态数组  包含默认初始化
          int [] sz1 = new int[10];
          sz1[0]=0;
          sz1[1]=1;
          System.out.println(sz1[1]);//
  
          //静态数组 创建+赋值
          int [] sz2 ={1,2,3,4,11,45,11,15123};
          System.out.println(sz2[5]);//45
  

• 数组操作

  public static void main(String[] args) {
          int[] a = {1,2,3,4,5};
          int[] result =数组反转(a);
          遍历2(result);
  
      }
      //打印数组
      public static void 遍历1(int[] arrys){
          for (int i = 0; i < arrys.length; i++) {
              System.out.println(arrys[i]);
          }
      }
  
      public static void 遍历2(int[] arrys){
          for (int i :arrys) {
              System.out.println(i);
          }
      }
  
      public static int[] 数组反转(int[] a){
          int[] results = new int[a.length];
  
          //反转操作
          for (int i = 0,j=results.length-1; i < a.length; i++,j--) {
              results[j] = a[i];
          }
          return results;
      }
  

• 多维数组

   public static void main(String[] args) {
  
          //二维数组
          int[][] arr = {{1,2},{2,3},{3,4},{4,5}};
          System.out.println(arr[1]);//输出对象值[I@14ae5a5
          遍历2(arr[0]);//输出  1 2
          System.out.println("\n=========和上面一样效果===========");
          System.out.print(arr[0][0]);
          System.out.println(arr[0][1]);//标准输出
          System.out.println("\n====================");
          遍历2(arr[1]);//2 3
          System.out.println("\n====================");
          遍历(arr);
  
  
      }
      //多维遍历
      public static void 遍历(int[][] arrys){
          for (int i = 0; i < arrys.length; i++) {//先遍历出二维每个对象
              for (int j = 0; j < arrys[i].length; j++) {//再次遍历单个一维值
                  System.out.println(arrys[i][j]);
              }
          }
      }
      
      //一维遍历
      public static void 遍历2(int[] arrys){
          for (int i :arrys) {
              System.out.print(i+" ");
          }
      }
  

• 数组测试(个人练习)

    public static void main(String[] args) {
          //自己感受数组的魅力
          //一维数组
          int[] ints1 = new int[5];
          System.out.println("===============可视化显示数组1============");
          System.out.println("数组总长度"+ints1.length);
  
          //==================一维赋值===========
          ints1[1]=666;
          ints1[3]=654613;
          //赋值后显示必须放在最后一位（不然得到的就是原来的内容）
          System.out.println(Arrays.toString(ints1));//可视化显示数组
  
          //二维数组
          //第一个是序号数，后面是序号里的结果
          int[][] ints2 = new int[3][2];
          ints2[2][0]=888;
          ints2[2][1]=666;
          System.out.println("===============可视化显示数组2============");
          System.out.println("数组总长度"+ints2.length);
  
          // ints2[2][2]=333;
          System.out.println("测试一下"+Arrays.toString(ints2[2]));
          for (int i = 0; i < ints2.length; i++) {
  
              //输出数组
              System.out.println("==========单个=========");
              System.out.println(Arrays.toString(ints2[i]));
              //输出每个数组的长度
              System.out.println(ints2[i].length);
              for (int j = 0; j < ints2[i].length; j++) {
                  System.out.println(ints2[i][j]);//遍历每个数组内容
              }
          }
  
          System.out.println("===============可视化显示数组3============");
  
  
          //试试三维
          int[][][] ints4=new int[3][2][3];
          ints4[0][0][1]=888;//赋值操作
          System.out.println(ints4.length);
          for (int i = 0; i < ints4.length; i++) {
  
  
              for (int j = 0; j < ints4.length-1; j++) {
                  System.out.print(Arrays.toString(ints4[i][j]));
              }
  
          }
          System.out.println("\n" +
                  "空格\t" +
                  ""+ints4[0][0][1]);
          
      }
  

• 稀疏数组

• 有许多相同的数字列表

• 把复杂的列表简单化

  
          /**稀疏数组
           * 格式
           * 数组个数 数组元素个数 有效值个数
           * 行        列        有效值1（这里其实是个定位坐标的)
           * ............
           */
          //==================================转化稀疏数组学习=============
          //看看大数组
          int[][] ints3 = new int[10][10];
  
          //赋值开始
          ints3[0][2] = 100;
          ints3[0][3] = 8800;
          ints3[1][4] = 999;
  
          //输出所有值
          for (int[] ints1 : ints3) {
              for (int i : ints1) {
                  System.out.print("\t"+i);
              }
              System.out.println();
          }
  
  //====================另一种输出数组====================
         /* //外部得到对像
          for (int i = 0; i < ints3.length; i++) {
              //换行操作
              System.out.println();
              //内部得到元素
              for (int j = 0; j < ints3.length; j++) {
                  //输出元素
                  System.out.print(ints3[i][j]);
                  //添加空格
                  System.out.print("\t");
              }
  
          }*/
          System.out.println("\n" +
                  "============数组转化稀疏数组===============");
  
  
          //统计数组总数
          int sum1 = 0;
          //获取单个数组个数
          int sum2 = 0;
          //统计有效数字
          int count = 0;
          System.out.println("统计数组总数" + ints3.length);
          //这里-1 是因为从零开始哦！！！！！
          System.out.println("获取单个数组个数" + ints3[ints3.length - 1].length);
  
          //计算有效值
          //遍历 非零数字就记录一次
          for (int i = 0; i < ints3.length; i++) {
              for (int j = 0; j < ints3.length; j++) {
                  if (ints3[i][j] != 0) {
                      //计数
                      count++;
                  }
              }
          }
          System.out.println("有效值"+count);
  
          //赋值
          sum1 = ints3.length;
          sum2 = ints3[ints3.length - 1].length;
  
  
          //创建稀疏数组
          //留出一行统计 10 10 3
          int[][] ints = new int[count + 1][3];
          //统计值
          ints[0][0] = sum1;
          ints[0][1] = sum2;
          ints[0][2] = count;
  
          //有效值计数(用于生成统计列表)
          int ccc = 0;
          for (int i = 0; i < ints3.length; i++) {
              for (int j = 0; j < ints3.length; j++) {
                  if (ints3[i][j] != 0) {
                      ccc++;
                      ints[ccc][0] = i;
                      ints[ccc][1] = j;
                      ints[ccc][2] = ints3[i][j];
  
                  }
  
              }
          }
  
  
          //输出稀疏数组
          for (int i = 0; i < ints.length; i++) {
          System.out.println(ints[i][0] + "\t" +
                      ints[i][1] + "\t" +
                      ints[i][2] + "\t");
  
  
          }
  
  
          //还原为数组
          int[][] ints5 = new int[ints[0][0]][ints[0][1]];
          //从1开始 因为0是统计表
          for (int i = 1; i < ints.length; i++) {
              ints5[ints[i][0]][ints[i][1]] = ints[i][2];
  
  
          }
  
  //读取
          for (int[] ints1 : ints5) {
              for (int i : ints1) {
                  System.out.print("\t"+i);
              }
              System.out.println();
          }
  

小科普

• 栈:创建对象名
• 堆:创建内容