propsX1. Java常用API概述与核心价值
Java作为一门成熟的编程语言，其标准库提供了丰富的API（Application Programming Interface）来简化开发工作。这些API涵盖了从基础数据结构到网络编程、从文件操作到并发处理的方方面面。对于Java开发者而言，熟练掌握常用API不仅能提升编码效率，还能写出更健壮、更易维护的代码。
在实际开发中，我们经常会遇到需要处理字符串、日期、集合等常见任务。Java标准库中的java.lang、java.util、java.time等包就包含了这些常用功能的实现。比如String类提供了字符串操作的各种方法，ArrayList实现了动态数组的功能，LocalDate则用于处理日期相关操作。
提示：虽然Java API文档非常全面，但初学者往往会感到无从下手。建议从最常用的几个类开始学习，逐步扩展到其他领域。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 字符串处理API详解
2.1 String类的核心方法
String类是Java中最常用的类之一，它提供了丰富的字符串操作方法。以下是一些最常用的方法及其使用场景：
java复制String str = "Hello, Java API!";
// 获取字符串长度
int length = str.length(); // 返回15
// 字符串连接
String newStr = str.concat(" Welcome!"); // "Hello, Java API! Welcome!"
// 字符串比较
boolean isEqual = str.equals("hello, java api!"); // false，区分大小写
boolean isEqualIgnoreCase = str.equalsIgnoreCase("hello, java api!"); // true
// 子字符串查找
int index = str.indexOf("Java"); // 返回7
boolean contains = str.contains("API"); // true
// 字符串分割
String[] parts = str.split(", "); // ["Hello", "Java API!"]
2.2 StringBuilder与StringBuffer
当需要频繁修改字符串时，使用StringBuilder或StringBuffer比直接使用String更高效：
java复制StringBuilder sb = new StringBuilder();
sb.append("Java");
sb.append(" ");
sb.append("API");
String result = sb.toString(); // "Java API"
StringBuilder和StringBuffer的主要区别在于线程安全性：
- StringBuilder：非线程安全，性能更高
- StringBuffer：线程安全，性能稍低
注意：在单线程环境下，优先使用StringBuilder以获得更好的性能。
3. 集合框架API解析
3.1 List接口及其实现
List是有序集合，允许重复元素。常用的实现类有ArrayList和LinkedList：
java复制List<String> arrayList = new ArrayList<>();
arrayList.add("Java");
arrayList.add("API");
arrayList.add(1, "Collection"); // 在索引1处插入
List<String> linkedList = new LinkedList<>();
linkedList.add("LinkedList");
linkedList.addAll(arrayList); // 合并集合
选择依据：
- ArrayList：随机访问频繁时使用（get/set操作快）
- LinkedList：频繁插入删除时使用（add/remove操作快）
3.2 Map接口及其实现
Map存储键值对，常用实现有HashMap和TreeMap：
java复制Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Java", 1);
hashMap.put("API", 2);
int value = hashMap.get("Java"); // 1
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.putAll(hashMap); // 按键的自然顺序排序
3.3 Set接口及其实现
Set是不允许重复元素的集合，常用实现有HashSet和TreeSet：
java复制Set<String> hashSet = new HashSet<>();
hashSet.add("Java");
hashSet.add("API");
hashSet.add("Java"); // 不会重复添加
Set<String> treeSet = new TreeSet<>();
treeSet.addAll(hashSet); // 元素按顺序排列
4. 日期时间API（java.time包）
Java 8引入了全新的日期时间API，解决了旧API的诸多问题：
4.1 基本日期时间类
java复制// 当前日期
LocalDate today = LocalDate.now();
// 特定日期
LocalDate birthDate = LocalDate.of(1990, Month.JANUARY, 1);
// 当前日期时间
LocalDateTime now = LocalDateTime.now();
// 时间计算
LocalDate nextWeek = today.plusWeeks(1);
Period period = Period.between(birthDate, today);
4.2 日期格式化和解析
java复制DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formattedDate = today.format(formatter); // "2023-11-15"
LocalDate parsedDate = LocalDate.parse("2023-11-15", formatter);
4.3 时区处理
java复制ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
Instant instant = Instant.now(); // 时间戳
5. 输入输出API（java.io和java.nio）
5.1 文件操作
java复制// 创建文件
File file = new File("test.txt");
if (!file.exists()) {
file.createNewFile();
}
// 读取文件
try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
// 写入文件
try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))) {
writer.write("Hello, Java IO API!");
}
5.2 NIO文件操作
Java NIO提供了更高效的文件操作方式：
java复制Path path = Paths.get("test.txt");
byte[] bytes = Files.readAllBytes(path);
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
// 写入文件
Files.write(path, "New content".getBytes(), StandardOpenOption.APPEND);
6. 异常处理API
Java异常处理是保证程序健壮性的重要机制：
6.1 异常类层次结构
code复制Throwable
├── Error
└── Exception
├── RuntimeException
└── 其他检查型异常
6.2 自定义异常
java复制class MyException extends Exception {
public MyException(String message) {
super(message);
}
}
void riskyMethod() throws MyException {
if (somethingWrong) {
throw new MyException("Something went wrong");
}
}
6.3 try-with-resources
自动资源管理语法：
java复制try (InputStream in = new FileInputStream("file.txt");
OutputStream out = new FileOutputStream("copy.txt")) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
}
} catch (IOException e) {
e.printStackTrace();
}
7. 多线程API
7.1 线程创建
java复制// 方式1：继承Thread类
class MyThread extends Thread {
public void run() {
System.out.println("Thread running");
}
}
// 方式2：实现Runnable接口
class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable running");
}
}
// 使用
new MyThread().start();
new Thread(new MyRunnable()).start();
7.2 线程池
java复制ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
executor.execute(() -> {
System.out.println("Task executed by " + Thread.currentThread().getName());
});
}
executor.shutdown();
7.3 同步机制
java复制// synchronized方法
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
}
// Lock接口
class CounterWithLock {
private final Lock lock = new ReentrantLock();
private int count = 0;
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
}
8. 反射API（java.lang.reflect）
反射允许程序在运行时检查类、接口、字段和方法：
8.1 获取Class对象
java复制Class<?> clazz1 = String.class;
Class<?> clazz2 = Class.forName("java.lang.String");
Class<?> clazz3 = "".getClass();
8.2 反射操作
java复制Class<?> clazz = Class.forName("com.example.MyClass");
Object instance = clazz.newInstance();
// 获取方法并调用
Method method = clazz.getMethod("methodName", String.class);
method.invoke(instance, "argument");
// 获取字段并修改
Field field = clazz.getDeclaredField("fieldName");
field.setAccessible(true);
field.set(instance, "new value");
注意：反射会破坏封装性并带来性能开销，应谨慎使用。
9. 函数式编程API（Java 8+）
9.1 Lambda表达式
java复制List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// 传统方式
Collections.sort(names, new Comparator<String>() {
public int compare(String a, String b) {
return a.compareTo(b);
}
});
// Lambda表达式
Collections.sort(names, (a, b) -> a.compareTo(b));
9.2 Stream API
java复制List<String> filtered = names.stream()
.filter(name -> name.startsWith("A"))
.map(String::toUpperCase)
.collect(Collectors.toList());
long count = names.stream()
.filter(name -> name.length() > 4)
.count();
9.3 Optional类
java复制Optional<String> optional = Optional.ofNullable(getName());
String result = optional.orElse("default");
optional.ifPresent(name -> System.out.println(name));
10. 网络编程API
10.1 URL处理
java复制URL url = new URL("https://example.com");
URLConnection connection = url.openConnection();
try (InputStream in = connection.getInputStream()) {
// 读取数据
}
10.2 Socket编程
java复制// 服务端
ServerSocket serverSocket = new ServerSocket(8080);
Socket clientSocket = serverSocket.accept();
// 客户端
Socket socket = new Socket("localhost", 8080);
10.3 HTTP客户端（Java 11+）
java复制HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://example.com"))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
11. 常用工具类
11.1 Arrays类
java复制int[] numbers = {3, 1, 4, 1, 5, 9};
Arrays.sort(numbers);
int index = Arrays.binarySearch(numbers, 4);
int[] copy = Arrays.copyOf(numbers, numbers.length);
11.2 Collections类
java复制List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 4));
Collections.sort(list);
Collections.reverse(list);
Collections.shuffle(list);
11.3 Objects类
java复制String str = null;
Objects.requireNonNull(str, "参数不能为null"); // 抛出NullPointerException
boolean isNull = Objects.isNull(str);
boolean equals = Objects.equals(str, "test");
12. 正则表达式API（java.util.regex）
java复制Pattern pattern = Pattern.compile("\\d+");
Matcher matcher = pattern.matcher("123 abc 456");
while (matcher.find()) {
System.out.println(matcher.group());
}
String replaced = "a1b2c3".replaceAll("\\d", "X"); // "aXbXcX"
boolean matches = "123".matches("\\d+"); // true
13. 国际化API（java.util和java.text）
13.1 资源束
java复制ResourceBundle bundle = ResourceBundle.getBundle("Messages", Locale.US);
String message = bundle.getString("greeting");
13.2 数字和日期格式化
java复制NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);
String formattedNumber = nf.format(1234567.89); // "1,234,567.89"
DateFormat df = DateFormat.getDateInstance(DateFormat.LONG, Locale.US);
String formattedDate = df.format(new Date()); // "November 15, 2023"
14. 注解处理API
14.1 内置注解
java复制@Override
public String toString() {
return "Overridden toString";
}
@Deprecated
public void oldMethod() {
// 不推荐使用的方法
}
@SuppressWarnings("unchecked")
public void methodWithWarning() {
List list = new ArrayList();
list.add("item");
}
14.2 自定义注解
java复制@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
String value() default "";
int priority() default 0;
}
@MyAnnotation(value = "test", priority = 1)
public void annotatedMethod() {
}
15. Java 9+新增API
15.1 集合工厂方法
java复制List<String> list = List.of("a", "b", "c");
Set<Integer> set = Set.of(1, 2, 3);
Map<String, Integer> map = Map.of("a", 1, "b", 2);
15.2 Stream增强
java复制List<Integer> numbers = List.of(1, 2, 3, 4, 5);
List<Integer> taken = numbers.stream()
.takeWhile(n -> n < 4) // [1, 2, 3]
.collect(Collectors.toList());
List<Integer> dropped = numbers.stream()
.dropWhile(n -> n < 4) // [4, 5]
.collect(Collectors.toList());
15.3 模块系统（JPMS）
java复制module com.example.myapp {
requires java.base;
requires java.sql;
exports com.example.api;
}
16. 性能监控与管理API
16.1 内存管理
java复制Runtime runtime = Runtime.getRuntime();
long freeMemory = runtime.freeMemory();
long totalMemory = runtime.totalMemory();
long maxMemory = runtime.maxMemory();
16.2 线程监控
java复制ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
ThreadInfo[] threads = threadBean.dumpAllThreads(false, false);
for (ThreadInfo info : threads) {
System.out.println(info.getThreadName());
}
16.3 垃圾收集信息
java复制List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
for (GarbageCollectorMXBean gcBean : gcBeans) {
System.out.println(gcBean.getName() + ": " + gcBean.getCollectionCount());
}
17. 安全API（java.security）
17.1 消息摘要
java复制MessageDigest md = MessageDigest.getInstance("SHA-256");
byte[] digest = md.digest("message".getBytes());
17.2 加密解密
java复制KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(256);
SecretKey key = keyGen.generateKey();
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encrypted = cipher.doFinal("secret".getBytes());
17.3 数字签名
java复制KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
KeyPair pair = keyGen.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSA");
sig.initSign(pair.getPrivate());
sig.update("data".getBytes());
byte[] signature = sig.sign();
18. 数据库连接API（JDBC）
18.1 基本操作
java复制try (Connection conn = DriverManager.getConnection(url, user, password);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
while (rs.next()) {
String name = rs.getString("name");
int age = rs.getInt("age");
}
}
18.2 预处理语句
java复制String sql = "INSERT INTO users (name, age) VALUES (?, ?)";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, "Alice");
pstmt.setInt(2, 25);
pstmt.executeUpdate();
}
18.3 事务处理
java复制conn.setAutoCommit(false);
try {
// 执行多个SQL操作
conn.commit();
} catch (SQLException e) {
conn.rollback();
} finally {
conn.setAutoCommit(true);
}
19. 日志API
19.1 java.util.logging
java复制Logger logger = Logger.getLogger("com.example.MyClass");
logger.setLevel(Level.INFO);
logger.info("This is an info message");
logger.warning("This is a warning");
19.2 SLF4J + Logback
java复制import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger logger = LoggerFactory.getLogger(MyClass.class);
logger.debug("Debug message");
logger.error("Error occurred", exception);
20. Java API最佳实践
-
API文档阅读：养成阅读官方API文档的习惯，理解每个方法的用途、参数和返回值。
-
异常处理：合理处理API可能抛出的异常，不要简单地捕获所有异常或忽略异常。
-
资源管理：使用try-with-resources确保资源（如流、连接）被正确关闭。
-
性能考虑：了解API的性能特征，如ArrayList和LinkedList的不同适用场景。
-
线程安全：注意API的线程安全性，必要时使用同步机制。
-
版本兼容：注意API的引入版本，确保与目标运行环境兼容。
-
合理封装：对常用API操作进行适当封装，提高代码复用性。
-
测试验证：对新使用的API进行充分测试，验证其行为是否符合预期。
在实际开发中，我发现很多开发者只关注API的"能用"，而忽略了"用好"。比如在字符串拼接时，在循环中使用"+"操作符而不是StringBuilder，或者在频繁查询时使用线性搜索而不是二分查找。这些细节往往会在系统规模扩大后成为性能瓶颈。因此，深入理解常用API的内部实现原理和适用场景，是成为高级Java开发者的必经之路。