Java学习笔记_第一阶段_1.7 数组、排序和查找

1.7 数组、排序和查找

数组

• 数组介绍

  数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。

  即：数组就是一组数据

  double[] 表示是double类型的数组

public class Array01 {
    public static void main(String[] args) {
        double[] hens = {3, 5, 1, 3.4, 2, 50};
        //遍历数组得到数组的所有元素的和，使用for
        //1.通过hens[下标]来访问数组的元素
        //	下标是从0开始编号的，比如第一个元素就是hens[0]，第二个元素就是hens[1]，以此类推
        //2.通过for就可以循环的访问数组的元素/值
        //3.使用一个变量totalWeight将各个元素累积
        //通过数组名.length得到数组得大小/长度
        double  totalWeight = 0;
        for (int i = 0;i < hens.length;i++) {
            System.out.println("第" + (i+1) + "个元素的值=" + hens[i]);
            totalWeight += hens[i];
        }
        System.out.println("总体重=" + totalWeight
                + " 平均体重=" + (totalWeight / hens.length));
    }
}

• 使用方式1-动态初始化

  1. 数组的定义

     数据类型 数组名[] = new 数据类型[大小];
     int a[] = new int[5];//创建了一个数组，名字a，存放5个int
     

     说明：这是定义数组的一种方法

  2. 数组的引用（使用/访问/获取数组元素）

     数组名[下标/索引]

     比如：你要是用a数组的第3个数 a[2]

  import java.util.Scanner;
  
  public class Array02 {
      public static void main(String[] args) {
          //循环输入5个成绩，保存到double数组，并输出
          double scores[] = new double[5];
          Scanner myScanner = new Scanner(System.in);
          //循环输入
          for (int i = 0;i < scores.length;i++) {
              System.out.println("请输入第" + (i+1) + "个元素的值");
              scores[i] = myScanner.nextDouble(); 
          }
          //输出，遍历数组
          System.out.println("==数组的元素/值得情况如下：==");
          for (int i = 0;i < scores.length;i++) {
              System.out.println("请输入第" + (i+1) + "个元素的值=" + scores[i]);
          }
      }
  }
  

• 使用方法2-动态初始化

  1. 先声明数组

     语法：

     数据类型 数组名[];
     也可以	
     数据类型[] 数组名;
     int a[];
     或者
     int[] a;
     

  2. 创建数组

     语法：

     数组名 = new 数据类似[大小];
     a = new int[10];
     

  例：

  public class Array02 {
      public static void main(String[] args) {
          double scores[];//声明数组，这时scores是null
          scores = new double[5];//分配内存空间，可以存放数据
      }
  }
  

• 使用方法3

  初始化数组

  语法：

  数据类型 数组名[] = {元素值,元素值,...};
  int a[] = {2,5,6,7,8,89,90,34,56};//如果知道数组有多少元素，具体值
  相当于
  int a[] = new int[9];
  a[0] = 2;
  a[1] = 5;
  a[2] = 6;
  a[3] = 7;
  a[4] = 8;
  a[5] = 89;
  a[6] = 90;
  a[7] = 34;
  a[8] = 56;
  

• 数组使用注意事项和细节

  1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理

  2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用

  3. 数组创建后，如果没有赋值，有默认值

     数据类型	默认值	数据类型	默认值	数据类型	默认值
     int	0	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. 数组下标必须在指定范围内使用，否则报：下标越界异常

     比如：int[] arr = new int[5];

     ​ 则有效下标为0-4

  7. 数组属引用类型，数组型数据是对象（object）

• 数组赋值的机制：

  1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响

     public class ArrayAssign {
         public static void main(String[] args) {
             int n1 = 2;
             int n2 = n1;
             System.out.println(n2);//2
             n1 = 3;
             System.out.println(n2);//2
         }
     }
     

  2. 数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值

     import java.util.Arrays;
     
     public class ArrayAssign {
         public static void main(String[] args) {
             int[] arr1 = {1,2,3};
             int[] arr2 = arr1;
             System.out.println(Arrays.toString(arr2));//[1, 2, 3]
             arr1[0] = 3;
             System.out.println(Arrays.toString(arr2));//[3, 2, 3]
         }
     }
     

例1：数组拷贝（内容复制）。

​ 将int[] arr1 = {10,20,30};拷贝到arr2数组，要求数据空间是独立的

public class ArrayCopy {
    public static void main(String[] args) {
        int[] arr1 = {10,20,30};
        //创建一个新的数组arr2，开辟新的数据空间
        //大小arr1.length
        int[] arr2 = new int[arr1.length];
        //遍历arr1，把每个元素拷贝到arr2对应的元素位置
        for (int i = 0;i < arr1.length;i++) {
            arr2[i] = arr1[i];
        }
        
        //修改arr2，不会对arr1有影响
        arr2[0] = 100;
        
        //输出arr1
        System.out.println("===arr1的元素===");
        for (int i = 0;i < arr1.length;i++) {
            System.out.println(arr1[i]);//10 20 30
        }
        
        //输出arr2
        System.out.println("===arr2的元素===");
        for (int i = 0;i < arr2.length;i++) {
            System.out.println(arr2[i]);//10 20 30
        }
    }
}

例2：数组反转。要求把数组的元素内容反转

​ arr {11,22,33,44,55,66} -> {66,55,44,33,22,11}

import java.util.Arrays;

public class ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77};
        int len = arr.length;
        for (int i = 0;i < (len / 2);i++) {
            int temp = arr[i];
            arr[i] = arr[len - 1 - i];
            arr[len - 1 - i] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

例3：数组添加。要求实现动态的给数组添加元素效果，实现对数组扩容

1. 原始数组使用静态分配 int[] arr =
2. 增加的元素，直接放在数组的最后 arr =
3. 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n

import java.util.Arrays;
import java.util.Scanner;

public class ArrayAdd01 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        Scanner myScanner = new Scanner(System.in);
        while (true){
            System.out.println("是否添加元素？y/n");
            char addSelect = myScanner.next().charAt(0);
            if (addSelect == 'y'){
                System.out.println("请输入添加的元素：");
                int newElement = myScanner.nextInt();
                int[] arrNew = new int[arr.length + 1];
                for (int i = 0;i < arr.length;i++)  {
                    arrNew[i] = arr[i];
                }
                arrNew[arrNew.length - 1] = newElement;
                arr = arrNew;
                System.out.println("添加成功，新数组为：" + Arrays.toString(arr));
            } else if (addSelect == 'n') {
                break;
            } else {
                System.out.println("请输入正确指令");
            }

        }
    }
}

排序

排序是将一组数据，依指定的顺序进行排列的过程

• 排序的分类：

  1. 内部排序

     指将需要处理的所有数据都加载到内部存储器中进行排序。包括交换式排序法、选择式排序法和插入式排序法

  2. 外部排序法

     数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括合并排序法和直接合并排序法

• 冒泡排序法

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

  例：将五个无序：24，69，80，57，13使用冒泡排序法将其排成一个从小到大的有序数列

  import java.util.Arrays;
  
  public class BubbleSort {
      public static void main(String[] args) {
          int[] nums = {24,69,80,57,13};
          int len = nums.length;
          for (int j = len;j > 1 ;j--) {
              for (int i = 0; i < j - 1; i++) {
                  if (nums[i] > nums[i + 1]) {
                      int temp = nums[i];
                      nums[i] = nums[i + 1];
                      nums[i + 1] = temp;
                  }
              }
          }
          System.out.println(Arrays.toString(nums));
      }
  }
  

查找

• 介绍

  在java中，我们常用的查找有两种：

  1. 顺序查找
  2. 二分查找

例1：有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：从键盘中任意输入一个名称，判断数列中是否包含此名称[顺序查找] 要求：如果找到了，就提示找到没并给出下标值

import java.util.Scanner;

public class SeqSearch {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        String[] set = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
        System.out.println("请输入名称：");
        String findName = myScanner.next();
        int index = -1;
        for (int i = 0;i < set.length;i++) {
            if (findName.equals(set[i])) {
                index = i;
                break;
            }
        }
        if (index != -1) {
            System.out.println("找到，下标为" + index);
        }else {
            System.out.println("没找到" + findName);
        }
    }
}

例2：请对一个有序数组进行二分查找{1,8,10,89,1000,1234}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示“没有这个数”

多维数组

多维数组只介绍二维数组

• 二维数组的应用场景

  比如开发一个五子棋游戏，棋盘就是需要二维数组来表示

例：用二维数组输出如下图形

\[\begin{matrix} 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 1 & 0 & 0 & 0\\ 0 & 2 & 0 & 3 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 \end{matrix} \]

public class TwoDimensionalArray {
    public static void main(String[] args) {
        int[][] arr = {{0,0,0,0,0,0},
                       {0,0,1,0,0,0},
                       {0,2,0,3,0,0},
                       {0,0,0,0,0,0}};
        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：动态初始化

  语法：类型[][] 数组名 = new 类型[大小][大小]

  比如：int a[][] = new int[2][3]

• 使用方式2：动态初始化

  1. 先声明：类型 数组名[][];
  2. 在定义（开辟空间）数组名 = new 类型[大小][大小]
  3. 赋值（有默认值，比如int类型的就是0）

• 使用方式3：动态初始化-列数不确定

  例：动态创建数组

  \[\begin{matrix} 1 & & \\ 2 & 2 & \\ 3 & 3 & 3 \end{matrix} \]

  public class TwoDimensionalArray03 {
      public static void main(String[] args) {
          int[][] arr = new int[3][];
          for (int i = 0;i < arr.length;i++) {//遍历arr每个一维数组
              //给每个一维数组开空间 new
              //如果没有给一维数组 new，那么arr[i]就是null
              arr[i] = new int[i + 1];
              //遍历一维数组，并给一维数组的每个元素赋值
              for (int j = 0;j < arr[i].length;j++) {
                  arr[i][j] = i + 1;//赋值
              }
          }
          System.out.println(Arrays.deepToString(arr));
      }
  }
  

• 使用方式4：静态初始化

  1. 定义 类型 数组名[][] = {{值1,值2,...},{值1,值2,...},{值1,值2,...}}
  2. 使用即可[固定方式访问]

例1：int arr[][] = {{4,6},{1,4,5,7},{-2}};遍历该二维数组，并得到和

public class TwoDimensionalArray05 {
    public static void main(String[] args) {
        int[][] arr = {{4,6},{1,4,5,7},{-2}};
        int sum = 0;
        for (int i = 0; i < arr.length;i++) {
            for (int j = 0;j < arr[i].length;j++) {
                sum += arr[i][j];
            }
        }
        System.out.println(sum);
    }
}

• 二维数组使用细节和注意事项

  1. 一维数组的声明方式有：

     int[] x 或者 int x[]

  2. 二维数组的声明方式有：

     int[][] y 或者 int[] y[] 或者 int y[][]

  3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同

     比如：map[][]是一个二维数组

     int map[][] = {{1,2},{3,4,5}}

     由map[0]是一个含有两个元素的一维数组，map[1]是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组