集合之泛型

泛型

基础

本质是参数化类型

泛型的格式：

• <类型> ：指定一种类型的格式，
• <类型1，类型2…>: 指定多种类型的格式

泛型的好处：

1.把运行时的问题提前到编译期间

2.避免了强制类型转换

泛型不能使用在静态变量和静态方法

泛型类

泛型类的定义格式：

• 格式：修饰符 class 类名<类型> { }
• 范例： public class Generic< T >{ }

泛型方法

public class GenericDemo {
public static void main(String[] args) {
	Generic test = new Generic();
	test.show("lily");
	test.show(10);
	test.show(false);
}
}	

public class Generic {
public void show(String s) {
	System.out.println(s);
}
public void show(Integer i) {
	System.out.println(i);
}
public void show(boolean flag) {
	System.out.println(flag);
}
}

改进方法：使用泛型类

public class GenericDemo {
public static void main(String[] args) {
	Generic<String> test1=new Generic<String>();
	test1.show("lily");
	Generic<Integer> test2=new Generic<Integer>();
	test2.show(10);
	Generic<Boolean> test3=new Generic<Boolean>();
	test3.show(false);
	
	
}
}

public class Generic<T>{
	public void show(T t) {
		System.out.println(t);
	}
}

泛型接口

泛型接口的定义格式：

• 格式： 修饰符 interface 接口名<类型>{ }

• 范例：public interface Generic< T > { }

  public class Generic_01Demo {
  public static void main(String[] args) {
  	Generic_01<String> test1=new Generic_01mpl<String>();
  	test1.show("hello java");
  	Generic_01<Integer> test2=new Generic_01mpl<Integer>();
  	test2.show(525);
  	Generic_01<Boolean> test3=new Generic_01mpl<Boolean>();
  	test3.show(true);
  }
  }
  
  //接口
  public interface Generic_01<T> {
  	void show(T t);
  
  }
  
  //接口 Generic_01的实现类
  public class Generic_01mpl<T> implements Generic_01<T> {
  	
  public	void show(T t) {
  		System.out.println(t);
  	}
  	
  }
  
  
  
  

类型通配符

为了表示各种泛型List的父类，可以使用类型通配符

• 类型通配符：<?>

• List<?> :表示元素类型未知的List，它的元素可以匹配任何的类型

• 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中。

如果我们不希望< List >是任何泛型List的父类，只希望它代表某一泛型的父类，可以使用类型通配符的上限。

• 类型通配符上限：<?extends 类型>

• List<? extends Number>:它表示的类型是Number或其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

• 类型通配符的下限：< ?super 类型>

• List<? super Number>:它表示的类型是Number或其父类型

public static void main(String[] args) {
	List<?> list1=new ArrayList<Object>();
	List<?> list2=new ArrayList<Number>();
	List<?> list3=new ArrayList<Integer>();
	
	//List<? extends Number> list4=new ArrayList<Object>();报错
	List<? extends Number> list5=new ArrayList<Number>();
	List<? extends Number> list6=new ArrayList<Integer>();
	
	List<? super Number> list7=new ArrayList<Object>();
	List<? super Number> list8=new ArrayList<Number>();
	//List<? super Number> list9=new ArrayList<Integer>();报错
}

可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

• 格式：修饰符 返回值类型 方法名（数据类型…变量名）{ }
• 范例：public static int sum(int … a){ }

可变参数注意事项：

• 这里的变量a其实是一个数组
• 如果一个方法拥有多个参数包含可变参数，可变参数要放在最后面

public static void main(String[] args) {
		System.out.println(sum(10,20));
		System.out.println(sum(10,20,30));
		System.out.println(sum(10,20,30,40));
		
	}
	public static double sum(int...a) {
		int sum=0;
		for(double i:a)
		{
			sum+=i;
		}
		return sum;
	}

可变参数的使用

Arrays 工具类中有一个静态方法：

• public static < T > List< T > asList(T…a)：返回由指定数组支持的固定大小的列表
• 返回的集合不能做增删操作，可以做修改操作

public static void main(String[] args) {
		List<String> list=Arrays.asList("hello","world","java");
     // list.add("javaSE");报错：UnsupportedOperationException
	  //list.remove("java");报错：UnsupportedOperationException
       list.set(1,"javaee");
		System.out.println(list);
	}

List接口中有一个静态方法:

• public static < E > List < E > of(E…elements): 返回包含任意数量元素的不可变列表
• 返回的集合不能做增删改操作

public static void main(String[] args) {
	List<String>list=List.of("hello","world","java");
     // list.add("javaSE");报错：UnsupportedOperationException
	  //list.remove("java");报错：UnsupportedOperationException
    //list.set(1,"javaee");报错：UnsupportedOperationException
	System.out.println(list);
	}

Set接口中有一个静态方法：

• public static < E > Set < E > of(E…elements): 返回一个包含任意数量元素的不可变集合

• 在给元素的时候，不能给重复的元素

• 返回的集合不能做增删操作，没有修改的方法

public static void main(String[] args) {
	Set<String>set=Set.of("hello","world","java");
   // Set<String>set=Set.of("hello","world","java","hello");报错：IllegalArgumentException
    // set.add("javaSE");报错：UnsupportedOperationException
	  //set.remove("java");报错：UnsupportedOperationException
	System.out.println(list);
	}