java 10

1. 线程安全计数（初学者最容易懂的并发代码）
   // 只用到最基础的Java语法，没有复杂类，直接运行
   public class SimpleCounter {
   // 用Java自带的原子类，保证多线程下计数不会出错
   private static int count = 0;

   public static void main(String[] args) throws InterruptedException {
   // 循环启动100个线程，每个线程加1000次
   for (int i = 0; i < 100; i++) {
   new Thread(() -> {
   for (int j = 0; j < 1000; j++) {
   // 加锁，保证同一时间只有一个线程执行+1
   synchronized (SimpleCounter.class) {
   count++;
   }
   }
   }).start();
   }

   // 等所有线程跑完，主线程再往下走
   Thread.sleep(2000);
   System.out.println("最终计数结果：" + count);
   }
   }
   运行结果一定是100000，不会出现少算的情况，刚好能帮你理解多线程安全的最基础逻辑。

2. Stream流简单分组统计（替代for循环的简化版）
   import java.util.ArrayList;
   import java.util.List;
   import java.util.stream.Collectors;

public class SimpleStream {
public static void main(String[] args) {
// 先造个简单的学生分数列表
List scores = new ArrayList<>();
scores.add(85);
scores.add(59);
scores.add(92);
scores.add(76);
scores.add(48);

// 一行代码直接筛选出所有及格的分数，不用写嵌套for循环
List passScores = scores.stream()
.filter(score -> score >= 60) // 过滤条件：分数≥60
.collect(Collectors.toList());// 把结果转成列表

System.out.println("及格分数列表：" + passScores);
System.out.println("及格人数：" + passScores.size());
}
}
不用手写判断条件，几行代码就完成数据筛选，是日常写业务最实用的简化函数式用法。

3. 异步任务简单演示（比多线程更简单的异步写法）
   import java.util.concurrent.CompletableFuture;

public class SimpleAsync {
public static void main(String[] args) throws Exception {
System.out.println("主线程开始执行...");

// 启动一个异步任务，后台慢慢跑，不卡主线程
CompletableFuture.runAsync(() -> {
System.out.println("子线程正在后台下载文件...");
try {
Thread.sleep(1000); // 模拟下载耗时1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程下载完成！");
});

// 主线程不用等下载，直接先做其他事
System.out.println("主线程正在处理其他任务...");

// 等异步任务全部做完再退出
Thread.sleep(2000);
}
}
运行后你能直观看到两个任务并行执行，比自己手动创建线程简单太多。

4. 动态代理极简版（理解AOP最基础原理）
   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;

// 第一步：先定义一个简单的用户操作接口
interface UserService {
void sayHello();
}

// 第二步：写普通的实现类
class UserServiceImpl implements UserService {
@Override
public void sayHello() {
System.out.println("你好，我是用户");
}
}

// 第三步：用代理在方法执行前后自动加日志
public class SimpleProxy implements InvocationHandler {
private Object target;

// 把要代理的对象传进来
public SimpleProxy(Object target) {
this.target = target;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("【方法前】打印日志");
Object result = method.invoke(target, args); // 调用原方法
System.out.println("【方法后】打印日志");
return result;
}

public static void main(String[] args) {
// 生成代理对象
UserService proxy = (UserService) Proxy.newProxyInstance(
UserService.class.getClassLoader(),
new Class[]{UserService.class},
new SimpleProxy(new UserServiceImpl())
);

// 调用代理的方法，自动带上前后日志
proxy.sayHello();
}
}