06 数组、排序和查找

数组、排序和查找

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

数组的使用

使用方式1

数组的定义：

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

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

数组名（下标/索引/index），数组的下标从0开始。

使用方式2

1. 先声明数组
   语法: 数据类型 数组名[]; == 数据类型[] 数组名;
   int a[]; 或者 int[] a;
2. 创建数组
   语法：数组名=new 数组类型[大小];
   a = new int[10];

使用方式3

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

数据使用注意事项和细节

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)

数组赋值机制

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

int n1= 2;
int n2 = n1;

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

具体细节看视频。

数组拷贝

public class ArrayCopy {
    public static void main(String[] args) {
        int[] arr1 = {10, 20, 30};
        int[] arr2 = new int[arr1.length];

        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }

        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

数组翻转

public class ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55, 66};
        int temp = 0;
        int 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 ArrayAdd {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = {1, 2, 3};
        do {
            int[] newArr = new int[arr.length + 1];
            for (int i = 0; i < arr.length; i++) {
                newArr[i] = arr[i];
            }
            System.out.println("请输入你添加的元素");
            int addNum = sc.nextInt();
            newArr[newArr.length - 1] = addNum;
            // 将新创建的数组指向旧的数组，可以自动销毁没有的占用
            arr = newArr;
        } while (true);
    }
}

排序

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

内部排序

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

外部排序法

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

冒泡排序

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

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13, -1, 30, 200, -110};
        int temp = 0;
        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;
                }
            }
        }
    }
}

查找

此处仅仅为顺序查找

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);
                index = i;
                break;
            }
        }
        if (index == -1) {
            System.out.println("sorry ,没有找到 " + findName);
        }
    }
}

多维数组 二维数组

使用方式 1: 动态初始化

1. 语法: 类型[][] 数组名=new 类型[大小] [ 大小]
2. int a[] [] = new int[2] [3]

使用方式 2: 动态初始化

先声明： 类型 数组名[] []

再定义(开辟空间) 数组名 = new 类型[大小] [大小]

赋值（有默认值，比如int型类型就是0）

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

java的二维数组可以不确定列数但是行数必须确定。

使用方式 4: 静态初始化

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

使用细节

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