Java基础语法[数组]

Java基础语法入门到放弃的第六天

数组

1.概述

​ 适用于集中管理类型相同、用途相近的多个数据。

• 数组长度一旦固定则不可改变
• 定义的数组是连续的所以可以通过下标进行访问，下标从0开始。

2.语法定义

​ 数据类型[ ] 变量名；

​ 数据类型 变量名 [ ];

3.数组初始化

• 静态初始化：int[ ] buf = new int[ ]{1,2,3,4,5}—>int[ ] buf ={1,2,3,4,5}

• 动态初始化：int[ ] buf=new int[5];

4.数组的访问

• 因为数组是引用数据类型，保存的是数据空间的地址。
• 数组通过下标进行访问。

在方法中定义一个基本数据类的变量进行赋值：在内存空间中开辟一个栈空间，将变量所赋的值直接放在栈空间中；

在方法中定义一个int类型的数组并进行赋值：在内存空间中开辟一个栈空间，栈中存放的就不是数组所赋的值，而是引用地址，地址指向堆空间，数组就存放在堆空间中。

5.变量初始化

• 局部变量：

  ​ 1.必须手动初始化；

  ​ 2.局部变量必须手动初始化再使用。

• 数组中的空间：

  ​ 1.系统会自动初始化；

  ​ 2.数值型：0； char: ‘\0’ ; boolean: ‘false’; 引用数据类型：null。

简单算法

1冒泡排序

​ 用我自己的话理解就是：想要把一个一维数组从小到大排序，把第一个数和第二个数进行比较，如果第一个数大于第二个就交换位置，小于或等于就不用交换；然后第二个数再与第三个数进行比较交换，后面的数依次进行直到把最大的数移到最后面。然后照这样依次排序。直接上代码。

Scanner sc = new Scanner(System.in);
        System.out.print("请输入数组的长度：");
        int[] arr1 = new int[sc.nextInt()];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = (int) (Math.random() * 100 + 1);
        }
        System.out.println(Arrays.toString(arr1));  //得到一个数组

        //冒泡排序由大到小
        for (int i = 0; i < arr1.length - 1; i++) {
            for (int j = 0; j < arr1.length - i - 1; j++) {
                if (arr1[j] > arr1[j + 1]) {
                    arr1[j] = arr1[j] ^ arr1[j + 1];
                    arr1[j + 1] = arr1[j] ^ arr1[j + 1];
                    arr1[j] = arr1[j] ^ arr1[j + 1];

                }
            }
        }

2.选择排序

​ 选择排序的思路比较简单：如果是从大到小排序的话，就是找到数组中的最大值的坐标与下标为0的数值交换位置，第二大的就与下标为1的数值交换位置，后面一次排序。上代码：

Scanner sc = new Scanner(System.in);
        System.out.print("请输入数组的长度：");
        int[] arr1 = new int[sc.nextInt()];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = (int) (Math.random() * 100 + 1);
        }
        System.out.println(Arrays.toString(arr1));  //得到一个数组
//定义一个变量当作最大值的下标
int maxIndex ;
        for (int j = 0; j < arr1.length; j++) {
            maxIndex = j;         //下标的初始值为0
            for (int i = j+1; i < arr1.length; i++) {
                if (arr1[maxIndex] < arr1[i]) {
                    maxIndex = i;          //循环结束后maxIndex成为最大值的下标
                }
            }
            //如果最大值不在第一个，那么最大值的和第一个数交换位置
            if (maxIndex != j) {
                arr1[maxIndex] = arr1[maxIndex] ^ arr1[j];
                arr1[j] = arr1[maxIndex] ^ arr1[j];
                arr1[maxIndex] = arr1[maxIndex] ^ arr1[j];
            }
        }
        System.out.println("选择排序由大到小：");
        System.out.println(Arrays.toString(arr1));

3.快速排序

​ 由于排序很快，被称之为快速排序。妈的没搞懂，直接上代码：

    public  static void quicksort(int[] arr,int star,int end) {
        int mid = arr[star];//设第一个变量为中间值
        int i = star;
        int j = end;
        while (i<j) {
            while (i<j) {
                //从尾部开始找比中间值小的数值
                if (arr[j] < mid) {
                    arr[i] = arr[i] ^ arr[j];
                    arr[j] = arr[i] ^ arr[j];
                    arr[i] = arr[i] ^ arr[j];
                    break;
                }
                else {
                    j--;
                }
            }
            while (i<j) {
                //从头部开始找比中间值大的数值
                if (arr[i] > mid) {
                    arr[i] = arr[i] ^ arr[j];
                    arr[j] = arr[i] ^ arr[j];
                    arr[i] = arr[i] ^ arr[j];
                    break;
                }
                else {
                    i++;
                }
            }
        }
            if (i-star>1) {
                quicksort(arr,star,i-1);
            }
            if (end-i >1) {
                quicksort(arr,i+1,end);
            }
    }

4.二分法

​ 找到指定数值在数组中的位置。首先要对数组进行排序，数值再与数组中间位置的元素进行比较，如果大于中间值，则再与数组右半边中间的的元素进行比较；如果小于中间值，则再与数组左半边中间的元素进行比较。直到找到对应元素。

 //二分法查找数
        //输入需要查找的数
        System.out.print("输入需要查找的数：");
        int a=sc.nextInt();
        //定义最小下标，中间下标，最大下标
        int minIndex=arr1.length-1;
        int maxIndex1=0;

        for(;;){
            int middleIndex=(minIndex+maxIndex1)/2;
            //如果a小于中间的的数
            if(a<arr1[middleIndex]){
                maxIndex1=middleIndex+1;
            }else if (a>arr1[middleIndex]){
               minIndex=middleIndex-1;
            }else{
                System.out.println(a+"的下标是"+middleIndex);
                break;
            }
        }