String S = "Hello";

System.out.println("===== 获取字符串信息 =====");
// 1. length(): 获取字符串长度
String str = "Hello, Java!";
int length = str.length();
System.out.println("字符串长度: " + length); // 输出: 12

// 2. charAt(int index): 获取指定索引处的字符
char ch = str.charAt(7);
System.out.println("索引 7 处的字符: " + ch); // 输出: J

// 3. indexOf(String str) 和 lastIndexOf(String str): 查找子字符串的位置
int firstIndex = str.indexOf("Java");
int lastIndex = str.lastIndexOf("Java");
System.out.println("第一次出现 'Java' 的位置: " + firstIndex); // 输出: 7
System.out.println("最后一次出现 'Java' 的位置: " + lastIndex); // 输出: 7


// ======================== 字符串比较 ========================
System.out.println("\n===== 字符串比较 =====");

// 4. equals() 和 equalsIgnoreCase(): 比较字符串内容
String str1 = "Java";
String str2 = "java";
boolean isEqual = str1.equals(str2);
boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2);
System.out.println("区分大小写比较: " + isEqual);           // 输出: false
System.out.println("忽略大小写比较: " + isEqualIgnoreCase); // 输出: true


// ======================== 字符串修改 ========================
System.out.println("\n===== 字符串修改 =====");

// 6. toLowerCase() 和 toUpperCase(): 大小写转换
String mixedCase = "Hello, World!";
String lowerCase = mixedCase.toLowerCase();
String upperCase = mixedCase.toUpperCase();
System.out.println("小写: " + lowerCase); // 输出: hello, world!
System.out.println("大写: " + upperCase); // 输出: HELLO, WORLD!

// 7. trim(): 去除首尾空白字符
String withSpaces = "   Hello, Java!   ";
String trimmed = withSpaces.trim();
System.out.println("去除空格后: '" + trimmed + "'"); // 输出: 'Hello, Java!'

// 8. replace(char oldChar, char newChar) 和 replace(CharSequence target, CharSequence replacement): 替换字符或子字符串
String original = "Hello, Java!";
String replacedChar = original.replace('J', 'L');
String replacedString = original.replace("Java", "Python");
System.out.println("替换字符: " + replacedChar);         // 输出: Hello, Lava!
System.out.println("替换子字符串: " + replacedString);   // 输出: Hello, Python!


// ======================== 字符串分割与拼接 ========================
System.out.println("\n===== 字符串分割与拼接 =====");

// 9. split(String regex): 按正则表达式分割字符串
String fruits = "apple,banana,cherry";
String[] parts = fruits.split(",");
System.out.print("分割后的字符串数组: ");
for (String part : parts) {
    System.out.print(part + " "); // 输出: apple banana cherry
}
System.out.println();

// 10. join(CharSequence delimiter, CharSequence... elements): 拼接字符串
String joined = String.join("-", "2023", "10", "05");
System.out.println("拼接后的字符串: " + joined); // 输出: 2023-10-05


// ======================== 字符串判断 ========================
System.out.println("\n===== 字符串判断 =====");

// 11. startsWith(String prefix) 和 endsWith(String suffix): 判断字符串是否以指定前缀或后缀开头/结尾
String sentence = "Hello, Java!";
boolean startsWithHello = sentence.startsWith("Hello");
boolean endsWithJava = sentence.endsWith("Java!");
System.out.println("以 'Hello' 开头: " + startsWithHello); // 输出: true
System.out.println("以 'Java!' 结尾: " + endsWithJava);     // 输出: true

// 12. isEmpty() 判断字符串是否为空或空白
String emptyString = "";
boolean isEmpty = emptyString.isEmpty();
System.out.println("是否为空字符串: " + isEmpty); // 输出: true


// ======================== 字符串提取 ========================
System.out.println("\n===== 字符串提取 =====");
// 13. substring(int beginIndex, int endIndex): 提取子字符串
String text = "Hello, Java!";
String subText = text.substring(7, 11); // 左闭右开
System.out.println("提取的子字符串: " + subText); // 输出: Java

String firstName = "Bi";
String lastName = "ouwai";
System.out.println(firstName + lastName);
System.out.println(firstName.concat(lastName));

// 与数字拼接
int x = 10;
int y = 20;
int z = x + y;      // z 将是 30（整数/数字）

String x = "10";
String y = "20";
String z = x + y;   // z 将是 1020（字符串）

String txt = "abc"d"e."; // d的位置会报错

// 数组基本概念
// 1. 声明并静态初始化一个数组
int[] numbers = {10, 20, 30, 40, 50};
System.out.println("初始化的数组:");
for (int i : numbers) System.out.println(i);

// 2. 访问数组元素
System.out.println("\n访问数组元素:");
System.out.println("numbers[0]: " + numbers[0]);  // 输出第一个元素
System.out.println("numbers[2]: " + numbers[2]);  // 输出第三个元素

// 3. 修改数组元素
numbers[1] = 25;  // 修改第二个元素
System.out.println("\n修改后的数组:");
for (int i : numbers) System.out.println(i);

// 4. 获取数组长度
System.out.println("\n数组的长度: " + numbers.length);

// 5. 遍历数组
System.out.println("\n遍历数组:");
for (int i = 0; i < numbers.length; i++) {
    System.out.println("Element at index " + i + ": " + numbers[i]);
}

// 6. 使用增强型for循环遍历数组
System.out.println("\n使用增强型for循环遍历数组:");
for (int num : numbers) {
    System.out.println(num);
}

// 7. 多维数组的静态初始化
int[][] matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
};
System.out.println("\n二维数组matrix:");
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

// 数组常用方法
// 1. 排序数组 (Arrays.sort)
Arrays.sort(numbers);  // 对数组进行升序排序
System.out.println("\n排序后的数组:");
for (int i : numbers) System.out.println(i);

// 2. 复制数组 (Arrays.copyOf)
int[] copiedArray = Arrays.copyOf(numbers, numbers.length);
System.out.println("\n复制后的数组:");
for (int i : copiedArray) System.out.println(i);

// 3. 填充数组 (Arrays.fill)
Arrays.fill(copiedArray, 10);  // 将数组的所有元素设置为10
System.out.println("\n填充后的数组:");
for (int i : copiedArray) System.out.println(i);

// 4. 查找元素 (Arrays.binarySearch)
// 注意：使用binarySearch前需要确保数组已排序
int searchKey = 3;
int index = Arrays.binarySearch(numbers, searchKey);
if (index >= 0) {
    System.out.println("\n元素 " + searchKey + " 在数组中的索引位置是: " + index);
} else {
    System.out.println("\n元素 " + searchKey + " 不在数组中");
}

// 5. 比较数组 (Arrays.equals)
int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};
System.out.println(array1 == array2);  // 此处比较的是两个array的地址是否相同
boolean isEqual = Arrays.equals(array1, array2);  // 比较两个数组是否相等
System.out.println("\narray1 和 array2 是否相等: " + isEqual);

// 6 转换数组为字符串 (Arrays.toString)
System.out.println("\n将数组转换为字符串:");
System.out.println(Arrays.toString(numbers));

// 7. 多维数组的操作 (Arrays.deepToString)
System.out.println("\n二维数组matrix:");
System.out.println(Arrays.toString(matrix));
System.out.println(Arrays.deepToString(matrix));  // 使用deepToString打印多维数组

public class 类名 {
    // 字段（属性）
    数据类型 属性名;

    // 构造器
    public 类名(参数列表) {
        // 初始化代码
    }

    // 方法
    public 返回值类型 方法名(参数列表) {
        // 方法体
    }
}

[访问修饰符] [其他修饰符] 返回值类型 方法名(参数列表) {
    // 方法体
}

// 抽象类 Animal
abstract class Animal {
    protected String name;

    // 构造方法
    public Animal(String name) {
        this.name = name;
    }

    // 抽象方法：子类必须实现
    public abstract void sound();

    // 普通方法：所有子类共享
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// 子类 Dog 继承自 Animal
class Dog extends Animal {
    // 构造方法
    public Dog(String name) {
        super(name);  // 如果父类没有无参构造方法，子类必须第一行用 super (...) 调用父类的有参构造方法，否则报错。
    }

    // 实现抽象方法
    @Override
    public void sound() {
        System.out.println(name + " says: Woof!");
    }
}

// 子类 Cat 继承自 Animal
class Cat extends Animal {
    // 构造方法
    public Cat(String name) {
        super(name);
    }

    // 实现抽象方法
    @Override
    public void sound() {
        System.out.println(name + " says: Meow!");
    }
}

// 测试类 Main
public class Main {
    public static void main(String[] args) {
        // 创建 Dog 对象
        Animal dog = new Dog("Buddy");
        dog.sound();  // 输出：Buddy says: Woof!
        dog.sleep();  // 输出：Buddy is sleeping.

        System.out.println();

        // 创建 Cat 对象
        Animal cat = new Cat("Kitty");
        cat.sound();  // 输出：Kitty says: Meow!
        cat.sleep();  // 输出：Kitty is sleeping.
    }
}

public class Main {
    // 成员内部类（非静态）
    class MemberInnerClass {
        public void display() {
            System.out.println("This is a member inner class.");
        }
    }

    // 静态嵌套类
    static class StaticNestedClass {
        public void display() {
            System.out.println("This is a static nested class.");
        }
    }

    // 外部类方法
    public void createLocalAndAnonymousClasses() {
        // 局部内部类
        class LocalInnerClass {
            public void display() {
                System.out.println("This is a local inner class.");
            }
        }

        // 创建局部内部类对象并调用方法
        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();

        // 匿名内部类 Runnable
        Runnable anonymousInner = new Runnable() {
            @Override
            public void run() {
                System.out.println("This is an anonymous inner class.");
            }
        };

        // 调用匿名内部类的方法
        anonymousInner.run();
    }

    // 测试主方法
    public static void main(String[] args) {
        // 创建外部类对象
        Main outer = new Main();

        // 创建成员内部类对象并调用方法
        Main.MemberInnerClass memberInner = outer.new MemberInnerClass();
        memberInner.display();

        // 创建静态嵌套类对象并调用方法
        Main.StaticNestedClass staticNested = new Main.StaticNestedClass();
        staticNested.display();

        // 调用方法以创建局部内部类和匿名内部类
        outer.createLocalAndAnonymousClasses();
    }
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

/**
 * 该类演示了 Collection 接口的基本操作。
 */
public class CollectionExample {

    public static void main(String[] args) {
        // 1. 创建一个 Collection 实例（使用 ArrayList）
        Collection<String> collection = new ArrayList<>();

        // 2. 添加元素到集合
        collection.add("Apple");
        collection.add("Banana");
        collection.add("Cherry");

        System.out.println("初始的 Collection: " + collection); // 初始的 Collection: [Apple, Banana, Cherry]

        // 3. 检查集合是否为空
        boolean isEmpty = collection.isEmpty();
        System.out.println("集合是否为空: " + isEmpty);

        // 4. 获取集合的大小
        int size = collection.size();
        System.out.println("集合的大小: " + size);

        // 5. 检查集合是否包含某个元素
        boolean containsBanana = collection.contains("Banana");
        System.out.println("集合是否包含 'Banana': " + containsBanana);

        // 6. 删除集合中的元素
        collection.remove("Banana");
        System.out.println("删除 'Banana' 后的 Collection: " + collection);

        // 7. 遍历集合（使用增强型 for 循环）
        System.out.println("使用增强型 for 循环遍历集合:");
        for (String item : collection) {
            System.out.println(item);
        }

        // 8. 使用 Iterator 遍历集合
        System.out.println("使用 Iterator 遍历集合:");
        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            System.out.println(item);
        }

        // 9. 清空集合
        collection.clear();
        System.out.println("清空后的 Collection: " + collection);

        // 10. 使用 HashSet 演示 Collection 的另一个实现
        // HashSet<> 是 Java 里的集合，特点：
        // ✅ 不能存重复元素
        // ✅ 无序（存的顺序和取出来不一样）
        // ✅ 底层靠哈希表，查询、增删很快
        Collection<String> hashSetCollection = new HashSet<>();
        hashSetCollection.add("Orange");
        hashSetCollection.add("Apple");
        hashSetCollection.add("Banana");

        System.out.println("HashSet Collection: " + hashSetCollection);  // HashSet Collection: [Apple, Orange, Banana]
    }
}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * 该类演示了 List 接口的基本操作。
 */
public class ListExample {

    public static void main(String[] args) {
        // 1. 创建一个 ArrayList 实例
        List<String> arrayList = new ArrayList<>();

        // 2. 添加元素到 List
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Cherry");

        System.out.println("初始的 ArrayList: " + arrayList);

        // 3. 在指定位置插入元素
        arrayList.add(1, "Blueberry"); // 在索引 1 的位置插入 "Blueberry"
        System.out.println("在索引 1 插入元素后的 ArrayList: " + arrayList);

        // 4. 访问 List 中的元素
        String element = arrayList.get(2); // 获取索引为 2 的元素
        System.out.println("索引 2 处的元素: " + element);

        // 5. 修改 List 中的元素
        arrayList.set(3, "Dragonfruit"); // 将索引 3 的元素替换为 "Dragonfruit"
        System.out.println("修改索引 3 元素后的 ArrayList: " + arrayList);

        // 6. 删除 List 中的元素
        arrayList.remove("Banana"); // 删除值为 "Banana" 的元素
        System.out.println("删除 'Banana' 后的 ArrayList: " + arrayList);

        // 7. 遍历 List（使用增强型 for 循环）
        System.out.println("使用增强型 for 循环遍历 ArrayList:");
        for (String item : arrayList) {
            System.out.println(item);
        }

        // 8. 使用 LinkedList 演示 List 的另一个实现
        List<String> linkedList = new LinkedList<>();
        linkedList.add("Orange");
        linkedList.add("Apple");
        linkedList.add("Banana");

        System.out.println("LinkedList: " + linkedList);

        // 9. 在 LinkedList 中插入和删除元素
        linkedList.add(1, "Mango"); // 在索引 1 的位置插入 "Mango"
        linkedList.remove(2);       // 删除索引为 2 的元素
        System.out.println("修改后的 LinkedList: " + linkedList);
    }
}

import java.util.*;

public class SetExample {

    public static void main(String[] args) {
        // 1. 使用 HashSet 演示无序且不允许重复的集合
        System.out.println("==== HashSet 示例 ====");
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Orange");
        hashSet.add("Apple"); // 重复元素不会被添加

        System.out.println("HashSet 内容: " + hashSet); // 输出顺序可能不同
        System.out.println("是否包含 'Banana': " + hashSet.contains("Banana")); // true
        System.out.println("HashSet 大小: " + hashSet.size()); // 3

        // 2. 使用 LinkedHashSet 演示按插入顺序存储的集合
        System.out.println("\n==== LinkedHashSet 示例 ====");
        Set<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("One");
        linkedHashSet.add("Two");
        linkedHashSet.add("Three");

        System.out.println("LinkedHashSet 内容: " + linkedHashSet); // 保持插入顺序
        linkedHashSet.remove("Two");
        System.out.println("移除 'Two' 后的内容: " + linkedHashSet);

        // 3. 使用 TreeSet 演示自动排序的集合
        System.out.println("\n==== TreeSet 示例 ====");
        Set<Integer> treeSet = new TreeSet<>();
        treeSet.add(10);
        treeSet.add(5);
        treeSet.add(20);
        treeSet.add(5); // 重复元素不会被添加

        System.out.println("TreeSet 内容: " + treeSet); // 自动按升序排列
        System.out.println("第一个元素: " + ((TreeSet<Integer>) treeSet).first()); // 5
        System.out.println("最后一个元素: " + ((TreeSet<Integer>) treeSet).last()); // 20

        // 4. 数学集合运算：交集、并集、差集
        System.out.println("\n==== 数学集合运算示例 ====");
        Set<Integer> setA = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
        Set<Integer> setB = new HashSet<>(Arrays.asList(4, 5, 6, 7));

        // 并集
        Set<Integer> union = new HashSet<>(setA);
        union.addAll(setB);
        System.out.println("并集: " + union);

        // 交集
        Set<Integer> intersection = new HashSet<>(setA);
        intersection.retainAll(setB);
        System.out.println("交集: " + intersection);

        // 差集
        Set<Integer> difference = new HashSet<>(setA);
        difference.removeAll(setB);
        System.out.println("差集 (setA - setB): " + difference);
    }
}

import java.util.ArrayList;
import java.util.List;

/**
 * 本文件展示了Java泛型的基本用法，包括泛型类、泛型接口和泛型方法。
 */
public class GenericExample {

    /**
     * 泛型类示例：Box<T>
     * 用于存储任意类型的数据。
     */
    public static class Box<T> {
        private T item;

        public void setItem(T item) {
            this.item = item;
        }

        public T getItem() {
            return item;
        }
    }

    /**
     * 泛型接口示例：Container<T>
     * 定义了一个可以存储和获取元素的容器。
     */
    public interface Container<T> {
        void add(T item);
        T get(int index);
    }

    /**
     * 实现泛型接口的类：StringContainer
     * 专门用于存储字符串类型的容器。
     */
    public static class StringContainer implements Container<String> {
        private List<String> items = new ArrayList<>();

        @Override
        public void add(String item) {
            items.add(item);
        }

        @Override
        public String get(int index) {
            return items.get(index);
        }
    }

    /**
     * 泛型方法示例：printArray(T[] array)
     * 打印任意类型的数组内容。
     */
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    /**
     * 主方法：测试泛型类、接口和方法的功能。
     */
    public static void main(String[] args) {
        // 测试泛型类 Box<T>
        Box<Integer> integerBox = new Box<>();
        integerBox.setItem(123);
        System.out.println("泛型类 Box<Integer> 存储的值: " + integerBox.getItem());

        Box<String> stringBox = new Box<>();
        stringBox.setItem("Hello, Generics!");
        System.out.println("泛型类 Box<String> 存储的值: " + stringBox.getItem());

        // 测试泛型接口 Container<T>
        Container<String> container = new StringContainer();
        container.add("Item 1");
        container.add("Item 2");
        System.out.println("泛型接口 Container<String> 获取的值: " + container.get(0));

        // 测试泛型方法 printArray(T[] array)
        Integer[] intArray = {1, 2, 3};
        System.out.println("泛型方法 printArray(Integer[]):");
        printArray(intArray);

        String[] stringArray = {"A", "B", "C"};
        System.out.println("泛型方法 printArray(String[]):");
        printArray(stringArray);
    }
}