// == 比较的是引用地址
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1 == str2);  // false，不同对象

// equals() 比较的是内容（String类重写了equals方法）
System.out.println(str1.equals(str2));  // true

// 特殊情况：字符串常量池
String str3 = "hello";
String str4 = "hello";
System.out.println(str3 == str4);  // true，指向常量池同一对象

// 重写equals()的规范
@Override
public boolean equals(Object obj) {
    if (this == obj) return true;  // 同一对象
    if (obj == null || getClass() != obj.getClass()) return false;  // 类型检查
    Person person = (Person) obj;
    return Objects.equals(name, person.name) && 
           Objects.equals(age, person.age);
}

// 重写equals()必须重写hashCode()
@Override
public int hashCode() {
    return Objects.hash(name, age);
}

// String - 不可变，每次拼接都创建新对象
String str = "Hello";
str += " World";  // 创建了新对象，原对象被GC

// StringBuilder - 单线程推荐
StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");  // 在原对象上修改

// StringBuffer - 多线程安全
StringBuffer sbf = new StringBuffer();
sbf.append("Hello").append(" World");  // 线程安全，但性能较低

public class Student {
    private String name;  // 私有属性
    private int age;

    // 提供公共方法访问
    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
}

class Animal {
    protected String name;
    public void eat() {
        System.out.println("eating...");
    }
}

class Dog extends Animal {  // 继承
    public void bark() {
        System.out.println("barking...");
    }
}

class Animal {
    public void makeSound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {  // 重写
        System.out.println("Woof!");
    }
}

// 多态体现
Animal animal = new Dog();
animal.makeSound();  // 输出 "Woof!"，运行时确定

// 抽象类
abstract class Animal {
    protected String name;  // 可以有成员变量

    public Animal(String name) {  // 可以有构造方法
        this.name = name;
    }

    abstract void makeSound();  // 抽象方法

    public void sleep() {  // 具体方法
        System.out.println("sleeping...");
    }
}

// 接口（Java 8+）
interface Flyable {
    int MAX_SPEED = 100;  // public static final

    void fly();  // 抽象方法

    // Java 8：默认方法
    default void land() {
        System.out.println("landing...");
    }

    // Java 8：静态方法
    static void info() {
        System.out.println("This is a flyable interface");
    }
}

class Parent {
    public void method(int x) {
        System.out.println("Parent: " + x);
    }
}

class Child extends Parent {
    // 重写
    @Override
    public void method(int x) {
        System.out.println("Child: " + x);
    }

    // 重载（同一类中）
    public void method(String s) {
        System.out.println("Overload: " + s);
    }

    public void method(int x, int y) {
        System.out.println("Overload: " + x + ", " + y);
    }
}

// ArrayList - 适合查询
List<String> arrayList = new ArrayList<>();
arrayList.add("A");
arrayList.get(0);  // O(1) 快速访问
arrayList.add(0, "B");  // O(n) 需要移动元素

// LinkedList - 适合插入删除
List<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.get(0);  // O(n) 需要遍历
linkedList.addFirst("B");  // O(1) 快速插入

// 1. 计算hash值
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

// 2. 确定数组索引
index = (n - 1) & hash  // n是数组长度

// 3. 插入逻辑
// - 如果位置为空，直接插入
// - 如果位置有值，判断key是否相等
//   - 相等：覆盖value
//   - 不等：插入链表/红黑树

// 为什么容量是2的幂次？
// 因为 (n-1) & hash 等价于 hash % n，但位运算更快
// 且能保证分布均匀

// 为什么负载因子是0.75？
// 平衡时间和空间：太小浪费空间，太大增加冲突

// 为什么链表转红黑树的阈值是8？
// 红黑树平均查找长度log(n)，链表是n/2
// 当n=8时，log(8)=3 < 8/2=4，红黑树更优

// HashSet底层使用HashMap实现
public class HashSet<E> {
    private transient HashMap<E,Object> map;
    private static final Object PRESENT = new Object();

    public boolean add(E e) {
        return map.put(e, PRESENT) == null;  // value固定为PRESENT
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}

MyThread thread = new MyThread();
thread.start();

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}

Thread thread = new Thread(new MyRunnable());
thread.start();

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }
}

FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();
String result = futureTask.get();  // 获取返回值

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> {
    System.out.println("Thread pool running");
});

public enum State {
    NEW,              // 新建，未调用start()
    RUNNABLE,         // 可运行（包括运行中）
    BLOCKED,          // 阻塞（等待锁）
    WAITING,          // 等待（wait/join）
    TIMED_WAITING,    // 超时等待（sleep/wait(timeout)）
    TERMINATED        // 终止
}

// sleep() - 不释放锁
synchronized (obj) {
    Thread.sleep(1000);  // 持有锁，其他线程无法进入
}

// wait() - 释放锁
synchronized (obj) {
    obj.wait();  // 释放锁，其他线程可以获取锁
    // 被notify()唤醒后重新竞争锁
}

public synchronized void method() {
    // 锁的是当前对象实例
}

public static synchronized void method() {
    // 锁的是当前类的Class对象
}

synchronized (obj) {
    // 锁的是指定对象
}

// synchronized的优化（JDK 1.6+）
// 1. 偏向锁：第一次获取锁时记录线程ID
// 2. 轻量级锁：CAS自旋，适合锁竞争不激烈
// 3. 重量级锁：真正的互斥，适合锁竞争激烈

// 不使用volatile
boolean flag = false;  // 线程A修改后，线程B可能看不到

// 使用volatile
volatile boolean flag = false;  // 修改后立即刷新到主内存

// 双重检查锁定单例模式
class Singleton {
    private static volatile Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();  // volatile防止重排序
                }
            }
        }
        return instance;
    }
}

volatile int count = 0;
count++;  // 不是原子操作，需要synchronized或AtomicInteger

ThreadPoolExecutor(
    int corePoolSize,              // 核心线程数
    int maximumPoolSize,           // 最大线程数
    long keepAliveTime,            // 空闲线程存活时间
    TimeUnit unit,                 // 时间单位
    BlockingQueue<Runnable> workQueue,  // 任务队列
    ThreadFactory threadFactory,        // 线程工厂
    RejectedExecutionHandler handler    // 拒绝策略
)

// 传统方式（紧耦合）
class UserService {
    private UserDao userDao = new UserDaoImpl();  // 自己创建
}

// Spring方式（松耦合）
class UserService {
    @Autowired
    private UserDao userDao;  // 容器注入
}

@Component
@Scope("prototype")  // 多例
public class MyBean {
    // ...
}

@Aspect
@Component
public class LogAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void before(JoinPoint joinPoint) {
        System.out.println("方法执行前：" + joinPoint.getSignature());
    }

    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", 
                    returning = "result")
    public void afterReturning(Object result) {
        System.out.println("方法返回：" + result);
    }
}

String lockKey = "order:" + orderNo;
if (redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS)) {
    try {
        // 处理业务逻辑
    } finally {
        redisTemplate.delete(lockKey);
    }
}

// 1. 生成token，存入Redis
String token = UUID.randomUUID().toString();
redisTemplate.opsForValue().set("token:" + token, "1", 5, TimeUnit.MINUTES);

// 2. 请求时携带token
// 3. 验证token，使用后删除

public void quickSort(int[] arr, int left, int right) {
    if (left < right) {
        int pivot = partition(arr, left, right);
        quickSort(arr, left, pivot - 1);
        quickSort(arr, pivot + 1, right);
    }
}

private int partition(int[] arr, int left, int right) {
    int pivot = arr[right];
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, right);
    return i + 1;
}

public boolean hasCycle(ListNode head) {
    if (head == null || head.next == null) {
        return false;
    }

    ListNode slow = head;
    ListNode fast = head.next;

    while (slow != fast) {
        if (fast == null || fast.next == null) {
            return false;
        }
        slow = slow.next;
        fast = fast.next.next;
    }
    return true;
}

public boolean hasCycle(ListNode head) {
    Set<ListNode> seen = new HashSet<>();
    while (head != null) {
        if (seen.contains(head)) {
            return true;
        }
        seen.add(head);
        head = head.next;
    }
    return false;
}