第6章 数组、排序和查找

6.1  为什么需要数组 Array

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

6.2  数组的使用

        ​​​​​​​1）使用方式1:动态初始化

        定义：数据类型 数组名[] = new 数据类型[大小]     int arr[] = new[3];//创建数组，名为arr，存放3个int

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

        数组名[下标/索引/index]，使用arr数组的第三个数 arr[2]，下标从0开始

        2）使用方式2:动态初始化

        先声明数组：数据类型 数组名[] 或 数据类型[] 数组名   int a[]; int[] a;

        创建数组：数组名 = new 数据类型[大小]   a = new int[5];

        3）使用方式3:静态初始化

        数据类型 数组名[] = {元素值，元素值……}  int[] a = {1,2,3,4};

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

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

        2）元素可以是任何数据类型，但不能混用

        3）数组创建后，若没赋值，则默认 int/short/byte/long/ 0;float/double 0.0;chaf \u0000 boolean false;String null

        4）使用步骤：声明数组并开辟空间-->给数组各个元素赋值-->使用

        5）数组下标从0开始，且必须在指定范围内使用，否则报：下标越界异常

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

6.4  应用案例

//创建一个char类型的26个元素的数组，分别放置 A-Z。for循环访问所有元素并打印
public class Exercise {
    public static void main(String[] args){
        char[] arr = new char[26];
        arr[i] = (char)('A' + i);
      
        for(int I = 0; I < arr.length; I++){
            
            System.out.println(arr[i]);
        }
    }
}

6.5  数组赋值机制

        数组在默认情况下是引用传递，赋的值是地址，值会变化

6.6  数组拷贝

        数组arr1 拷贝到 arr2 ，arr2的变化不会影响arr1（创建arr2，遍历arr1，将arr1的值赋给arr2）

6.7  数组反转

        方式1 ：找规律--前后交换

public class Exercise{
    public static void main(String[] args){
        int arr = {1,2,3,4};
        int temp = 0;
        for(int I = 0; I < a.length/2; I++){
            temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[a.length-1-i] = temp;
            
        }
        for(int I = 0; I < arr.length; I++){
            System.our.println(arr[i]);
        }
        
    }
}

        方式2 ：逆序赋值法--创建新数组逆序赋值

public class Exercise{
    public static void main(String[] args){
        int[] arr = {1,2,3,4};
        int[] arr2 = new int[4];
        for(int I = arr.length - 1, j = 0; I >= 0; I--, j++){
            arr2[j] = arr[i];
        }
        arr = arr2;
        for(int I = 0; I < arr.length; I++){
            System.out.println(arr[i]);
        }
        
    }
}

6.8  数组添加/扩容

        实现动态的给数组添加元素效果，实现对数组的扩容

import java.util.Scanner;
public class Exercise {
    public static void main(String[] args){
        int[] arr = {1,2,3};
        do{
            int[] arr2 = new int[arr.length + 1];
            for(int I = 0; I < arr.length; I++){
                arr2[i] = arr[i];
                }
            Scanner myScanner = new Scanner;
            System.out.println("请输入需要添加的元素");
            int num = myScanner.nextInt();
            arr2[arr2.length - 1] = num;
            arr = arr2;
            for(int I = 0; I < arr.length; I++){
                System.out.println(arr[i]);
                }
            System.out.println("请问是否继续添加，y/n");
            char word = myScanner.next().charAt(0);
            if(word == 'n'){
                break;
                }

          }while(true);

    }
}

6.9  排序的介绍

        排序是将多个数据，依指定的顺序进行排列的过程。

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

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

6.10  冒泡排序法 Bubble Sorting

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

6.11  冒泡排序

         int[] a = {24,69,80,57,13];//5个元素，一共进行4轮排序（外层），每一轮里面又进行5-i次循环（内层），i表示第几轮排序；进行比较如果前面大于后面就交换

public class Exercise {
    public static void main(String[] args){
        int[] a = {24,69,80,57,13};
        int temp = 0;
        for(int I = 0; I < a.length - 1; I++){
            for(int j = 0; j < a.length - I -1; j++){
                    if(a[j] > a[j + 1]){
                            temp = a[j];
                            a[j] = a[j +1];
                            a[j + 1] = temp;
                }
            }
        for(int j = 0; j < a.length; j++){
            System.out.print(arr[j] + " ");
        }
        }
    }
}

​​​​​​​​​​​​​​6.12  查找

        常用顺序查找 SeqSearch 和 二分查找（算法讲解）

        记：字符串寻找  变量名.equals（数组名）；利用index = -1 来判断是否结束

import java.util.Scanner;
public class Exercise {
    public static void main(String[] args){
        String[] names = {张三，李四，王二，段利昌};
        System.out.println{"请输入您要查找的姓名"};
        Scanner myScanner = new Scanner(System.in);
        String inputName = Scanner.next();
        int index = -1;
        
        
        for(int I = 0; I < names.length; I++{
            if(inputName.equal(names[I])){
                System.out.println{"恭喜你找到了"};
                System.out.println{"名字为" + arr[i] + "下标为" + i};
                index = I;
                break;
            }
        }
        if(index == -1){
            System.out.println("没找到");
        }
    }
}

6.13  多维数组--二维数组

        可以理解成原来的一维数组的每个元素是一维数组，就构成二维数组  形式[][]

6.14  二维数组的使用

        二维数组的每个元素是一维数组，所以如果要得到每个一维数组的值需遍历两次。

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

    }
}

        使用方式1 ： 动态初始化

        类型[][] 数组名 = new 类型[大小][大小]； int[][] a = new int[3][4];

        使用方式2 ： 动态初始化

        先声明：类型[][]  数组名；在定义（开辟空间） 数组名 = new 类型[大小][大小];

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

        i = 0 : j = 1;  i = 1 : j = 2, 2; i = 2 : j = 3, 3, 3;

public class Exercise {
    public static void main(String[] args){
        int[][] a = new int[3][];
        for(int I = 0; I < a.length; I++){
            a[I] = new int[I + 1];
            for(int j = 0; j < a[I].length; I++){
                    a[I][j] = I + 1;
            }
        for(int I = 0; I < a.length; I++){
            for(int j = 0; j < a[I].length; j++){
                
                    System.out.print(a[I][j] + " ");
                }
        
            }
        }
    }
}

        使用方式4 ：静态初始化

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

6.15  二维数组应用案例

        杨辉三角

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

         声明方式：int[][] y    int[] y[]    int y[][]

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