Java开发教程：新手入门指南

概述

本文提供了全面的Java开发教程，涵盖了环境搭建、基础语法、面向对象编程、集合框架及异常处理等知识点。文章详细介绍了如何安装JDK并编写第一个Java程序，适合初学者快速入门。此外，还介绍了变量与数据类型、运算符与表达式、字符串操作和流程控制等内容。通过这些内容，读者可以系统地学习和掌握Java编程技能。

Java简介与环境搭建

什么是Java

Java是一种广泛使用的编程语言和平台，由Sun Microsystems公司于1995年推出。Java的设计目的是为了编写一次，可以在任何平台上运行的代码（Write Once, Run Anywhere）。Java语言的语法和C语言相似，但它包含了许多面向对象的特性，使得开发大型应用程序变得更加容易。

Java的特点和优势

Java有以下主要特点和优势：

• 平台无关性：Java程序可以在任何支持Java的平台上运行，无需重新编译。
• 面向对象：Java支持类和对象的概念，使代码组织和重用更加方便。
• 自动内存管理：Java有自动垃圾回收机制，可以自动回收不再使用的内存。
• 丰富的库支持：Java有大量的库支持，这些库可以用来进行网络编程、图形用户界面开发、数据库操作等。
• 安全性：Java提供了安全的特性，使得Java程序可以在浏览器安全地执行。

Java开发环境的搭建（安装JDK）

安装Java开发工具包（JDK，Java Development Kit）是开始使用Java编程的第一步。以下是安装JDK的步骤：

1. 访问Oracle官网下载页面，下载JDK的安装包。
2. 安装JDK，按照提示完成安装过程。
3. 配置环境变量，以便在命令行中使用Java命令。具体配置如下：
   • 打开环境变量设置。
   • 在系统变量中找到Path，编辑并在其中添加JDK的bin目录路径（例如，C:\Program Files\Java\jdk-11.0.1\bin）。
   • 新建或编辑JAVA_HOME环境变量，将其值设置为JDK的安装目录（例如，C:\Program Files\Java\jdk-11.0.1）。

编写第一个Java程序

编写第一个Java程序，需要创建一个包含main方法的类。main方法是程序的入口点。以下是示例代码：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

1. 使用任意文本编辑器（如Notepad++、VSCode等）创建一个新的.java文件，命名为HelloWorld.java。
2. 将上述代码粘贴到文件中。
3. 打开命令行窗口，切换到文件所在目录。
4. 输入javac HelloWorld.java编译代码。
5. 输入java HelloWorld运行程序，会输出Hello, World!。

Java基础语法

变量与数据类型

在Java中，变量是用来存储数据的容器，变量的类型决定了它可以存储的数据类型。Java支持多种基本数据类型，包括int、double、boolean、char等。

• int：表示整数，例如int num = 10;
• double：表示浮点数，例如double num = 3.14;
• boolean：表示布尔值，例如boolean flag = true;
• char：表示单个字符，例如char ch = 'A';

运算符与表达式

Java中的运算符用于对变量和常量执行操作。常见的运算符包括算术运算符、关系运算符和逻辑运算符等。

算术运算符

• +：加法，例如int a = 10 + 5;
• -：减法，例如int b = 10 - 5;
• *：乘法，例如int c = 10 * 5;
• /：除法，例如int d = 10 / 5;
• %：取模，例如int e = 10 % 3;

关系运算符

• ==：等于，例如boolean isEqual = (10 == 10);
• !=：不等于，例如boolean isNotEqual = (10 != 11);
• >：大于，例如boolean isGreater = (10 > 9);
• <：小于，例如boolean isLess = (9 < 10);
• >=：大于等于，例如boolean isGreaterEqual = (10 >= 10);
• <=：小于等于，例如boolean isLessEqual = (9 <= 10);

逻辑运算符

• &&：逻辑与，例如boolean result = (10 > 9) && (10 < 11);
• ||：逻辑或，例如boolean result = (10 > 11) || (10 < 11);
• !：逻辑非，例如boolean result = !(10 > 11);

示例代码：

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        int add = a + b;
        int sub = a - b;
        int mul = a * b;
        int div = a / b;
        int mod = a % b;

        boolean isEqual = (10 == 10);
        boolean isNotEqual = (10 != 11);
        boolean isGreater = (10 > 9);
        boolean isLess = (9 < 10);
        boolean isGreaterEqual = (10 >= 10);
        boolean isLessEqual = (9 <= 10);

        boolean resultAnd = (10 > 9) && (10 < 11);
        boolean resultOr = (10 > 11) || (10 < 11);
        boolean resultNot = !(10 > 11);

        System.out.println("加法: " + add);
        System.out.println("减法: " + sub);
        System.out.println("乘法: " + mul);
        System.out.println("除法: " + div);
        System.out.println("取模: " + mod);

        System.out.println("等于: " + isEqual);
        System.out.println("不等于: " + isNotEqual);
        System.out.println("大于: " + isGreater);
        System.out.println("小于: " + isLess);
        System.out.println("大于等于: " + isGreaterEqual);
        System.out.println("小于等于: " + isLessEqual);

        System.out.println("逻辑与: " + resultAnd);
        System.out.println("逻辑或: " + resultOr);
        System.out.println("逻辑非: " + resultNot);
    }
}

字符串操作

Java中的字符串是用String类表示的，提供了许多方法来操作字符串。以下是一些常用的字符串操作方法：

• length()：返回字符串的长度。
• charAt(int index)：返回指定索引位置的字符。
• substring(int beginIndex)：返回从指定索引位置开始的子字符串。
• substring(int beginIndex, int endIndex)：返回从指定开始索引到结束索引的子字符串。
• replace(char oldChar, char newChar)：将字符串中的旧字符替换为新字符。
• toLowerCase()：将字符串转换为小写。
• toUpperCase()：将字符串转换为大写。
• trim()：去除字符串两端的空白字符。
• concat(String str)：将指定字符串与当前字符串连接起来。
• equals(String str)：比较两个字符串是否相等。
• equalsIgnoreCase(String str)：比较两个字符串是否相等，忽略大小写。

示例代码：

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";

        int length = str.length();
        char firstChar = str.charAt(0);
        String substring = str.substring(7);
        String replace = str.replace('o', '0');
        String toLowerCase = str.toLowerCase();
        String toUpperCase = str.toUpperCase();
        String trimmed = str.trim();
        String concatenated = str.concat(" Welcome!");
        boolean equals = str.equals("Hello, World!");
        boolean equalsIgnoreCase = str.equalsIgnoreCase("hello, world!");

        System.out.println("长度: " + length);
        System.out.println("第一个字符: " + firstChar);
        System.out.println("子字符串: " + substring);
        System.out.println("替换字符: " + replace);
        System.out.println("转小写: " + toLowerCase);
        System.out.println("转大写: " + toUpperCase);
        System.out.println("去除空白字符: " + trimmed);
        System.out.println("连接字符串: " + concatenated);
        System.out.println("比较是否相等: " + equals);
        System.out.println("忽略大小写比较是否相等: " + equalsIgnoreCase);
    }
}

流程控制

条件语句（if, switch）

Java中的条件语句用于根据条件判断来执行不同的代码块。最常用的条件语句是if语句和switch语句。

if语句

if语句的基本语法如下：

if (条件) {
    // 如果条件为真，则执行这里的代码
}

if语句还可以包含else子句，用于在条件不为真时执行其他代码：

if (条件) {
    // 如果条件为真，则执行这里的代码
} else {
    // 如果条件不为真，则执行这里的代码
}

还可以使用else if来处理多个条件：

if (条件1) {
    // 如果条件1为真，则执行这里的代码
} else if (条件2) {
    // 如果条件2为真，则执行这里的代码
} else {
    // 如果所有条件都不为真，则执行这里的代码
}

示例代码：

public class IfExample {
    public static void main(String[] args) {
        int num = 10;

        if (num > 0) {
            System.out.println("正数");
        } else if (num < 0) {
            System.out.println("负数");
        } else {
            System.out.println("零");
        }
    }
}

switch语句

switch语句用于根据变量的值来执行不同的代码块。基本语法如下：

switch (变量) {
    case 值1:
        // 如果变量等于值1，则执行这里的代码
        break;
    case 值2:
        // 如果变量等于值2，则执行这里的代码
        break;
    default:
        // 如果变量不等于任何case的值，则执行这里的代码
}

示例代码：

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("其他");
        }
    }
}

循环语句（for, while, do-while）

循环语句用于执行重复的代码块，直到某个条件不再满足为止。Java支持三种主要的循环语句：for、while和do-while。

for循环

for循环允许您在循环体执行前指定初始化和条件判断，以及每次循环执行后的操作。

for (初始化; 条件; 每次循环后执行的操作) {
    // 循环体
}

示例代码：

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

while循环

while循环会在每次循环开始时检查条件，如果条件为真，则执行循环体内的代码。

while (条件) {
    // 循环体
}

示例代码：

public class WhileExample {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            System.out.println("数字: " + i);
            i++;
        }
    }
}

do-while循环

do-while循环首先执行循环体内的代码，然后在每次循环结束时检查条件。即使第一次循环开始时条件为假，也会至少执行一次循环体内的代码。

do {
    // 循环体
} while (条件);

示例代码：

public class DoWhileExample {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("数字: " + i);
            i++;
        } while (i < 5);
    }
}

面向对象编程

类与对象

在面向对象编程中，类是一个抽象的数据类型，用于定义对象的结构和行为。对象是类的实例，包含状态（属性）和行为（方法）。

定义类

定义一个类的基本语法如下：

public class 类名 {
    // 变量（属性）
    private int 属性1;
    private String 属性2;

    // 方法（行为）
    public void 方法1() {
        // 方法实现
    }

    public void 方法2() {
        // 方法实现
    }
}

创建对象

创建类的对象的基本语法如下：

类名 对象名 = new 类名();

示例代码：

public class Person {
    // 变量（属性）
    private String name;
    private int age;

    // 方法（行为）
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(25);
        person.displayInfo();
    }
}

封装

封装是面向对象编程的一个重要特性，它将数据（属性）和操作（方法）封装在一起，隐藏内部的实现细节。封装可以通过访问修饰符（如private）来实现。

示例代码：

public class Car {
    // 变量（属性）
    private String brand;
    private int year;

    // 方法（行为）
    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getYear() {
        return year;
    }

    public void displayInfo() {
        System.out.println("品牌: " + brand + ", 年份: " + year);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.setBrand("Toyota");
        car.setYear(2020);
        car.displayInfo();
    }
}

继承

继承是面向对象编程中的另一个重要特性，它允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以重写父类的方法或添加新的方法。

定义继承关系

定义继承关系的基本语法如下：

public class 子类 extends 父类 {
    // 子类特有的属性和方法
}

示例代码：

public class Animal {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void displayInfo() {
        System.out.println("名称: " + name);
    }
}

public class Dog extends Animal {
    private String breed;

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public String getBreed() {
        return breed;
    }

    public void displayInfo() {
        super.displayInfo();
        System.out.println("品种: " + breed);
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.setBreed("哈士奇");
        dog.displayInfo();
    }
}

多态

多态是面向对象编程中的一个关键概念，它允许子类对象可以像父类对象一样被使用。多态使得在同一个接口中可以调用不同对象的方法，从而实现代码的灵活性。

示例代码：

public class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.makeSound(); // 输出: 汪汪汪
        animal2.makeSound(); // 输出: 喵喵喵
    }
}

集合框架

Java提供了丰富的集合类，用于存储和操作一组对象。常用的集合类包括ArrayList、LinkedList、HashMap、TreeMap等。

ArrayList与LinkedList

ArrayList和LinkedList都是集合接口List的实现类，用于存储有序的元素集。它们的主要区别在于内部实现和操作效率。

ArrayList

ArrayList使用数组实现，随机访问效率高，但是插入和删除操作需要移动元素。

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

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        System.out.println("列表: " + list);

        // 插入元素
        list.add(1, "元素1.5");
        System.out.println("插入元素后: " + list);

        // 删除元素
        list.remove("元素2");
        System.out.println("删除元素后: " + list);

        // 查询元素
        System.out.println("元素1是否在列表中: " + list.contains("元素1"));
    }
}

LinkedList

LinkedList使用双向链表实现，插入和删除操作效率高，但是随机访问效率低。

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

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        System.out.println("列表: " + list);

        // 插入元素
        list.add(1, "元素1.5");
        System.out.println("插入元素后: " + list);

        // 删除元素
        list.remove("元素2");
        System.out.println("删除元素后: " + list);

        // 查询元素
        System.out.println("元素1是否在列表中: " + list.contains("元素1"));
    }
}

HashMap与TreeMap

HashMap和TreeMap都是集合接口Map的实现类，用于存储键值对。它们的主要区别在于内部实现和排序方式。

HashMap

HashMap使用散列存储键值对，查询效率高，但是元素没有排序。

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

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("元素1", 1);
        map.put("元素2", 2);
        map.put("元素3", 3);

        System.out.println("映射: " + map);

        // 查询值
        System.out.println("元素1的值: " + map.get("元素1"));

        // 修改值
        map.put("元素1", 10);
        System.out.println("修改值后: " + map);

        // 删除键值对
        map.remove("元素2");
        System.out.println("删除键值对后: " + map);
    }
}

TreeMap

TreeMap使用红黑树实现键值对，元素按键的自然顺序排序。

import java.util.TreeMap;
import java.util.Map;

public class TreeMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<>();
        map.put("元素1", 1);
        map.put("元素2", 2);
        map.put("元素3", 3);

        System.out.println("映射: " + map);

        // 查询值
        System.out.println("元素1的值: " + map.get("元素1"));

        // 修改值
        map.put("元素1", 10);
        System.out.println("修改值后: " + map);

        // 删除键值对
        map.remove("元素2");
        System.out.println("删除键值对后: " + map);
    }
}

异常处理与输入输出

异常处理机制

异常处理是Java编程中非常重要的部分，用于处理程序运行时可能发生的错误。Java中的异常处理机制通过try-catch-finally语句来实现。

try-catch-finally

try块用于包围可能抛出异常的代码，catch块用于捕获并处理异常，finally块用于执行清理操作。

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            // 可能抛出异常的代码
            int result = 10 / 0;
        } catch (Exception e) {
            // 捕获并处理异常
            e.printStackTrace();
        } finally {
            // 执行清理操作
            System.out.println("清理操作");
        }
    }
}

文件的读写操作

Java提供了丰富的文件操作类，用于读写文件。常用的文件操作类包括FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等。

读取文件

读取文件的基本步骤如下：

1. 创建FileInputStream对象。
2. 使用BufferedReader读取文件内容。
3. 关闭文件输入流。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

写入文件

写入文件的基本步骤如下：

1. 创建FileWriter对象。
2. 使用BufferedWriter写入文件内容。
3. 关闭文件输出流。

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String[] args) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
            writer.write("Hello, World!");
            writer.newLine();
            writer.write("这是一个测试文件。");
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

示例代码总结

以下是总结的示例代码：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        int add = a + b;
        int sub = a - b;
        int mul = a * b;
        int div = a / b;
        int mod = a % b;

        boolean isEqual = (10 == 10);
        boolean isNotEqual = (10 != 11);
        boolean isGreater = (10 > 9);
        boolean isLess = (9 < 10);
        boolean isGreaterEqual = (10 >= 10);
        boolean isLessEqual = (9 <= 10);

        boolean resultAnd = (10 > 9) && (10 < 11);
        boolean resultOr = (10 > 11) || (10 < 11);
        boolean resultNot = !(10 > 11);

        System.out.println("加法: " + add);
        System.out.println("减法: " + sub);
        System.out.println("乘法: " + mul);
        System.out.println("除法: " + div);
        System.out.println("取模: " + mod);

        System.out.println("等于: " + isEqual);
        System.out.println("不等于: " + isNotEqual);
        System.out.println("大于: " + isGreater);
        System.out.println("小于: " + isLess);
        System.out.println("大于等于: " + isGreaterEqual);
        System.out.println("小于等于: " + isLessEqual);

        System.out.println("逻辑与: " + resultAnd);
        System.out.println("逻辑或: " + resultOr);
        System.out.println("逻辑非: " + resultNot);
    }
}

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";

        int length = str.length();
        char firstChar = str.charAt(0);
        String substring = str.substring(7);
        String replace = str.replace('o', '0');
        String toLowerCase = str.toLowerCase();
        String toUpperCase = str.toUpperCase();
        String trimmed = str.trim();
        String concatenated = str.concat(" Welcome!");
        boolean equals = str.equals("Hello, World!");
        boolean equalsIgnoreCase = str.equalsIgnoreCase("hello, world!");

        System.out.println("长度: " + length);
        System.out.println("第一个字符: " + firstChar);
        System.out.println("子字符串: " + substring);
        System.out.println("替换字符: " + replace);
        System.out.println("转小写: " + toLowerCase);
        System.out.println("转大写: " + toUpperCase);
        System.out.println("去除空白字符: " + trimmed);
        System.out.println("连接字符串: " + concatenated);
        System.out.println("比较是否相等: " + equals);
        System.out.println("忽略大小写比较是否相等: " + equalsIgnoreCase);
    }
}

public class IfExample {
    public static void main(String[] args) {
        int num = 10;

        if (num > 0) {
            System.out.println("正数");
        } else if (num < 0) {
            System.out.println("负数");
        } else {
            System.out.println("零");
        }
    }
}

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("其他");
        }
    }
}

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

public class WhileExample {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            System.out.println("数字: " + i);
            i++;
        }
    }
}

public class DoWhileExample {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("数字: " + i);
            i++;
        } while (i < 5);
    }
}

public class Person {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(25);
        person.displayInfo();
    }
}

public class Car {
    private String brand;
    private int year;

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getYear() {
        return year;
    }

    public void displayInfo() {
        System.out.println("品牌: " + brand + ", 年份: " + year);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.setBrand("Toyota");
        car.setYear(2020);
        car.displayInfo();
    }
}

public class Animal {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void displayInfo() {
        System.out.println("名称: " + name);
    }
}

public class Dog extends Animal {
    private String breed;

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public String getBreed() {
        return breed;
    }

    public void displayInfo() {
        super.displayInfo();
        System.out.println("品种: " + breed);
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.setBreed("哈士奇");
        dog.displayInfo();
    }
}

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

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        System.out.println("列表: " + list);

        // 插入元素
        list.add(1, "元素1.5");
        System.out.println("插入元素后: " + list);

        // 删除元素
        list.remove("元素2");
        System.out.println("删除元素后: " + list);

        // 查询元素
        System.out.println("元素1是否在列表中: " + list.contains("元素1"));
    }
}

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

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        System.out.println("列表: " + list);

        // 插入元素
        list.add(1, "元素1.5");
        System.out.println("插入元素后: " + list);

        // 删除元素
        list.remove("元素2");
        System.out.println("删除元素后: " + list);

        // 查询元素
        System.out.println("元素1是否在列表中: " + list.contains("元素1"));
    }
}

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

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("元素1", 1);
        map.put("元素2", 2);
        map.put("元素3", 3);

        System.out.println("映射: " + map);

        // 查询值
        System.out.println("元素1的值: " + map.get("元素1"));

        // 修改值
        map.put("元素1", 10);
        System.out.println("修改值后: " + map);

        // 删除键值对
        map.remove("元素2");
        System.out.println("删除键值对后: " + map);
    }
}

import java.util.TreeMap;
import java.util.Map;

public class TreeMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<>();
        map.put("元素1", 1);
        map.put("元素2", 2);
        map.put("元素3", 3);

        System.out.println("映射: " + map);

        // 查询值
        System.out.println("元素1的值: " + map.get("元素1"));

        // 修改值
        map.put("元素1", 10);
        System.out.println("修改值后: " + map);

        // 删除键值对
        map.remove("元素2");
        System.out.println("删除键值对后: " + map);
    }
}

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            // 可能抛出异常的代码
            int result = 10 / 0;
        } catch (Exception e) {
            // 捕获并处理异常
            e.printStackTrace();
        } finally {
            // 执行清理操作
            System.out.println("清理操作");
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String[] args) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
            writer.write("Hello, World!");
            writer.newLine();
            writer.write("这是一个测试文件。");
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}