Java学习笔记--数组

Java数组

创建一个数组

Java使用new操作符来创建

数组初始化

dataType[] arrayRefVar = new dataType[arraySize]
    
    public class ArrayDemo02
{
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};  // 静态初始化：创建+赋值

        int[] b = new int[10]; // 动态初始化，包含默认初始化0
        System.out.println(b[0]);
    }
}

public class ArrayDemo {
    public static void main(String[] args) {
        int[] nums;  //首选
        int nums1[];
                //1、声明数组的两种方法
        nums = new int[10];//2、创建一个数组
        for (int i = 0; i < 10; i++) {
            nums[i] = i;                 // 数组赋值以及输出，下标从0开始
            System.out.println(nums[i]);
        }
        int sum = 0;
        for (int i = 0; i < nums.length; i++) { //length获取数组长度
            sum += nums[i]; // 下标索引
        }
    }
}

数组内存分析

数组的基本特点

数组范围：0 到 length-1

数组使用

• for-each循环

• 最为方法参数

• 作为返回值

  public class ArrayDemo03 {
      public static void main(String[] args) {
          int[] nums = {1,2,3,4,5};
          // 打印数组
          for (int i = 0; i < nums.length; i++) {
              System.out.println(nums[i]);
          }
          int sum=0;
          // 求和
          for (int k = 0; k < nums.length; k++) {
              sum  +=  nums[k];
  
          }
          // 求最大
          int max = 0;
          for ( int i = 0; i <nums.length ; i++) {
              if(nums[i]>max)
                  max = nums[i];
          }
      }
  }
  

  public class ArrayDemo04 {
      public static void main(String[] args) {
          int[] array = new int[10];
          array = new int[]{1, 2, 3, 3, 4, 4, 5, 5, 6, 10};
          // 增强for循环遍历数组 (array.for + 回车直接生成)
          for (int i : array) {
              System.out.println(i);
          }
          int[] reverse=reverse(array);
          printArray(array);
          System.out.println();
          printArray(reverse);
      }
  
          // 数组作为方法参数
      public static void printArray(int[] array){
          for (int i : array) {
              System.out.print(i+"\t");
          }
      }
          // 数组作为返回值
      public static int[] reverse(int[] array){
          int[] result = new int[array.length];
          for (int i = 0; i < array.length; i++) {
              result[i] = array[array.length-1-i];
          }
          return result;
      }
  }
  

  多维数组

  多维数组定义和操作

  public class ArrayDemo05 {
      public static void main(String[] args) {
          int[][] array = {{1,2},{2,3},{3,5}};
          System.out.println(array[1][0]);
          System.out.println(array.length); // 外层长度
          System.out.println(array[1].length); // 内层长度
          printTwoDimensionalArray(array);
      }
      // 遍历二维数组
      public static void printTwoDimensionalArray(int[][] array){
          for (int i = 0; i < array.length; i++) {
              for(int j =0;j < array[i].length;j++){
                  System.out.print(array[i][j]+"\t");
              }
          }
      }
  }
  

  Arrays类

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a ={1, 3,4,22,2,12213,234,};
        System.out.println(Arrays.toString(a));// 等价于printArray()
        //printArray(a);
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4,0);
        System.out.print(Arrays.toString(a));
    }
    public static void printArray(int[] a) {
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            if (i == a.length - 1) {
                System.out.print(a[i] + "]");
                return;
            }
            System.out.print(a[i] + ", ");
        }
    }
}

冒泡排序

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a ={1,2,4,22,333,5,44,1,0};
        bubbleSort(a);
        System.out.println(Arrays.toString(a));
    }
    public static void bubbleSort(int[] a){
        for (int i = 0; i < a.length-1; i++) { // 外层循环，判断排序次数
            for(int j=0;j < a.length-1-i;j++) { // 内层循环，比较并交换相邻两个数
                int temp=0;
                if (a[j] < a[j+1]){
                    temp =  a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                }
            }
        }
    }
}

稀疏数组

public class ArrayDemo08 {
    public static void main(String[] args) {
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        a[1][7] = 10;
        a[10][10] = 7;
        print2DArray(a);
        int[][] sparseArray = sparseArray(a);
        System.out.println("===============================");
        print2DArray(sparseArray);
        int[][] b = resetArray(sparseArray);
        System.out.println("===============================");
        print2DArray(b);
    }

    public static void print2DArray(int[][] a){ // 打印二维数组
            for (int[] ints : a) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }
                System.out.println();
            }
    }

    //生成稀疏数组
    public static int[][] sparseArray(int[][] a){
        int validNumSum = 0; // 有效数字数量
        int lines=0;  // 二位数组的行数
        for (int i = 0; i < a.length; i++) {
            for(int j=0;j<a[i].length;j++){    // 遍历二维数组获取有效数字的数量
                lines =a[i].length; // 获取原数组的行数
                if(a[i][j]!=0)
                    validNumSum++;
            }
        }
        int [][] result = new int[validNumSum+1][3]; // 创建一个有有效数子加一行的3列的稀疏数组
        result[0][0] = a.length;
        result[0][1] = lines;      // 将原数组的行数列数以及有效数字的数目写入到稀疏数组第一行
        result[0][2] = validNumSum;
        int count = 0; // 用于储存有效数字的个数
        for (int i = 0; i < a.length; i++) {
            for(int j=0;j<a[i].length;j++){
                if(a[i][j]!=0){
                    count++;
                    result[count][0] = i;
                    result[count][1] = j;     // 遍历原二维数组将原数组中的有效数字行数、列数、值储存在稀疏数组的count行中
                    result[count][2] = a[i][j];
                }
            }
        }
        return result;
    }
    public static int[][] resetArray(int[][] sparseArray ){

        int columns = sparseArray[0][1];
        int rows = sparseArray[0][0];   // 获取原数组的行数和列数
        int [][] result = new int[rows][columns]; //  产生一个行列数与原数组相同的空数组
        for (int i = 1; i < sparseArray.length; i++) {
                result[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2]; //遍历稀疏数组的每行，将有效数字还原到原来的位置
            }
        return result;
        }
    }