JavaSE基础---数组

数组声明创建

1. 首先必须声明数组变量，才能在程序中使用数组。下面试声明数组变量的语法：

// dataType[] arrayRefVar;
  int[] arr;

2. Java语言使用new操作字符来创建数组，语法如下：

// dataType[] arrayRefVar = new dataType[arraySize];
int[] array = new int[4];
// 赋值
array[0] = 1;
array[1] = 1;
array[2] = 1;
array[3] = 1;
// 创建方式2
 int arr1[] = new int[]{1,2,3,4,5};

3. 数组的元素是通过索引访问的，数组索引从0开始。
4. 获取数组长度：arrays.length

内存分析

1. Java内存分析

三种初始化

1. 静态初始化

int[] a = {1,2,3};

2. 动态初始化

int[] b = new int[2];
b[0] = 1;
b[2] = 2;

3. 数组的默认初始化
   数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。默认为0；

数组的四个基本特点

1. 其长度是确定的，一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型，不允许出现混合类型。
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
5. 数组本身就是对象，Java中对象是在堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身就是在堆中。

数组边界

注意：java.lang.ArrayIndexOutOfBoundsException
表明数组下标越界异常！！

小结：

1. 数组是相同数据类型的有序集合。
2. 数组也是对象，数组元素相当于对象的成员变量。
3. 数组的长度是确定的，不可变的，如果越界，则报异常。

数组的使用

1. 遍历数组元素

 	// 创建二维数组
        int a[][] = new int[2][3];
        for (int i = 0;i<a.length;i++){
            for (int j = 0;j<a[i].length;j++){
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }

2. 反转数组

	// 反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        // 反转操作
        for (int i = 0 ,j = result.length - 1;i < arrays.length-1;i++,j-- ){
            result[j] = arrays[i];
        }
        return result;
    }

多维数组

1. 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
2. 二维数组
   int a[][] = new int [2][5];
   解析：a是一个2行5列的数组。
   

Arrays类

3. 常用的数组工具类：java.util.Arrays
4. 具有以下常用功能：
   给数组赋值：通过fill方法
   对数组排序：通过sort方法
   比较数组：通过equals方法比较数组元素值是否相等
   查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找
5. 打印数组System.out.println(Arrays.toString(arr));

八大排序

1. 冒泡排序

package sort;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3,9,-1,10,20};
        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr){

        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;
                }
            }
        }
    }
}

2. 插入排序

package sort;

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {3,9,-1,10,20};
        System.out.println("插入排序前");
        System.out.println(Arrays.toString(arr));
        insertSort(arr);
        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));
    }

    // 插入排序:往前插
    public static void insertSort(int[] arr){
        int insertVal = 0;
        int insertIndex = 0;

        for (int i = 1; i < arr.length;i++){
            insertVal = arr[i];// 插入的值
            insertIndex = i - 1 ;// 插入的位置
            while (insertIndex >= 0 && insertVal <= arr[insertIndex]){
                // 换位置
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            if (insertIndex + 1 != i){
                arr[insertIndex + 1] = insertVal;
            }

        }
    }
}

3. 选择排序

package sort;

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {3,9,-1,10,20};
        System.out.println("选择排序前");
        System.out.println(Arrays.toString(arr));
        selectSort(arr);
        System.out.println("选择排序后");
        System.out.println(Arrays.toString(arr));
    }

    // 选择排序
    public static void selectSort(int[] arr){
        for (int i = 0; i < arr.length -1;i++){
            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1;j< arr.length;j++){
                if (min > arr[j]){
                    min = arr[j];
                    minIndex = j;
                }
            }
            if (minIndex != i){
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }
}

4. 快速排序
5. 归并排序
6. 堆排序
7. 基数（桶）排序
8. 希尔排序
   后序更新！！！点赞哦！一起进步