java基础——函数、数组、排序

函数的重载

函数的重载：在一个类中出现两个或者两个以上的同名函数，这个称作为函数的重载。

函数重载的作用： 同一个函数名可以出现了不同的函数，以应对不同个数或者不同数据类型的参数。

函数重载的要求：
1. 函数名一致。
2. 形参列表不一致。（形式参数的个数或者是对应的数据类型不一致）
3. 与函数的返回值类型是无关的。

数组

数组的定义格式：
数据类型[] 变量名 = new 数据类型[长度];
局部变量： 如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。

成员变量： 成员变量就是定义在方法之外，类之内的.

以下代码报错：空指针异常

int[] arr = new int[2];
        arr = null ;  //null 让该变量不要引用任何的对象。 不要记录任何 的内存地址。
        arr[1] = 10;
        System.out.println(arr[1]);

数组的初始化方式：

动态初始化:
    数据类型[] 变量名 = new 数据类型[长度];

静态初始化：
    数据类型[] 变量名 = {元素1，元素2.....};

如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果
数据一开始还不太明确，这时候就建议使用动态初始化。

算一个数组的最大值：

public static int  getMax(int[] arr){
        int max = arr[0]; //用于记录最大值  --这里容易出错，如果int max=0；那么在这个数组的所有元素都为负数时，结果会出错
        for(int i = 1 ; i < arr.length ; i++){
            if(arr[i]>max){  //如果发现有元素比max大，那么max变量就记录该元素。
                max = arr[i];
            }
        }
        return max;
    }

选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。

public static void selectSort(int[] arr){

        //把最大值放在首位置。
        for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
            for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
                if(arr[i]>arr[j]){
                    //交换位置
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

冒泡排序：冒泡排序的思想就是使用相邻的2个元素挨个比较一次，符合条件交换位置

public static void bubbleSort(int[] arr){

        //把最大值放在首位置。
        for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
            for(int i = 0 ; i<arr.length-1-j ; i++){ // 找出最大值
                if(arr[i]>arr[i+1]){
                    //交换位置
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
    }

需求：定义一个函数接收一个数组对象和一个要查找的目标元素，函数要返回该目标元素在
数组中的索引值，如果目标元素不存在数组中，那么返回-1表示。

折半查找法(二分法): 使用前提必需是有序的数组。

public static int halfSearch(int[] arr, int target){
        //定义三个变量分别记录最大、最小、中间的查找范围索引值
        int max = arr.length-1;
        int min = 0;
        int mid = (max+min)/2;
        while(true){
            if(target>arr[mid]){
                min = mid+1;
            }else if(target<arr[mid]){
                max = mid -1;
            }else{
                //找到了元素
                return mid;
            }

            //没有找到的情况
            if (max<min){
                return -1;
            }

            //重新计算中间索引值
            mid = (min+max)/2;
        }

    }

排序（sort）
找元素在数组中的位置(二分查找法) binarySearch
数组转换为字符串 toString();
数组的工具类（Arrays）：

public static void main(String[] args)
    {
        int[] arr = {12,3,1,10,8};
        //排序的方法
        Arrays.sort(arr);
        String info = Arrays.toString(arr);
        System.out.println("数组的元素："+ info);

        // 1, 3, 8, 10, 12
        int index = Arrays.binarySearch(arr,9);// 二分法查找（使用之前要先排序） : 如果能在数组中找到对应 的元素，那么就返回该数据的索引值，如果没有找到那么就返回一个负数表示。
        System.out.println("找到的索引值："+ index);

    }

数组的特点：
1. 数组只能存储同一种 数据类型的数据。
2. 数组是会给存储到数组中 的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；
3. 数组一旦初始化，长度固定。
4. 数组中的元素与元素之间的内存地址是连续的。
二维数组： 二维数组就是数组中的数组。

二维数组 的定义格式：

    数据类型[][] 变量名 = new 数据类型[长度1][长度2];

    长度1：一条烟有多少盒。

    长度2： 一盒烟有多少根。

二维数组 的初始化方式：

    动态初始化:

        数据类型[][] 变量名 = new 数据类型[长度1][长度2];

    静态初始化：

        数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}

    int[][] arr = new int[3][4];
    System.out.println("二维数组的长度："+ arr.length);  // 3