9.23学习记录（可变参数、递归、数组、Arrays类、冒泡排序）

可变参数

• JDK1.5开始，JAVA支持传递同类型的可变参数给一个方法

• 在方法的声明中，在指定参数类型后加一个省略号（...）。

• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何参数必须在它之前声明。

• 类似于数组

  public static void main(String[] args) {
      printMax(5,87,45,34,55);
      printMax(new int[]{45,56,44,2,34});
    }
  ​
    public static void printMax( int... numbers){
        if (numbers.length==0){
            System.out.println("No argument passed");
            return;
        }
        int result=numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i]>result) {
                result=numbers[i];
            }
        }
        System.out.println("The max Number is " + result);
    }

 

递归

 

• 递归结构包含两个部分：

  • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。

  • 递归体：什么时候需要调用自身方法。

 public static void main(String[] args) {
        System.out.println(Factorial(5));
    }
​
    public static int Factorial(int n){
        if (n==1) {
            return 1;
        }
        else {
            return n*Factorial(n-1);
        }
    }

 

计算器

public static void main(String[] args) {
        int over=1;
        while(over==1)
        {
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入第一个数：");
            double first=sc.nextDouble();
            System.out.println("请输入+-*/运算符：");
            String str=sc.next();
            System.out.println("请输入第二个数：");
            double second=sc.nextDouble();
            System.out.println("运算结果：");
            switch (str)
            {
                case "+":
                    System.out.println(first+"+"+second+"="+add(first,second));
                    break;
                case "-":
                    System.out.println(first+"-"+second+"="+sub(first,second));
                    break;
                case "*":
                    System.out.println(first+"*"+second+"="+mul(first,second));
                    break;
                case "/":
                    System.out.println(first+"/"+second+"="+div(first,second));
                    break;
                default:
                    System.out.println("输入运算符有误！");
            }
            System.out.println("按1继续,按0结束");
            over=sc.nextInt();
        }
    }
​
    public static double add(double a,double b){
       return a+b;
    }
    public static double sub(double a,double b){
            return a-b;
    }
    public static double mul(double a,double b){
        return a*b;
    }
    public static double div(double a,double b){
       return a/b;
    }

 

一维数组

• 数组的创建

datatype[] arrayRefVar= new datatype[arraySize];

• 数组下标越界提示

java.lang.ArrayIndexOutOfBoundsException

• 静态初始化

int[] a={1,4,6,3};

• 动态初始化

int[] b=new int[10];

• 加强for循环输出数组 for. Each

     int[] arrays={4,5,2,8,3};
            //Jdk1.5 ,没有下标  
        for (int i : arrays) {
            System.out.println(i);
        }

• 数组的反转代码实现

 public static void main(String[] args) {
            int[] arrays={1,2,3,4,5};
            printarray(arrays);
        System.out.println("\n*****************");
            int[] result=reverse(arrays);
            printarray(result);
    }
    //反转数组元素
    public static int[] reverse(int[] arrays){
        int[] result=new int[arrays.length];
        for (int i = 0; i < arrays.length; i++) {
            result[arrays.length-1-i]=arrays[i];
        }
        return result;
    }
    //打印数组元素
    public  static void  printarray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }

 

二维数组

• 二维数组遍历输出

 public static void main(String[] args) {
        int[][] arrays={{5,6,4,8,2},{6,5,4,7,1}};
       printarray(arrays);
    }
    public  static void  printarray(int[][] arrays){
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j <arrays[i].length ; j++) {
                System.out.print(arrays[i][j]+" ");
            }
            System.out.println();
        }
    }

 

Arrays类

• 数组的打印输出和排序

  public static void main(String[] args) {
        int[] a={4,5,3,9,6,2,7};
        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);//升序排序
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,0);//数组的填充
        System.out.println(Arrays.toString(a));
    }

• 常用功能

  • 给数组赋值：通过fill方法

  • 对数组排序：通过sort方法，默认升序排序

  • 比较数组：通过equals方法比较数组中元素的值是否相等

  • 查找数组元素：通过binary Search方法能对排序好的数组进行二分查找法操作

 

冒泡排序

1. 比较数组中，两个相邻元素，如果第一个数比第二个数大，就交换他的位置

2. 每一次比较都会产生一个最大或者最小的数字

3. 下一轮，怎会少一次排序

4. 依次循环，直至结束！

 public static void main(String[] args) {
        int[] a={7,9,5,8,3,2,1,6,4};
        System.out.println(Arrays.toString(a));
        arraysort(a);
    }
    
    public static  int[] arraysort(int[] a){
        int temp=0;
        for (int i = 0; i <a.length-1; i++) {
            for (int j =0; j <a.length-1-i; j++) {
                if(a[j+1]>a[j]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
        return a;
    }