深入探索Java开发世界：Java基础~类型分析大揭秘

import java.util.ArrayList;
import java.util.List;

public class WrapperExample {
    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        // 自动装箱：int -> Integer
        intList.add(10); 
        intList.add(20);
        
        for (Integer num : intList) {
            // 自动拆箱：Integer -> int
            // 输出：10 20
            System.out.println(num); 
        }
    }
}

public class GenericContainer<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }

    public static void main(String[] args) {
        GenericContainer<Integer> container = new GenericContainer<>();
        // 自动装箱：int -> Integer
        container.setItem(100); 
        // 自动拆箱：Integer -> int
        // 输出：100
        System.out.println(container.getItem()); 
    }
}

import java.util.Optional;

public class ApiExample {
    public static void main(String[] args) {
        // 自动装箱：int -> Integer
        Optional<Integer> optionalInt = Optional.of(30); 
        // 自动拆箱：Integer -> int
        // 输出：30
        optionalInt.ifPresent(System.out::println); 
    }
}

public class NullHandlingExample {
    public static void main(String[] args) {
        // 封装类型可以为null
        Integer possibleNullInt = null; 
        if (possibleNullInt == null) {
            System.out.println("The value is null");
        } else {
            System.out.println(possibleNullInt);
        }
    }
}

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        Method parseIntMethod = Integer.class.getMethod("parseInt", String.class);
        // 使用Integer类的静态方法
        Object result = parseIntMethod.invoke(null, "123"); 
        // 输出：123
        System.out.println(result); 
    }
}

public class ImplicitConversion {
    public static void main(String[] args) {
        int intVal = 100;
        // 自动将 int 转换为 long
        long longVal = intVal; 
        // 自动将 long 转换为 float
        float floatVal = longVal; 

        System.out.println("intVal: " + intVal);
        System.out.println("longVal: " + longVal);
        System.out.println("floatVal: " + floatVal);
    }
}

public class ExplicitConversion {
    public static void main(String[] args) {
        double doubleVal = 100.99;

        // 强制将 double 转换为 int
        int intVal = (int) doubleVal; 

        System.out.println("doubleVal: " + doubleVal);
        // 可能会丢失小数部分
        System.out.println("intVal: " + intVal); 
    }
}

public class CharConversion {
    public static void main(String[] args) {
        char charVal = 'A';
        // char 自动转换为 int
        int intVal = charVal; 

        System.out.println("charVal: " + charVal);
        // 输出65，'A'对应的ASCII码
        System.out.println("intVal: " + intVal); 

        intVal = 66;
        // 强制将 int 转换为 char
        charVal = (char) intVal; 
        System.out.println("intVal: " + intVal);
        // 输出'B'
        System.out.println("charVal: " + charVal); 
    }
}

List<String> arrayList = new ArrayList<>();
arrayList.add("Apple");
arrayList.add("Banana");
// 输出：Banana
System.out.println(arrayList.get(1)); 

List<String> linkedList = new LinkedList<>();
linkedList.add("Apple");
linkedList.addFirst("Banana");
// 输出：Banana
System.out.println(linkedList.get(0)); 

Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
// 重复元素不会被添加
hashSet.add("Apple"); 
System.out.println(hashSet.size()); // 输出：2

Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Apple", 3);
hashMap.put("Banana", 2);
// 输出：3
System.out.println(hashMap.get("Apple")); 

Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("Apple", 3);
linkedHashMap.put("Banana", 2);
for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 输出：
Apple: 3
Banana: 2

Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Banana", 2);
treeMap.put("Apple", 3);
for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 输出：
Apple: 3
Banana: 2

public synchronized void synchronizedMethod() {
    // 同步的方法体
}

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // 需要同步的代码块
} finally {
    lock.unlock();
}

// 允许10个线程同时访问
Semaphore semaphore = new Semaphore(10); 
semaphore.acquire();
try {
    // 资源访问操作
} finally {
    semaphore.release();
}

// 等待3个线程到达
CyclicBarrier barrier = new CyclicBarrier(3); 
// 线程1
barrier.await();
// 线程2
barrier.await();
// 线程3
barrier.await();
// 所有线程都到达后继续执行

ConcurrentMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("key", 1);