Java 常用类库详解

2024-06-18 19:52
文章标签 java 详解 常用 类库

本文主要是介绍Java 常用类库详解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

  1. Java 核心类库
    1. java.lang
    2. java.util
    3. java.io
    4. java.nio
  2. 集合框架
    1. List 接口及其实现类
    2. Set 接口及其实现类
    3. Map 接口及其实现类
  3. 并发编程
    1. java.util.concurrent
    2. Atomic 类
    3. Lock 类
  4. 网络编程
    1. java.net
    2. HttpClient
  5. 日期和时间处理
    1. java.util.Date 和 java.util.Calendar
    2. java.time
  6. 常用第三方库
    1. Apache Commons
    2. Google Guava
    3. Jackson
  7. 总结

Java 核心类库

java.lang

java.lang 是 Java 核心类库中最基础的部分，包含了 Java 编程的核心类。常用的类有：

  • String：表示字符串的类。
  • Math：包含基本数学运算方法的类。
  • System：包含标准输入、输出、错误输出流，访问外部属性和环境的方法。
  • Thread：实现多线程的类。
  • Object：所有类的父类，包含对象的基本方法。
示例代码
public class LangExample {public static void main(String[] args) {// String 操作String greeting = "Hello, World!";System.out.println(greeting.toUpperCase());// Math 操作double randomValue = Math.random();System.out.println("Random Value: " + randomValue);// System 操作System.out.println("Current Time: " + System.currentTimeMillis());// Thread 操作Thread thread = new Thread(() -> System.out.println("Thread Running"));thread.start();// Object 操作Object obj = new Object();System.out.println(obj.toString());}
}

java.util

java.util 包含了集合框架、日期和时间、随机数生成等常用工具类。

  • ArrayList：动态数组实现类。
  • HashMap：基于哈希表的 Map 接口实现。
  • Calendar：日期和时间的抽象类。
  • Random：用于生成伪随机数。
示例代码
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Calendar;
import java.util.Random;public class UtilExample {public static void main(String[] args) {// ArrayList 操作ArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");System.out.println(list);// HashMap 操作HashMap<String, Integer> map = new HashMap<>();map.put("Apple", 1);map.put("Banana", 2);System.out.println(map);// Calendar 操作Calendar calendar = Calendar.getInstance();System.out.println("Current Time: " + calendar.getTime());// Random 操作Random random = new Random();System.out.println("Random Number: " + random.nextInt(100));}
}

java.io

java.io 提供了系统输入、输出、文件操作等 I/O 功能。

  • File：表示文件和目录路径名的抽象表示。
  • FileInputStream：用于读取文件的输入流。
  • FileOutputStream：用于写入文件的输出流。
  • BufferedReader：缓冲读取字符的输入流。
示例代码
import java.io.*;public class IOExample {public static void main(String[] args) {// File 操作File file = new File("example.txt");try {if (file.createNewFile()) {System.out.println("File created: " + file.getName());} else {System.out.println("File already exists.");}// FileOutputStream 操作FileOutputStream fos = new FileOutputStream(file);fos.write("Hello, World!".getBytes());fos.close();// FileInputStream 操作FileInputStream fis = new FileInputStream(file);int i;while ((i = fis.read()) != -1) {System.out.print((char) i);}fis.close();// BufferedReader 操作BufferedReader br = new BufferedReader(new FileReader(file));String line;while ((line = br.readLine()) != null) {System.out.println(line);}br.close();} catch (IOException e) {e.printStackTrace();}}
}

java.nio

java.nio (New I/O) 是 Java 1.4 引入的新的 I/O API，提供了更高效的 I/O 操作。

  • ByteBuffer：字节缓冲区，读写缓冲区中的字节。
  • FileChannel：与文件、内存映射文件、文件锁定有关的通道。
  • Selector：用于多路复用选择的选择器。
示例代码
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class NIOExample {public static void main(String[] args) {try {// 创建 ByteBufferByteBuffer buffer = ByteBuffer.allocate(48);buffer.put("Hello, NIO!".getBytes());buffer.flip();// 写入文件FileOutputStream fos = new FileOutputStream("nio-example.txt");FileChannel channel = fos.getChannel();channel.write(buffer);channel.close();fos.close();// 读取文件FileInputStream fis = new FileInputStream("nio-example.txt");FileChannel readChannel = fis.getChannel();ByteBuffer readBuffer = ByteBuffer.allocate(48);readChannel.read(readBuffer);readBuffer.flip();while (readBuffer.hasRemaining()) {System.out.print((char) readBuffer.get());}readChannel.close();fis.close();} catch (IOException e) {e.printStackTrace();}}
}

集合框架

Java 集合框架提供了一组用于存储和操作数据的类和接口，包括 List、Set、Map 等。以下是一些常用集合类的详细介绍。

List 接口及其实现类

List 接口表示一个有序的集合，允许重复的元素。常见的实现类有：

  • ArrayList：基于数组实现的列表，支持快速随机访问。
  • LinkedList：基于链表实现的列表，适合频繁插入和删除操作。
示例代码
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;public class ListExample {public static void main(String[] args) {// ArrayList 操作List<String> arrayList = new ArrayList<>();arrayList.add("Apple");arrayList.add("Banana");System.out.println("ArrayList: " + arrayList);// LinkedList 操作List<String> linkedList = new LinkedList<>();linkedList.add("Cherry");linkedList.add("Date");System.out.println("LinkedList: " + linkedList);}
}

Set 接口及其实现类

Set 接口表示一个不允许重复元素的集合。常见的实现类有：

  • HashSet：基于哈希表实现的集合，允许快速查找。
  • TreeSet：基于红黑树实现的集合，保证元素的有序性。
示例代码
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;public class SetExample {public static void main(String[] args) {// HashSet 操作Set<String> hashSet = new HashSet<>();hashSet.add("Apple");hashSet.add("Banana");hashSet.add("Apple"); // 重复元素不会被添加System.out.println("HashSet: " + hashSet);// TreeSet 操作Set<String> treeSet = new TreeSet<>();treeSet.add("Cherry");treeSet.add("Date");treeSet.add("Banana");System.out.println("TreeSet: " + treeSet);}
}

Map 接口及其实现类

Map 接口表示一个键值对映射的集合。常见的实现类有：

  • HashMap：基于哈希表实现的映射，允许快速查找。
  • TreeMap：基于红黑树实现的映射，保证键的有序性。
示例代码
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;public class MapExample {public static void main(String[] args) {// HashMap 操作Map<String, Integer> hashMap = new HashMap<>();hashMap.put("Apple", 1);hashMap.put("Banana", 2);System.out.println("HashMap: " + hashMap);// TreeMap 操作Map<String, Integer> treeMap = new TreeMap<>();treeMap.put("Cherry", 3);treeMap.put("Date", 4);System.out.println("TreeMap: " + treeMap);}
}

并发编程

并发编程是 Java 的一大特点，Java 提供了一整套并发编程的工具和类。

java.util.concurrent

java.util.concurrent 包含了并发编程所需的类和接口，例如线程池、同步工具等。

  • ExecutorService：框架中用于执行异步任务的接口。
  • CountDownLatch：允许一个或多个线程等待其他线程完成操作的同步辅助工具。
  • ConcurrentHashMap：线程安全的哈希表。
示例代码
import java.util.concurrent.*;public class ConcurrentExample {public static void main(String[] args) {// ExecutorService 操作ExecutorService executor = Executors.newFixedThreadPool(2);executor.submit(() -> System.out.println("Task 1"));executor.submit(() -> System.out.println("Task 2"));executor.shutdown();// CountDownLatch 操作CountDownLatch latch = new CountDownLatch(2);new Thread(() -> {System.out.println("Thread 1");latch.countDown();}).start();new Thread(() -> {System.out.println("Thread 2");latch.countDown();}).start();try {latch.await();System.out.println("All threads finished");} catch (InterruptedException e) {e.printStackTrace();}// ConcurrentHashMap 操作ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();map.put("Apple", 1);map.put("Banana", 2);System.out.println("ConcurrentHashMap: " + map);}
}

Atomic 类

java.util.concurrent.atomic 提供了一些用于并发编程的原子类，确保在多线程环境下对变量的操作是原子性的。

  • AtomicInteger：提供对 int 类型的原子操作。
  • AtomicBoolean：提供对 boolean 类型的原子操作。
示例代码
import java.util.concurrent.atomic.AtomicInteger;public class AtomicExample {public static void main(String[] args) {// AtomicInteger 操作AtomicInteger atomicInt = new AtomicInteger(0);System.out.println("Initial Value: " + atomicInt.get());atomicInt.incrementAndGet();System.out.println("After Increment: " + atomicInt.get());}
}

Lock 类

java.util.concurrent.locks 包含了一些用于控制多线程访问共享资源的锁类。

  • ReentrantLock：一个可重入的互斥锁。
  • ReadWriteLock：读写锁，允许多个读线程同时访问，但写线程独占访问。
示例代码
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class LockExample {private static int counter = 0;private static final Lock lock = new ReentrantLock();public static void main(String[] args) {Runnable task = () -> {lock.lock();try {counter++;System.out.println("Counter: " + counter);} finally {lock.unlock();}};Thread thread1 = new Thread(task);Thread thread2 = new Thread(task);thread1.start();thread2.start();}
}

网络编程

Java 提供了丰富的类库来支持网络编程，包括传统的 java.net 和更现代的 HttpClient。

java.net

java.net 包含了进行网络操作的类，如 Socket、ServerSocket、URL 等。

  • Socket：实现客户端和服务器之间的通信。
  • ServerSocket：实现服务器端的监听。
示例代码
import java.net.*;
import java.io.*;public class NetworkExample {public static void main(String[] args) {try {// 启动服务器new Thread(() -> {try (ServerSocket serverSocket = new ServerSocket(8080)) {Socket socket = serverSocket.accept();BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));System.out.println("Server received: " + in.readLine());} catch (IOException e) {e.printStackTrace();}}).start();// 启动客户端Thread.sleep(1000); // 等待服务器启动try (Socket socket = new Socket("localhost", 8080)) {PrintWriter out = new PrintWriter(socket.getOutputStream(), true);out.println("Hello, Server!");}} catch (IOException | InterruptedException e) {e.printStackTrace();}}
}

HttpClient

java.net.http.HttpClient 是 Java 11 引入的新特性，用于发送 HTTP 请求和接收响应。

示例代码
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;public class HttpClientExample {public static void main(String[] args) {HttpClient client = HttpClient.newHttpClient();HttpRequest request = HttpRequest.newBuilder().uri(URI.create("https://jsonplaceholder.typicode.com/posts/1")).build();try {HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());System.out.println("Response: " + response.body());} catch (IOException | InterruptedException e) {e.printStackTrace();}}
}

日期和时间处理

Java 提供了多种类来处理日期和时间，从早期的 java.util.Date 和 java.util.Calendar 到现代的 java.time。

java.util.Date 和 java.util.Calendar

这些类是早期 Java 中处理日期和时间的主要工具。

示例代码
import java.util.Date;
import java.util.Calendar;public class DateExample {public static void main(String[] args) {// Date 操作Date date = new Date();System.out.println("Current Date: " + date);// Calendar 操作Calendar calendar = Calendar.getInstance();System.out.println("Current Time: " + calendar.getTime());}
}

java.time

java.time 包含了一套新的日期和时间 API，是 Java 8 引入的，提供了更好的日期和时间处理能力。

  • LocalDate：表示日期，无时间部分。
  • LocalTime：表示时间，无日期部分。
  • LocalDateTime：表示日期和时间。
  • ZonedDateTime：表示带时区的日期和时间。
示例代码
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.ZonedDateTime;
import java.time.ZoneId;public class TimeExample {public static void main(String[] args) {// LocalDate 操作LocalDate date = LocalDate.now();System.out.println("Current Date: " + date);// LocalTime 操作LocalTime time = LocalTime.now();System.out.println("Current Time: " + time);// LocalDateTime 操作LocalDateTime dateTime = LocalDateTime.now();System.out.println("Current DateTime: " + dateTime);// ZonedDateTime 操作ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("America/New_York"));System.out.println("Current ZonedDateTime: " + zonedDateTime);}
}

常用第三方库

除了 Java 标准库外，许多第三方库也在 Java 开发中被广泛使用，如 Apache Commons、Google Guava 和 Jackson 等。

Apache Commons

Apache Commons 提供了许多实用的类库，涵盖了各种常见的开发需求。

  • Commons Lang：扩展了 java.lang 包的功能。
  • Commons IO：提供了对 I/O 操作的支持。
  • Commons Collections

：扩展了 Java 的集合框架。

示例代码
import org.apache.commons.lang3.StringUtils;public class CommonsExample {public static void main(String[] args) {// StringUtils 操作String str = "  Hello, Commons!  ";System.out.println("Trimmed String: '" + StringUtils.trim(str) + "'");}
}

Google Guava

Google Guava 提供了许多有用的工具类和方法。

  • Lists：处理列表的工具类。
  • Maps：处理映射的工具类。
  • Preconditions：用于参数验证。
示例代码
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.base.Preconditions;import java.util.List;
import java.util.Map;public class GuavaExample {public static void main(String[] args) {// Lists 操作List<String> list = Lists.newArrayList("Apple", "Banana", "Cherry");System.out.println("List: " + list);// Maps 操作Map<String, Integer> map = Maps.newHashMap();map.put("Apple", 1);map.put("Banana", 2);System.out.println("Map: " + map);// Preconditions 操作String str = "Hello, Guava!";Preconditions.checkNotNull(str, "String should not be null");System.out.println(str);}
}

Jackson

Jackson 是一个处理 JSON 数据的强大工具。

  • ObjectMapper：用于读写 JSON 数据。
示例代码
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;public class JacksonExample {public static void main(String[] args) {ObjectMapper mapper = new ObjectMapper();// 对象转 JSONMap<String, String> map = new HashMap<>();map.put("name", "John");map.put("age", "30");try {String json = mapper.writeValueAsString(map);System.out.println("JSON: " + json);// JSON 转对象Map<String, String> resultMap = mapper.readValue(json, HashMap.class);System.out.println("Map: " + resultMap);} catch (IOException e) {e.printStackTrace();}}
}

总结

本文详细介绍了 Java 开发中常用的类库，包括 Java 核心类库、集合框架、并发编程、网络编程、日期和时间处理以及常用的第三方库。通过这些类库，开发者可以高效地完成各种编程任务。希望本文能够帮助读者更好地理解和使用这些类库，从而提高开发效率和代码质量。

这篇关于Java 常用类库详解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1072952。

相关文章

HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
JS常用组件收集

JS常用组件收集

收集了一些平时遇到的前端比较优秀的组件，方便以后开发的时候查找！！！ 函数工具： Lodash 页面固定： stickUp、jQuery.Pin 轮播： unslider、swiper 开关: switch 复选框： icheck 气泡： grumble 隐藏元素： Headroom
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2