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

 

 

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 游动-白 设计师: 上身试试
应支付0元
点击重新获取
扫码支付

支付成功即可阅读