66个JAVA常见代码大全：学完这篇从Java小白到AI全栈架构师

摘要：本文详细列举了 66 个 Java 编程中的关键代码示例，包括基础语法、数据类型、条件判断、循环、数组、方法、面向对象、继承、接口、抽象类、多态、封装、静态变量、内部类、匿名类、泛型、集合框架、异常处理、文件 I/O、多线程、同步以及高级并发概念，帮助你从入门到成长为架构师。

66个Java常见代码大全：学完这篇从Java小白到AI全栈架构师

引言

在当今的编程世界中，Java 作为一种广泛使用的编程语言，涵盖了从基础语法到复杂架构的方方面面。无论是刚接触编程的新手，还是经验丰富的开发者，掌握Java的核心技术和常用模式，都是成为一名高效开发者的必经之路。本篇文章将带您通过 66 个关键代码示例，从零开始深入学习 Java，从最基础的语法到高阶的并发编程，帮助您成为一名合格的 全栈开发者 或 架构师。

这篇文章不仅包含了 Java 编程语言 中的核心概念、常见技术栈，还为您详细解析了 面向对象编程（OOP）与 多线程并发 的实际应用技巧。无论是构建简单的应用程序，还是设计复杂的分布式系统，本文的示例代码将为您提供明确的指导，帮助您快速上手并实现功能。

---

使用说明

• 环境建议：JDK 17（兼容 11+）、Gradle/Maven 均可。

• 示例风格：每节给出 1 个小示例，

  • 简短解释 + 可运行/可复用的核心代码；
  • 为避免类名冲突，示例类名各不相同或仅展示片段；
  • 可将多个示例放入同一工程的 src/main/java 目录下单独运行。

• 如何运行：

  # 以单文件方式运行
  javac Demo01.java && java Demo01
  

---

1. Hello World

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

2. 变量与类型

public class Demo02 {
    public static void main(String[] args) {
        int age = 18; double score = 98.5; boolean ok = true; char c = 'A';
        long big = 9_223_372_036_854_775_807L; // 下划线增强可读性
        var msg = "Java"; // JDK 10 局部类型推断
        System.out.printf("age=%d, score=%.1f, ok=%b, c=%c, msg=%s\n", age, score, ok, c, msg);
    }
}

3. 类型转换

public class Demo03 {
    public static void main(String[] args) {
        int i = 10; long l = i; // 自动提升
        double d = l; int j = (int) d; // 强转可能丢失精度
        System.out.println(j);
    }
}

4. 常量 final

public class Demo04 {
    public static final double PI = 3.141592653589793;
    public static void main(String[] args) { System.out.println(PI); }
}

5. 运算符

public class Demo05 {
    public static void main(String[] args) {
        int a = 5, b = 2;
        System.out.println(a / b); // 2 整除
        System.out.println(a / (double) b); // 2.5 浮点
        System.out.println(a++); // 5（先用后加）
        System.out.println(++a); // 7（先加后用）
        System.out.println(a & 1); // 位运算判断奇偶
    }
}

6. 字符串操作

public class Demo06 {
    public static void main(String[] args) {
        String s = " Java ";
        System.out.println(s.trim().toUpperCase().replace(" ", ""));
        System.out.println(String.join(",", "A", "B", "C"));
    }
}

7. 控制台输入

import java.util.*;
public class Demo07 {
    public static void main(String[] args) {
        try (Scanner sc = new Scanner(System.in)) {
            System.out.print("请输入名字: ");
            String name = sc.nextLine();
            System.out.println("Hi, " + name);
        }
    }
}

8. 格式化输出

public class Demo08 {
    public static void main(String[] args) {
        System.out.printf("%-10s | %8.2f\n", "Revenue", 12345.678);
    }
}

9. if-else

public class Demo09 {
    public static void main(String[] args) {
        int score = 86;
        String level = score >= 90 ? "A" : score >= 80 ? "B" : "C";
        System.out.println(level);
    }
}

10. switch 表达式

public class Demo10 {
    public static void main(String[] args) {
        String day = "MON";
        int num = switch (day) {
            case "MON", "TUE", "WED", "THU", "FRI" -> 1;
            case "SAT", "SUN" -> 2;
            default -> 0;
        };
        System.out.println(num);
    }
}

11. for 循环

public class Demo11 {
    public static void main(String[] args) {
        int sum = 0; for (int i = 1; i <= 100; i++) sum += i; System.out.println(sum);
    }
}

12. while/do-while

public class Demo12 {
    public static void main(String[] args) {
        int n = 3;
        do { System.out.println(n--); } while (n > 0);
    }
}

13. break/continue/标签

public class Demo13 {
    public static void main(String[] args) {
        outer: for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i == 1 && j == 1) break outer;
                System.out.printf("(%d,%d) ", i, j);
            }
        }
    }
}

14. 增强 for

import java.util.*;
public class Demo14 {
    public static void main(String[] args) { for (var x : List.of(1,2,3)) System.out.println(x); }
}

15. 一维数组

import java.util.Arrays;
public class Demo15 {
    public static void main(String[] args) {
        int[] arr = {3,1,2}; Arrays.sort(arr); System.out.println(Arrays.toString(arr));
    }
}

16. 二维数组

import java.util.Arrays;
public class Demo16 {
    public static void main(String[] args) {
        int[][] m = {{1,2},{3,4}}; System.out.println(Arrays.deepToString(m));
    }
}

17. Arrays 工具类

import java.util.Arrays;
public class Demo17 {
    public static void main(String[] args) {
        int[] a = {1,3,5,7}; System.out.println(Arrays.binarySearch(a,5));
        int[] b = Arrays.copyOf(a, 6); System.out.println(Arrays.toString(b));
    }
}

18. 方法与重载

public class Demo18 {
    static int add(int a, int b){return a+b;}
    static double add(double a, double b){return a+b;}
    public static void main(String[] args){System.out.println(add(1,2));System.out.println(add(1.2,3.4));}
}

19. 可变参数

public class Demo19 {
    static int sum(int... xs){int s=0; for(int x:xs) s+=x; return s;}
    public static void main(String[] a){System.out.println(sum(1,2,3,4));}
}

20. 类与对象

class User { String name; int age; }
public class Demo20 { public static void main(String[] args){ User u=new User(); u.name="Tom"; u.age=20; System.out.println(u.name+":"+u.age);} }

21. 封装

class Account {
    private double balance;
    public double getBalance(){return balance;}
    public void deposit(double amt){ if(amt<=0) throw new IllegalArgumentException(); balance+=amt; }
}

22. 构造器与 this

class Point {
    int x,y; Point(){this(0,0);} Point(int x,int y){this.x=x;this.y=y;}
}

23. static 成员与静态块

class IdGen {
    static long next=1; static { System.out.println("class loaded"); }
    static synchronized long nextId(){return next++;}
}

24. 继承与 super

class Animal { void say(){System.out.println("...");} }
class Dog extends Animal { @Override void say(){ super.say(); System.out.println("wang"); } }

25. 多态与重写

class Shape { double area(){return 0;} }
class Circle extends Shape { double r; Circle(double r){this.r=r;} @Override double area(){return Math.PI*r*r;} }
class Square extends Shape { double a; Square(double a){this.a=a;} @Override double area(){return a*a;} }

26. 抽象类

abstract class Transport { abstract void move(); }
class Car extends Transport { void move(){ System.out.println("Car go"); } }

27. 接口（default/static）

interface Logger { void info(String msg); default void warn(String msg){System.out.println("WARN "+msg);} static Logger nop(){return m->{};} }

28. 内部类与匿名类

class Outer {
    private int v=42;
    class Inner { int get(){ return v; } } // 成员内部类
}
class UseAnon {
    static Runnable r = new Runnable(){ public void run(){ System.out.println("anon run"); } };
}

29. 泛型类

class Box<T> { private T v; public void set(T v){this.v=v;} public T get(){return v;} }

30. 泛型方法与通配符（PECS）

import java.util.*;
class G {
    static <T> void copy(List<? super T> dst, List<? extends T> src){ dst.addAll(src); } // Producer Extends, Consumer Super
}

31. 枚举

enum Role { ADMIN, USER, GUEST }

32. ArrayList/LinkedList

import java.util.*;
public class Demo32 { public static void main(String[] a){
    List<Integer> arr = new ArrayList<>(); arr.add(1); arr.add(2);
    Deque<Integer> link = new LinkedList<>(); link.addFirst(3); link.addLast(4);
    System.out.println(arr+" | "+link);
}}

33. HashMap/LinkedHashMap/TreeMap

import java.util.*;
public class Demo33 { public static void main(String[] a){
    Map<String,Integer> m1=new HashMap<>(); m1.put("b",2); m1.put("a",1);
    Map<String,Integer> m2=new LinkedHashMap<>(); m2.put("b",2); m2.put("a",1);
    Map<String,Integer> m3=new TreeMap<>(); m3.put("b",2); m3.put("a",1);
    System.out.println(m1.keySet()); System.out.println(m2.keySet()); System.out.println(m3.keySet());
}}

34. HashSet/LinkedHashSet/TreeSet

import java.util.*;
public class Demo34 { public static void main(String[] a){
    System.out.println(new HashSet<>(List.of(3,1,2))); // 无序
    System.out.println(new LinkedHashSet<>(List.of(3,1,2))); // 插入序
    System.out.println(new TreeSet<>(List.of(3,1,2))); // 自然序
}}

35. Queue/Deque

import java.util.*;
public class Demo35 { public static void main(String[] a){
    Queue<Integer> q = new ArrayDeque<>(); q.offer(1); q.offer(2); System.out.println(q.poll());
    Deque<Integer> d = new ArrayDeque<>(); d.addFirst(1); d.addLast(2); System.out.println(d.removeLast());
}}

36. Comparable/Comparator

import java.util.*;
class Person implements Comparable<Person>{ String n; int a; Person(String n,int a){this.n=n;this.a=a;} public int compareTo(Person o){return Integer.compare(a,o.a);} public String toString(){return n+":"+a;} }
public class Demo36 { public static void main(String[] a){
    List<Person> list = new ArrayList<>(List.of(new Person("A",30),new Person("B",20)));
    list.sort(Comparator.comparing(p->p.n)); // 使用 Comparator
    System.out.println(list);
}}

37. Stream 基本操作

import java.util.*; import java.util.stream.*;
public class Demo37 { public static void main(String[] a){
    var r = IntStream.rangeClosed(1,10).filter(x->x%2==0).map(x->x*x).boxed().toList();
    System.out.println(r);
}}

38. Optional

import java.util.*;
public class Demo38 { static Optional<String> find(boolean ok){ return ok?Optional.of("ok"):Optional.empty(); }
    public static void main(String[] a){ System.out.println(find(true).orElse("N/A")); }
}

39. Collectors 分组/分区

import java.util.*; import java.util.stream.*;
public class Demo39 { public static void main(String[] a){
    record P(String n,int a){}
    var ps = List.of(new P("A",18), new P("B",20), new P("C",20));
    var byAge = ps.stream().collect(Collectors.groupingBy(P::a));
    var part = ps.stream().collect(Collectors.partitioningBy(p->p.a>=20));
    System.out.println(byAge); System.out.println(part);
}}

40. try-catch-finally & 多重捕获

public class Demo40 {
    public static void main(String[] args) {
        try { Integer.parseInt("x"); }
        catch (NumberFormatException | NullPointerException e) { System.out.println("bad number"); }
        finally { System.out.println("done"); }
    }
}

41. 自定义异常

class BizException extends RuntimeException { BizException(String m){super(m);} }

42. try-with-resources

import java.io.*;
public class Demo42 {
    public static void main(String[] args) throws Exception {
        try (var in = new ByteArrayInputStream("hi".getBytes()); var out = new ByteArrayOutputStream()) {
            out.write(in.readAllBytes()); System.out.println(out);
        }
    }
}

43. NIO.2 文件读写

import java.nio.file.*; import java.nio.charset.StandardCharsets; import java.io.IOException;
public class Demo43 {
    public static void main(String[] args) throws IOException {
        Path p = Path.of("/tmp/demo.txt");
        Files.writeString(p, "hello", StandardCharsets.UTF_8);
        System.out.println(Files.readString(p));
    }
}

44. 对象序列化

import java.io.*;
class Book implements Serializable { String name; Book(String n){name=n;} }
public class Demo44 {
    public static void main(String[] args) throws Exception {
        var f = new File("/tmp/book.bin");
        try (var o = new ObjectOutputStream(new FileOutputStream(f))) { o.writeObject(new Book("Java")); }
        try (var i = new ObjectInputStream(new FileInputStream(f))) { System.out.println(((Book)i.readObject()).name); }
    }
}

45. 缓冲流

import java.io.*;
public class Demo45 {
    public static void main(String[] args) throws Exception {
        try (var in = new BufferedInputStream(new FileInputStream("/etc/hosts"))) {
            byte[] buf = in.readAllBytes(); System.out.println(buf.length);
        }
    }
}

46. 目录遍历 Files.walk

import java.nio.file.*; import java.io.IOException;
public class Demo46 {
    public static void main(String[] a) throws IOException {
        try (var s = Files.walk(Path.of("."), 1)) { s.forEach(System.out::println); }
    }
}

47. 正则表达式

import java.util.regex.*;
public class Demo47 { public static void main(String[] a){
    var m = Pattern.compile("(\\w+)@(\\w+\\.\\w+)").matcher("hi a@b.com");
    if(m.find()) System.out.println(m.group(1)+"@"+m.group(2));
}}

48. 命令行参数

public class Demo48 { public static void main(String[] args){ for(String s:args) System.out.println(s); } }

49. 创建线程：Thread/Runnable

public class Demo49 {
    public static void main(String[] a){ new Thread(() -> System.out.println("hi from " + Thread.currentThread().getName())).start(); }
}

50. sleep/yield/join

public class Demo50 {
    public static void main(String[] a) throws InterruptedException {
        Thread t = new Thread(() -> { try { Thread.sleep(100); } catch (InterruptedException ignored) {} });
        t.start(); t.join(); System.out.println("joined");
    }
}

51. synchronized 同步

class Counter { private int c; public synchronized void inc(){ c++; } public synchronized int get(){ return c; } }

52. volatile 可见性演示

public class Demo52 {
    static volatile boolean running = true; // 保证线程间可见
    public static void main(String[] a) throws Exception {
        var t = new Thread(() -> { while(running){} }); t.start();
        Thread.sleep(10); running = false; t.join(); System.out.println("stop");
    }
}

53. 原子类 AtomicInteger

import java.util.concurrent.atomic.*;
class Cnt { AtomicInteger n = new AtomicInteger(); void inc(){ n.incrementAndGet(); } }

54. ReentrantLock

import java.util.concurrent.locks.*;
class SafeBox { private int v; private final Lock lock=new ReentrantLock();
    void set(int x){ lock.lock(); try{ v=x; } finally{ lock.unlock(); } }
    int get(){ lock.lock(); try{ return v; } finally{ lock.unlock(); } }
}

55. ReadWriteLock

import java.util.concurrent.locks.*;
class CacheRW { private int v; private final ReadWriteLock rw = new ReentrantReadWriteLock();
    int get(){ rw.readLock().lock(); try { return v; } finally { rw.readLock().unlock(); } }
    void set(int x){ rw.writeLock().lock(); try { v=x; } finally { rw.writeLock().unlock(); } }
}

56. Condition await/signal

import java.util.concurrent.locks.*;
class Waiter { final Lock lock=new ReentrantLock(); final Condition ready=lock.newCondition(); boolean ok=false;
    void waitIt() throws InterruptedException { lock.lock(); try{ while(!ok) ready.await(); } finally{ lock.unlock(); } }
    void fire(){ lock.lock(); try{ ok=true; ready.signalAll(); } finally{ lock.unlock(); } }
}

57. ThreadLocal

public class Demo57 { static ThreadLocal<String> ctx = ThreadLocal.withInitial(() -> "guest"); }

58. BlockingQueue 生产者-消费者

import java.util.concurrent.*;
public class Demo58 {
    public static void main(String[] a) throws Exception {
        BlockingQueue<Integer> q = new LinkedBlockingQueue<>(2);
        new Thread(() -> { try { for(int i=1;i<=3;i++){ q.put(i); } q.put(-1); } catch (InterruptedException ignored){} }).start();
        new Thread(() -> { try { for(;;){ int x=q.take(); if(x==-1) break; System.out.println("consume "+x); } } catch (InterruptedException ignored){} }).start();
    }
}

59. CountDownLatch

import java.util.concurrent.*;
public class Demo59 { public static void main(String[] a) throws Exception {
    var latch=new CountDownLatch(3);
    for(int i=0;i<3;i++) new Thread(() -> { latch.countDown(); }).start();
    latch.await(); System.out.println("all done");
}}

60. CyclicBarrier

import java.util.concurrent.*;
public class Demo60 { public static void main(String[] a){
    var barrier=new CyclicBarrier(3, ()-> System.out.println("go!"));
    for(int i=0;i<3;i++) new Thread(() -> { try { barrier.await(); } catch (Exception ignored){} }).start();
}}

61. Semaphore

import java.util.concurrent.*;
public class Demo61 { public static void main(String[] a){
    var sem = new Semaphore(2);
    for(int i=0;i<5;i++) new Thread(() -> { try { sem.acquire(); System.out.println("in"); Thread.sleep(50); } catch (Exception ignored){} finally { sem.release(); } }).start();
}}

62. Phaser

import java.util.concurrent.*;
public class Demo62 { public static void main(String[] a){
    Phaser p = new Phaser(3);
    for(int i=0;i<3;i++) new Thread(() -> { p.arriveAndAwaitAdvance(); System.out.println("phase1"); p.arriveAndDeregister(); }).start();
}}

63. ExecutorService 线程池

import java.util.concurrent.*;
public class Demo63 { public static void main(String[] a) throws Exception {
    ExecutorService pool = Executors.newFixedThreadPool(4);
    Future<Integer> f = pool.submit(() -> 42);
    System.out.println(f.get()); pool.shutdown();
}}

64. ScheduledExecutorService 定时任务

import java.util.concurrent.*;
public class Demo64 { public static void main(String[] a){
    var sch = Executors.newScheduledThreadPool(1);
    sch.scheduleAtFixedRate(() -> System.out.println("tick"), 0, 1, TimeUnit.SECONDS);
}}

提示：示例 64 会持续打印，可在演示时添加退出条件或手动停止进程。

65. CompletableFuture

import java.util.concurrent.*;
public class Demo65 { public static void main(String[] a) throws Exception {
    var f = CompletableFuture.supplyAsync(() -> 21).thenApply(x -> x * 2);
    System.out.println(f.get());
}}

66. ForkJoinPool

import java.util.concurrent.*; import java.util.*;
public class Demo66 {
    static class Sum extends RecursiveTask<Long> {
        final int[] arr; final int lo, hi; static final int TH = 1_000;
        Sum(int[] arr,int lo,int hi){this.arr=arr;this.lo=lo;this.hi=hi;}
        protected Long compute(){
            if(hi-lo<=TH){ long s=0; for(int i=lo;i<hi;i++) s+=arr[i]; return s; }
            int mid=(lo+hi)/2; var left=new Sum(arr,lo,mid); var right=new Sum(arr,mid,hi);
            left.fork(); long r=right.compute(); return left.join()+r;
        }
    }
    public static void main(String[] a){ int[] data=new Random().ints(1_000_000,1,10).toArray();
        long s = ForkJoinPool.commonPool().invoke(new Sum(data,0,data.length)); System.out.println(s);
    }
}

---

进一步学习与架构思维

• 从“写得通”到“写得稳”：单元测试、异常边界、不可变对象（record / Collections.unmodifiable*）。
• 从单体到分布式：理解并发原语到线程池隔离，进而到服务化（超时、重试、熔断、限流）的设计理念。
• 数据与 AI 接口：HTTP 客户端（Java 11+ HttpClient）、JSON 编解码（选择 Jackson/Gson 等库）、向量数据库/消息队列客户端的异步调用，落地到 CompletableFuture 组合编排。
• 性能与可观测：JFR（Java Flight Recorder）、JIT/GC 基础、指标与日志链路。

结束语

通过本文的详细讲解和丰富示例，我们已经涵盖了 Java 编程中的 66 个关键技术点，并为您提供了从基础到进阶的学习路径。从 基本语法 到 多线程，每个概念都为您奠定了坚实的基础。通过实际代码示例和常见模式的掌握，您将能够轻松应对复杂项目和架构设计。

然而，技术的学习是一个持续的过程。希望本文能够成为您的学习指南，带领您迈向更加专业的编程生涯。接下来，您可以进一步探索 Java 的高级应用，如 分布式系统设计、微服务架构、以及 人工智能与大数据处理 等方向。让我们从基础到架构，再到性能优化和高可用设计，逐步提升您的技术能力。

如果您在学习过程中有任何问题，欢迎在评论区留言，或与我互动交流。不断实践，持续成长，未来的全栈架构师之路，已经向您敞开。让我们一起迎接下一个技术高峰！

---