DAY4方法、数组

一、方法：

1、System（类）.out（对象）.println()（方法）

2、值传递（Java都是值传递）、引用传递

public class Demo01 {
    public static void main(String[] args) {
        int nub = max(3,3);
        System.out.println(nub);

    }
    public static int max(int a,int b){
        int maxnum = 0;
        if(a==b){
            System.out.println("相等");//打印要在return之前，return标志着方法结束
            return a;
        }
        if(a<b){
            maxnum = b;
        }
        else {
            maxnum = a;
        }
        return maxnum;
    }
}

3、方法的重载：

public static int max(int a,int b)

public static int max(double a,double b,double c)

名字完全相同，形参类型不同

仅仅返回值类型不同，不构成重载

4、命令行传参：

执行的时候必须带着包名args，传的参数args[***]，通过下标取出

5、可变参数：

（不定项参数，不知道方法括号里的参数），

public class Demo02 {
public static void main(String[] args) {
    printmax(1,3,5,3,7,8);
}
    public static void printmax(int...numbers){//...个点，如果还有还他参数，那么应该把不定长参数放在最后。

        if(numbers.length==0){
            System.out.println("0");
            return;//如果不return还会接着执行下面的。
        }
        double result = numbers[0];
        for (int i = 1;i < numbers.length;i++){
            if(numbers[i]>result){
                result = numbers[i];
            }
        }
        System.out.println(result);
    }
}

6、递归

1、边界

2、方法体

3、返回

自己调自己会造成一个方法压一个方法的放在栈中，内存容易溢出。小的f（x）可以使用，大的不行！

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

 

二、数组：相同类型的有序集合

1、数组：球队（数组）队员，身上的号，数组已经创建不可以改变长度，不允许出现混合元素，

public class Arrays {
    public static void main(String[] args) {
        int[] number;//声明数组
        number = new int[5];  //创建数组
        number[0]=1;
        number[1]=2;
        number[2]=3;
        number[3]=4;
        number[4]=5;
        System.out.println(number[0]);
        int sum = 0;
        for(int i=0;i<=number.length;i++){
            sum= sum +i;
        }
        System.out.println(sum);
    }
}

2、堆、栈、方法区

静态初始化：

int [] num = {1,2,3,4,5,6};

动态初始化：

1、int[] number;//栈

2、number = new int[5]; //堆

3、数组边界（如果越界会报错）

for each循环遍历数组

 

public class Demo01 {

    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};
     //输出所有元素
        for (int i = 0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }
        System.out.println("=========================");
        //for each循环，没有下标
        for (int array:arrays){
            System.out.println(array);
        }
        System.out.println("=========================");
        //输出所有元素的和
        int sum = 0;
        for (int i = 0; i< arrays.length;i++){
            sum = sum + arrays[i];
        }
        System.out.println(sum);
        System.out.println("=========================");
        //输出最大值
        int max = 0;
        for(int i =0;i<arrays.length;i++){
            if(arrays[i]>max){
                max = arrays[i];
            }
        }
        System.out.println(max);
        System.out.println("=========================");
        printArray(reverse(arrays));
    }
    //数据元素反转方法
public static int [] reverse(int arrays[]){
        int result[] = new int[arrays.length];
for (int i = 0,j=arrays.length-1;i<arrays.length;i++,j--){
    result[j] = arrays[i];
        }
    return result;
    }
    //打印数组方法
    public static void printArray(int array[]){
        for (int i = 0;i<array.length;i++){
            System.out.println(array[i]+" ");
        }
    }

}

多维数组：（最多使用到2维数组）

int arrays[][]={[1,2],[2,3]}

冒泡法：比较相邻的数，每次产生这组数字中，一个最大或最小的数。

fori（idea中for循环的快捷键）

public class Demo02 {
    public static void main(String[] args) {
        int[] a = {1, 2, 4, 6, 7, 2, 9, 23, 64, 23, 66};
        int[] b = sort(a);
        for (int i = 0; i <b.length-1 ; i++) {
            System.out.println(b[i]);
        }
    }
        public static int[] sort (int[]array){
            int temp = 0;
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array ;
    }
}

稀疏数组：

11 11 3

1  6  1

5  8  3