方法与数组

一、方法

　　1.1、语法结构　　

　　　　修饰符返回值类型方法名(形参列表){

　　　　　　方法体

　　　　}

　　1.2、定义

　　1、明确方法三要素：返回值、参数列表、方法体

　　 2、可以模仿main方法：修改方法名、参数列表、返回值、方法体

　　1.3、使用

　　类名.方法名(); ：静态方法的调用

　　对象.方法名(); ：非静态方法的调用

　　　　方法名(); ：在同一个类中方法间的调用，注意静态方法只能调用静态方法

　　1.4、注意

　　 方法重载：方法名相同，参数个数或类型不同，与返回值类型和权限无关

　　 方法重写：方法名、参数个数、类型、返回值类型完全相同，方法体不同，发生在继承类中

二、数组

　　2.1、数组定义

　　静态创建：创建的同时放入数据

格式1：int [] arr={1,2,3,4};//推荐

格式2：int [] arr=new int[]{1,2,3,4};

注意：int [] arr=new int[4]{1,2,3,4};//错误

　　动态创建：创建时，只是设置数组长度（有默认值，但是默认值是没有多大实际意义的）

格式1：int [] arr=new int[4];//推荐

格式2：int [] arr;

arr=new int[4];

注意：int[] arr;

　　　　　　　arr = {1,2,3,4}；//错误

　　2.2、数组使用（赋值、取值）

　　三个术语：元素、长度、下标（0~length-1）

　　数组的存、取值，均可通过数组下标进行操作

　　数组的遍历：即是将数组中的每个元素取出来

　　　　　　　　　　方式一：for循环

　　　　　方式二：foreach

　　2.3、数组加强

　　　　二维数组：严格的来说，java中没有多维数组，都可以看成一维数组，只是数组中存储的元素类型是数组。

　　　　　//二维数组的静态创建
        int[][] arr={new int[]{1,2,3},new int[]{2,3,4,5}};
        int[][] arr2={{1,2},{2,3,4}};
        //二维数组的动态创建
        int [][] arr3=new int[4][];
        int [][] arr4=new int[2][3];
        //遍历二维数组
        for(int i=0;i<=arr.length-1;i++){
            for(int j=0;j<=arr[i].length-1;j++){
                System.out.println(arr[i][j]);
            }
        }

　　2.4、Arrays工具类

　　　　　　static int binarySearch(int[ ] a, int key)//二分查找

　　　　　　static int[ ] copyOf(int[ ] original, int newLength)// 复制数组

　　　　　　static int[ ] copyOfRange(int[ ] original, int from, int to)// 将数组指定范围复制到新数组

　　　　　　static void fill(int[ ] a, int val)//将指定的 int 值分配给指定 int 型数组的每个元素

　　　　　　static void fill(int[ ] a, int fromIndex, int toIndex, int val)//将值分配给数组指定范围每个元素

　　　　　　static void sort(int[ ] a) //对数组按数字升序进行排序

　　　　　　static String toString(int[ ] a)//返回指定数组内容的字符串表示形式

　　2.5、可变参数

　　　　　　本质就是一个动态创建的数组

　　　　　　语法格式：

　　　　　　修饰符返回值类型方法名（数据类型...变量名）｛

　　　　　　　　方法体

　　　　　　｝

　　　　　　注意：1、完全当做数组来操作

　　　　　　2、一个方法有且只有一个可变参数

　　　　　　3、如果有其他参数，可变参数需方末尾

　　2.6、二分查找

　　　　思想：每一次和中间的数做比较

　　/**二分查找*/
    public static int binarySearch(int[] arr,int a ) {
        int minIndex=0;//最大索引
        int maxIndex=arr.length-1;//最小索引
        //每一次将中间位置和查询数比较
        while(minIndex<=maxIndex){
            int midIndex=(minIndex+maxIndex)/2;//中间索引
            if(a==arr[midIndex]){
                return midIndex;
            }else if(arr[midIndex]>a){//中间数值大于查询数
                maxIndex=midIndex-1;
            }else{
                minIndex=midIndex+1;
            }
        }
        //如果没有这个数，返回-1
        return -1;
    }

　　2.7、冒泡排序

　　　　思想：依次比较相邻的两个数，将小数放在前面，大数放在后面。

　　/**冒泡排序*/
    public static void bubbleSort(int[] arr) {
        for(int i=0;i<arr.length-1;i++){//轮数，5个数比较4轮 0 1 2 3，即小于5-1
            for(int j=0;j<arr.length-1-i;j++){//比较出来的数不需要再比较，每轮比出来一个数
                if(arr[j]>arr[j+1]){
                    //交换位置
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

　　2.8、直接选择排序

　　　　思想：第一次从R[0]~R[n-1]中选取最小值，与R[0]交换，第二次从R[1]~R[n-1]中选取最小值，与R[1]交换，....

　　/**选择直接排序*/
    public static void selectSort(int[] arr) {
        for(int i=0;i<arr.length-1;i++){//轮数,也是每次比较的下标
            //假定最小的数是i位，即每轮开头
            int minIndex=i;
            for(int j=i+1;j<=arr.length-1;j++){//一直比较到到最后一位
                if(arr[minIndex]>arr[j]){
                    minIndex=j;
                }
            }
            //每一轮最后的时候，交换值
            int temp=arr[i];
            arr[i]=arr[minIndex];
            arr[minIndex]=temp;
        }
    }

　　2.9、反转排序

　　/*** 反转排序*/
    public static void reverseSort(int[] arr) {
        //交换次数是长度/2，即4个数换两次，5个数也是换两次
        for(int i=0;i<arr.length/2;i++){
            int temp=arr[i];
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i]=temp;
        }
    }