import java.util.List;

/**
 * 無界通配符實(shí)戰(zhàn)：通用集合打印工具
 * 快速打印集合，不用重復(fù)寫循環(huán)
 */
public class WildcardDemo {
    // 無界通配符?，匹配任意類型的List
    public static void printList(List<?> list) {
        if (list == null || list.isEmpty()) {
            System.out.println("集合為空");
            return;
        }
        for (Object obj : list) {
            // 只能讀成Object類型，因?yàn)椴恢谰唧w是啥類型
            System.out.println("元素值：" + obj);
        }
        
        // 這里是我踩過的坑：想加個字符串，編譯直接報錯
        // list.add("test"); // 編譯錯誤：沒法確定list的具體類型，寫入會亂套
        // 唯一能加的只有null，因?yàn)閚ull是所有類型的子類
        list.add(null);
    }

    public static void main(String[] args) {
        List<String> strList = List.of("Java", "泛型", "通配符");
        List<Integer> intList = List.of(1, 2, 3);
        
        printList(strList); // 正常打印字符串列表
        printList(intList); // 正常打印整數(shù)列表
    }
}

import java.util.List;

/**
 * 上界通配符實(shí)戰(zhàn)：數(shù)值集合求和
 * 做報表統(tǒng)計時經(jīng)常用這個方法，不用給每種數(shù)值類型都寫一遍求和
 */
public class UpperBoundDemo {
    // 上界通配符：匹配Number或其子類（Integer、Long、Double都算）
    public static double sum(List<? extends Number> numberList) {
        double total = 0.0;
        for (Number num : numberList) {
            // 讀數(shù)據(jù)：所有子類都能轉(zhuǎn)成Number，安全
            total += num.doubleValue();
        }
        
        // 踩坑點(diǎn)：想加Integer，編譯報錯
        // numberList.add(10); // 編譯器不知道list是存Integer還是Long，不敢讓加
        // 就算加Number也不行
        // numberList.add(10.0); // 同樣報錯
        
        return total;
    }

    public static void main(String[] args) {
        List<Integer> intList = List.of(1, 2, 3);
        List<Double> doubleList = List.of(1.5, 2.5);
        
        System.out.println("整數(shù)列表求和：" + sum(intList)); // 輸出6.0
        System.out.println("小數(shù)列表求和：" + sum(doubleList)); // 輸出4.0
    }
}

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

/**
 * 下界通配符實(shí)戰(zhàn)：數(shù)據(jù)批量插入
 * 用這個方法往不同類型的集合里插數(shù)據(jù)
 */
public class LowerBoundDemo {
    // 下界通配符：匹配Integer或其父類（Number、Object）
    public static void batchAddInteger(List<? super Integer> list, int count) {
        for (int i = 1; i <= count; i++) {
            // 寫數(shù)據(jù)：Integer能存到任意父類集合里，安全
            list.add(i);
        }
        
        // 讀數(shù)據(jù)：只能拿到Object類型，這是坑點(diǎn)
        for (Object obj : list) {
            System.out.println("插入的元素：" + obj);
        }
        
        // 我踩過的坑：想直接讀成Integer，編譯報錯
        // for (Integer num : list) { // 編譯錯誤：list可能是Number或Object類型，沒法轉(zhuǎn)Integer
        //     System.out.println(num);
        // }
    }

    public static void main(String[] args) {
        // 場景1：List<Integer>（直接存Integer）
        List<Integer> intList = new ArrayList<>();
        batchAddInteger(intList, 3); // 插入1、2、3
        
        // 場景2：List<Number>（Integer的父類）
        List<Number> numList = new ArrayList<>();
        batchAddInteger(numList, 2); // 插入1、2
        
        // 場景3：List<Object>（Integer的頂級父類）
        List<Object> objList = new ArrayList<>();
        batchAddInteger(objList, 1); // 插入1
    }
}

// 編譯前
List<String> strList = new ArrayList<>();
strList.add("Java");
String str = strList.get(0);

// 編譯后（編譯器自動改的）
List strList = new ArrayList();
strList.add("Java");
String str = (String) strList.get(0); // 自動加了強(qiáng)制轉(zhuǎn)換

/**
 * 我踩過的坑：instanceof判斷泛型類型
 */
public class TypeErasureDemo2 {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();
        
        // 坑：instanceof沒法判斷泛型類型，編譯報錯
        // if (strList instanceof List<String>) { // 編譯錯誤
        
        // 看似能寫，但沒意義——只能判斷是不是List，沒法判斷泛型
        if (strList instanceof List<?>) {
            System.out.println("是List，但不知道存的是啥");
        }
    }
}

import java.util.List;

/**
 * 我的解決方案：用類型令牌判斷元素類型
 */
public class TypeErasureDemo2Fix {
    // 我項目里的通用方法：判斷List里的元素是不是指定類型
    public static <T> boolean isListOfType(List<?> list, Class<T> type) {
        if (list.isEmpty()) {
            return false; // 空集合沒法判斷
        }
        for (Object obj : list) {
            if (!type.isInstance(obj)) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        List<String> strList = List.of("Java", "泛型");
        List<Integer> intList = List.of(1, 2);
        
        // 用類型令牌判斷，靠譜！
        System.out.println("是不是String列表：" + isListOfType(strList, String.class)); // true
        System.out.println("是不是String列表：" + isListOfType(intList, String.class)); // false
    }
}

/**
 * 我踩過的坑：泛型類里的靜態(tài)變量不能用泛型
 */
public class TypeErasureDemo3<T> {
    // 坑：靜態(tài)變量用T，編譯報錯
    // private static T staticValue; // Compile error: Cannot make a static reference to the non-static type T
    
    // 勉強(qiáng)能寫，但沒意義
    private static List<?> staticList = new ArrayList<>();
}

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

/**
 * 我的解決方案：靜態(tài)方法自己定義泛型參數(shù)
 */
public class TypeErasureDemo3Fix {
    // 靜態(tài)變量：用具體類型，別用泛型
    private static List<String> staticStrList = new ArrayList<>();

    // 靜態(tài)泛型方法：自己定義<T>，和類無關(guān)
    public static <T> void addElement(List<T> list, T element) {
        list.add(element);
    }

    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();
        List<Integer> intList = new ArrayList<>();
        
        // 靜態(tài)方法能支持不同類型，好用！
        addElement(strList, "Java");
        addElement(intList, 123);
        
        System.out.println(strList); // [Java]
        System.out.println(intList); // [123]
    }
}

/**
 * 我踩過的坑：捕獲泛型異常
 */
public class TypeErasureDemo4 {
    // 自定義泛型異常（編譯不報錯，但用不了）
    static class GenericException<T> extends Exception {
        private T errorData;
        
        public GenericException(T errorData) {
            this.errorData = errorData;
        }
    }

    public static void main(String[] args) {
        try {
            throw new GenericException<>("測試異常");
        } catch (GenericException<String> e) { // 編譯錯誤：不讓捕泛型異常
            e.printStackTrace();
        }
    }
}

/**
 * 我的解決方案：非泛型異常+泛型getter
 */
public class TypeErasureDemo4Fix {
    // 非泛型異常，用Object存任意類型數(shù)據(jù)
    static class DataException extends Exception {
        private Object errorData;
        
        public DataException(Object errorData) {
            this.errorData = errorData;
        }
        
        // 泛型方法：安全取數(shù)據(jù)，自己控制類型轉(zhuǎn)換
        public <T> T getErrorData(Class<T> type) {
            if (type.isInstance(errorData)) {
                return type.cast(errorData);
            }
            throw new ClassCastException("類型對不上");
        }
    }

    public static void main(String[] args) {
        try {
            throw new DataException("字符串錯誤");
            // throw new DataException(12345); // 也能傳整數(shù)
        } catch (DataException e) {
            // 安全取數(shù)據(jù)，不會亂轉(zhuǎn)
            String errorMsg = e.getErrorData(String.class);
            System.out.println("錯誤信息：" + errorMsg);
        }
    }
}

/**
 * 我踩過的坑：泛型方法重載沖突
 */
public class TypeErasureDemo5 {
    // 方法1：處理String列表
    public static void processData(List<String> list) {
        System.out.println("處理字符串");
    }
    
    // 方法2：處理Integer列表，編譯報錯
    // public static void processData(List<Integer> list) { // 編譯錯誤：簽名擦除后一樣
    //     System.out.println("處理整數(shù)");
    // }
}

import java.util.List;

/**
 * 我的解決方案：加類型令牌區(qū)分重載
 */
public class TypeErasureDemo5Fix {
    // 通用方法：加類型令牌，判斷類型后處理
    public static <T> void processData(List<T> list, Class<T> type) {
        if (type == String.class) {
            System.out.println("處理字符串列表：" + list);
        } else if (type == Integer.class) {
            System.out.println("處理整數(shù)列表：" + list);
        } else {
            System.out.println("處理其他類型");
        }
    }

    public static void main(String[] args) {
        List<String> strList = List.of("Java", "泛型");
        List<Integer> intList = List.of(1, 2);
        
        // 傳類型令牌，就能區(qū)分了
        processData(strList, String.class);
        processData(intList, Integer.class);
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;

/**
 * 通用數(shù)據(jù)校驗(yàn)工具類
 * 功能：校驗(yàn)任意類型數(shù)據(jù)、批量寫入有效數(shù)據(jù)、返回?zé)o效數(shù)據(jù)、拋出帶錯誤信息的異常
 * 避坑點(diǎn)：通配符用法、類型擦除、靜態(tài)泛型、異常處理
 */
public class GenericDataValidator<T> {
    // 靜態(tài)常量：不用泛型，避免靜態(tài)泛型坑
    private static final String DEFAULT_ERROR_MSG = "數(shù)據(jù)校驗(yàn)失敗";
    // 類型令牌：解決類型擦除后沒法判斷類型的問題
    private final Class<T> typeToken;

    // 構(gòu)造方法：傳入類型令牌，必須的！
    public GenericDataValidator(Class<T> typeToken) {
        this.typeToken = typeToken;
    }

    /**
     * 校驗(yàn)所有元素是否符合規(guī)則（上界通配符：只讀取，生產(chǎn)者）
     * @param dataList 待校驗(yàn)集合（T或T的子類）
     * @param rule 校驗(yàn)規(guī)則（比如字符串非空、數(shù)值大于0）
     * @return true=全部符合，false=有不符合的
     */
    public boolean validateAll(List<? extends T> dataList, Predicate<T> rule) {
        if (dataList == null || dataList.isEmpty()) {
            return true;
        }
        for (T data : dataList) {
            // 先判斷類型對不對，避免類型擦除導(dǎo)致的轉(zhuǎn)換異常
            if (!typeToken.isInstance(data)) {
                throw new ClassCastException("集合里有不是" + typeToken.getName() + "類型的數(shù)據(jù)");
            }
            // 再校驗(yàn)規(guī)則
            if (!rule.test(data)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 批量寫入有效數(shù)據(jù)（下界通配符：只寫入，消費(fèi)者）
     * @param targetList 目標(biāo)集合（T或T的父類）
     * @param sourceList 源數(shù)據(jù)集合
     * @param rule 校驗(yàn)規(guī)則
     * @return 成功寫入的數(shù)量
     */
    public int addValidData(List<? super T> targetList, List<? extends T> sourceList, Predicate<T> rule) {
        // 先判空，避免空指針
        Objects.requireNonNull(targetList, "目標(biāo)集合不能為null");
        Objects.requireNonNull(sourceList, "源數(shù)據(jù)集合不能為null");
        
        int successCount = 0;
        for (T data : sourceList) {
            if (rule.test(data)) {
                targetList.add(data); // 下界通配符，寫入安全
                successCount++;
            }
        }
        return successCount;
    }

    /**
     * 獲取校驗(yàn)失敗的數(shù)據(jù)（靜態(tài)泛型方法：自己定義<T>，避開靜態(tài)泛型坑）
     * @param dataList 待校驗(yàn)集合
     * @param rule 校驗(yàn)規(guī)則
     * @param <T> 數(shù)據(jù)類型
     * @return 失敗的數(shù)據(jù)列表
     */
    public static <T> List<T> getInvalidData(List<? extends T> dataList, Predicate<T> rule) {
        List<T> invalidList = new ArrayList<>();
        if (dataList == null || dataList.isEmpty()) {
            return invalidList;
        }
        for (T data : dataList) {
            if (!rule.test(data)) {
                invalidList.add(data);
            }
        }
        return invalidList;
    }

    /**
     * 自定義異常：非泛型，用Object存錯誤數(shù)據(jù)（避開泛型異?？樱?
     */
    public static class ValidationException extends RuntimeException {
        private final Object invalidData; // 存任意類型的錯誤數(shù)據(jù)

        public ValidationException(String message, Object invalidData) {
            super(message);
            this.invalidData = invalidData;
        }

        // 泛型方法：安全獲取錯誤數(shù)據(jù)
        public <E> E getInvalidData(Class<E> type) {
            if (type.isInstance(invalidData)) {
                return type.cast(invalidData);
            }
            throw new ClassCastException("錯誤數(shù)據(jù)類型不對，想要：" + type.getName());
        }
    }

    /**
     * 嚴(yán)格校驗(yàn)：失敗就拋異常
     */
    public void strictValidate(List<? extends T> dataList, Predicate<T> rule) {
        List<T> invalidData = getInvalidData(dataList, rule);
        if (!invalidData.isEmpty()) {
            // 拋非泛型異常，帶錯誤數(shù)據(jù)
            throw new ValidationException(DEFAULT_ERROR_MSG, invalidData.get(0));
        }
    }

    // 測試方法
    public static void main(String[] args) {
        // 1. 字符串校驗(yàn)示例（校驗(yàn)非空非空白）
        GenericDataValidator<String> strValidator = new GenericDataValidator<>(String.class);
        List<String> strList = List.of("Java", "", "泛型", "   ", "高級特性");
        // 校驗(yàn)規(guī)則：非空且非空白
        Predicate<String> strRule = s -> s != null && !s.isBlank();
        
        // 校驗(yàn)所有數(shù)據(jù)
        boolean allValid = strValidator.validateAll(strList, strRule);
        System.out.println("字符串是否全部有效：" + allValid); // false
        
        // 獲取無效數(shù)據(jù)
        List<String> invalidStr = GenericDataValidator.getInvalidData(strList, strRule);
        System.out.println("無效字符串：" + invalidStr); // ["", "   "]
        
        // 批量寫入有效數(shù)據(jù)到Object集合（下界通配符）
        List<Object> targetList = new ArrayList<>();
        int successCount = strValidator.addValidData(targetList, strList, strRule);
        System.out.println("成功寫入有效字符串?dāng)?shù)量：" + successCount); // 3
        System.out.println("目標(biāo)集合內(nèi)容：" + targetList); // [Java, 泛型, 高級特性]
        
        // 嚴(yán)格校驗(yàn)，失敗拋異常
        try {
            strValidator.strictValidate(strList, strRule);
        } catch (ValidationException e) {
            String invalidData = e.getInvalidData(String.class);
            System.out.println("校驗(yàn)失敗，錯誤數(shù)據(jù)：" + invalidData); // ""
        }

        // 2. 整數(shù)校驗(yàn)示例（校驗(yàn)大于0）
        GenericDataValidator<Integer> intValidator = new GenericDataValidator<>(Integer.class);
        List<Integer> intList = List.of(10, 20, -5, 30);
        Predicate<Integer> intRule = num -> num > 0;
        
        boolean intAllValid = intValidator.validateAll(intList, intRule);
        System.out.println("整數(shù)是否全部有效：" + intAllValid); // false
        List<Integer> invalidInt = GenericDataValidator.getInvalidData(intList, intRule);
        System.out.println("無效整數(shù)：" + invalidInt); // [-5]
    }
}