Java泛型方法案例怎么编写

本文目录导读：

1. 基础泛型方法
2. 返回泛型类型的方法
3. 带边界（Bounded）的泛型方法
4. 多类型参数泛型方法
5. 实用案例：集合工具类
6. 泛型方法的最佳实践示例

我来通过几个实际案例系统地讲解Java泛型方法的编写。

基础泛型方法

public class GenericMethodDemo {
    // 基础泛型方法 - 打印任意类型的数组
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
    // 测试
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"Hello", "World", "Java"};
        Double[] doubleArray = {1.1, 2.2, 3.3};
        // 调用泛型方法
        printArray(intArray);
        printArray(strArray);
        printArray(doubleArray);
    }
}

返回泛型类型的方法

public class GenericReturnDemo {
    // 返回第一个元素
    public static <T> T getFirst(T[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        return array[0];
    }
    // 交换数组中的两个元素
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    public static void main(String[] args) {
        Integer[] numbers = {1, 2, 3, 4, 5};
        String[] names = {"Alice", "Bob", "Charlie"};
        // 类型推断 - 不需要显式指定类型
        Integer firstNum = getFirst(numbers);
        String firstName = getFirst(names);
        System.out.println("First number: " + firstNum);
        System.out.println("First name: " + firstName);
        // 交换方法测试
        swap(names, 0, 2);
        System.out.println("After swap - First: " + names[0]);
    }
}

带边界（Bounded）的泛型方法

public class BoundedGenericDemo {
    // 比较两个对象，返回较大的一个
    public static <T extends Comparable<T>> T max(T x, T y) {
        if (x.compareTo(y) > 0) {
            return x;
        }
        return y;
    }
    // 计算数值类型的总和
    public static <T extends Number> double sum(T num1, T num2) {
        return num1.doubleValue() + num2.doubleValue();
    }
    public static void main(String[] args) {
        // 测试 max 方法
        System.out.println("Max of 3 and 7: " + max(3, 7));
        System.out.println("Max of 'apple' and 'banana': " + max("apple", "banana"));
        // 测试 sum 方法
        System.out.println("Sum of 5 and 10: " + sum(5, 10));
        System.out.println("Sum of 3.14 and 2.86: " + sum(3.14, 2.86));
    }
}

多类型参数泛型方法

public class MultipleTypeParams {
    // 键值对方法
    public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
        return p1.getKey().equals(p2.getKey()) && 
               p1.getValue().equals(p2.getValue());
    }
    // 自定义Pair类
    static class Pair<K, V> {
        private K key;
        private V value;
        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }
        public K getKey() { return key; }
        public V getValue() { return value; }
    }
    public static void main(String[] args) {
        Pair<Integer, String> p1 = new Pair<>(1, "apple");
        Pair<Integer, String> p2 = new Pair<>(2, "banana");
        Pair<Integer, String> p3 = new Pair<>(1, "apple");
        System.out.println("p1 equals p2: " + compare(p1, p2));
        System.out.println("p1 equals p3: " + compare(p1, p3));
    }
}

实用案例：集合工具类

import java.util.*;
public class CollectionUtils {
    // 将数组转换为List
    public static <T> List<T> arrayToList(T[] array) {
        List<T> list = new ArrayList<>();
        for (T element : array) {
            list.add(element);
        }
        return list;
    }
    // 查找集合中的最大值
    public static <T extends Comparable<T>> T findMax(Collection<T> collection) {
        if (collection.isEmpty()) {
            return null;
        }
        return Collections.max(collection);
    }
    // 过滤null值
    public static <T> List<T> filterNull(List<T> list) {
        List<T> result = new ArrayList<>();
        for (T item : list) {
            if (item != null) {
                result.add(item);
            }
        }
        return result;
    }
    // 合并两个集合（去重）
    public static <T> Set<T> union(Collection<T> col1, Collection<T> col2) {
        Set<T> result = new HashSet<>(col1);
        result.addAll(col2);
        return result;
    }
    public static void main(String[] args) {
        // 测试 arrayToList
        String[] strArray = {"Java", "Python", "C++"};
        List<String> strList = arrayToList(strArray);
        System.out.println("Array to List: " + strList);
        // 测试 findMax
        List<Integer> numbers = Arrays.asList(3, 8, 1, 9, 4);
        Integer max = findMax(numbers);
        System.out.println("Max number: " + max);
        // 测试 filterNull
        List<String> withNull = new ArrayList<>(Arrays.asList("a", null, "b", null, "c"));
        List<String> withoutNull = filterNull(withNull);
        System.out.println("Filtered list: " + withoutNull);
        // 测试 union
        Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4));
        Set<Integer> set2 = new HashSet<>(Arrays.asList(3, 4, 5, 6));
        Set<Integer> unionSet = union(set1, set2);
        System.out.println("Union: " + unionSet);
    }
}

泛型方法的最佳实践示例

public class BestPracticesDemo {
    // 泛型方法中的类型推断
    public static <T> T getValue(T value) {
        return value;
    }
    // 使用通配符的泛型方法
    public static void printList(List<?> list) {
        for (Object elem : list) {
            System.out.print(elem + " ");
        }
        System.out.println();
    }
    // 生产者和消费者原则 (PECS)
    public static <T> void copy(List<? extends T> source, List<? super T> dest) {
        for (T item : source) {
            dest.add(item);
        }
    }
    public static void main(String[] args) {
        // 类型推断
        Integer intVal = getValue(42);
        String strVal = getValue("Hello");
        System.out.println("Inferred types: " + intVal + ", " + strVal);
        // 通配符使用
        List<Integer> intList = Arrays.asList(1, 2, 3);
        List<String> strList = Arrays.asList("A", "B", "C");
        printList(intList);
        printList(strList);
        // PECS原则应用
        List<Integer> ints = Arrays.asList(1, 2, 3);
        List<Number> nums = new ArrayList<>();
        copy(ints, nums);
        System.out.println("Copied numbers: " + nums);
    }
}

1. 语法格式：<T> 放在返回类型之前
2. 类型推断：Java能自动推断泛型类型
3. 边界限定：使用 extends 限制类型范围
4. 多类型参数：可以定义 <K, V> 等多种类型
5. PECS原则：Producer extends, Consumer super

这些案例涵盖了Java泛型方法的主要使用场景,从基础到高级应用。