java数组4

Posted 2021-06-14 Wltong

数组

• 首先必须声明一个数组变量，才能在程序中使用数组

  int[]  array;

• 使用new操作符来创建一个数组

  array = new int[10];

• 数组的元素是通过索引访问的，数组索引从0开始

• 获取数组长度

  array.length

• 声明和创建数组可以写到一起

  int[]  array = new int[10];  //10代表初始化了一个arraySize
  或
  int[] array = {1,2,3,4,5,6,7,8,9,10}

  案例
  public class Demo01 {
      public static void main(String[] args) {
          int[] a = new int[5]; //声明一个数组，创建一个数组
          //给数组赋值
          a[0] = 1;
          a[1] = 2;
          a[2] = 3;
          a[3] = 4;
          a[4] = 5;
          // System.out.println(a[0]);
          //计算所有元素的和
          int sum = 0;
          for (int i = 0; i < a.length; i++) {
              sum = sum + a[i];
          }
          System.out.println("所有元素的和是 "+sum);
      }
  }

内存分析

数组的使用

• 普通的for循环

• For-Each循环

• 数组作方法入参

• 数组作返回值

  案例
  public class Demo04 {
      public static void main(String[] args) {
            int[] arrays = {1,2,3,4,5};
  //        //For-Each循环
  //        for (int array : arrays) {    //arrays是一个数组    前边int array是数组中得值
  //            System.out.print(array+" ");
  //        }
  //           printArray(arrays);
            int[] reverse = reverse(arrays);  //调用完方法reverse(arrays)这个方法，返回给reverse数组
              printArray(reverse);            //输出反转后得数组
      }
      //打印数组元素
      public static   void    printArray(int[] arrays){
          for (int i = 0; i < arrays.length; i++) {
              System.out.print(arrays[i]+" ");
          }
      }
      //数组作返回值
      public static   int[]  reverse(int[] arrays){
          int[] result = new int[arrays.length];
          //反转
          for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
              result[j] = arrays[i];
          }
          return result;
      }
  }

多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

• 二维数组

  int a[][] = new int[2][5];

  解析：二维数组a可以看成一个两行五列的数组

  案例
  public class Demo05 {
      //二维数组
      public static void main(String[] args) {
          int[][] array = {{1,2,3,4,5,6,7},{2,3,4},{3,4,5},{4,5,6}};
          for (int i = 0; i < array.length; i++) {
              for (int j = 0; j < array[i].length; j++) {
                  System.out.println(array[i][j]);
  ​
              }
              System.out.println("====================");
              //System.out.println(array[2][0]);
          }
         // System.out.println(array[0][1]);
      }
  }

冒泡排序

• 冒泡排序思路

1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我就交换他们的位置

2. 每一次比较，都会产生出一个最大，或者最小的数字

3. 下一轮则可以少一次排序

4. 一次循环，直到结束

public class Demo06 {
    public static void main(String[] args) {
        int[] a = {12,21,11,15,35,53,54,431,1,2,5};
        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 a = false;   //通过这个flag 标识位减少没有意义得比较
            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]){
                    temp  = array[j];
                    array[j] = array[j+1];
                    array[j+1]= temp;
                    a = true;
                }
            }
            if (a==false){
                break;
            }
        }
        return  array;
    }
}

稀疏数组

• 案例编写五子棋游戏中，有存盘退出和续上盘的功能

 

public class Demo08 {
    public static void main(String[] args) {
       //创建一个二维数组 11*11 0：没有棋子  1：黑棋  2：白棋
         int[][] arrary1 = new int[11][11];
         arrary1[1][2] = 1;
         arrary1[2][3] = 2;
        System.out.println("遍历数组");
        for (int[] ints : arrary1) {
            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 (arrary1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数是"+sum);
        //创建一个稀疏数组
        int[][] arrary2 = new int[sum+1][3];
        arrary2[0][0] = 11;
        arrary2[0][1] = 11;
        arrary2[0][2] = sum;
        int count = 0;
        //遍历二维数组，将非零的值，存放稀疏数组中
        for (int i = 0; i < arrary1.length; i++) {
            for (int j = 0; j < arrary1[i].length; j++) {
                if (arrary1[i][j]!=0){
                    count++;
                    arrary2[count][0]=i;
                    arrary2[count][1]=j;
                    arrary2[count][2]=arrary1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < arrary2.length; i++) {
            System.out.println(arrary2[i][0]+"\\t"
            +arrary2[i][1]+"\\t"
            +arrary2[i][2]);
        }
        System.out.println("==================");
        System.out.println("还原");
        //1、读取稀疏数组
        int[][] arrary3 = new int[arrary2[0][0]][arrary2[0][1]];
        //2、给其中的元素还原他的值
        for (int i = 1; i < arrary2.length; i++) {
            arrary3[arrary2[i][0]][arrary2[i][1]] = arrary2[i][2];
        }
        //打印数组
        System.out.println("还原稀疏数组");
        for (int[] ints : arrary3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\\t");
            }
            System.out.println();
        }
    }
}