数组最基础

一维数组

静态初始化数组

数据类型[] 数组名;

动态初始化数组

数据类型[] 数组名 = new 数据类型[数组长都度]

定义数组时，元素类型不同，默认值不同

数组元素类型	默认初始值
byte、short、int，long	0
float，double	0.0
char	'\u0000'（空字符）
boolean	false
引用数据类型	null

数组执行原理

方法区：字节码文件先加载到这里

栈：方法运行时所进入的内存区域，由于变量在方法中，所以变量也在这一块 区域中

堆：存储new出来的东西，并分配地址。由于数组是new 出来的，所以数组也在 这块区域。

数组使用过程可能出现的问题

数组下标越界

如果在数组中保存的元素可以自动提升(自动类型转化)为数组自己的类型，那是可以保存的

数组反转：

某个数组有5个数据：10,20,30,40,50，请将这个数组中的数据进行反转。 [10, 20, 30, 40, 50] 反转后 [50, 40, 30, 20, 10]

解法：

1.每次交换，需要有左右两边的两个索引，我们可以用i和j表示 刚开始i=0，j=数组长度-1;

2.每次让i和j索引位置的两个元素互换位置 arr[i]和arr[j]互换位置

3.每次还完位置之后，让i往右移动一位，让j往前移动一位

排序

排序算法 有多种，常用的排序算法有冒泡排序、插入排序、选择排序、快速排序、 堆排序、归并排序、希尔排序、二叉树排序、计数排序等。

选择排序：

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所 以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了 吧。

选择排序(Selection-sort)是一种简单直观的排序算法。

它的工作原理：首先在未排序序 列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素 中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素 均排序完毕。 n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。

具体算法描述如 下： 初始状态：无序区为R[1..n]，有序区为空；

第 i 趟 排 序 (i=1,2,3…n-1) 开 始 时 ， 当 前 有 序 区 和 无 序 区 分 别 为 R[1..i-1] 和 R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区 的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区 和记录个数减少1个的新无序区；

n-1趟结束，数组有序化了

public static void main(String[] args) {
        //选择排序
        int[] arr = {55,34,2,77,45,4,8,40};
        for (int i = 0; i < arr.length - 1; i++) {
            int current = arr[i];
            int index = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[index] > arr[j]){
                    index = j;
                }
            }
            arr[i] = arr[index];
            arr[index] = current;
        }
        for (int i1 = 0; i1 < arr.length; i1++) {
            System.out.println(arr[i1]);
        }
    }

插入排序

从第i + 1个数据向前找，认为前面的数据是已经排列好的，若索引大于等于零并且若前面的数大于当前数，把前面数据赋值给当前数据，若不满足索引大于等于零并且若前面的数大于当前数，跳出循环，把当前数据插入

public static void main(String[] args) {
        //插入排序
        int[] arr = {55,34,2,77,45,4,8,40};
        for (int i = 0; i < arr.length -1; i++) {
            int current = arr[i + 1];
            int index = i;
            for(;index >= 0 && current < arr[index];index--){
                   arr[index + 1] = arr[index];
                }
            arr[index + 1 ] = current;
            }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        }

冒泡排序

每次循环，比较相邻的两个数据，进行交换位置，会找到一个最大或最小的数字，把他放到数组一边

每循环一次，都可以少遍历一个数据

public static void main(String[] args) {
        //冒泡排序
        int[] arr = {2,3,1,8,3,9,6};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j + 1] > arr[j]){
                    arr[j] = arr[j + 1] ^ arr[j];
                    arr[j + 1] = arr[j + 1] ^ arr[j];
                    arr[j] = arr[j + 1] ^ arr[j];
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }

二分查找:

二分查找（Binary Search）算法，也叫折半查找算法。二分查找的思想非常简单，有 点类似分治的思想。二分查找针对的是一个有序的数据集合，每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间 被缩小为 0。

public static void main(String[] args) {
        int[] arr = {1,2,5,7,9,10};
        int start = arr[0];
        int end = arr.length - 1;
        int mid = (start + end) / 2;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字");
        int key = sc.nextInt();
        while( end >= start){
           if (key == arr[mid]){
               System.out.println(mid);
               break;
           }else if (key < arr[mid]){
               end = mid - 1;
           }else {
               start = mid + 1;
           }
             mid = (start + end) / 2;
        }
        if (end < start){
            System.out.println(-1);
        }
​
    }

多维数组：

二维数组：

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

初始化

int[] [] arr = new int[3] [4];

int[] [] arr = {

{1,2,3},

{4,5}

}

二维数组的迭代

for(int i = 0;i < arr.length;i++){
​
•   for(int j; j< arr[i].length;j++){
​
•   System.out.println(a)
​
}}