day05-Methon-Array

method 方法的重载/参数/数组

方法的重载：

1. 方法名必须相同
2. 参数列不同（包括参数类型，参数顺序，参数个数等等）
3. 返回类没有特别要求

package com.example.demo.method;
/*8-31-25方法重载
* */
public class Demo02 {
    public static void main(String[] args) {
        System.out.println(add2(1,2));//d
        System.out.println(add2(1.0,2.0));//d
        System.out.println(add2(1.0,2));//d
    }
    public static int add2(int a,int b){
        System.out.println("this is int add2");
        return a+b;
    }
    public static double add2(double a,double b){
        System.out.println("this is double add2");
        return a+b;
    }
}

在使用命令行编译java类时，需要对应包的完整路径。

🌰:你不能在method路径下java Demo02,找不到或加载主参数类。但是

可变参数（即不确定传参数量）

可变传参：

1. 写法

   public void printMax(double x,double... numbers);
   

   x是普通参数，numbers是可变传参

2. 必须在普通参数之后

3. package com.example.demo.method;
   /*可变传参
   * */
   public class Demo03 {
       public static void main(String[] args) {
           Demo03 demo03=new Demo03();
           double[] nums=new double[]{1,2,3,4};//显示创建数组
           demo03.printMax(new double[]{1,2,3});//匿名函数传参
           demo03.printMax(nums);
   
       }
       public void printMax(double... numbers){
           if (numbers==null||numbers.length==0){
               return;
           }
           double max=numbers[0];
           for (double num:numbers){
               //System.out.println(num);
               if (num>max){
                   max=num;
               }
           }
           System.out.println(max);
       }
   }
   

new double[]{1,2,3} 是在创建一个新的 double 数组对象，new 关键字的作用就是 “实例化” 这个数组对象，为它分配内存空间。

递归

package com.example.demo.method;
/*递归-递归头（出口规则）-递归体（主要递归内容）--消耗计算机资源
* */
public class Demo04 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public  static int f(int n){
        if(n==1){
            return 1;
        }
        return n*f(n-1);
    }
}

数组

package com.example.demo.method;

import java.util.Arrays;

/*数组
声明数组dataType[] arrayRefVar;
创建数组dataType[] arrayRefVar = new dataType[arraySize];
数组在堆里
java里数组本质是对象，对象是在堆里的。
作为参数  返回数组
多维数组 dataType[][] arrayRefVar=new dataType[][]

Arrays类-Java工具类 java.util.Arrays
* */
public class Demo05 {
    public static void main(String[] args) {
        //int[] numbers=new int[10];//初始化长度，默认值
        int[] numbers = new int[]{2,5,4,3,2,1};
        int[][] numbers2 = new int[][]{{1, 2}, {3, 4}, {5, 6}};//二维
        System.out.println(Arrays.toString(sort2(numbers)));
    }
//bubbleSort
    public static int[] sort2(int[] arrays) {
        int temp;
        for (int i = 0; i < arrays.length - 1; i++) {
            for (int j = 0; j < arrays.length - 1 - i; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                }
            }
        }
        return arrays;
    }
}

Arrays类

public final class Arrays
/*final禁止继承，保证工具类不被篡改
Arrays.toString(array)
Arrays.sort()
Arrays.fill(array,fillValue)
*/

稀疏数组的创建和还原简单演示

package com.example.demo.method;
/*稀疏数组

* */
public class Demo6 {
    public static void main(String[] args) {
        int[][] arrays1=new int[11][11];
        arrays1[1][2]=1;
        arrays1[2][3]=2;
        System.out.println("输出原始数组");
        for(int[] out:arrays1){
            for(int inner:out){
                System.out.print(inner+"\t");
            }
            System.out.println();
        }
        System.out.println("=====稀疏数组====");
        //获取有效数来确定行(就是非0有效数)，列固定为3表示行，列，值
        int num=0;
        for (int[] ints : arrays1) {
            for (int anInt : ints) {
                if (anInt != 0) {
                    num++;
                }
            }
        }
        int[][] arrays2=new int[num+1][3];//+1是因为第一行即[0][0]存的是总共行列和有戏值个数num
        arrays2[0][0]=arrays1.length;
        arrays2[0][1]=arrays1[0].length;
        arrays2[0][2]=num;
        int count=1;
        //获取稀疏数组
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                if (arrays1[i][j] != 0) {
                    arrays2[count][0] = i;
                    arrays2[count][1] = j;
                    arrays2[count][2] = arrays1[i][j];
                    count++;
                }
            }
        }
        System.out.println("行"+'\t'+"列"+'\t'+"值");
        //打印稀疏数组
        for(int[] out:arrays2){
            for(int inner:out){
                System.out.print(inner+"\t");
            }
            System.out.println();
        }
        /*还原稀疏数组
        1.初始化数组
        2.遍历稀疏数组，得到row,col,value
        3.填入输出即可
        * */

        //初始化
        int[][] restore=new int[arrays2[0][0]][arrays2[0][1]];
        int valueNum=arrays2[0][2];//获取有效个数
        //替换0为有效数
        for (int row = 1; row <= valueNum; row++) {
            restore[arrays2[row][0]][arrays2[row][1]] = arrays2[row][2];
        }
        
        System.out.println("输出还原后的数组");
        for(int[] out:restore){
            for(int inner:out){
                System.out.print(inner+"\t");
            }
            System.out.println();
        }
    }
}