网址:www.xservx.com•备案号:蜀ICP备2026035467号-3

java代码大全复制

本平台专注提供java代码大全复制服务,致力于构建最全面、最实用、最易用的Java代码资源库。无论您是初学者还是资深开发者,都能在此找到即刻可用的代码片段。所有代码均经过严格校验,确保可复制、可运行、可理解。

我们深知,开发者最需要的是:准确、完整、可执行、易理解的代码示例。因此,每一份代码都严格遵循以下标准:

从基础语法到高级特性,从集合操作到并发控制,从网络编程到数据库连接,从设计模式到工程实践——本库覆盖Java开发全栈知识体系。所有内容均基于真实项目经验提炼,拒绝理论空谈,强调实战价值。

我们持续更新:每月新增200+高质量代码片段,覆盖最新技术趋势(如虚拟线程、结构化并发、模式匹配等JDK新特性)。所有代码支持一键复制,直接粘贴至IDE即可运行。

平台特色:

特别说明:本平台不提供图片占位符,所有示例均为真实可运行代码。我们坚信——代码即内容,内容即价值。

基础语法与核心结构

掌握Java基础是进阶的前提。以下提供高频、易错、实用的基础代码示例,助您夯实根基。

变量与数据类型

Java提供8种基本数据类型及对应的包装类。正确选择类型是避免精度丢失、内存浪费的关键。

public class DataTypeDemo {
    public static void main(String[] args) {
        // 整数类型:byte(1字节)、short(2字节)、int(4字节)、long(8字节)
        byte b = 127;      // 范围:-128 ~ 127
        short s = 32767;   // 范围:-32768 ~ 32767
        int i = 2147483647; // 最大值
        long l = 9223372036854775807L; // 注意后缀L
        // 浮点类型:float(4字节)、double(8字节)
        float f = 3.1415926f; // 必须加f后缀
        double d = 3.141592653589793; // 默认精度更高
        // 字符类型:char(2字节,Unicode编码)
        char c = 'A'; // 单引号
        char emoji = '😀'; // 支持Unicode字符
        // 布尔类型:boolean(仅true/false)
        boolean isPass = true;
        // 字符串类型:String(引用类型,非基本类型)
        String name = "Java代码大全";
        System.out.println("基本类型总占用字节数:" + (1+2+4+8+4+8+2+1));
        System.out.println("字符串长度:" + name.length());
    }
}

⚠️ 注意事项:

  • 整数字面量默认为int,long需加L/l后缀
  • 浮点字面量默认为double,float需加F/f后缀
  • 字符用单引号,字符串用双引号
  • boolean不能与int互转(与C/C++不同)
  • String是final类,不可变性保障线程安全

控制流与循环结构

复杂业务逻辑常依赖条件判断与循环嵌套。以下展示多种控制结构的规范写法。

public class ControlFlowDemo {
    public static void main(String[] args) {
        // if-else嵌套优化:使用switch或策略模式
        int score = 85;
        String grade = score >= 90 ? "A" :
                       score >= 80 ? "B" :
                       score >= 70 ? "C" :
                       score >= 60 ? "D" : "F";
        // for循环:遍历数组/集合
        int[] numbers = {1, 2, 3, 4, 5};
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        // while与do-while:循环前不确定次数
        int count = 0;
        while (count < 3) {
            System.out.println("while循环第" + (++count) + "次");
        }
        // 增强for循环:仅适用于数组和Iterable对象
        String[] fruits = {"苹果", "香蕉", "橙子"};
        for (String fruit : fruits) {
            System.out.println("水果:" + fruit);
        }
        // break与continue:控制循环流程
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue; // 跳过偶数
            if (i > 7) break; // 超过7则终止
            System.out.print(i + " "); // 输出:1 3 5 7
        }
    }
}

💡 最佳实践:

  • 优先使用增强for循环(代码简洁、避免索引越界)
  • 避免深层嵌套(超过3层考虑重构)
  • 条件表达式过长时,拆分为多个if-else
  • 循环内避免重复计算(如length()结果提前保存)

字符串处理与正则表达式

字符串操作是Java开发中最频繁的任务之一。掌握常用方法与正则技巧可大幅提升效率。

public class StringDemo {
    public static void main(String[] args) {
        String text = "Java代码大全复制_2026-03-15_10:30";
        // 常用方法
        System.out.println("长度:" + text.length()); // 29
        System.out.println("首字符:" + text.charAt(0)); // 'J'
        System.out.println("子串:" + text.substring(5, 11)); // "代码大全"
        System.out.println("包含:" + text.contains("代码")); // true
        System.out.println("替换:" + text.replace("_", "-")); // "Java代码大全复制-2026-03-15-10:30"
        System.out.println("分割:" + Arrays.toString(text.split("_"))); // ["Java代码大全复制", "2026-03-15", "10:30"]
        // 正则表达式:提取数字
        String date = "2026年03月15日";
        String[] parts = date.replaceAll("[^0-9]", " ").trim().split("\\s+");
        System.out.println("年:" + parts[0] + ",月:" + parts[1] + ",日:" + parts[2]);
        // 正则校验邮箱
        String email = "user@example.com";
        boolean isValid = email.matches("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$");
        System.out.println("邮箱格式:" + (isValid ? "有效" : "无效"));
        // StringBuilder高效拼接(避免+号导致的多次创建对象)
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            sb.append("第").append(i+1).append("次拼接|");
        }
        System.out.println(sb.deleteCharAt(sb.length()-1).toString()); // 去除末尾分隔符
    }
}

🔧 正则高频模式:

  • 手机号:^1[3-9]\d{9}$
  • 身份证号:^\d{17}[\dXx]$
  • URL:^https?://[\\w\\-]+(\\.[\\w\\-]+)+[/\\w\\-\\./?%&=]*$
  • 中文字符:[\\u4e00-\\u9fa5]

集合框架与泛型编程

Java集合框架是开发的核心组件。理解各集合类的特性、适用场景及性能差异至关重要。

List实现类对比

ArrayList:基于动态数组,随机访问快(O(1)),插入/删除慢(O(n)),线程不安全。

LinkedList:基于双向链表,插入/删除快(O(1)),随机访问慢(O(n)),支持队列操作。

Vector:线程安全的ArrayList,但效率低,已不推荐使用。

public class ListDemo {
    public static void main(String[] args) {
        // ArrayList示例:适合频繁读取的场景
        List list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add(1, "C++"); // 在索引1处插入
        System.out.println(list.get(1)); // 输出:C++(O(1)访问)
        // LinkedList示例:适合频繁插入/删除
        LinkedList linked = new LinkedList<>();
        linked.addFirst("Front"); // 头部插入
        linked.addLast("Back");   // 尾部插入
        System.out.println(linked.removeFirst()); // 输出:Front(O(1)删除)
    }
}

Map实现类对比

HashMap:基于哈希表,无序,允许null键值,线程不安全。

LinkedHashMap:HashMap的子类,维护插入顺序(或访问顺序)。

TreeMap:基于红黑树,按键排序(自然顺序或自定义比较器)。

ConcurrentHashMap:线程安全的HashMap,高并发场景首选。

public class MapDemo {
    public static void main(String[] args) {
        // HashMap:无序
        Map map = new HashMap<>();
        map.put("Java", 10);
        map.put("Python", 8);
        map.forEach((k, v) -> System.out.println(k + ":" + v));
        // LinkedHashMap:按插入顺序
        Map linkedMap = new LinkedHashMap<>();
        linkedMap.put("A", 1);
        linkedMap.put("B", 2);
        linkedMap.forEach((k, v) -> System.out.println(k + ":" + v)); // 顺序:A→B
        // TreeMap:按键排序
        Map treeMap = new TreeMap<>();
        treeMap.put("C", 3);
        treeMap.put("A", 1);
        treeMap.forEach((k, v) -> System.out.println(k + ":" + v)); // 顺序:A→C
    }
}

泛型与类型安全

泛型(Generics)是Java 5引入的核心特性,提升代码安全性与可读性。

public class GenericDemo {
    // 泛型方法:支持任意类型
    public static  T getFirst(List list) {
        return list.isEmpty() ? null : list.get(0);
    }
    // 泛型类:类型参数化
    public static class Box {
        private T content;
        public void set(T content) { this.content = content; }
        public T get() { return content; }
    }
    public static void main(String[] args) {
        Box stringBox = new Box<>();
        stringBox.set("Hello");
        System.out.println(stringBox.get()); // 输出:Hello
        List numbers = Arrays.asList(1, 2, 3);
        System.out.println(getFirst(numbers)); // 输出:1
    }
}

⚠️ 注意:

  • 泛型仅在编译期有效(类型擦除),运行时无法获取T的具体类型
  • 不能创建泛型数组:new T[] → 需用Object[]并强转
  • 通配符用于未知类型,表示上界

主流框架核心代码示例

企业级开发离不开框架支持。以下精选Spring、MyBatis等常用框架的核心功能实现。

Spring依赖注入与AOP

Spring通过IoC容器管理Bean生命周期,AOP实现横切关注点分离。

// 服务接口
public interface UserService {
    void saveUser(User user);
}
// 实现类(无Spring注解,纯POJO)
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(User user) {
        System.out.println("保存用户:" + user.getName());
    }
}
// 配置类(替代XML)
@Configuration
@ComponentScan("com.example")
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}
// 主程序启动
public class SpringDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
        userService.saveUser(new User("张三"));
    }
}

💡 AOP实现日志记录:

@Aspect
@Component
public class LogAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("执行方法:" + joinPoint.getSignature().getName());
    }
}

MyBatis动态SQL

MyBatis通过XML或注解实现SQL与Java的映射,动态SQL提升灵活性。

<!-- XML映射文件 -->
<select id="findUsers" parameterType="map" resultType="User">
    SELECT * FROM user
    <where>
        <if test="name != null and name != ''">
            AND name LIKE CONCAT('%', #{name}, '%')
        </if>
        <if test="minAge != null">
            AND age > #{minAge}
        </if>
    </where>
</select>

Java调用:

public interface UserMapper {
    List findUsers(@Param("name") String name, @Param("minAge") Integer minAge);
}
// 使用示例
List users = userMapper.findUsers("张", 20); // 动态生成WHERE条件

Spring MVC请求处理

基于注解的MVC开发模式,简化Web请求处理流程。

@Controller
@RequestMapping("/api/user")
public class UserController {
    @Autowired
    private UserService userService;
    // GET请求:查询用户列表
    @GetMapping("/list")
    @ResponseBody
    public List listUsers(@RequestParam(defaultValue = "10") int size) {
        return userService.getAllUsers().subList(0, Math.min(size, 10));
    }
    // POST请求:新增用户
    @PostMapping("/add")
    @ResponseBody
    public Map addUser(@RequestBody User user) {
        Map result = new HashMap<>();
        try {
            userService.saveUser(user);
            result.put("status", "success");
            result.put("message", "用户添加成功");
        } catch (Exception e) {
            result.put("status", "error");
            result.put("message", e.getMessage());
        }
        return result;
    }
}

Web开发与HTTP协议

Java Web开发需深入理解HTTP协议、会话管理及安全机制。

HTTP请求与响应处理

使用Java原生API实现简易HTTP客户端与服务端。

// HTTP客户端:GET请求
public class HttpClientDemo {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://jsonplaceholder.typicode.com/posts/1");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        int status = conn.getResponseCode();
        System.out.println("响应状态:" + status); // 200
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(conn.getInputStream()));
        String line;
        StringBuilder response = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();
        conn.disconnect();
        System.out.println("响应内容:" + response.toString());
    }
}

会话管理(Session/Cookie)

通过Session与Cookie实现用户状态保持。

// 设置Cookie
Cookie userCookie = new Cookie("username", "admin");
userCookie.setMaxAge(60 * 60); // 1小时有效期
response.addCookie(userCookie);
// 读取Cookie
Cookie[] cookies = request.getCookies();
for (Cookie cookie : cookies) {
    if ("username".equals(cookie.getName())) {
        String username = cookie.getValue();
        System.out.println("欢迎," + username);
    }
}
// Session操作
HttpSession session = request.getSession();
session.setAttribute("userId", 123);
Integer userId = (Integer) session.getAttribute("userId");

RESTful API设计规范

遵循REST原则设计接口,提升可维护性与可扩展性。

  • 资源命名用名词复数:/users 而非 /getUser
  • HTTP方法映射操作:
    • GET:查询(/users/123)
    • POST:创建(/users)
    • PUT:全量更新(/users/123)
    • PATCH:部分更新(/users/123)
    • DELETE:删除(/users/123)
  • 状态码规范:
    • 200 OK:成功
    • 201 Created:创建成功
    • 400 Bad Request:请求参数错误
    • 401 Unauthorized:未认证
    • 404 Not Found:资源不存在
    • 500 Internal Server Error:服务器异常

数据库连接与操作

Java通过JDBC连接数据库,配合连接池提升性能。

JDBC基础操作

public class JdbcDemo {
    private static final String URL = "jdbc:mysql://localhost:3306/test";
    private static final String USER = "root";
    private static final String PASSWORD = "password";
    public static void main(String[] args) throws Exception {
        Class.forName("com.mysql.cj.jdbc.Driver"); // 加载驱动
        try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement stmt = conn.prepareStatement("SELECT * FROM user WHERE id = ?")) {
            stmt.setInt(1, 1);
            try (ResultSet rs = stmt.executeQuery()) {
                while (rs.next()) {
                    System.out.println("用户ID:" + rs.getInt("id") +
                                     ",姓名:" + rs.getString("name"));
                }
            }
        }
    }
}

💡 最佳实践:

  • 使用try-with-resources自动关闭资源
  • PreparedStatement防SQL注入
  • 连接池(如HikariCP)管理连接,避免频繁创建

HikariCP连接池配置

// Maven依赖:com.zaxxer:HikariCP:5.0.1
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
config.setUsername("root");
config.setPassword("password");
config.setMaximumPoolSize(10);
config.setMinimumIdle(2);
config.setConnectionTimeout(30000);
HikariDataSource dataSource = new HikariDataSource(config);
try (Connection conn = dataSource.getConnection()) {
    // 使用连接
}

多线程与并发编程

并发编程是Java高级特性的核心,掌握线程管理与同步机制至关重要。

线程创建与启动
public class ThreadDemo {
    // 方式1:继承Thread类
    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("线程1运行中:" + Thread.currentThread().getName());
        }
    }
    // 方式2:实现Runnable接口
    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("线程2运行中:" + Thread.currentThread().getName());
        }
    }
    // 方式3:Lambda表达式(推荐)
    public static void main(String[] args) {
        new MyThread().start();
        new Thread(new MyRunnable()).start();
        new Thread(() -> System.out.println("线程3运行中:" + Thread.currentThread().getName())).start();
    }
}
线程同步与锁机制
public class SynchronizationDemo {
    private static int count = 0;
    private static final Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (lock) { // 同步代码块
                    count++;
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (lock) {
                    count++;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("最终计数:" + count); // 正确结果:20000
    }
}

💡 使用ReentrantLock替代synchronized:

Lock lock = new ReentrantLock();
lock.lock();
try {
    count++;
} finally {
    lock.unlock();
}
线程池与Executor框架
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建固定大小线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);
        // 提交任务
        for (int i = 0; i < 5; i++) {
            int taskId = i;
            pool.execute(() -> {
                System.out.println("任务" + taskId + "由线程" +
                    Thread.currentThread().getName() + "执行");
            });
        }
        pool.shutdown(); // 关闭线程池
    }
}

💡 自定义线程池(推荐):

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, 10, 60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100),
    new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("Custom-Thread-" + t.getId());
            return t;
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy()
);

设计模式与架构实践

设计模式是代码复用的模板,掌握常用模式可提升系统可维护性。

单例模式(Singleton)

确保类仅有一个实例,并提供全局访问点。

public enum Singleton {
    INSTANCE; // 枚举实现最安全(防反射、序列化破坏)
    public void doSomething() {
        System.out.println("单例模式执行操作");
    }
}
// 调用
Singleton.INSTANCE.doSomething();

⚠️ 避免使用双重检查锁(DCL)的旧式写法,易因指令重排序失效。

工厂模式(Factory)

定义创建对象的接口,但让子类决定实例化哪个类。

interface Shape {
    void draw();
}
class Circle implements Shape {
    @Override
    public void draw() { System.out.println("画圆"); }
}
class Rectangle implements Shape {
    @Override
    public void draw() { System.out.println("画矩形"); }
}
class ShapeFactory {
    public Shape getShape(String type) {
        if (type == null) return null;
        switch (type.toLowerCase()) {
            case "circle": return new Circle();
            case "rectangle": return new Rectangle();
            default: return null;
        }
    }
}
// 使用
ShapeFactory factory = new ShapeFactory();
Shape shape = factory.getShape("circle");
shape.draw(); // 输出:画圆

策略模式(Strategy)

定义一系列算法,将每个算法封装起来,并使它们可互换。

interface Strategy {
    int execute(int a, int b);
}
class AddStrategy implements Strategy {
    public int execute(int a, int b) { return a + b; }
}
class MultiplyStrategy implements Strategy {
    public int execute(int a, int b) { return a * b; }
}
class Context {
    private Strategy strategy;
    public Context(Strategy strategy) { this.strategy = strategy; }
    public int executeStrategy(int a, int b) { return strategy.execute(a, b); }
}
// 使用
Context context = new Context(new AddStrategy());
System.out.println("加法结果:" + context.executeStrategy(5, 3)); // 8
context = new Context(new MultiplyStrategy());
System.out.println("乘法结果:" + context.executeStrategy(5, 3)); // 15

开发工具与调试技巧

高效开发离不开工具支持,掌握调试技巧可快速定位问题。

常用调试命令

  • 断点调试:在IDE中设置断点,逐步执行(Step Into/Over)
  • 变量监视:观察变量值变化
  • 日志输出:使用SLF4J记录运行时信息
  • 内存分析:通过JProfiler或VisualVM查看堆内存

日志框架最佳实践

使用SLF4J + Logback组合,提升日志性能与可读性。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class LoggingDemo {
    private static final Logger logger = LoggerFactory.getLogger(LoggingDemo.class);
    public static void main(String[] args) {
        logger.trace("跟踪信息(开发环境)");
        logger.debug("调试信息(开发环境)");
        logger.info("普通信息(生产环境)");
        logger.warn("警告信息");
        logger.error("错误信息", new Exception("模拟异常"));
        // 格式化日志(避免字符串拼接)
        String name = "Java";
        logger.info("欢迎学习{}编程", name); // 性能更优
    }
}

常见问题与解决方案

整理开发者高频问题,提供即用型解决方案。

常见异常处理方案

  • NullPointerException:使用Optional或Objects.requireNonNull()预防
  • ArrayIndexOutOfBoundsException:循环前检查索引范围
  • ClassCastException:使用泛型或instanceof校验类型
  • ConcurrentModificationException:使用CopyOnWriteArrayList或迭代器的remove()