花几千上万学习Java，真没必要！（三十四）

1、泛型类：

测试代码：

创建一个Box类;

package settest.com;
public class Box<T> {  
    // T stands for "Type" - T是一个占位符，用于表示具体的类型  
    // 类的内部可以使用T作为类型声明变量  
    private T t;  
  
    // 构造方法，用于设置对象的值  
    public void set(T t) {  
        this.t = t;  
    }  
  
    // 获取存储的对象  
    public T get() {  
        return t;  
    }  
}

测试代码：

package settest.com;
public class GenericBoxTest {  
    public static void main(String[] args) {  
        // 创建一个可以存储String的Box  
        Box<String> stringBox = new Box<>();  
        stringBox.set("Hello World");  
        System.out.println(stringBox.get()); 
  
        // 创建一个可以存储Integer的Box  
        Box<Integer> integerBox = new Box<>();  
        integerBox.set(100);  
        System.out.println(integerBox.get()); 
        // 下面的代码会引发编译错误，因为类型不匹配  
        //stringBox.set(100); // 错误：类型不兼容。  
    }  
}

运行结果如下：

2、泛型方法：

测试代码1：

package settest.com;

public class GenericMethodTest {

	// 泛型方法printArray，可以接受任何类型的数组并打印。
	public static <E> void printArray(E[] inputArray) {
		// 显示数组元素
		for (E element : inputArray) {
			System.out.printf("%s ", element);
		}
		System.out.println();
	}

	public static void main(String[] args) {
		// 创建不同类型数组： Integer, Double 和 Character
		Integer[] intArray = { 1, 2, 3, 4, 5 };
		Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
		Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
		String[] stringArray = { "Java", "Generics", "Method" };
		
		System.out.println("整型数组元素为:");
		printArray(intArray); // 传递一个整型数组

		System.out.println("\n双精度型数组元素为:");
		printArray(doubleArray); // 传递一个双精度型数组

		System.out.println("\n字符型数组元素为:");
		printArray(charArray); // 传递一个字符型数组
		
		System.out.println("\n字符串数组元素为:");
		printArray(stringArray); // 传递一个字符串数组
	}
}

运行结果如下：

测试代码2：

package maptest.com;
import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.Collections;  
import java.util.List;  
  
public class ListUtilsAndMain {  
  
    // 泛型方法
    public static <T extends Comparable<? super T>> void sort(List<T> list) { 
    	
    	//排序，List是泛型，需要确保列表中的元素类型是可以比较的（即实现Comparable接口）
        Collections.sort(list);  
    }  
  
    public static void reverse(List<?> list) {  
    	//反转列表中的元素顺序不需要列表元素实现任何接口，它只是简单地交换列表中的元素位置。
        Collections.reverse(list);  
    }  
  
    public static void shuffle(List<?> list) {  
    	//打乱列表中的元素顺序使用一个随机源重新排列元素
        Collections.shuffle(list);  
    }  
  

    public static void main(String[] args) {  
        // ArrayList 确保列表是可修改的  
        List<Integer> numbers = new ArrayList<>(Arrays.asList(5, 3, 8, 4, 2));  
  
        System.out.println("Original: " + numbers);  
  
        sort(numbers);  
        System.out.println("Sorted: " + numbers);  
  
        reverse(numbers);  
        System.out.println("Reversed: " + numbers);  
  
        shuffle(numbers);  
        System.out.println("Shuffled: " + numbers);  
    }  
}

运行结果如下;

 

 

3、泛型接口：

创建一个 Holder泛型接口：

package settest.com;
//定义泛型接口Holder，它有一个泛型方法get用于获取存储的数据。
public interface Holder<T> {  
    // 获取存储的数据  
    T get();  

}

创建一个SimpleHolder类：

package settest.com;
//创建一个具体的SimpleHolder类，该类可以存储并返回任何类型的数据。
public class SimpleHolder<T> implements Holder<T> {
	private T data;

	public SimpleHolder(T data) {
		this.data = data;
	}
	@Override
	public T get() {
		return data;
	}
}

测试代码：

package settest.com;
//在需要封装单个值或对象时非常有用。
public class GenericInterfaceTest {  
    public static void main(String[] args) {  
        // 创建一个持有String的Holder  
        Holder<String> stringHolder = new SimpleHolder<>("Hello, World!");  
        System.out.println(stringHolder.get());  
  
        // 创建一个持有Integer的Holder  
        Holder<Integer> integerHolder = new SimpleHolder<>(42);  
        System.out.println(integerHolder.get());  

    }  
}

运行结果如下：

4、类型通配符;

测试代码：

能力有限，希望各位朋友，各位网友别见笑。

/无界通配符适合只读操作且不关心具体类型，上界通配符适合只读操作且需要子类型关系，下界通配符适合写操作且需要添加特定类型或其子类型的元素。
class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}

public class WildcardExample {

	public static void main(String[] args) {
		// 无界通配符
		List<?> unboundedList = new ArrayList<>();
		unboundedList = new ArrayList<Animal>();
		// 无法添加除null之外的任何元素
		// unboundedList.add(new Animal());
		unboundedList.add(null);
		if (!unboundedList.isEmpty()) {
			// 如果列表不为空，安全地访问第一个元素
			// 可以读取元素
			Object element = unboundedList.get(0);
			System.out.println("第一个元素是: " + element);

		} else {
			// 如果列表为空，打印一条消息
			System.out.println("列表是空的，没有元素可以访问。");
		}

		// 上界通配符
		List<? extends Animal> upperBoundedList = new ArrayList<>();
		upperBoundedList = new ArrayList<Dog>();
		// 无法添加任何元素
		// upperBoundedList.add(new Dog());
		// 可以读取元素，且元素类型为Animal或其子类
		if (!upperBoundedList.isEmpty()) {
			// 如果列表不为空，安全地访问第一个元素
			Animal animal = upperBoundedList.get(0);
			System.out.println("第一个元素是: " + animal);
		} else {
			// 如果列表为空，打印一条消息
			System.out.println("列表是空的，没有元素可以访问。");
		}

		// 下界通配符
		List<? super Dog> lowerBoundedList = new ArrayList<>();
		// 可以添加Dog及其子类元素
		lowerBoundedList.add(new Dog());
		// 可以读取元素，但需要进行类型转换
		Object obj = lowerBoundedList.get(0);
		if (obj instanceof Dog) {
			Dog dog = (Dog) obj;
			System.out.println("Dog: " + dog);
		}
	}
}

 运行结果如下;

5、可变参数：
1. Arrays.asList(T... a)
方法签名：public static <T> List<T> asList(T... a)
功能：该方法将传入的数组转换成一个固定大小的列表。这个列表是由原始数组支持的，因此对列表的非结构性修改（即修改元素的值，如果元素是可变的）会反映到原始数组中，反之亦然。但是，这个列表的大小是固定的，尝试进行结构性修改（如添加、删除元素）会抛出ConcurrentModificationException异常（如果迭代器正在使用中）或UnsupportedOperationException（如果直接调用add、remove等方法）。
限制：返回的列表大小固定，不支持增删操作，但支持修改元素（如果元素本身是可变的）。
2. List.of(E... elements)
方法签名：public static <E> List<E> of(E... elements)（这是Java 9及以后版本引入的）
功能：该方法创建了一个包含任意数量元素的不可变列表。这个列表的大小在创建时就确定了，之后不能修改（即不支持增删改操作）。
限制：返回的列表不可变，不支持增删改操作。
3. Set.of(E... elements)
方法签名：public static <E> Set<E> of(E... elements)（这是Java 9及以后版本引入的）
功能：该方法创建了一个包含任意数量元素的不可变集合。这个集合不允许重复元素，如果尝试添加重复元素，将抛出IllegalArgumentException。集合的大小在创建时就确定了，之后不能修改（即不支持增删改操作）。
限制：返回的集合不可变，不支持增删改操作，且元素唯一，不允许重复。
总结
Arrays.asList返回的列表大小固定，不支持增删操作，但支持修改元素（如果元素本身是可变的）。
List.of和Set.of返回的都是不可变集合，不支持增删改操作。List.of可以包含重复元素，而Set.of则不允许重复元素。

测试代码1：

package settest.com;

public class VarargsExample {
	// 第一个参数是String类型，第二个可变参数是int类型。
	// 实际上，不会在同一个方法中使用多个可变参数，而是使用单个可变参数或者不使用可变参数。
	public void printMessages(String prefix, int... numbers) {
		for (int number : numbers) {
			System.out.println(prefix + ": " + number);
		}
	}

	public static void main(String[] args) {
		VarargsExample example = new VarargsExample();
		example.printMessages("Number", 1, 2, 3, 4, 5);
		// 如果将可变参数放在非可变参数之前，编译器会报错。
		// public void wrongMethod(int... numbers, String prefix) {...}
	}
}

运行结果如下：

测试代码2：

package settest.com;
import java.util.*;

public class VariableParameters {
    public static void main(String[] args) {
        // 使用 Arrays.asList 方法创建固定大小的不可变 List
        List<String> fixedList = Arrays.asList("apple", "banana", "cherry");
        System.out.println("Fixed List: " + fixedList);

        // 使用 List.of 方法创建不可变 List
        List<String> immutableList = List.of("apple", "banana", "cherry");
        System.out.println("Immutable List: " + immutableList);

        // 尝试修改不可变 List，会抛出 UnsupportedOperationException 异常
        // immutableList.add("date");

        // 使用 Set.of 方法创建不可变 Set
        Set<String> immutableSet = Set.of("apple", "banana", "cherry");
        System.out.println("Immutable Set: " + immutableSet);

        // 尝试添加重复元素到不可变 Set，会抛出 IllegalArgumentException 异常
        // Set<String> immutableSetWithDuplicate = Set.of("apple", "banana", "apple");

        // 尝试修改不可变 Set，会抛出 UnsupportedOperationException 异常
        // immutableSet.add("date");
    }
}

运行结果如下：