前端在职开发挑战 120 天学 Java （Day1-3）

前端在职开发挑战 120 天学 Java （Day1-3）

120 天 Java 学习挑战进行中！感兴趣的小伙伴可以联系我，共享学习，少走弯路

内容总结
- Day1：基本类型、包装类、自动装箱拆箱、引用数据类型、变量
- Day2：类型转换（自动 / 强制）、运算符、控制语句
- Day3：数组、字符串

Day1：Java 基础语法与数据类型

一、基本数据类型

// 8种基本数据类型定义示例
byte f = 100;        // 字节类型
short g = 1000;      // 短整数类型
int a = 10;          // 整数类型
long h = 1000000L;   // 长整数类型（需加L）
float i = 3.14f;     // 单精度浮点数（需加f）
double b = 3.14;     // 双精度浮点数
char c = 'a';        // 字符类型
boolean d = true;    // 布尔类型

二、包装数据类型

包装类（Wrapper Class）是 Java 为 8 种基本数据类型提供的对象形式，允许基本类型参与面向对象编程

创建包装类及其方法

 // 创建包装类
Integer num1 = new Integer(10); // 不推荐（已过时）
Integer num2 = Integer.valueOf(10); // 推荐（利用缓存）

// 字符串转基本类型
Integer.parseInt("123")

// 基本类型转字符串
Integer.toString(123)

// 最大值/最小值
Integer.MAX_VALUE
Integer.MIN_VALUE

SDK文档中查阅包装类使用：
https://tool.oschina.net/apidocs/apidoc?api=jdk-zh

自动装箱与拆箱：

// 自动装箱（基本类型→包装类）
// 编译器自动调用valueOf()
Integer x = 1000; // 等价于 Integer x = Integer.valueOf(1000)

// 自动拆箱（包装类→基本类型）
// 编译器自动调用xxxValue()
int num = x; // 等价于 int num = x.intValue()

缓存机制：

Byte/Short/Integer/Long 默认缓存 -128~127 范围的对象

Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true（缓存区范围：-128~127）

Integer m = 128;
Integer n = 128;
System.out.println(m == n); // false（超出缓存范围）

三、变量类型

1. 静态变量：存在默认值，static修饰
2. 实例变量：存在默认值，实例中申明
3. 局部变量：必须要申明，方法体中申明

public class Main {
    static float n; // 静态变量（类级别，默认值0.0f）
    int z;          // 实例变量（对象级别，默认值0）
    
    public static void main(String[] args) {
        int a = 10; // 局部变量（方法内，必须初始化）
        System.out.println(n); // 输出0.0
    }
}

四、引用数据类型

引用数据类型包含类（自定义类、内置类）、数组、接口，默认值为null

public class Main {
    public static void main(String[] args) {
        // 内置类String，Java自身内置的类
        String str3 = "hello";
        // 自定义类
        Teacher teacher = new Teacher();
        System.out.println(teacher.i);
    }
}

Day2：类型转换

一、类型转换

自动转换（小范围→大范围）：

• 小范围数值类型 → 大范围数值类型（如byte → short → int → long → float → double）
• char 类型转换为 int（ASCII 值）

byte a = 100;
int b = a; // byte自动转换为int
double c = b; // int自动转换为double

char c = 'A';
int ascii = c; // 结果为65

强制转换（大范围→小范围）：

目标类型 变量名 = (目标类型)源变量;

double d = 3.14;
int e = (int)d; // 结果为3，小数部分被截断

常见类型转换：

public class Main {
    public static void main(String[] args) {
        // 字符串转换为整数
        String str = "123";
        int i = Integer.parseInt(str);
        System.out.println(i);

        // 字符串转换为浮点数
        String str2 = "123.456";
        double d = Double.parseDouble(str2);
        System.out.println(d);

        // 字符串转换为布尔值
        String str3 = "true";
        boolean b = Boolean.parseBoolean(str3);
        System.out.println(b);

        // 字符串转换为字符
        String str4 = "a";
        char c = str4.charAt(0);
        System.out.println(c);

        // 数字转换为字符串
        int i2 = 123;
        String str5 = String.valueOf(i2);
        System.out.println(str5);
    }
}

运算符和控制语句

所有语言互通，用法和前端一模一样

Day3：数组、字符串

字符串

常用字符串方法

String helloString = "Hello";
String worldString = "World";
// 返回字符串长度
System.out.println(helloString.length());
// 字符串拼接
System.out.println(helloString.concat(worldString));
// 输出指定位置字符
System.out.println(helloString.charAt(2));

// 判断字符串是否为空（长度为 0）
String emptyStr = "";
boolean isEmpty = emptyStr.isEmpty(); // true

// equals严格比较字符串内容（区分大小写）   equalsIgnoreCase忽略大小写比较内容
String s1 = "Java";
String s2 = new String("Java");
boolean isEqual = s1.equals(s2); // true

// 判断是否包含指定子串
String str = "Hello World";
boolean hasWorld = str.contains("World"); // true

// 返回子串首次出现的索引（未找到返回 -1）
String str = "apple banana apple";
int firstIndex = str.indexOf("apple"); // 0
int lastIndex = str.lastIndexOf("apple"); // 12

// 从 beginIndex 开始截取到末尾
String str = "HelloWorld";
String sub1 = str.substring(5); // "World"
String sub2 = str.substring(0, 5); // "Hello"  截取 [beginIndex, endIndex) 范围的子串

// 按正则表达式分割字符串为数组
String data = "A,B,C";
String[] parts = data.split(","); // ["A", "B", "C"]
String data1 = String.join(",", parts); // "A,B,C"

// 替换所有匹配字符
String str = "apple";
String replaced = str.replace('a', 'A'); // "Apple"

// 转换为全小写或全大写
String mixed = "Hello World";
String lower = mixed.toLowerCase(); // "hello world"
String upper = mixed.toUpperCase(); // "HELLO WORLD"

// 去除字符串两端的空白字符
String str = "   Hello   ";
String trimmed = str.trim(); // "Hello"

// 拼接字符串（等效于 + 操作符）
String s1 = "Hello";
String s2 = s1.concat(" World"); // "Hello World"

// 用分隔符拼接多个字符串
String joined = String.join("-", "2023", "10", "01"); // "2023-10-01"

// 按格式模板生成字符串
String name = "Alice";
int age = 25;
String formatted = String.format("Name: %s, Age: %d", name, age);//"Name: Alice, Age: 25"

// 返回指定索引处的字符
String str = "Java";
char c = str.charAt(0); // 'J'

// 将字符串转换为字符数组
String str = "Hello";
char[] arr = str.toCharArray(); // ['H','e','l','l','o']

数组

数组的定义

public class Main {
    public static void main(String[] args) {
        // 数组的定义
        int[] arr = new int[5];
        // 数组的定义
        String[] arr1 = {"a", "b", "c", "d", "e"};
        // 数组的遍历
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
            System.out.println(arr[i]); // 0 1 2 3 4
        }
        // foreach遍历
        for (int i : arr) {
            System.out.println(i); // 0 1 2 3 4
        }
    }
}

Arrays方法

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String args[]) {
        int[] arr = {1, 2, 3, 4, 5};
        // toString() 方法
        Arrays.toString(arr); // [1, 2, 3, 4, 5]

        // sort() 方法  parallelSort() 方法 并行排序（大数据量时效率更高）
        int [] arr2 = {5, 3, 14, 21, 2};
        Arrays.sort(arr2); // [2, 3, 5, 14, 21]

        // fill() 方法 填充数组
        int [] arr3 = new int[5];
        Arrays.fill(arr3, 8); // [8, 8, 8, 8, 8]
        Arrays.fill(arr3, 0,3,8); // [8, 8, 8, 0, 0]

        // binarySearch() 方法 二分查找
        int [] arr4 = {2, 3, 5, 8, 14, 21};
        Arrays.binarySearch(arr4, 8); // 3
        Arrays.binarySearch(arr4, 0, 3, 8); // -1

        // equals() 方法 比较两个数组是否相等
        int [] arr5 = {2, 3, 5, 8, 14, 21};
        int [] arr6 = {2, 3, 5, 8, 14, 21};
        Arrays.equals(arr5, arr6); // true

        // deepEquals() 方法 比较两个多维数组是否相等
        int [][] arr7 = {{2, 3, 5, 8, 14, 21}};
        int [][] arr8 = {{2, 3, 5, 8, 14, 21}};
        Arrays.deepEquals(arr7, arr8); // true

        // asList() 方法 将数组转换为列表 （不可增删元素）
        List<String> list = Arrays.asList("A", "B"); // [A, B]
        // list.add("C"); // UnsupportedOperationException异常报错

        // stream() 方法 将数组转换为流
        int [] arr9 = {2, 3, 5, 8, 14, 21};
        Arrays.stream(arr9).forEach(System.out::println); // 2 3 5 8 14 21

        // copyOf() 方法 复制数组
        int [] arr10 = {2, 3, 5, 8, 14, 21};
        Arrays.copyOf(arr10, 3); // [2, 3, 5]

        // copyOfRange() 方法 复制数组指定范围
        int [] arr11 = {2, 3, 5, 8, 14, 21};
        Arrays.copyOfRange(arr11, 2, 5); // [5, 8, 14]

        //  parallelPrefix() 方法 并行前缀计算
        int [] arr12 = {2, 3, 5, 8, 14, 21};
        Arrays.parallelPrefix(arr12, (x, y) -> x + y); // [2, 5, 10, 18, 32, 53]

        // setAll() 方法 设置数组元素
        int [] arr13 = new int[5];
        Arrays.setAll(arr13, i -> i * 2); // [0, 2, 4, 6, 8]
    }
}

三、练习题解析

找AI出了两个练习题，适当练习一下

类型转换综合题：

byte a = 10;
short b = 20;
int c = 300;
long d = 1000L;
float e = 3.14f;
double f = 9.8;
char g = 'A'; // ASCII值为65

// 计算下列表达式结果，并说明类型转换规则
1. a + b = ? （结果类型及值）
2. c * d = ? （结果类型及值）
3. e + f = ? （结果类型及值，是否有精度损失）
4. (int)e + g = ? （结果值及计算过程）
5. (short)(a * 200) = ? （结果值及是否溢出）

控制语句与包装类综合应用：

编写 Java 程序实现以下功能：

1. 定义一个 Integer 数组，包含元素：[5, null, 12, 8, null, 20]
2. 使用 for 循环遍历数组，计算所有非 null 元素的累加和
3. 统计数组中 null 元素的个数
4. 输出结果格式：“累加和：X，null元素个数：Y”
5. 处理可能出现的 NullPointerException

如果想要一起学习，可以联系我，大家分享一下自己好的学习渠道，优秀的学习资源，共同进步