Java中自定义泛型方法及其应用示例代码

public <T> void genericMethod(T param) {
    // 方法体
}

public class GenericMethodExample {
    // 定义一个泛型方法
    public <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();
        // 使用泛型方法打印整数数组
        Integer[] intArray = {1, 2, 3, 4, 5};
        example.printArray(intArray);
        // 使用泛型方法打印字符串数组
        String[] strArray = {"Hello", "World"};
        example.printArray(strArray);
    }
}

public class TypeInferenceExample {
    // 定义一个泛型方法
    public static <T> T getFirstElement(T[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        return array[0];
    }
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3};
        String[] strArray = {"Hello", "World"};
        // 编译器自动推断类型为Integer
        Integer firstInt = getFirstElement(intArray);
        System.out.println("First Integer: " + firstInt);
        // 编译器自动推断类型为String
        String firstStr = getFirstElement(strArray);
        System.out.println("First String: " + firstStr);
    }
}

public class BoundedTypeParameterExample {
    // 定义一个泛型方法，类型参数必须是Number或其子类
    public static <T extends Number> double sum(T[] array) {
        double sum = 0.0;
        for (T element : array) {
            sum += element.doubleValue();
        }
        return sum;
    }
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3};
        Double[] doubleArray = {1.1, 2.2, 3.3};
        // 计算整数数组的和
        System.out.println("Sum of integers: " + sum(intArray));
        // 计算双精度浮点数数组的和
        System.out.println("Sum of doubles: " + sum(doubleArray));
    }
}

import java.util.ArrayList;
import java.util.List;
public class CollectionUtils {
    // 定义一个泛型方法，用于过滤集合中的元素
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T element : list) {
            if (predicate.test(element)) {
                result.add(element);
            }
        }
        return result;
    }
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 过滤出偶数
        List<Integer> evenNumbers = filter(numbers, n -> n % 2 == 0);
        System.out.println("Even numbers: " + evenNumbers);
    }
}
// 定义一个函数式接口
interface Predicate<T> {
    boolean test(T t);
}

public class ComparatorUtils {
    // 定义一个泛型方法，用于比较两个对象的大小
    public static <T extends Comparable<T>> int compare(T a, T b) {
        return a.compareTo(b);
    }
    public static void main(String[] args) {
        Integer a = 10;
        Integer b = 20;
        // 比较两个整数的大小
        int result = compare(a, b);
        System.out.println("Comparison result: " + result);
    }
}

public class FactoryUtils {
    // 定义一个泛型方法，用于创建对象
    public static <T> T createInstance(Class<T> clazz) {
        try {
            return clazz.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException("Failed to create instance", e);
        }
    }
    public static void main(String[] args) {
        // 创建一个String对象
        String str = createInstance(String.class);
        System.out.println("Created string: " + str);
        // 创建一个ArrayList对象
        ArrayList<Integer> list = createInstance(ArrayList.class);
        list.add(1);
        list.add(2);
        System.out.println("Created list: " + list);
    }
}