Java第三天：数组与字符串

📚 学习目标

• 掌握一维数组的声明与使用
• 掌握二维数组的声明与使用
• 理解数组的内存模型
• 掌握常用的数组排序算法
• 掌握String类的常用方法
• 理解StringBuilder和StringBuffer
• 了解正则表达式基础

---

一、一维数组

1.1 数组概述

什么是数组？

数组是一种容器，可以存储多个相同类型的数据。

数组特点

特点	说明
固定长度	数组一旦创建，长度不可变
类型统一	数组中所有元素类型必须相同
连续内存	数组元素在内存中连续存储
索引访问	通过索引（下标）访问元素，从0开始

---

1.2 数组声明与初始化

声明语法

// 方式1：推荐
数据类型[] 数组名;

// 方式2：不推荐
数据类型 数组名[];

初始化方式

public class ArrayDeclaration {
    public static void main(String[] args) {
        // 1. 动态初始化（指定长度）
        int[] arr1 = new int[5];  // 创建长度为5的int数组
        System.out.println("arr1长度: " + arr1.length);  // 5
        
        // 2. 静态初始化（指定元素）
        int[] arr2 = new int[]{1, 2, 3, 4, 5};
        
        // 3. 静态初始化简化写法
        int[] arr3 = {1, 2, 3, 4, 5};
        
        // 4. 先声明后初始化
        int[] arr4;
        arr4 = new int[]{10, 20, 30};
        
        // 5. 不同类型的数组
        String[] names = {"张三", "李四", "王五"};
        double[] scores = {85.5, 92.0, 78.5};
        boolean[] flags = {true, false, true};
        
        // 6. 数组的默认值
        int[] arr5 = new int[5];
        System.out.println("int默认值: " + arr5[0]);  // 0
        
        String[] arr6 = new String[3];
        System.out.println("String默认值: " + arr6[0]);  // null
        
        boolean[] arr7 = new boolean[2];
        System.out.println("boolean默认值: " + arr7[0]);  // false
    }
}

---

1.3 数组访问与遍历

索引访问

public class ArrayAccess {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        
        // 获取元素
        System.out.println("第一个元素: " + arr[0]);  // 10
        System.out.println("最后一个元素: " + arr[arr.length - 1]);  // 50
        
        // 修改元素
        arr[0] = 100;
        System.out.println("修改后第一个元素: " + arr[0]);  // 100
        
        // 数组长度
        System.out.println("数组长度: " + arr.length);  // 5
        
        // 注意：索引越界会抛出ArrayIndexOutOfBoundsException
        // System.out.println(arr[10]);  // 错误！
    }
}

数组遍历

public class ArrayTraversal {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        
        // 方式1：普通for循环
        System.out.println("方式1：普通for循环");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        
        // 方式2：增强for循环（foreach）
        System.out.println("\n\n方式2：增强for循环");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        
        // 方式3：使用Arrays.toString()
        System.out.println("\n\n方式3：Arrays.toString()");
        System.out.println(java.util.Arrays.toString(arr));
        
        // 方式4：倒序遍历
        System.out.println("\n方式4：倒序遍历");
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.print(arr[i] + " ");
        }
    }
}

---

1.4 数组内存模型

内存分配

栈内存（Stack）          堆内存（Heap）
┌─────────────┐         ┌─────────────────────┐
│ arr         │────────>│ [0]  [1]  [2]  [3]  │
│ (引用地址)   │         │ 10   20   30   40   │
└─────────────┘         └─────────────────────┘

内存特点

1. 栈内存：存储局部变量和引用
2. 堆内存：存储实际的对象（数组）
3. 引用：变量存储的是对象的地址

示例

public class ArrayMemory {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = arr1;  // arr2指向arr1的地址
        
        System.out.println("arr1: " + java.util.Arrays.toString(arr1));
        System.out.println("arr2: " + java.util.Arrays.toString(arr2));
        
        arr2[0] = 100;  // 修改arr2
        
        System.out.println("修改后arr1: " + java.util.Arrays.toString(arr1));
        // arr1也变了，因为指向同一个数组
        
        // 数组拷贝（创建新数组）
        int[] arr3 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr3[i] = arr1[i];
        }
        
        arr3[0] = 999;
        System.out.println("arr1: " + java.util.Arrays.toString(arr1));
        System.out.println("arr3: " + java.util.Arrays.toString(arr3));
    }
}

---

二、二维数组

2.1 二维数组概述

二维数组可以看作是一维数组的数组，即数组的每个元素又是一个数组。

---

2.2 二维数组声明与初始化

public class TwoDArray {
    public static void main(String[] args) {
        // 1. 动态初始化
        int[][] arr1 = new int[3][4];  // 3行4列
        
        // 2. 静态初始化
        int[][] arr2 = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 3. 不规则数组（每行列数不同）
        int[][] arr3 = new int[3][];
        arr3[0] = new int[]{1, 2};
        arr3[1] = new int[]{3, 4, 5};
        arr3[2] = new int[]{6, 7, 8, 9};
        
        // 4. 静态初始化不规则数组
        int[][] arr4 = {
            {1, 2},
            {3, 4, 5},
            {6, 7, 8, 9, 10}
        };
    }
}

---

2.3 二维数组访问与遍历

public class TwoDArrayAccess {
    public static void main(String[] args) {
        int[][] arr = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 访问元素
        System.out.println("arr[0][0] = " + arr[0][0]);  // 1
        System.out.println("arr[1][2] = " + arr[1][2]);  // 6
        
        // 获取行数
        System.out.println("行数: " + arr.length);  // 3
        
        // 获取某行的列数
        System.out.println("第1行列数: " + arr[0].length);  // 3
        
        // 遍历方式1：双重for循环
        System.out.println("\n遍历方式1：");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        
        // 遍历方式2：增强for循环
        System.out.println("\n遍历方式2：");
        for (int[] row : arr) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }
}

---

三、数组排序与查找

3.1 冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        
        System.out.println("排序前: " + java.util.Arrays.toString(arr));
        
        // 冒泡排序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        
        System.out.println("排序后: " + java.util.Arrays.toString(arr));
    }
}

---

3.2 选择排序

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {64, 25, 12, 22, 11};
        
        System.out.println("排序前: " + java.util.Arrays.toString(arr));
        
        // 选择排序
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            
            // 找最小值的索引
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            
            // 交换
            if (minIndex != i) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
        
        System.out.println("排序后: " + java.util.Arrays.toString(arr));
    }
}

---

3.3 二分查找

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
        int target = 13;
        
        int index = binarySearch(arr, target);
        
        if (index != -1) {
            System.out.println("找到目标值 " + target + "，索引为 " + index);
        } else {
            System.out.println("未找到目标值 " + target);
        }
    }
    
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        return -1;  // 未找到
    }
}

---

3.4 Arrays工具类

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
        
        // 1. toString：数组转字符串
        System.out.println("toString: " + Arrays.toString(arr));
        
        // 2. sort：排序
        Arrays.sort(arr);
        System.out.println("sort后: " + Arrays.toString(arr));
        
        // 3. binarySearch：二分查找（数组必须有序）
        int index = Arrays.binarySearch(arr, 5);
        System.out.println("5的索引: " + index);
        
        // 4. fill：填充
        int[] arr2 = new int[5];
        Arrays.fill(arr2, 10);
        System.out.println("fill后: " + Arrays.toString(arr2));
        
        // 5. copyOf：复制
        int[] arr3 = Arrays.copyOf(arr, arr.length);
        System.out.println("copyOf: " + Arrays.toString(arr3));
        
        // 6. copyOfRange：范围复制
        int[] arr4 = Arrays.copyOfRange(arr, 2, 5);
        System.out.println("copyOfRange(2,5): " + Arrays.toString(arr4));
        
        // 7. equals：比较数组内容
        int[] arr5 = {1, 2, 3, 4, 5, 6, 9};
        System.out.println("equals: " + Arrays.equals(arr, arr5));
    }
}

---

四、String类详解

4.1 String概述

String特点

特点	说明
不可变	String对象创建后，内容不可修改
常量池	字符串常量存储在字符串常量池
final类	String类不能被继承
Unicode	内部使用char数组存储Unicode字符

---

4.2 String创建方式

public class StringCreation {
    public static void main(String[] args) {
        // 方式1：字面量
        String s1 = "Hello";
        
        // 方式2：new关键字
        String s2 = new String("Hello");
        
        // 方式3：字符数组
        char[] chars = {'H', 'e', 'l', 'l', 'o'};
        String s3 = new String(chars);
        
        // 方式4：字节数组
        byte[] bytes = {72, 101, 108, 108, 111};
        String s4 = new String(bytes);
        
        // 字符串常量池
        String a = "Java";
        String b = "Java";
        String c = new String("Java");
        
        System.out.println("a == b: " + (a == b));      // true
        System.out.println("a == c: " + (a == c));      // false
        System.out.println("a.equals(c): " + a.equals(c));  // true
    }
}

---

4.3 String常用方法

public class StringMethods {
    public static void main(String[] args) {
        String str = "Hello, Java World!";
        
        // 1. 获取长度
        System.out.println("长度: " + str.length());
        
        // 2. 获取字符
        System.out.println("索引5的字符: " + str.charAt(5));
        
        // 3. 获取子串
        System.out.println("substring(7): " + str.substring(7));
        System.out.println("substring(7, 11): " + str.substring(7, 11));
        
        // 4. 查找
        System.out.println("indexOf('Java'): " + str.indexOf("Java"));
        System.out.println("lastIndexOf('o'): " + str.lastIndexOf('o'));
        
        // 5. 判断
        System.out.println("startsWith('Hello'): " + str.startsWith("Hello"));
        System.out.println("endsWith('!'): " + str.endsWith("!"));
        System.out.println("contains('Java'): " + str.contains("Java"));
        System.out.println("isEmpty(): " + str.isEmpty());
        
        // 6. 比较
        System.out.println("equals: " + str.equals("Hello, Java World!"));
        System.out.println("equalsIgnoreCase: " + "hello".equalsIgnoreCase("HELLO"));
        System.out.println("compareTo: " + "abc".compareTo("abd"));
        
        // 7. 大小写转换
        System.out.println("toUpperCase: " + str.toUpperCase());
        System.out.println("toLowerCase: " + str.toLowerCase());
        
        // 8. 去除空格
        String s = "  Hello  ";
        System.out.println("trim: '" + s.trim() + "'");
        
        // 9. 替换
        System.out.println("replace: " + str.replace("Java", "Python"));
        System.out.println("replaceAll: " + "a1b2c3".replaceAll("\\d", "-"));
        
        // 10. 分割
        String[] parts = "apple,banana,orange".split(",");
        System.out.println("split: " + java.util.Arrays.toString(parts));
        
        // 11. 转换
        char[] charArray = str.toCharArray();
        byte[] byteArray = str.getBytes();
    }
}

---

4.4 字符串反转与回文判断

public class StringPractice {
    public static void main(String[] args) {
        // 字符串反转
        String str = "Hello";
        String reversed = reverse(str);
        System.out.println("反转: " + str + " -> " + reversed);
        
        // 判断回文
        String s1 = "上海自来水来自海上";
        String s2 = "hello";
        System.out.println(s1 + "是回文: " + isPalindrome(s1));
        System.out.println(s2 + "是回文: " + isPalindrome(s2));
        
        // 统计字符出现次数
        String text = "Hello, Java!";
        char target = 'l';
        int count = countChar(text, target);
        System.out.println("'" + target + "'出现次数: " + count);
    }
    
    // 字符串反转
    public static String reverse(String str) {
        return new StringBuilder(str).reverse().toString();
    }
    
    // 判断回文
    public static boolean isPalindrome(String str) {
        String s = str.replaceAll("[^a-zA-Z0-9\u4e00-\u9fa5]", "").toLowerCase();
        return s.equals(new StringBuilder(s).reverse().toString());
    }
    
    // 统计字符出现次数
    public static int countChar(String str, char target) {
        int count = 0;
        for (char c : str.toCharArray()) {
            if (c == target) {
                count++;
            }
        }
        return count;
    }
}

---

五、StringBuilder与StringBuffer

5.1 为什么需要StringBuilder？

public class StringProblem {
    public static void main(String[] args) {
        // String拼接问题
        String s = "";
        long start = System.currentTimeMillis();
        
        for (int i = 0; i < 10000; i++) {
            s += i;  // 每次都创建新的String对象
        }
        
        long end = System.currentTimeMillis();
        System.out.println("String拼接耗时: " + (end - start) + "ms");
        
        // StringBuilder解决
        StringBuilder sb = new StringBuilder();
        start = System.currentTimeMillis();
        
        for (int i = 0; i < 10000; i++) {
            sb.append(i);  // 在原对象上追加
        }
        
        end = System.currentTimeMillis();
        System.out.println("StringBuilder耗时: " + (end - start) + "ms");
    }
}

---

5.2 StringBuilder常用方法

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        
        // 1. append：追加
        sb.append("Hello");
        sb.append(" ");
        sb.append("World");
        System.out.println("append: " + sb);
        
        // 2. insert：插入
        sb.insert(5, ",");
        System.out.println("insert: " + sb);
        
        // 3. delete：删除
        sb.delete(5, 6);
        System.out.println("delete: " + sb);
        
        // 4. replace：替换
        sb.replace(6, 11, "Java");
        System.out.println("replace: " + sb);
        
        // 5. reverse：反转
        sb.reverse();
        System.out.println("reverse: " + sb);
        
        // 6. toString：转String
        String result = sb.toString();
        System.out.println("toString: " + result);
        
        // 7. 链式调用
        StringBuilder sb2 = new StringBuilder();
        sb2.append("A").append("B").append("C");
        System.out.println("链式调用: " + sb2);
    }
}

---

5.3 String、StringBuilder、StringBuffer对比

特性	String	StringBuilder	StringBuffer
可变性	不可变	可变	可变
线程安全	安全（不可变）	不安全	安全（同步）
性能	低（频繁创建）	高	中等
适用场景	少量字符串操作	单线程大量操作	多线程大量操作

public class StringCompare {
    public static void main(String[] args) {
        // String：不可变
        String s1 = "Hello";
        String s2 = s1 + " World";  // 创建新对象
        System.out.println("s1: " + s1);  // Hello
        System.out.println("s2: " + s2);  // Hello World
        
        // StringBuilder：可变，非线程安全
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" World");  // 在原对象上修改
        System.out.println("StringBuilder: " + sb);
        
        // StringBuffer：可变，线程安全
        StringBuffer sbuf = new StringBuffer("Hello");
        sbuf.append(" World");
        System.out.println("StringBuffer: " + sbuf);
    }
}

---

六、正则表达式基础

6.1 正则表达式概述

正则表达式是一种字符串匹配模式，用于检查字符串是否符合某种格式。

---

6.2 常用正则表达式

表达式	说明	示例
.	任意字符	a.c 匹配 abc, adc
\d	数字	\d{3} 匹配 123
\D	非数字	\D+ 匹配 abc
\w	单词字符	\w+ 匹配 abc123
\W	非单词字符	\W+ 匹配 !@#
\s	空白字符	\s+ 匹配空格、制表符
\S	非空白字符	\S+ 匹配非空格
^	开头	^Hello 匹配以Hello开头
$	结尾	World$ 匹配以World结尾
*	0次或多次	a* 匹配 “”, a, aa
+	1次或多次	a+ 匹配 a, aa
?	0次或1次	a? 匹配 “”, a
{n}	恰好n次	a{3} 匹配 aaa
{n,}	至少n次	a{2,} 匹配 aa, aaa
{n,m}	n到m次	a{2,4} 匹配 aa, aaa, aaaa
[abc]	字符集合	[aeiou] 匹配元音
[^abc]	排除字符	[^0-9] 匹配非数字

---

6.3 正则表达式使用

public class RegexDemo {
    public static void main(String[] args) {
        // 1. matches：完全匹配
        String phone = "13812345678";
        boolean isPhone = phone.matches("1[3-9]\\d{9}");
        System.out.println("手机号验证: " + isPhone);
        
        // 2. 邮箱验证
        String email = "test@example.com";
        boolean isEmail = email.matches("\\w+@\\w+\\.\\w+");
        System.out.println("邮箱验证: " + isEmail);
        
        // 3. split：分割
        String str = "apple,banana;orange|grape";
        String[] fruits = str.split("[,;|]");
        System.out.println("分割: " + java.util.Arrays.toString(fruits));
        
        // 4. replaceAll：替换
        String text = "手机号：13812345678，邮箱：test@example.com";
        String masked = text.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
        System.out.println("脱敏: " + masked);
        
        // 5. 身份证验证
        String idCard = "110101199001011234";
        boolean isIdCard = idCard.matches("\\d{17}[\\dXx]");
        System.out.println("身份证验证: " + isIdCard);
    }
}

---

七、实践案例

7.1 学生成绩管理系统

import java.util.Arrays;

/**
 * 学生成绩管理系统
 * 使用数组存储学生信息和成绩
 */
public class StudentGradeSystem {
    public static void main(String[] args) {
        // 学生姓名
        String[] names = {"张三", "李四", "王五", "赵六", "钱七"};
        
        // 三科成绩
        int[][] scores = {
            {85, 92, 78},
            {90, 88, 95},
            {76, 82, 80},
            {92, 95, 98},
            {68, 72, 70}
        };
        
        // 科目名称
        String[] subjects = {"语文", "数学", "英语"};
        
        System.out.println("========== 学生成绩表 ==========");
        System.out.printf("%-8s", "姓名");
        for (String subject : subjects) {
            System.out.printf("%-8s", subject);
        }
        System.out.printf("%-8s%-8s%-8s\n", "平均分", "最高分", "最低分");
        System.out.println("-".repeat(60));
        
        // 计算并显示每个学生的成绩
        for (int i = 0; i < names.length; i++) {
            System.out.printf("%-8s", names[i]);
            
            for (int score : scores[i]) {
                System.out.printf("%-8d", score);
            }
            
            double avg = calculateAverage(scores[i]);
            int max = getMax(scores[i]);
            int min = getMin(scores[i]);
            
            System.out.printf("%-8.2f%-8d%-8d\n", avg, max, min);
        }
        
        System.out.println("-".repeat(60));
        
        // 计算每科平均分
        System.out.printf("%-8s", "平均分");
        for (int j = 0; j < subjects.length; j++) {
            double subjectAvg = 0;
            for (int i = 0; i < names.length; i++) {
                subjectAvg += scores[i][j];
            }
            System.out.printf("%-8.2f", subjectAvg / names.length);
        }
        System.out.println();
    }
    
    // 计算平均分
    public static double calculateAverage(int[] scores) {
        int sum = 0;
        for (int score : scores) {
            sum += score;
        }
        return (double) sum / scores.length;
    }
    
    // 获取最高分
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int num : arr) {
            if (num > max) max = num;
        }
        return max;
    }
    
    // 获取最低分
    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int num : arr) {
            if (num < min) min = num;
        }
        return min;
    }
}

---

7.2 字符串统计工具

import java.util.HashMap;
import java.util.Map;

/**
 * 字符串统计工具
 * 统计字符串中字符、单词等出现次数
 */
public class StringStatistics {
    public static void main(String[] args) {
        String text = "Hello World! Hello Java! Java is great!";
        
        // 1. 统计字符出现次数
        System.out.println("========== 字符统计 ==========");
        Map<Character, Integer> charCount = countCharacters(text);
        for (Map.Entry<Character, Integer> entry : charCount.entrySet()) {
            if (entry.getKey() != ' ') {
                System.out.println("'" + entry.getKey() + "': " + entry.getValue());
            }
        }
        
        // 2. 统计单词出现次数
        System.out.println("\n========== 单词统计 ==========");
        Map<String, Integer> wordCount = countWords(text);
        for (Map.Entry<String, Integer> entry : wordCount.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        
        // 3. 统计字母、数字、空格等
        System.out.println("\n========== 类型统计 ==========");
        int letters = 0, digits = 0, spaces = 0, others = 0;
        
        for (char c : text.toCharArray()) {
            if (Character.isLetter(c)) {
                letters++;
            } else if (Character.isDigit(c)) {
                digits++;
            } else if (Character.isWhitespace(c)) {
                spaces++;
            } else {
                others++;
            }
        }
        
        System.out.println("字母: " + letters);
        System.out.println("数字: " + digits);
        System.out.println("空格: " + spaces);
        System.out.println("其他: " + others);
    }
    
    // 统计字符出现次数
    public static Map<Character, Integer> countCharacters(String str) {
        Map<Character, Integer> map = new HashMap<>();
        for (char c : str.toCharArray()) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        return map;
    }
    
    // 统计单词出现次数
    public static Map<String, Integer> countWords(String str) {
        Map<String, Integer> map = new HashMap<>();
        String[] words = str.toLowerCase().split("[\\s\\p{Punct}]+");
        
        for (String word : words) {
            if (!word.isEmpty()) {
                map.put(word, map.getOrDefault(word, 0) + 1);
            }
        }
        return map;
    }
}

---

八、常见问题与注意事项

8.1 数组索引越界

public class ArrayIndexError {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        
        // 错误：索引越界
        try {
            System.out.println(arr[3]);  // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("错误：数组索引越界");
        }
        
        // 正确做法：检查索引
        int index = 3;
        if (index >= 0 && index < arr.length) {
            System.out.println(arr[index]);
        } else {
            System.out.println("索引无效");
        }
    }
}

---

8.2 空指针异常

public class NullPointerError {
    public static void main(String[] args) {
        String str = null;
        
        // 错误：空指针
        try {
            System.out.println(str.length());  // NullPointerException
        } catch (NullPointerException e) {
            System.out.println("错误：空指针异常");
        }
        
        // 正确做法：先判断非空
        if (str != null) {
            System.out.println(str.length());
        } else {
            System.out.println("字符串为null");
        }
    }
}

---

8.3 字符串比较

public class StringCompareError {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        
        // 错误：使用==比较
        if (s1 == s2) {
            System.out.println("相等");  // 不会执行
        }
        
        // 正确：使用equals比较
        if (s1.equals(s2)) {
            System.out.println("内容相等");  // 会执行
        }
        
        // 更安全的写法
        String s3 = null;
        if ("hello".equals(s3)) {  // 常量在前，避免空指针
            System.out.println("相等");
        }
    }
}

---

九、课后作业

必做题

1. 数组操作

   • 实现冒泡排序和选择排序
   • 实现数组的复制、反转、查找
   • 找出数组中的最大值和最小值

2. 字符串操作

   • 实现字符串反转
   • 判断字符串是否是回文
   • 统计字符串中字符出现次数

3. 综合练习

   • 实现学生成绩管理系统
   • 实现字符串统计工具

选做题

1. 数组高级

   • 实现快速排序算法
   • 实现数组去重
   • 合并两个有序数组

2. 字符串高级

   • 实现字符串压缩（aabcccccaaa → a2b1c5a3）
   • 判断两个字符串是否是变位词
   • 实现简单的文本编辑器功能

---

十、学习总结

今日要点

1. 一维数组

   • 声明、初始化、访问、遍历
   • 数组内存模型
   • 数组排序与查找

2. 二维数组

   • 声明、初始化、遍历
   • 不规则数组

3. String类

   • 创建方式、常用方法
   • 字符串不可变性
   • 字符串常量池

4. StringBuilder与StringBuffer

   • 可变字符串
   • 性能对比

5. 正则表达式

   • 基本语法
   • 常用方法

学习建议

1. 理解内存模型：画图理解数组在内存中的存储
2. 多练习排序算法：手写冒泡、选择排序
3. 熟练使用String方法：记住常用的字符串操作方法
4. 注意性能：字符串拼接使用StringBuilder

---

下一课预告：面向对象基础

学习时间：建议3小时（理论1小时 + 实践2小时）