第二周 Day5

1.方法重载

方法重载:
        方法名相同,参数列表不同,与返回值无关!
        (为了提供某个功能的扩展性)
        
参数列表不同:
                1)参数个数不同
                2)参数类型不同
                3)考虑参数类型的顺序

2.数组的应用

2.1数组的应用---制定格式遍历

定义一个数组,静态初始化,将数组中的元素按照下面格式输出
    [元素1, 元素2, 元素3, 元素4 ....元素n] ,使用方法调用完成

class Test1{
    public static void main(String[] args){
​
        int[] arr = {11,22,33,44,55} ;
​
        printArray(arr) ;
    }
​
    public static void printArray(int[] array){//
        System.out.print("[") ;
        
        for(int x = 0 ; x <array.length ; x ++){
​
            if(x == array.length-1){
        System.out.println(array[x]+"]") ;
            }else{
        System.out.print(array[x]+", ") ;
            }
        }
        
    }
}

2.2数组的应用---最值

class Test2{
    public static void main(String[] args){
        //已知一个数组,静态初始化了
        int[] arr = {69,87,52,13,24} ;
​
        //定义一个参照物,arr[0] 就是最大值
        int max = arr[0] ;
        
        //从角标1遍历其他元素
        for(int x = 1 ; x < arr.length ; x++){
        //获取到了每一个元素
        //判断:使用后面的元素依次和参照物max进行对比
            if(arr[x] > max){
                //后面的元素大
                //重新赋值新的元素给max变量
                max = arr[x] ;
            }
        }
        
        //输出即可
        System.out.println("当前数组中的最大值是:"+max) ;
        
        System.out.println("------------------------------------") ;
        
        //继续优化:使用方法改进
        int max2 = getArrayMax(arr) ;
        System.out.println("当前数组中的最大值是:"+max2) ;
    }
​
    //定义一个求数组最大值的方法
    /*
        两个明确
            1)明确返回值类型
                    int
            2)明确参数类型以及参数个数
                    int[] 数组,1个参数
    */
    public static int getArrayMax(int[] array){
        //定义参照物
        int max = array[0] ;
        
        //遍历其他元素
        for(int x =1 ; x < array.length ; x ++){
            //使用后面的元素依次和参照物max进行对比
            if(array[x] > max){
                max = array[x] ;
            }
        }
        return max ;//返回
    }
    
    
}

2.3数组的逆序

逆序:
    就是将数组中的一个元素和最后一个元素互换
    将数组中的第二个元素和倒数第二个元素进行互换
    
分析:
    arr[0]和arr.length-1互换
            arr[1]和arr.length-1-1 换行
            ...
            ...
            
            保证数组的长度 arr.length/2
            
            先将原始数组---进行遍历---
逆序之前:
        输出([元素1, 元素2, 元素3, 元素4...元素n])
        
            调用逆序的方法(完成逆序)
逆序之后:
        输出([元素1, 元素2, 元素3, 元素4...元素n])

class Test3{
    public static void main(String[] args){
        int[] arr = {69,87,52,13,24} ;
        
       public static void reverse(int[] array){
        
        for(int x = 0 ; x < array.length/2 ; x ++){//x=0,1,2,...arr.length-1
            //互换
            int temp = array[x] ;
            array[x]  =array[array.length-1-x] ;
            array[array.length-1-x] = temp ;
        }
    }
                
        //遍历数组的方法
    public static void printArray(int[] array){
        System.out.print("[") ;
        //遍历数组array
        for(int x = 0 ;x < array.length ; x ++){
            //判断x是否取到最大索引值,取到了最大索引值,
            //获取最后一个元素以及输出"]"
            if(x == array.length-1){
        System.out.println(array[x] +"]") ;
            }else{
                //中间的元素输出,同时不换行的输出", "
        System.out.print(array[x] +", ") ;
            }
        }
       
        System.out.println("逆序前:") ;
        printArray(arr) ;
        
        System.out.println("逆序后: ") ;
        reverse(arr) ;
        printArray(arr) ;
    }
}

3.数组查询

3.数组的基本查表法

数组的基本查表法:
    就是通过数组的对象名称[索引值]----获取元素内容

数据结构:
            底层数据结构:(先去了解)
                数组: 查询快(角标就直接访问),增删慢
                链表:由数据域和指针域组成: 
                            查询慢(从链表开头查),
                            增删快
                            
字符串数组           
    String[] weeks ={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;       
            
键盘录入指定的数据:
    (0-6的范围),通过数组查表法:通过角标查询元素!

import java.util.Scanner ;
class ArrayTest4{
    
    public static void main(String[] args){
        
        String[] weeks = 
        {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;   
        
        Scanner sc = new Scanner(System.in) ;
        
        System.out.println("请您输入一个数据: ") ;
        int n = sc.nextInt() ;
        
        if(n>=0 && n<=6){
            System.out.println("您要查找的是:"+weeks[n]) ;
            
        }else{
            System.out.println("录入的数据,不再数据表的范围内...") ;
        }
    }
    
}

3.2数组的高级查询---二分法

前提条件: 只能针对数组有序的情况下
    
class ArrayTest5{
    public static void main(String[] args){
        
        int[] arr = {11,45,5,78,96,13} ; //无序的数组
         
        //调用一个方法,查询 45这个元素的索引值
        int index = getIndex(arr,45) ;
        System.out.println("当前该元素的索引值是:"+index) ;
        
        
        //调用一个方法,查询 450这个元素的索引值
        int index2 = getIndex(arr,450) ;
        System.out.println("当前该元素的索引值是:"+index2) ;
        
        System.out.println("------------------------------------------") ;
        int index3 = getIndex2(arr,250) ;
        System.out.println("index3:"+index3) ;
        
        int index4 = getIndex2(arr,78) ;
        System.out.println("index4:"+index4) ;
        
        
    }
    //方式2:
    public static int getIndex2(int[] array,int target){
        //使用假设思想:
        //先定义变量index:就是我们的索引值
        int index = -1 ; //找不到
        
        //遍历指定的array数组
        
        for(int x = 0 ; x < array.length; x ++){
            //获取到了所有元素,
            //判断:如果当前array[x]== target 一致,找到了
            if(array[x] == target){
                //重新改变index 的值
                index = x ;
                break ;
            }
        }
        return index ;
    }
    
    
    /*
    定义一个方法,查询在指定数组中的指定元素出现的索引值
        
        两个明确
                1)明确返回值类型
                        int
                2)明确参数类型以及参数个数
                    2个参数
                    int[] array 数组
                    int target  目标元素
    */
    public static int getIndex(int[] array,int target){
        
        //遍历数组
        for(int x = 0 ; x < array.length ; x ++){
            //获取到每个数组中的元素
            //判断
            //如果当前array[x] == target  ----找到了元素了
            if(array[x] == target){
                //返回x--索引值
                return x ; 
            }
        }
        //如果上面循环中找不到这个元素,就说明没有这个元素,方法调用完毕,必须结果值
        return -1 ;//找不到
    }
​
}

4.冒泡排序

冒泡排序思想:
    两两比较,将较大的值往后方法,第一次比较完毕之后,最大值出现

class ArrayTest6{
    public static void main(String[] args){
        int[] arr = {24,69,87,56,13} ;
        
        System.out.println("排序前: ") ;
        printArray(arr) ;
        
        System.out.println("排序后:") ;
        bubbleSort(arr) ;
        printArray(arr) ;
        /*
        定义冒泡排序的方法:
            两个明确
            1)明确返回值类型
                没有具体返回值结果 void代替
                            
            2)明确参数类型以及参数个数
                    int[] 数组,1个参数
    */
    public static void bubbleSort(int[] array){
        for(int x = 0 ; x < array.length-1 ; x ++){//比较次数
    
    
            //里面元素进行判断比较
            for(int y = 0 ; y < array.length-1-x ; y ++){//arr.length-1-0/
                                                        //arr.length-1-1
                //前面的元素比较后面的元素大,互换
                if(array[y] > array[y+1]){
                    
                    //中间变量互换
                    int temp = array[y] ;
                    array[y] = array[y+1] ;
                    array[y+1] = temp ;
                }
            }
        }
    }
        
        
        //定义遍历的方法
    public static void printArray(int[] array){
        //输出左中括号
        System.out.print("[") ;
        //遍历数组
        for(int x = 0 ; x < array.length ; x ++){
            //判断
            if(x == array.length-1){
        System.out.println(array[x]+"]") ;
            }else{
        System.out.print(array[x]+", ") ;
            }
        }
        
        
        
    }
}