Java 基本语法详解（五）

Java 基本语法详解（五）

十二、常用 API 基础（以 String 类为例）

示例：String 类常用方法的使用（完整示例）

public class StringApiDemo {
    public static void main(String[] args) {
        String str = "Hello Java!";
        
        // 1. 获取字符串长度（length()）
        System.out.println("1. 字符串长度：" + str.length()); 
        // 输出：1. 字符串长度：7

        // 2. 获取指定索引的字符（charAt(int index)）
        System.out.println("2. 索引3的字符：" + str.charAt(3)); 
        // 输出：2. 索引3的字符：l

        // 3. 比较字符串内容（equals() 与 equalsIgnoreCase()）
        String str2 = "hello java!";
        System.out.println("3. equals比较（区分大小写）：" + str.equals(str2)); 
        // 输出：3. equals比较（区分大小写）：false
        System.out.println("   equalsIgnoreCase比较（不区分大小写）：" + str.equalsIgnoreCase(str2)); 
        // 输出：   equalsIgnoreCase比较（不区分大小写）：true

        // 4. 判断是否包含子串（contains()）
        System.out.println("4. 是否包含'Java'：" + str.contains("Java")); 
        // 输出：4. 是否包含'Java'：true

        // 5. 查找子串首次出现的索引（indexOf()）
        System.out.println("5. 'Java'首次出现的索引：" + str.indexOf("Java")); 
        // 输出：5. 'Java'首次出现的索引：6

        // 6. 截取子串（substring()）
        System.out.println("6. 从索引6截取子串：" + str.substring(6)); 
        // 输出：6. 从索引6截取子串：Java!
        System.out.println("   从索引0到5截取子串（左闭右开）：" + str.substring(0, 5)); 
        // 输出：   从索引0到5截取子串（左闭右开）：Hello

        // 7. 替换子串（replace()）
        String newStr = str.replace("Java", "World");
        System.out.println("7. 替换后字符串：" + newStr); 
        // 输出：7. 替换后字符串：Hello World!

        // 8. 按分隔符分割字符串（split()）
        String str3 = "apple,banana,orange";
        String[] fruits = str3.split(",");
        System.out.print("8. 分割后的水果数组：");
        for (String fruit : fruits) {
            System.out.print(fruit + " ");
        }
        // 输出：8. 分割后的水果数组：apple banana orange 

        // 9. 字符串大小写转换（toUpperCase() 与 toLowerCase()）
        System.out.println("\n9. 转为大写：" + str.toUpperCase()); 
        // 输出：9. 转为大写：HELLO JAVA!
        System.out.println("   转为小写：" + str.toLowerCase()); 
        // 输出：   转为小写：hello java!
    }
}

十三、集合框架基础（以 ArrayList 为例）

数组的长度固定，无法动态添加 / 删除元素，而集合是长度可变的容器，用于存储多个对象，Java 集合框架（java.util包）提供了丰富的集合类，ArrayList是最常用的 “动态数组” 集合。

1. ArrayList 的核心特性

• 底层基于数组实现，支持动态扩容（长度不足时自动增加容量）；

• 允许存储重复元素，且有序（存储顺序与取出顺序一致）；

• 支持快速随机访问（通过索引获取元素，类似数组）；

• 线程不安全（适合单线程场景，多线程需用Vector或CopyOnWriteArrayList）。

2. ArrayList 的常用操作（CRUD）

使用ArrayList需先导入包：import java.util.ArrayList;

（1）创建 ArrayList 对象

格式：

// 方式1：创建存储指定类型的ArrayList（推荐，需指定泛型，见下文）
ArrayList<数据类型> list = new ArrayList<>();

// 方式2：创建时指定初始容量（减少扩容次数，提升效率）
ArrayList<数据类型> list = new ArrayList<>(初始容量);

（2）常用方法（CRUD）

方法名	功能描述
add(E e)	向集合末尾添加元素
add(int index, E e)	在指定索引处插入元素
get(int index)	获取指定索引的元素
set(int index, E e)	修改指定索引的元素（返回原元素）
remove(int index)	删除指定索引的元素（返回被删除元素）
remove(Object o)	删除指定内容的元素（返回是否删除成功，boolean）
size()	获取集合的元素个数
isEmpty()	判断集合是否为空（空返回 true，否则 false）
clear()	清空集合中的所有元素
contains(Object o)	判断集合是否包含指定元素（包含返回 true）

示例：ArrayList 常用操作

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        // 1. 创建ArrayList（存储String类型，指定泛型）
        ArrayList<String> fruits = new ArrayList<>();

        // 2. 添加元素（add()）
        fruits.add("apple");    // 末尾添加
        fruits.add("banana");
        fruits.add(1, "orange");// 索引1处插入
        System.out.println("2. 添加元素后：" + fruits); 
        // 输出：2. 添加元素后：[apple, orange, banana]

        // 3. 获取元素（get()）与获取长度（size()）
        System.out.println("3. 索引2的元素：" + fruits.get(2)); // 输出：3. 索引2的元素：banana
        System.out.println("   集合元素个数：" + fruits.size()); // 输出：   集合元素个数：3

        // 4. 修改元素（set()）
        String oldFruit = fruits.set(0, "grape"); // 修改索引0的元素，返回原元素
        System.out.println("4. 修改后集合：" + fruits); // 输出：4. 修改后集合：[grape, orange, banana]
        System.out.println("   被修改的原元素：" + oldFruit); // 输出：   被修改的原元素：apple

        // 5. 删除元素（remove()）
        String removedFruit1 = fruits.remove(1); // 删除索引1的元素
        System.out.println("5. 删除索引1后：" + fruits); // 输出：5. 删除索引1后：[grape, banana]
        boolean isRemoved = fruits.remove("banana"); // 删除内容为"banana"的元素
        System.out.println("   删除'banana'是否成功：" + isRemoved); // 输出：   删除'banana'是否成功：true
        System.out.println("   删除后集合：" + fruits); // 输出：   删除后集合：[grape]

        // 6. 判断操作（contains()、isEmpty()）
        System.out.println("6. 是否包含'grape'：" + fruits.contains("grape")); // 输出：6. 是否包含'grape'：true
        System.out.println("   集合是否为空：" + fruits.isEmpty()); // 输出：   集合是否为空：false

        // 7. 清空集合（clear()）
        fruits.clear();
        System.out.println("7. 清空后集合：" + fruits); // 输出：7. 清空后集合：[]
        System.out.println("   清空后是否为空：" + fruits.isEmpty()); // 输出：   清空后是否为空：true
    }
}

3. ArrayList 的遍历方式

（1）普通 for 循环（通过索引遍历）

ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i)); // 输出：a、b、c
}

（2）增强 for 循环（foreach，推荐）

for (String element : list) {
    System.out.println(element); // 输出：a、b、c
}

十四、泛型（Generic）基础

泛型是 Java 5 引入的特性，用于限制集合 / 类 / 方法存储的数据类型，避免 “类型转换异常”，实现 “编译时类型检查”，核心是 “参数化类型”（将类型作为参数传递）。

1. 泛型的核心作用

• 类型安全：编译时检查数据类型，避免运行时出现ClassCastException（如集合中误存不同类型数据）；

• 简化代码：无需手动强制类型转换（非泛型集合需手动转换，如(String) list.get(0)）；

• 代码复用：通过泛型参数实现通用类 / 方法（如一个ArrayList可存储任意类型，只需指定泛型）。

2. 泛型的使用场景

（1）泛型集合（最常用）

非泛型集合（JDK 5 前）会存储Object类型，取出时需强制转换，存在风险；泛型集合指定类型后，仅允许存储该类型数据。

示例：泛型集合 vs 非泛型集合

import java.util.ArrayList;

public class GenericCollectionDemo {
    public static void main(String[] args) {
        // 1. 非泛型集合（风险）
        ArrayList nonGenericList = new ArrayList();
        nonGenericList.add("hello");   // 存String
        nonGenericList.add(123);       // 存int（自动装箱为Integer）
        // 取出时需强制转换，若类型不匹配，运行时抛异常
        String str1 = (String) nonGenericList.get(1); // 运行时异常：ClassCastException

        // 2. 泛型集合（安全）
        ArrayList<String> genericList = new ArrayList<>();
        genericList.add("hello");      // 仅允许存String
        // genericList.add(123);       // 编译报错：不允许存int类型
        String str2 = genericList.get(0); // 无需强制转换，编译时检查类型
    }
}

（2）泛型类（自定义通用类）

格式：class 类名 { 成员变量类型为 T; }，其中T是泛型参数（可自定义名称，如E、K、V）。

示例：自定义泛型类（存储一对数据的 “键值对”）

// 泛型类：T 表示键的类型，U 表示值的类型
class Pair<T, U> {
    private T key;   // 键（类型为T）
    private U value; // 值（类型为U）

    // 构造方法
    public Pair(T key, U value) {
        this.key = key;
        this.value = value;
    }

    // getter方法
    public T getKey() {
        return key;
    }

    public U getValue() {
        return value;
    }
}

// 测试泛型类
public class GenericClassDemo {
    public static void main(String[] args) {
        // 1. 创建Pair对象，指定键为String，值为Integer
        Pair<String, Integer> studentPair = new Pair<>("张三", 20);
        System.out.println("1. 学生：" + studentPair.getKey() + "，年龄：" + studentPair.getValue());
        // 输出：1. 学生：张三，年龄：20

        // 2. 创建Pair对象，指定键为Integer，值为String
        Pair<Integer, String> idPair = new Pair<>(1001, "Java班");
        System.out.println("2. 学号：" + idPair.getKey() + "，班级：" + idPair.getValue());
        // 输出：2. 学号：1001，班级：Java班
    }
}

（3）泛型方法（自定义通用方法）

格式：修饰符 返回值类型 方法名(T 参数) { … }，泛型参数T需在方法返回值前声明。

示例：泛型方法（打印任意类型数组）

public class GenericMethodDemo {
    // 泛型方法：T 表示数组元素类型
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // 1. 打印String数组
        String[] strArray = {"a", "b", "c"};
        System.out.print("1. String数组：");
        printArray(strArray); // 输出：1. String数组：a b c 

        // 2. 打印Integer数组
        Integer[] intArray = {1, 2, 3};
        System.out.print("2. Integer数组：");
        printArray(intArray); // 输出：2. Integer数组：1 2 3 

        // 3. 打印Double数组
        Double[] doubleArray = {1.1, 2.2, 3.3};
        System.out.print("3. Double数组：");
        printArray(doubleArray); // 输出：3. Double数组：1.1 2.2 3.3 
    }
}

3. 泛型通配符（?）

泛型通配符?用于表示 “任意类型”，常见于方法参数，限制泛型的范围。

（1）无界通配符（?）：表示任意类型

示例：打印任意类型的 ArrayList

import java.util.ArrayList;

public class GenericWildcardDemo1 {
    // 无界通配符：接收任意类型的ArrayList
    public static void printList(ArrayList<?> list) {
        for (Object obj : list) {
            System.out.print(obj + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ArrayList<String> strList = new ArrayList<>();
        strList.add("hello");
        strList.add("java");
        System.out.print("1. String列表：");
        printList(strList); // 输出：1. String列表：hello java 

        ArrayList<Integer> intList = new ArrayList<>();
        intList.add(1);
        intList.add(2);
        System.out.print("2. Integer列表：");
        printList(intList); // 输出：2. Integer列表：1 2 
    }
}

（2）上界通配符（? extends 父类）：表示 “父类及其子类”

示例：接收 “Number 及其子类”（如 Integer、Double）的 ArrayList

import java.util.ArrayList;

public class GenericWildcardDemo2 {
    // 上界通配符：仅接收Number及其子类的ArrayList
    public static double sum(ArrayList<? extends Number> list) {
        double total = 0;
        for (Number num : list) {
            total += num.doubleValue(); // Number类的方法，子类均继承
        }
        return total;
    }

    public static void main(String[] args) {
        ArrayList<Integer> intList = new ArrayList<>();
        intList.add(10);
        intList.add(20);
        System.out.println("1. Integer列表求和：" + sum(intList)); // 输出：1. Integer列表求和：30.0

        ArrayList<Double> doubleList = new ArrayList<>();
        doubleList.add(1.5);
        doubleList.add(2.5);
        System.out.println("2. Double列表求和：" + sum(doubleList)); // 输出：2. Double列表求和：4.0

        // ArrayList<String> strList = new ArrayList<>();
        // sum(strList); // 编译报错：String不是Number的子类
    }
}