java基础------函数与数组

函数（方法）

　　　　　　定义：如果一个功能的代码要被复用起来，那么这时候可以把这里的功能代码封装起来，在java中把功能代码封装起来的是以函数的形式体现的。

　　　　　　函数的格式：

　　　　　　　　　　修饰符　返回值类型　函数名（形式参数.....）{

　　　　　　　　　　　　　　需要被封装的功能代码；

　　　　　　　　　　　　　　return 结果；

　　　　　　　　　　　　　　　　}

　　　　　　例如：

　　　　　　　　　　public static int add（）{

　　　　　　　　　　　　　　int a=2；

　　　　　　　　　　　　　　int b=3；

　　　　　　　　　　　　　　return a+b；

　　　　　　　　　　　　　　}

　　　　　　分析函数：

　　　　　　　　　　修饰符：public static

　　　　　　　　　　返回值类型：int  返回值类型就是指函数运行完毕后，返回结果的数据类型。

　　　　　　　　　　　　　　　　注意： 某些函数是没有结果返回给调用者的,那么这时候返回值类型是void。

　　　　　　　　　　函数名：add

　　　　　　　　　　　　　　函数名的作用：如果需要调用该函数就需要使用的函数名。 函数名只要符合标识符的命名规则即可。 

　　　　　　　　　　　　　　函数名的命名规范： 首单词全部小写，其他单词的首字母大写，其他小写。

　　　　　　　　　　形式参数： 如果一个函数在运行的时候，存在的数据是要调用者确定的，那么这时候就应该定义形式参数。

　　　　　　　　　　return：把一个结果返回给调用者。

　　　　　　函数的作用：提高功能代码的复用性

　　　　　　函数的特点：

　　　　　　　　　　1. 函数的作用就是把一个功能代码给封装起来，已达到提高功能代码的复用性。

　　　　　　　　　　2.函数定义好之后是需要被调用才会执行的。其中main函数是由jvm调用的，不需要我们手动调用。

　　　　　　　　　　3.如果一个函数没有返回值返回给调用者，那么返回值类型必须是使用void表示。　

　　　　　　如何定义一个函数：
　　　　　　　　　　1. 返回值类型。
　　　　　　　　　　2. 是否存在未知的参数(是否存在要由调用者确定的参数)。---->形式参数

class Demo1
{
    public static void main(String[] args) 
    {
        //int max = getMax(14,5); //调用了需求1的函数，括号内填写的是实际参数，实际参数由调用者确定
        //System.out.println("最大值："+ max);//输出需求1的结果 结果为14

        getMax(3,7);//调用了需求2的函数
    }    

/*
    //需求1： 定义一个函数比较两个int类型的数据大小，把最大值返回给调用者。
    public static int  getMax(int a, int b){  // 形式参数
        int max = 0; //定义一个变量用于保存最大值的
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        return max;//把结果返回给调用者
    }
*/

    //需求2：定义一个函数比较两个int类型的数据大小，不需要把最大值返回给调用者,直接打印即可。
    public static void getMax(int a, int b){
        int max = 0; //定义一个变量用于保存最大值的
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        System.out.println("最大值："+ max);
    }

}

class Demo2 
{
    public static void main(String[] args) {
        //String result = getGrade(91);//调用了需求1的函数，并把结果赋值给result
        //System.out.println(result);//输出的结果为：A等级

        print(7);//调用了需求2的函数
    }

//需求1： 定义一个函数判断一个分数的等级，把分数的等级返回给调用者。
    public static String getGrade(int score){
        String grade = "";    //定义一个变量存储等级
        if(score>=90&&score<=100){
            grade = "A等级";
        }else if(score>=80&&score<=89){
            grade = "B等级";
        }else if(score>=70&&score<=79){
            grade = "C等级";
        }else if(score>=60&&score<=69){
            grade = "D等级";
        }else if(score>=0&&score<=59){
            grade = "E等级";
        }else{
            grade = "补考等级";
        }
        return grade;//把等级返回给调用者
    }

    //需求2： 定义一个函数打印一个乘法表，不需要返回任何数据。 
    public static void  print(int row){
        for(int i = 1 ; i<= row ; i++){
            for (int j = 1 ;j<=i  ;j++ ){
                System.out.print(i+"*"+j+"="+i*j+"	");
            }
            //换行
            System.out.println();
        }
    }

}

　　　　　　注意： 如果一个函数的返回值类型是具体的数据类型，那么该函数必须要保证在任意情况下都保证有返回值。（除了返回值类型是void以外）

class Demo3{
    public static void main(String[] args) 
    {
        String result = getGrade(10);//调用函数
        System.out.println("对应的等级是："+ result );
    }
    public static String getGrade(int score){//未知的参数定义在形参中，由函数的调用者确定。
        if(score>=90&&score<=100){
            return "A等级";
        }else if(score>=80&&score<=89){
            return "B等级";
        }else if(score>=70&&score<=79){
            return "C等级";
        }else if(score>=60&&score<=69){
            return "D等级";
        }else if(score>=0&&score<=59){
            return "E等级";
        }else{
            //如果一个函数的返回值类型是具体的数据类型，那么该函数就必须要保证在任意情况下都保证有返回值。（除了返回值类型是void以外）
            return "补考等级";
        }
    }
}

　　　　　　return 关键字的作用：

　　　　　　　　　　1. 返回数据给函数的调用者。

　　　　　　　　　　2. 函数一旦执行到了return关键字，那么该函数马上结束。 (能结束一个函数)

　　　　　　注意：如果一个函数的返回值类型是void，那么也可以出现return关键字，但是return关键字的后面不能有数据。

　　　　　　break关键字与return关键字的区别：

　　　　　　　　　　1.break关键字是结束一个循环。

　　　　　　　　　　2. return关键字是结束一个函数。

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

　　　　　　函数重载的要求：

　　　　　　　　　　1. 函数名一致。

　　　　　　　　　　2. 形参列表不一致。（形式参数的个数或者是对应的数据类型不一致）

　　　　　　　　　　3. 与函数的返回值类型是无关的。

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

class Demo4 {
    public static void main(String[] args) {
        add1(1,2);//调用了含有两个参数的函数
        add(1,2.0);//调用了含有三个参数的函数
    }

        // 一下两个函数都是以函数重载在做加法运算。
    public static double add(int a, int b){
        System.out.println("两个参数的总和: "+ (a+b));
        return 3.14;
    }

    public static void add(int a , int b , int c){
        System.out.println("三个参数的总和: "+ (a+b+c));
    }

}

数组

　　　　　　定义：数组是存储同一种数据类型数据的集合容器。

　　　　　　数组的定义格式：

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

　　　　　　分析数组:

　　　　　　　　　　左边： int[] arr    声明了一个int类型的的数组变量，变量名为arr。

　　　　　　　　　　　　　　int : 表示该数组容器只能存储int类型的数据。

　　　　　　　　　　　　　　[] ： 这是一个数组类型。

　　　　　　　　　　　　　　arr ： 变量名。

　　　　　　　　　　右边：new int[50]　创建了一个长度为50的int类型数组对象。

　　　　　　　　　　　　　　new ： 创建数组对象的关键字。

　　　　　　　　　　　　　　int：表示该数组对象只能存储int类型数据。

　　　　　　　　　　　　　　[]： 表示是数组类型。

　　　　　　　　　　　　　　50 : 该数组最多能存储50个数据。数组的容量。

　　　　　　数组的好处： 对分配到数组对象中的每一个数据都能够分配到一个索引值（编号、角标、下标）,索引值的范围是从0开始，最大是： 长度-1。

　　　　　　局部变量： 如果一个变量是在一个函数（方法）的内部声明的，那么该变量就是一个局部变量。

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

class Demo5 {
    public static void main(String[] args) 
    {
        //定义一个数组
        int[] arr = new int[4];
        arr[0] = 10;
        arr[1] = 30;
        arr[2] = 50;
        arr[3] = 90; 
        
        //System.out.println("数组的容量："+ arr.length);    //数组里有一个length 的属性，可以查看数组的容量。
        //System.out.println("arr[2] = "+ arr[2]);//查看索引值为2的数组的值    结果为：50
        
        //查看数组中的所有数据。
        for(int index = 0 ; index<arr.length ; index++){
            System.out.println(arr[index]);
        }
    }
}

　　　　　　数组的内存分析图：

　　　　　　数组中常见的问题：

　　　　　　　　　　1. NullPointerException 空指针异常

　　　　　　　　　　原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。

　　　　　　　　　　2. ArrayIndexOutOfBoundsException 索引值越界。

　　　　　　　　　　原因：访问了不存在的索引值。

　　　　　　数组的初始方式：

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

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

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

class Demo6{
    public static void main(String[] args) 
    {    
            /*
        //动态初始化
        int[] arr = new int[10];
        Scanner scanner = new Scanner(System.in);//创建扫描器对象
        for(int i  = 0 ; i< arr.length ; i++){
            arr[i] = scanner.nextInt();//调用扫描器的nextInt()扫描数据，并把数据赋值于数组中
        }
        */

        //静态初始化
        int[] arr = {10,20,30,40,50};
                //查看数组的所有数据
        for(int index = 0 ; index<arr.length ; index++){
             System.out.print(arr[index]+",");
        }


    
    }
}

/*
    需求： 定义一个函数接收一个int类型的数组对象，找出数组对象中的最大元素并返回给调用者。
*/
class Demo7 {
    public static void main(String[] args) 
    {
        int[] arr = {-12,-14,-5,-26,-4};//静态初始化
        int max = getMax(arr);
        System.out.println("最大值："+ max); //结果为：-4
    }

    public static int  getMax(int[] arr){
        int max = arr[0]; //用于记录最大值
        for(int i = 1 ; i < arr.length ; i++){
            if(arr[i]>max){  //如果发现有元素比max大，那么max变量就记录该元素。
                max = arr[i];
            }
        }
        return max;//把max的值返回给调用者
    }
}

　　　　　　数组常见的操作：

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

　　　　　　　　　　需求： 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的第一位。

class Demo8{
    public static void main(String[] args) 
    {
        int[] arr = {12,5,17,8,9};  //对于有5个元素的数组，只需要找出4个最大值就可以排序了。
        selectSort(arr);
    }

    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;
                }
            }
        }
        

/*
                //把老大放在第一个位置
                for(int i=1;i<arr.length;i++）{
                       if(arr[i]>arr[0]){
                int temp = arr[i];
                arr[i] = arr[0];
                arr[0] = temp;
            }
                 }
                
        //把老二放在第二个位置
        for(int i = 2  ; i< arr.length ; i++){
            if(arr[i]>arr[1]){
                int temp = arr[i];
                arr[i] = arr[1];
                arr[1] = temp;
            }
        }
        

        //把老三放在第三个位置
        for(int i = 3  ; i< arr.length ; i++){
            if(arr[i]>arr[2]){
                int temp = arr[i];
                arr[i] = arr[2];
                arr[2] = temp;
            }
        }

        //把老四放在第四个位置
        for(int i = 4  ; i< arr.length ; i++){
            if(arr[i]>arr[3]){
                int temp = arr[i];
                arr[i] = arr[3];
                arr[3] = temp;
            }
        }

*/

        //遍历数组，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }
    }
}
        

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

　　　　　　　　　　需求： 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的最后一位。

class Demo9 {
    public static void main(String[] args) 
    {
        int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量：5 
         bubbleSort(arr);
    }


    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;
                }
            }
        }

/*
                // 把最大值放在最后一个位置
            for(int i = 0 ;  i <arr.length-1-0 ; i++){
                if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

        //把老二放在倒数第二个位置上。
        for(int i = 0 ;  i <arr.length-1-1 ; i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

        //把老三放在倒数第三个位置上。
        for(int i = 0 ;  i <arr.length-1-2 ; i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

        //把老四放在倒数第四个位置上。
        for(int i = 0 ;  i <arr.length-1-3 ; i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

*/

        //遍历数组，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length; i++){
            System.out.print(arr[i]+",");
        }
    }
}

　　　　　　　　　　二分查找法：定义三个变量分别记录要查找元素的范围最大索引值、中间索引值、最小索引值，每次都是使用中间索引值的元素与目标元素比较一次，如果不是我们所需要的元素，那么缩小查找的范围。

　　　　　　　　　　注意：使用二分查找法的前提必须是有序的数组。

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

class Demo10 {
    public static void main(String[] args) 
    {
        int[] arr = {12,16,19,23,54};
        //int index = searchEle(arr,23);//调用searchEle（），但是效率低
        int index = halfSearch(arr,116);
        System.out.println("元素所在的索引值是："+ index);
    }
    
        
    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;
        }
    
    }
/*
    public static int searchEle(int[] arr, int target){
        for(int i = 0 ; i<arr.length ; i++){
            if(arr[i]==target){
                return i;
            }
        }
        return -1;
    }
*/
}

/*
需求： 定义 一个函数接收一个char类型的数组对象,然后翻转数组中的元素。    
例如：char[] arr = {'a','b','c','d','e'};翻转元素后的结果为e、d、c、b、a
*/
class Demo11{
    public static void main(String[] args){
        char[] arr = {'a','b','c','d','e'};
        reverse(arr);
    }

    public static void reverse(char[] arr){
        for(int startIndex = 0 ,endIndex = arr.length-1 ;   startIndex<endIndex ; startIndex++,endIndex--){
            char temp = arr[startIndex];
            arr[startIndex] = arr[endIndex];
            arr[endIndex] = temp;
        }

        //遍历数组，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }

    }
}

 　　　　　　二维数组：二维数组就是数组中的数组。

　　　　　　二维数组的定义格式：数据类型[][] 变量名 = new 数据类型[长度1][长度2]；

　　　　　　二维数组的初始化方式：

　　　　　　　　　　动态初始化：数据类型[][] 变量名 = new 数据类型[长度1][长度2]；

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

　　　　　　二维数组的内存分析图：

　　　　　　数组的特点：

　　　　　　　　　　1. 数组只能存储同一种数据类型的数据。

　　　　　　　　　　2. 数组是会给存储到数组中的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；

　　　　　　　　　　3. 数组一旦初始化，长度固定。

　　　　　　　　　　4. 数组中的元素与元素之间的内存地址是连续的。

class Demo12{
    public static void main(String[] args) 
    {    
        //定义了一个二维数组
        int[][] arr = new int[3][4];
        arr[1][1] = 100;
        /*
        System.out.println("二维数组的长度："+ arr.length);  //长度为3
        System.out.println("二维数组的长度："+ arr[1].length); //长度为4
        */
        System.out.println("数组的元素："+ arr[1][1]);结果为100
        
    }
}