数组

数组

• 相同类型数据的有序集合，数组也是对象，数组长度一旦确定不可更改。

• 每一个数据被称为一个数组元素，每个数组元素可以通过索引（下标，从0开始）访问

• 必须先声明数组变量，才能使用数组：数据类型 [] 数组名称 ；例：Int[] nums;

• Java用new操作符创建数组，例：nums=new int[10];

• 获取数组长度：例如：nums.length;

  int[] nums;//声明一个数组，名为nums，数据类型为int
          nums =new int[5];//创建一个数组，可以存放5个int型数字（声明数组是，数组并不存在，创建数时才存在）
          //以上两步亦可以写成：int[] nums=new int[5];
  

  数组特点：

  长度确定，一旦创建，长度大小不可以更改

  元素必须是相同类型

  类型可以为任何数据类型，包括基本类型，引用类型

  数组对象在堆中

  内存分析

  堆：

  存放new的对象和数组 例：nums =new int[5];

  可以被所有的线程共享，不会存放别的对象引用

  栈：

  存放基本变量类型（会包含这个基本类型的具体数值）

  引用对象的变量（存放这个引用在堆里面的具体地址）

  方法区：

  可以被所有的线程共享

  包含了所有的class和static变量

  数组初始化

  静态初始化：定义后不可在更改：int[] nums={1,2,3},创建数组并赋值

  动态初始化:（）包含默认初始化；int[] nums=new int[2]; nums[0]=1; nums[1]=2;

  默认初始化:未赋值，基本类型为0,0.0；string类型为null。

  数组使用

  for循环：

   //打印全部数组元素
          int[] nums={1,2,3,4,5};
          for (int i = 0; i < nums.length; i++) {
              System.out.print(nums[i]);
          }
   //打印数组元素
  public static void printArray(int[] nums) {
          for (int i = 0; i < nums.length; i++) {
              System.out.print(nums[i] + " ");
          }
      }
  

  //for循环  计算所有元素和
          int sum=0;
          int[] nums={1,2,3,4,5};
          for (int i = 0; i <nums.length ; i++) {
              sum=sum+nums[i];
          }
          System.out.println("和为："+sum);
  

   //for循环  查找最大元素
  int[] nums={1,2,3,4,5};
          int max=nums[0];
          for (int i = 0; i < nums.length; i++) {
              if (max<nums[i]){
                  max=nums[i];
              }
          }
          System.out.println("最大值为："+max);
  

  增强for循环：（array.for）for(int array:数组名）{}

   public static void main(String[] args) {
          int[] nums={1,2,3,4,6};
          for(int array:nums){
              System.out.print(array+"  ");
          }
      }
  

  数组作方法入参：

  //数组作方法入参：
  public static void main(String[] args) {
          int[] nums={1,2,3,4,6};
          printArray(nums);
      }
  //打印数组元素
      public static void printArray(int[] nums){
          for (int i = 0; i < nums.length; i++) {
              System.out.print(nums[i]+" ");
          }
      }
  

  数组作返回值：

  public static void main(String[] args) {
          int[] nums = {1, 2, 3, 4, 6};
          int[] reverse=reverse(nums);
          printArray(reverse);
      }
      public static int[] reverse(int[] nums) {
          int[] result = new int[nums.length];
          //进行反转的语句
          for (int i = 0,j =result.length-1;i< nums.length; i++,j--){
             result[j]=nums[i];
          }
          return result;
      }
      //打印数组元素
      public static void printArray(int[] nums) {
          for (int i = 0; i < nums.length; i++) {
              System.out.print(nums[i] + " ");
          }
      }
  

  二维数组：

  int a[][]=new int[2][5];//一个2行5列的数组
  

   public static void main(String[] args) {
          int[][]array={{1,2},{2,3},{5,6},{5,2}};
          System.out.println(array[0][1]);//第一行，第二列，输出结果为2
          System.out.println(array[1][1]);//第二行，第二列，输出结果为3
      }
  

  冒泡排序：

  import java.util.Arrays;
  public class Demo07 {
      //冒泡排序
      // 1.比较数组中，两个相邻的元素，如果第一个比第二个大，我们就交换他们的位置
      //2.每一次比较，都会产生一个最大或最小的数字
      //3.下一轮，则可以少一次排序
      //4.依次循环，直到结束
      public static void main(String[] args) {
          int[] arr = {8, 65, 1, 54, 10, 5,8};
          System.out.println(arr.length);
          int[] a = sort(arr);
          System.out.println(Arrays.toString(a));
      }
      public static int[] sort(int[] array) {
          //临时变量
          int temp = 0;
          //外层循环，判断我们这个要走多少次；
          for(int i = 0; i < array.length; i++) {
              boolean flag = false;
              //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
              for(int j = 0; j < array.length - 1 - i; j++) {
                  if(array[j] > array[j + 1]) { //如果第一个数大于第二个数，2>1，第二个数放前，第一个数放后。
                      temp = array[j];
                      array[j] = array[j + 1];
                      array[j + 1] = temp;
                      flag = true;
                  }
              }if(flag == false) {
                  break;
              }
          }
          return array;
      }
  }
  

  稀疏数组：

  //稀疏数组
  public class Demo08 {
      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+"\t");
              }
              System.out.println();
          }
          //转换为稀疏数组：第一行为行，列，有效值个数
          //1.获取有效值个数
          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);
          //2.创建一个稀疏数组的数组：第一行为行，列，有效值个数，共三列
          int[][] array2 = new int[sum + 1][3];
          /*sum+1,三行两个有效数字，
          第一列第一个数存横坐标，
          第二列第二个数存纵坐标，
          第三列第三个数存有效个数*/
          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 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("还原数组");
          //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];
              //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();
          }
      }
  }