Java学习_Day 06(学习内容：狂神说JAVA零基础2P48-2P57)

Charis Hu

已于 2022-04-16 10:54:11 修改

阅读量281

点赞数

分类专栏： JAVA学习文章标签： java

于 2022-04-13 22:44:02 首次发布

本文链接：https://blog.csdn.net/weixin_48814364/article/details/124142895

版权

JAVA学习专栏收录该内容

34 篇文章 0 订阅

订阅专栏

2P48 命令行传参

package com.hu.method;

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

2P49 可变参数

package com.hu.method;

public class P49 {
    public static void main(String[] args) {
        // 可变参数
        // 指定参数类型+一个省略号
        // 一个方法只能有一个可变参数，剩下所有参数都必须在可变参数之前声明
        P49 p49 = new P49();
        p49.test(1);
    }
    public void test(int x,int... i){
        System.out.println(i[0]);
    }
}

package com.hu.method;

public class P49_1 {
    public static void main(String[] args) {
        P49_1 p49_1 = new P49_1();
        System.out.println(p49_1.max(1,2,3,7,58));
    }


    public int max(int... numbers){
        if (numbers.length == 0){
            System.out.println("无参数");
            return 0;
        }
        int maxNumber = 0;
        for (int num : numbers){
            if (num > maxNumber){
                maxNumber = num;
            }
        }
        return maxNumber;
    }
}

2P50 递归

边界条件

package com.hu.method;

public class P50 {
    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);
        }
    }
}

计算器

package com.hu.method;

import java.util.Scanner;

public class P50_1 {
    // 写一个加减乘除计算器，循环接收新的数据，通过用户交互来实现
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        P50_1 p50_1 = new P50_1();
        String way = "";

        while (true){
            System.out.println("请选择运算方式:");

            if (scanner.hasNextLine()){
                way = scanner.nextLine();
            }
            switch (way){
                case "add":
                    System.out.println("请输入第一个数字:");
                    double x = scanner.nextDouble();
                    System.out.println("请输入第二个数字:");
                    double y = scanner.nextDouble();
                    System.out.println(x + "+" + y + "计算结果为:"+ p50_1.add(x, y));
                    break;
                case "sub":
                    System.out.println("请输入第一个数字:");
                    x = scanner.nextDouble();
                    System.out.println("请输入第二个数字:");
                    y = scanner.nextDouble();
                    System.out.println(x + "-" + y + "计算结果为:"+ p50_1.sub(x, y));
                    break;
                case "mul":
                    System.out.println("请输入第一个数字:");
                    x = scanner.nextDouble();
                    System.out.println("请输入第二个数字:");
                    y = scanner.nextDouble();
                    System.out.println(x + "*" + y + "计算结果为:"+ p50_1.mul(x, y));
                    break;
                case "div":
                    System.out.println("请输入第一个数字:");
                    x = scanner.nextDouble();
                    System.out.println("请输入第二个数字:");
                    y = scanner.nextDouble();
                    System.out.println(x + "÷" + y + "计算结果为:"+ p50_1.div(x, y));
                    break;
            }
        //scanner.close();
        }
    }

    public double add(double a, double b){
        double sum = 0;
        sum = a + b;
        return sum;
    }

    public double sub(double a, double b){
        double diff = 0;
        diff = a - b;
        return diff;
    }

    public double mul(double a, double b){
        double product = 0;
        product = a * b;
        return product;
    }

    public double div(double a, double b){
        double quotient = 0;
        quotient = a / b;
        return quotient;
    }

}

2P51 什么是数组

相同类型数据的有序集合

2P52 数组的声明和创建

package com.hu.array;

public class P52 {
    // 变量类型 变量名 变量值
    public static void main(String[] args) {
        // 数组类型
        int[] nums; // 声明一个数组
        //int nums2[];  // 不推荐
        // 使用new来创建数组  分配内存空间
        nums = new int[8];

        // 给数组元素赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        //System.out.println(nums[7]);

        // 计算所有元素的和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println("sum为:" + sum);
    }
}

2P53 三种初始化及内存分析

声明、创建和初始化
Java内存（堆、栈、方法区等）

分为动态初始化和静态初始化

在这里插入图片描述

package com.hu.array;

public class P53 {
    public static void main(String[] args) {
        // 静态初始化  创建+赋值
        int[] a = {1, 2, 3, 4, 5, 6};
        System.out.println(a[0]);

        // 动态初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);

        // 数组也是引用类型，数组元素相当于类的实例变量  int默认是0
        System.out.println(b[1]);
    }
}

2P54 下标越界及小结

数组一旦创建，大小不可改变
数组元素必须是相同类型
数组元素可以是基本数据类型和引用数据类型
数组变量属于引用类型
数组对象是在堆中的

数组下标越界会出现ArrayIndexOutofBounds错误

2P55 数组的使用

普通for循环
for each循环
数组作入参
数组作返回值

package com.hu.array;

public class P55 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        // 打印数组元素

        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }

        System.out.println("============");
        // 计算数组元素和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum = sum + arrays[i];
        }
        System.out.println("sum为" + sum);

        // 查找最大元素
        int max = arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i] > max){
                max = arrays[i];
            }
        }
        System.out.println("最大元素为:" + max);
    }
}

package com.hu.array;

public class P55_1 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        // 省略了下标，适合打印输出，不适合操作
//        for (int array : arrays) {
//            System.out.println(array);
//        }
        // printArray(arrays);
        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;
    }
}

2P56 二维数组

数组嵌套数组

package com.hu.array;

public class P56 {
    public static void main(String[] args) {
        // [3][2]
        int[][] array = {{1,2}, {2,3}, {3,4}};

//        printArray(array[0]);
//        System.out.println(array[0][0]);
//        System.out.println(array[0][1]);
//        System.out.println(array.length);
//        System.out.println(array[0].length);

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                System.out.println(array[i][j]);
            }
        }


    }
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");

        }
    }
}

2P57 Arrays类

这里关于数组类有一些常用方法可以学习一下

package com.hu.array;

import java.util.Arrays;

public class P57 {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 589, 777, 12};

        System.out.println(a);
        // 打印数组元素
        // System.out.println(Arrays.toString(a));
        // printArray(a);
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 0);
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2, 4, 1);
        System.out.println(Arrays.toString(a));
    }
    // 重复造轮子
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i == 0){
                System.out.print("[");
            }
            if (i == a.length-1){
                System.out.println(a[i] + "]");
            }else {
                System.out.print(a[i] + ",");
            }

        }
        
    }
}

2P58 冒泡排序

嵌套循环时间复杂度O(n2)

package com.hu.array;

import java.util.Arrays;

public class P58 {
    public static void main(String[] args) {
        int[] a = {75, 34, 17, 25, 36};
        System.out.println(Arrays.toString(sort(a)));
    }

    public static int[] sort(int[] a){
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-i-1; j++) {
                if (a[j] > a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;

                }
            }

        }
        return a;
    }
}