标签：Test2 int arrays static 数组 array public

Exercise

Test02

方法

方法的定义和调用

修饰符 返回值类型 方法名称(参数列表){
     程序语句;
     return表达式;//普通方法如果有返回值的话必须有return，return也可以用来终止方法。如果没有返回值，返回值类型则写成void
     }

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

规则：①方法名必须相同

②参数列表必须不同（个数、类型、参数排列顺序不同等）

③方法的返回值类型可以相同也可以不同

命令行传参（拓展）

package com.weibo02.exercise;

public class Test3 {
    public static void main(String[] args) {
        for (int i = 0;i < args.length;i++){
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}

编译：javac

运行：java（直接运行class文件需要找到其包的路径，执行并传参）

可变参数（了解）

在方法声明中，在指定参数类型后加一个省略号(...)

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

public class Test4 {
    public static void main(String[] args) {
        Test4 test4 = new Test4();
        test4.test(1,2,3,4,5,6);
    }
    public void test(int x,int ...i){
        System.out.println(i[0]);
    }
}

递归（掌握思想，尽量避免使用）

结构：递归头（什么时候不调用自身方法。没有头会陷入死循环）

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

案例：5的阶乘

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

数组

数组的声明和创建

数组类型 数组名[] = new 数据类型[长度]
//声明一个元素个数为10的整型数组score，同时开辟一块内存空间供其使用
int[] score = new int[10];

三种初始化

int[] arrays = {1,2,3,4};   //静态初始化
int[] b = new int [10];    //动态初始化
b[0] = 10;  //给第一个元素赋值，未被赋值的默认是0即默认初始化

int类型默认值是0，布尔类型默认值是false，其他默认值都是null

数组下标越界的话会出现异常：ArrayIndexOutOfBoundsException

数组的使用

普通的For循环

For-Each循环

数组作方法入参

数组作为返回值

eg.没有下标的循环遍历

for(int array:arrays){    //arrays是上一步声明创建的数组
     System.out.println(array);
}

eg.反转数组

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

}

二维数组

int a[][] = new int[2][5];

Arrays类（自行查找jdk帮助文档）

Arrays类都是static修饰的静态方法，可以直接通过类名调用

常见功能：

给数组赋值：通过fill方法

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

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

查找数组元素：通过binarySearch方法能对排好序的数组进行二分查找

package com.weibo02.exercise;

import java.util.Arrays;  //idea可以自动导包

public class ArrayDemo2 {
    public static void main(String[] args) {
        int [] a = {12,1,56,89,45,58,122};
        System.out.println(a);    //直接打印a是hashcold
        System.out.println(Arrays.toString(a));   //toString是把数组以字符串形式表现出来
        Arrays.sort(a);    //排序（升序）
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4,0);   //左闭右开区间：[2,4)倍填充为0
        System.out.println(Arrays.toString(a));
    }
}

★冒泡排序

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

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

下一轮比较则少一次排序。

依次循环直到结束

时间复杂度O(n^2)

package com.weibo02.exercise;

import java.util.Arrays;

public class ArrayDemo3 {
    public static void main(String[] args) {
        int[]a = {2,6,7,8,9,4,5,45,85,12};
        int[] rank = rank(a);  //调用完自己写的方法后，返回一个排序后的数组
        System.out.println(Arrays.toString(rank));
    }
    public static int[] rank(int[] array){
        int temp;
        //外层循环，判断比较次数
        for (int i = 0;i < array.length-1;i++){
            boolean flag = false;    //通过flag标识位减少没有意义的比较
            //内层循环：比较两个数并交换
            for (int j = 0;j < array.length-1;j++){
                if (array[j+1] > array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
        }
        return array;
    }
}

运用Debug自行调试加深理解

标签：Test2,int,arrays,static,数组,array,public
From： https://www.cnblogs.com/RRubp/p/16837262.html

Test2