泛型

• 为什么要使用泛型？
  - 一般使用在集合上
  ** 比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本事的类型，只能是object类型，
  这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误，怎么解决这个问题，可以使用泛型来解决

  • 在集合上如何使用泛型

    • 常用集合 list set map
    • 泛型语法 集合 比如 List

  • 在泛型里面写是一个对象，String 不能写基本的数据类型 比如int (****)
    ** 写基本的数据类型对应包装类
    byte – Byte
    short – Short
    int – Integer
    long – Long
    float – Float
    double – Double
    char – Character
    boolean – Boolean

  • 在list上使用泛型
    list的三种实现 ArrayList linkedList Vector
    代码：

     @Test
      public void testList() {
      List<String> list = new ArrayList<String>();
      list.add("aaa");
      list.add("bbb");
      list.add("ccc");
    
      //遍历list集合 有几种方式  三种
      //普通for循环  迭代器  增强for
    
      //普通for循环
      for(int i=0;i<list.size();i++) {
      	String s = list.get(i);
      	System.out.println(s);
      }
    
      System.out.println("=================");
      //使用增强for
      for (String s1 : list) {
      	System.out.println(s1);
      }
    
      System.out.println("=================");
      //使用迭代器遍历
      Iterator<String> it = list.iterator();
      while(it.hasNext()) {
      	System.out.println(it.next());
      }
    

  • 在set上使用泛型
    代码：

      /泛型使用set集合上
      @Test
      public void testSet() {
      Set<String> set = new HashSet<String>();
      set.add("www");
      set.add("qqq");
      set.add("zzz");
      //set.add("qqq");
      //遍历set 有几种方式  两种
      //迭代器  增强for
      //使用增强for遍历
      for (String s2 : set) {
      	System.out.println(s2);
      }
      System.out.println("=================");
      //使用迭代器遍历
      Iterator<String> it1 = set.iterator();
      while(it1.hasNext()) {
      	System.out.println(it1.next());
      }
    

    }

  • 在map上面使用泛型

    • map结构：key-valu形式
      代码：

  //在map上使用泛型

 @Test
	    public void testMap() {
		Map<String,String> map = new HashMap<String,String>();
		map.put("aaa", "111");
		map.put("bbb", "222");
		map.put("ccc", "333");
		//遍历map 有几种遍历方式 两种
		// 1、获取所有的key，通过key得到value 使用get方法
		// 2、获取key和value的关系
		//使用第一种方式遍历
		//获取所有的key
		Set<String> sets = map.keySet();
		//遍历所有key返回的set
		for (String key : sets) {
			//通过key得到value
			String value = map.get(key);
			System.out.println(key+" : "+value);
		}

	System.out.println("==============");
	//得到key和value的关系
	Set<Entry<String, String>> sets1 = map.entrySet();
	//遍历sets1
	for (Entry<String, String> entry : sets1) {
		//entry是key和value关系
		String keyv = entry.getKey();
		String valuev = entry.getValue();
		System.out.println(keyv+" : "+valuev);
	}
}

泛型使用在方法上
* 定义一个数组，实现指定位置上数组元素的交换
* 方法逻辑相同，只是数据类型不同，这个时候使用泛型方法
* /*
* 使用泛型方法 需要定义一个类型 使用大写字母表示 T :这个T表示任意的类型
* 写在返回值之前 void之前
* =======表示定义了一个类型 这个类型是 T
* 在下面就可以使用这个类型了 T
* */

public static <T> void swap1(T[] arr ,int a,int b) {
	T temp = arr[a];
	arr[a] = arr[b];
	arr[b] = temp;
}

** 作业2： 实现一个泛型方法，接受任意一个数组，颠倒数组中所有元素

泛型在类上的使用（了解）
* 在一个类上定义一个类型，这个类型可以在类里面直接使用

* public class TestDemo04<T> {
	
	//在类里面可以直接使用T的类型
	T aa;
	public void test11(T bb) {}
	
	//写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用
	public static <A> void test12(A cc) {}
	}

来源：CSDN

作者：鹏鹏入门

链接：https://blog.csdn.net/weixin_44860598/article/details/104457467