Java基础笔记（第五章 数组）

5 数组、排序、查找

5.1 数组⭐️

5.1.1 使用方式

1-动态初始化

• 语法：

  数据类型 数组名 [] = new 数据类型[大小]

  int[] a = new int[5];//创建一个数字名字为a，存放了五个int
  

• 数组的引用：

  数组名[下标/索引]，下标从0开始

2-动态初始化

• 先声明数组：

  数据类型 数组名[]；也可以 数据类型[] 数组名；

  例：int a[];或者int[] a;

• 再创建数组：

  数组名 = new 数据类型[大小];

  例：a = new int [10];

3-静态初始化

• 语法：

  数据类型 数组名[] = {元素值，元素值…}

• 注意事项和细节

1. 数组是多个相同类型数据的组合
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
3. 数组创建后如果没有赋值，有默认值:
   int0,short 0, byte 0, long 0, float 0.0,double 0.0
   char \u0000,boolean false, String null
4. 使用数组的步骤 (1)声明数组并开辟空间(2)给数组各个元素赋值(3)使用数组
5. 数组的下标是从0开始的
6. 数组下标必须在指定范围内使用，否则报：下标越界异常
7. 数组属引用类型，数组型数据是对象(object)

5.1.2 数组赋值机制

• 数组在默认情況下是引用传递，赋的值是地址

  int arr1 = {1,2,3};
  int arr2 = arr1;
  arr2[0] = 10;  //arr1[0]=10
  

  

5.1.3 数组拷贝

• int[] arr1 = {1,2,3};
  int[] arr2 = new int[arr1.length];
  for (int i = 0;i < arr1.length;i++){
    arr2[i] = arr1[i];
  }
  

  

5.1.4 数组反转

• 规律反转

  public class ArrayReverse01 {
      public static void main(String[] args) {
          int[] arr = {11,22,33,44,55,66};
          int temp = 0,len = arr.length;
          for (int i = 0;i < len/2;i++){
              temp = arr[len-1-i];
              arr[len-1-i] = arr[i];
              arr[i] = temp;
          }
          for(int i = 0;i < arr.length;i++){
              System.out.print(arr[i]+"\t");
          }
      }
  }
  

• 逆序赋值

  public class ArrayReverse02 {
      public static void main(String[] args) {
          int[] arr1 = {11,22,33,44,55,66};
          int[] arr2 = new int[arr1.length];
          int len = arr1.length;
          for(int i = len-1;i >= 0;i--){
              arr2[len-i-1] = arr1[i];
          }
          arr1 = arr2;//arr1指向arr2数据空间，此时arr原来的数据空间没有变量引用，会被当作垃圾销毁
          for(int i = 0;i < arr1.length;i++) {
              System.out.print(arr1[i] + "\t");
          }
      }
  }
  

5.1.6 数组添加

• 静态添加

  public class ArrayAdd01 {
      public static void main(String[] args) {
          int[] arr = {1,2,3};
          int[] arr2 = new int[arr.length+1];
          for (int i = 0;i < arr.length;i++){
              arr2[i] = arr[i];
          }
          arr2[arr2.length-1] = 4;
          arr = arr2;
          for(int i = 0;i < arr.length;i++) {
              System.out.print(arr[i] + "\t");
          }
      }
  }
  

• 动态添加

  import java.util.Scanner;
  
  public class ArrayAdd02 {
      public static void main(String[] args) {
          Scanner myScanner = new Scanner(System.in);
          double[] arr = {1,2,3};
          do{
              double[] arr2 = new double[arr.length+1];
              for (int i = 0;i < arr.length;i++) {
                  arr2[i] = arr[i];
              }
              System.out.println("请输入添加的元素");
              double addNum = myScanner.nextInt();
              arr2[arr2.length-1] = addNum;
              arr = arr2;
              for(int i = 0;i < arr.length;i++) {
                  System.out.print(arr[i] + "\t");
              }
              System.out.println("是否继续添加 y/n");
              char key = myScanner.next().charAt(0);
              if(key == 'n'){
                  break;
              }
          }while (true);
      }
  }
  
  

• 动态删减

  import java.util.Scanner;
  
  public class ArrayReduce01 {
      public static void main(String[] args) {
          Scanner myScanner = new Scanner(System.in);
          int[] arr = {1,2,3,4,5};
          while (true){
              int[] arr2 = new int[arr.length-1];
              for (int i = 0;i < arr2.length;i++){
                  arr2[i] = arr[i];
              }
              arr = arr2;
              for(int i = 0;i < arr.length;i++) {
                  System.out.print(arr[i] + "\t");
              }
              System.out.println("请输入是否删除最后一个数字 yes/no");
              char key = myScanner.next().charAt(0);
              if(key == 'n'){
                  break;
              }
          }
      }
  }
  

5.2 二维数组

• 基本介绍：

  一维数组构成了二维数组

• 二维数组遍历

  public class TwoDimensionalArrary {
      public static void main(String[] args) {
          int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
          for (int i = 0;i < arr.length;i++){
              for (int j = 0;j < arr[i].length;j++){
                  System.out.print(arr[i][j]+"\t");
              }System.out.println();
          }
      }
  }
  

• 二维数组内存图

  

• 注意事项和细节：

  1. 二维数组元素个数：arr.length
  2. 取出一维元素需要遍历两次
  3. 访问第(i+1)个一维数组的第(j+1)个值 arr [i] [j]

5.2.1 使用方式

1-动态初始化

• 语法：

  类型 数组名[] [] = new 类型 [大小] [大小]

  public class TwoDimensionalArrary02 {
      public static void main(String[] args) {
          int arr[][] = new int[2][3];
          arr[1][1] = 8;
          for(int i = 0;i < arr.length;i++){
              for(int j = 0;j < arr[i].length;j++){
                  System.out.print(arr[i][j]+" ");
              }
              System.out.println();
          }
      }
  }
  

2-动态初始化2

• 先声明数组：

  数据类型 数组名[] [];

  例：int a[] [];

• 再创建数组：

  数组名 = new 数据类型[大小] [大小];

  例：a = new int [2] [3];

3-动态初始化-列数不确定

• public class TwoDimensionalArrary03 {
      public static void main(String[] args) {
          int[][] arr = new int[3][];//创建二维数组，只确定一维数组的个数，一维数组开没有开数据空间
          for(int i = 0;i < arr.length;i++){
              arr[i] = new int[i+1];//给一维数组开空间
              for (int j = 0; j < arr[i].length;j++){
                  arr[i][j] = i+1;//给每一个一维数组元素赋值
              }
          }
          for(int i = 0;i < arr.length;i++){
              for (int j = 0; j < arr[i].length;j++){
                  System.out.print(arr[i][j]+" ");
              }
              System.out.println(" ");
          }
      }
  }
  //输出结果：1 22 333
  

4-静态初始化

• 语法：

  类型 数组名[] [] = {{值1,值2},{值1,值2},{值1,值2}}

• 注意事项和细节：

1. 一维数组声明方式：int [] x 或者 int x []
2. 二维数组声明方式：int [] [] y 或者 int[] y [] 或者 int y [] []
3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同

5.3 排序(基础)

5.3.1 排序分类

1. 想需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法)
2. 数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)

5.3.2 冒泡排序

• 定义：

  冒泡排序 (Bubble Sorting)的基本思想是：通过对待排序序列从后向前(从下标较大的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒

• 冒泡排序特点

  1. 一共有n个元素
  2. 一共进行了n-1轮排序，可以看成是外层循
  3. 每1轮排序可以确定一个数的位置，比如第1轮排序确定最大数,第2轮排序，确定第2大的数位置，依次类推
  4. 当进行比较时，如果前面的数大于后面的数，就交换

• public class BubbleSort {
      public static void main(String[] args) {
          int temp = 0;
          int[] arr = {24,69,80,57,13,321,34,56,7,-4};
          for (int i = 0;i < arr.length-1;i++){
              for(int j = 0;j < arr.length-1-i;j++){
                  if(arr[j] > arr[j + 1]){
                      temp = arr[j];
                      arr[j] = arr[j+1];
                      arr[j+1] = temp;
                  }
              }
          }
          System.out.println("==排序结果==");
          for(int i = 0;i < arr.length;i++) {
              System.out.print(arr[i] + "\t");
          }
      }
  }
  

5.4 查找(基础)

5.4.1 顺序查找

• import java.util.Scanner;
  
  public class SeqSearch {
      public static void main(String[] args) {
          String[] names = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
          Scanner myScanner = new Scanner(System.in);
          System.out.println("请输入名字");
          String findName = myScanner.next();
  
          int index = -1;
          for(int i = 0;i < names.length;i++){
              if(findName.equals(names[i])){
                  System.out.println("恭喜找到"+findName);
                  System.out.println("序号为"+(i+1));
                  index = 1;
                  break;
              }
          }
          if(index == -1){
              System.out.println("sorry,没有找到"+findName);
          }
      }
  }
  

5.4.2 二分查找