【Java】跟着小丛学Java第三阶段：Java核心API

异常处理

什么是异常

在编写Java应用程序时，可能会遇到各种类型的错误，例如输入无效的数据或尝试访问不存在的文件等。当这种错误发生时，Java会抛出一个异常，这可能会导致程序崩溃或产生不可预测的结果。

Java中的异常是一个对象，它包含有关错误的信息，例如错误消息和堆栈跟踪。可以使用异常来识别和处理错误，以避免程序崩溃或产生不可预测的结果。

异常处理语法

异常处理可以帮助我们捕获和处理Java程序中的异常，从而使程序更加稳定和可靠。Java中的异常处理可以使用try-catch语句来实现。

以下是try-catch语句的基本语法：

try {
    // 可能会抛出异常的代码块
} catch (Exception e) {
    // 处理异常的代码块
}

在上述代码中，try块是包含可能会抛出异常的代码的代码块。如果此代码块中抛出异常，则执行catch块。catch块是用于处理异常的代码块，其中e表示捕获到的异常对象。

以下是一个使用try-catch语句处理异常的示例应用程序。该程序从用户输入文件名，并尝试打开并读取该文件的内容。如果文件不存在，则会捕获并处理FileNotFoundException异常。

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        Scanner inputScanner = new Scanner(System.in);

        System.out.print("Enter file name: ");
        String fileName = inputScanner.nextLine();

        try {
            File file = new File(fileName);
            Scanner fileScanner = new Scanner(file);

            while (fileScanner.hasNextLine()) {
                String line = fileScanner.nextLine();
                System.out.println(line);
            }

            fileScanner.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + fileName);
        } finally {
            inputScanner.close();
        }
    }
}

在上述代码中，我们使用try-catch语句来尝试打开并读取用户输入的文件。如果文件不存在，则会捕获FileNotFoundException异常，并输出错误消息。在try块执行完毕后，我们使用finally块来关闭用户输入的Scanner对象。

总结

异常处理可以帮助我们捕获和处理Java程序中的异常，从而使程序更加稳定和可靠。Java中的异常是一个对象，它包含有关错误的信息，例如错误消息和堆栈跟踪。可以使用try-catch语句来实现异常处理。在实际应用中，我们可以根据具体情况，采用不同的异常处理策略，以确保程序能够在遇到异常时保持稳定和可靠。

集合

Java集合是一组对象，用于存储和操作数据。Java集合框架提供了一组接口和实现类，用于处理集合数据。Java集合框架中的主要接口包括List、Set、Queue和Map等。

List

List接口表示一个有序的集合，其中每个元素都有一个对应的索引。Java集合框架中常见的List实现类包括ArrayList和LinkedList。

ArrayList

ArrayList是基于数组实现的List类。它可以动态增加和减少元素数量，具有快速的随机访问和操作元素的能力。

以下是一个使用ArrayList实现的示例应用程序。该程序从用户输入一组数字，并计算它们的平均值。

import java.util.ArrayList;
import java.util.Scanner;

public class ArrayListExample {
    public static void main(String[] args) {
        Scanner inputScanner = new Scanner(System.in);
        ArrayList<Integer> numbers = new ArrayList<>();

        System.out.print("Enter numbers (one per line, end with a negative number): ");

        int number;
        do {
            number = inputScanner.nextInt();
            if (number >= 0) {
                numbers.add(number);
            }
        } while (number >= 0);

        inputScanner.close();

        int sum = 0;
        for (int n : numbers) {
            sum += n;
        }

        double average = (double) sum / numbers.size();
        System.out.printf("The average is %.2f", average);
    }
}

在上述代码中，我们使用ArrayList来存储用户输入的数字，并计算它们的平均值。在用户输入一组数字后，我们使用ArrayList的add方法将它们添加到列表中。然后，我们使用for-each循环和ArrayList的size方法计算数字的总和和平均值。

LinkedList

LinkedList是基于链表实现的List类。它也可以动态增加和减少元素数量，但相比于ArrayList，LinkedList具有更快的插入和删除元素的能力。

以下是一个使用LinkedList实现的示例应用程序。该程序从用户输入一个字符串，并按照单词顺序翻转字符串。

import java.util.LinkedList;
import java.util.Scanner;

public class LinkedListExample {
    public static void main(String[] args) {
        Scanner inputScanner = new Scanner(System.in);
        LinkedList<String> words = new LinkedList<>();

        System.out.print("Enter a sentence: ");
        String sentence = inputScanner.nextLine();

        String[] wordArray = sentence.split(" ");
        for (String word : wordArray) {
            words.addFirst(word);
        }

        StringBuilder reversedSentence = new StringBuilder();
        for (String word : words) {
            reversedSentence.append(word).append(" ");
        }

        inputScanner.close();

        System.out.println("Reversed sentence: " + reversedSentence.toString().trim());
    }
}

在上述代码中，我们使用LinkedList来存储用户输入的字符串，并按照单词顺序翻转它。在将字符串分割为单词后，我们使用LinkedList的addFirst方法将每个单词添加到列表的开头。然后，我们使用StringBuilder和LinkedList的for-each循环将单词顺序翻转，并输出翻转后的字符串。

Map

Map接口表示一组键值对，其中每个键对应一个唯一的值。Java集合框架中常见的Map实现类包括HashMap和TreeMap。

HashMap

HashMap是基于哈希表实现的Map类。它可以动态增加和减少键值对数量，具有快速的查找和插入操作能力。

以下是一个使用HashMap实现的示例应用程序。该程序从用户输入一组单词，并统计它们的出现次数。

import java.util.HashMap;
import java.util.Scanner;

public class HashMapExample {
    public static void main(String[] args) {
        Scanner inputScanner = new Scanner(System.in);
        HashMap<String, Integer> wordCounts = new HashMap<>();

        System.out.print("Enter words (separated by spaces): ");
        String input = inputScanner.nextLine();

        String[] words = input.split(" ");
        for (String word : words) {
            if (wordCounts.containsKey(word)) {
                wordCounts.put(word, wordCounts.get(word) + 1);
            } else {
                wordCounts.put(word, 1);
            }
        }

        inputScanner.close();

        for (String word : wordCounts.keySet()) {
            int count = wordCounts.get(word);
            System.out.printf("%s: %d%n", word, count);
        }
    }
}

在上述代码中，我们使用HashMap来存储用户输入的单词，并统计它们的出现次数。在将输入字符串分割为单词后，我们使用HashMap的put方法将每个单词和相应的计数器插入到Map中。然后，我们使用HashMap的keySet方法和for-each循环遍历Map，并输出每个单词和相应的计数器。

TreeMap

TreeMap是基于红黑树实现的Map类。与HashMap不同，TreeMap中的键值对是按照键的自然顺序或比较器顺序进行排序的。

以下是一个使用TreeMap实现的示例应用程序。该程序从用户输入一组数字，并按照升序和降序分别排序它们。

import java.util.Scanner;
import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        Scanner inputScanner = new Scanner(System.in);
        TreeMap<Integer, String> numbers = new TreeMap<>();

        System.out.print("Enter numbers (one per line, end with a negative number): ");

        int number;
        do {
            number = inputScanner.nextInt();
            if (number >= 0) {
                numbers.put(number, null);
            }
        } while (number >= 0);

        inputScanner.close();

        System.out.print("Ascending order: ");
        for (int n : numbers.keySet()) {
            System.out.print(n + " ");
        }
        System.out.println();

        System.out.print("Descending order: ");
        for (int n : numbers.descendingKeySet()) {
            System.out.print(n + " ");
        }
        System.out.println();
    }
}

在上述代码中，我们使用TreeMap来存储用户输入的数字，并按照升序和降序分别排序它们。在用户输入一组数字后，我们使用TreeMap的put方法将它们插入到Map中。然后，我们使用TreeMap的keySet方法和descendingKeySet方法以升序和降序方式遍历Map，并输出排序结果。

总结

Java集合是一组对象，用于存储和操作数据。Java集合框架提供了一组接口和实现类，用于处理集合数据。常见的List实现类包括ArrayList和LinkedList；常见的Map实现类包括HashMap和TreeMap。在实际应用中，我们可以选择合适的数据结构和算法，以更高效地处理集合数据。

输入输出

Java输入输出是指将数据从程序输入到计算机内存中或将数据从计算机内存输出到程序中的过程。Java中的输入输出可以使用标准输入输出流(System.in和System.out)、文件输入输出流(FileInputStream和FileOutputStream)和字符输入输出流等方式来实现。

标准输入输出

标准输入输出是指Java程序的控制台输入输出。Java中的标准输入流(System.in)可以使用Scanner类来操作，标准输出流(System.out)可以使用System.out.println方法来输出数据。

以下是一个使用标准输入输出的示例应用程序。该程序从用户输入一个数字，并将其平方输出。

import java.util.Scanner;

public class StandardIOExample {
    public static void main(String[] args) {
        Scanner inputScanner = new Scanner(System.in);

        System.out.print("Enter a number: ");
        int number = inputScanner.nextInt();

        inputScanner.close();

        int square = number * number;
        System.out.printf("%d squared is %d", number, square);
    }
}

在上述代码中，我们使用Scanner类从标准输入流读取用户输入的数字，并将其计算平方后输出到标准输出流中。

文件输入输出

文件输入输出是指Java程序对文件的读取和写入操作。Java中的文件输入输出流(FileInputStream和FileOutputStream)可以用于读取和写入文件数据。

以下是一个使用文件输入输出的示例应用程序。该程序从一个文件读取一组数字，并将它们的平均值写入另一个文件中。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class FileIOExample {
    public static void main(String[] args) {
        Scanner inputScanner = new Scanner(System.in);

        System.out.print("Enter input file name: ");
        String inputFileName = inputScanner.nextLine();

        System.out.print("Enter output file name: ");
        String outputFileName = inputScanner.nextLine();

        inputScanner.close();

        try {
            FileInputStream inputFileStream = new FileInputStream(new File(inputFileName));
            Scanner inputFileScanner = new Scanner(inputFileStream);

            int sum = 0;
            int count = 0;
            while (inputFileScanner.hasNextInt()) {
                count++;
                sum += inputFileScanner.nextInt();
            }

            inputFileScanner.close();
            inputFileStream.close();

            FileOutputStream outputFileStream = new FileOutputStream(new File(outputFileName));
            String outputString = String.format("The average is %.2f", (double) sum / count);
            outputFileStream.write(outputString.getBytes());

            outputFileStream.close();
        } catch (IOException e) {
            System.out.println("An error occurred while processing files.");
            e.printStackTrace();
        }
    }
}

在上述代码中，我们使用FileInputStream从用户输入的文件中读取一组数字，并使用FileOutputStream将它们的平均值写入用户输入的另一个文件中。文件输入输出流需要使用try-catch语句来处理IOException（文件读取或写入错误）。

总结

Java输入输出可以使用标准输入输出流、文件输入输出流和字符输入输出流等方式来实现。标准输入输出可以使用Scanner类和System.out.println方法来操作；文件输入输出可以使用FileInputStream和FileOutputStream来读取和写入文件数据。在实际应用中，我们需要考虑文件读取或写入的安全性和效率等问题，并采取相应的处理策略。

泛型、注解、反射

泛型

泛型是Java编程语言的一项重要特性，它允许我们编写具有类型参数的类和方法，并在编译时执行类型检查。泛型可以使代码更具可读性、可维护性和重用性。

以下是一个使用泛型的示例应用程序。该程序定义了一个泛型类，用于存储和操作各种类型的数据。

public class GenericExample<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public static void main(String[] args) {
        GenericExample<String> stringExample = new GenericExample<>();
        stringExample.setData("Hello, world!");
        System.out.println(stringExample.getData());

        GenericExample<Integer> integerExample = new GenericExample<>();
        integerExample.setData(42);
        System.out.println(integerExample.getData());
    }
}

在上述代码中，我们使用泛型类定义一个通用的数据存储和操作类。我们可以使用<T>来定义类中的类型参数，并使用它来定义类中的字段、方法及其参数和返回类型。在使用泛型类时，我们可以指定类型参数的类型，编译器将执行类型检查，并保证代码的类型安全性。

反射

Java反射是一种能够在运行时检查和修改类的能力。Java反射可以使我们在运行时调用对象的方法、访问对象的字段、创建对象、获取类的注解信息等，在某些情况下可以提高程序的灵活性和扩展性。

以下是一个使用反射的示例应用程序。该程序定义了一个基础类和一个子类，并使用Java反射API获取并输出它们的信息。

import java.lang.reflect.Field;
import java.lang.reflect.Method;

class BaseClass {
    protected int id;
    private String name;

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

    public String getName() {
        return name;
    }

    private void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }
}

public class ReflectionExample extends BaseClass {
    private double value;

    public void setValue(double value) {
        this.value = value;
    }

    public double getValue() {
        return value;
    }

    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
        ReflectionExample example = new ReflectionExample();

        Class<? extends BaseClass> classObj = example.getClass();

        System.out.print("Fields: ");
        for (Field field : classObj.getDeclaredFields()) {
            System.out.print(field.getName() + " ");
        }
        System.out.println();

        System.out.print("Methods: ");
        for (Method method : classObj.getDeclaredMethods()) {
            System.out.print(method.getName() + " ");
        }
        System.out.println();

        Field field = classObj.getSuperclass().getDeclaredField("id");
        field.setAccessible(true);
        example.setId(42);
        System.out.println("ID: " + field.get(example));
    }
}

在上述代码中，我们定义了一个基础类BaseClass和一个子类ReflectionExample，并使用Java反射API获取并输出它们的字段和方法信息。我们也使用Java反射API来获取父类BaseClass的私有字段id，并使用其setAccessible方法获取和设置其值。

注解

在上述代码中，我们定义了一个自定义注解@Test，并应用到一个示例方法中。注解@Test包含了一个值属性value()，用于描述需要测试的方法的名称。在应用注解后，我们使用Java反射API来获取方法对象和注解信息，并输出到控制台中。

import java.lang.annotation.*;
import java.lang.reflect.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface TrackTime {}

class MyClass {
    @TrackTime
    public void method1() throws InterruptedException {
        Thread.sleep(1000);
        System.out.println("Method 1");
    }

    @TrackTime
    public void method2() throws InterruptedException {
        Thread.sleep(2000);
        System.out.println("Method 2");
    }
}

public class AnnotationExample {
    public static void main(String[] args) throws InterruptedException {
        MyClass obj = new MyClass();

        for (Method method : obj.getClass().getMethods()) {
            if (method.isAnnotationPresent(TrackTime.class)) {
                long startTime = System.currentTimeMillis();

                method.invoke(obj);

                long endTime = System.currentTimeMillis();
                System.out.println(method.getName() + " took " + (endTime - startTime) + "ms to execute.");
            }
        }
    }
}

在上述代码中，我们使用@TrackTime注解标记了MyClass类中的method1和method2方法。在主程序中，我们使用Java反射API获取MyClass类中的所有方法，并检查每个方法是否使用@TrackTime注解。如果是，我们记录方法的执行时间，并输出到控制台中。

当我们运行上面的程序时，我们将看到方法1和方法2的执行时间都被记录下来了。这个例子展示了注解如何帮助我们在程序中添加元数据信息，以及如何在程序中使用Java反射API检查和使用这些注解。

总结

Java泛型、注解和反射是Java编程语言的一些重要特性，它们可以使代码更加具有可读性、可维护性、重用性和灵活性。