java 数组及数组的操作

1、为什么会有数组？

在java中，我们通常会定义变量来储存一系列的值，例如需要存储小明的数学成绩，那么我们可以直接定义一个double类型的小数

 double grade = xx.xx;

如果需要存储小明所在班的数学成绩，那么给每个同学的成绩都开辟一个空间吗？显然这样是很繁琐的，且不利于我们进行操作，为此我们就可以用到数组了。这样就可以使用一个变量来存储多个信息。

2、java中定义数组的几种方式

//第一种：创建数组的长度，但不确定数组的内容

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

//第二种：确定数组的内容（此方法，长度自然就确定了）

数据类型[] 数组名 = new 数据类型[] {数据1,数据2....数据n};  //常用此方法定义一个数组

数据类型[] 数组名 = {数据1,数据2....数据n}  //此方法不常用

3、数组的特点

（1）大小是固定的，根据所需要的数组，定义完成数组的长度就已经固定了。

（2）它是连续内存地址，此特点便决定了数组的大小是固定的。

（3）存储的数据类型是固定的，定义完数组，那么该数组的数据类型就定义好了。

（4）数组是保存在堆内存中的。

地址连续且大小空间是固定的就可以方便计算后续元素的物理地址。

数组变量存的就是数组在堆内存中收元素的地址。

4、数组的操作

（1）访问数组的长度

数组名.length

int[ ] arr = new int[ ]{1,8,5,6,2,0,1,74,12};

//数组arr的长度为：arr.length

 （3）访问数组中的元素

//索引：访问数组元素的重要标志，即为数组元素的下标，在数组中索引一般都是从0开始的
//数组（int[ ] arr = new int[ ]{1,8,5};）中的元素表示方法
arr[0] = 1;     
arr[1] = 8;
arr[2] = 5;

//数组中元素的遍历

//第一种

for(int i = 0;i < arr.length;i++){
    System.out.print(arr[i] + " ,");
}

//第二种

for(int i :arr){
            System.out.print(i + " ,");
        }

5、数组的应用——排序

A、插入排序

思想：从一个无序数组中的第二个元素开始，依次和他前面的数组进行比较，如果小于就插在比较的前面（交换两个元素的位置），然后进行下一趟比较，依次执行次操作，知道最后一个元素和第一个元素比较结束。

//插入排序
public class insertSort {
    public static void main(String[] args) {
        int[] arr = new int[]{17, 11, -9, -8, -6, 47, -23, 44, 22, 88, 63, 52, -511};
        InsertSort(arr);
        for (int i : arr) {
            System.out.print(i + " ,");
        }
    }
    public static void InsertSort(int[] arr){
        //比较的趟数
        for (int i = 0; i < arr.length - 1; i++) {
            //两两进行比较，从第二个元素开始和前面的比较，比他小就交换
            for (int j = i + 1; j > 0 ; j--) {
            /*交换符合条件的两个数字，定义一个temp变量存放arr[j],然后arr[j] = arr[j - 1]，                    
            arr[j - 1] = temp,这是便完成交换*/
                if(arr[j] < arr[j - 1]){
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
    }
}

//运行结果:-511 ,-23 ,-9 ,-8 ,-6 ,11 ,17 ,22 ,44 ,47 ,52 ,63 ,88 ,

B、冒泡排序

思想：从数组元素第一个元素开始依次两两比较，前面的元素小于后面的元素就交换（如果他们的顺序错误就把他们交换过来）。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

public class BubbleSort {
    public static void main(String[] args){
        int[] arr = new int[]{10,4,8,-9,41,63,45,17,36,25,14};
        bubbleSort(arr);//调用方法
//打印数组中的数组元素
        for (int i: arr) {
            System.out.print(i + ",");
        }
    }
    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
        //这个for循环是比较趟数的
            for (int j = 0; j < arr.length -1 -i; j++) {
                //两两比较，符合就交换两个元素
                if (arr[j+1] > arr[j]) {
                    arr[j] = arr[j] ^ arr [j+1];
                    arr[j + 1] = arr[j + 1] ^ arr[j];
                    arr[j] = arr[j] ^ arr[j + 1];
                }

            }
        }
    }
}
//运行结果:63,45,41,36,25,17,14,10,8,4,-9,

C、选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。重复第二步，直到所有元素均排序完毕。

public class selectionSort {
    public static void main(String[] args){
        int[] arr = new int[]{17, 11, -9, -8, -6, 47, -23, 44, 22, 88, 63, 52, -511 };
        selectSort(arr);
        for(int i :arr){
            System.out.print(i + " ,");
        }
    }
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }
        return arr;
    }
}
    
//运行结果:-511 ,-23 ,-9 ,-8 ,-6 ,11 ,17 ,22 ,44 ,47 ,52 ,63 ,88 ,

6、查找

二分查找

思想：这是针对一个有序数组的，假设从下到大的有序数组，定义变量 中间变量，找到数组的中间值，如果中间值小于目标值，那么就找 右边的中间值，反之和左边的中间值做比较，依次进行直到找到或者左后左边的下标大于等于右边下标查找结束。

public class BinarySearch {
    public static void main(String [] args){
        int[] nums = {1,2,3,4};
        int a = 5;

        System.out.println(binarySearch(nums,a));
    }
    public static int binarySearch(int[] nums,int a){
        int left = 0;
        int right = nums.length - 1;
        while (left <= right){
            int middle = (left + right) / 2;
            if (nums[middle] == a) {
                return middle;
            }else if(nums[middle] > a){
                right = middle - 1;
            }else{
                left = middle + 1;
            }
            }

           return left;//没找到返回这个数顺序插入的位置数组元素下标
    }

}
//运行结果：4

未完，待更新，欢迎大家指正