目录
1、泛型的简介
2、在集合上如何使用泛型(会用)
3、泛型在方法上使用(会用)
4、泛型在类上的使用(了解)
5、泛型擦除
6、练习
====================================================
1、泛型的简介
为什么要使用泛型?
一般使用在集合上。
比如现在把一个字符串类型的值放入到集合里面,这个时候,这个值放入到集合之后,失去本事的类型,只能是object类型,
这个时候,比如想要对这个值进行类型转换,很容易出现类型转换错误,怎么解决这个问题,可以使用泛型来解决。
2、在集合上如何使用泛型
常用集合 List、Set、Map
泛型语法:集合<String> 。 比如:List<String>
在泛型里面写是一个类,不能写8种原始数据类型。比如 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);
}
//增强for
for (String s1 : list) {
System.out.println(s1);
}
//迭代器遍历
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
作业1: ArrayList、linkedList、Vector 这三个区别
在Set上使用泛型
回顾Set的特性:
代码:
//泛型使用set集合上
@Test
public void testSet() {
Set<String> set = new HashSet<String>();
set.add("www");
set.add("qqq");
set.add("zzz");
//遍历set 有几种方式? 两种
//增强for、迭代器
==============================================
//使用增强for遍历
for (String s2 : set) {
System.out.println(s2);
}
//使用迭代器遍历
Iterator<String> it1 = set.iterator();
while(it1.hasNext()) {
System.out.println(it1.next());
}
}
在Map上面使用泛型
map结构:key-valu形式
代码:
@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);
}
//使用第一种方式遍历:得到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);
}
}
3、泛型在方法上使用
使用方法:
使用泛型方法,需要定义一个类型,一般使用大写字母'T'表示,这个T表示任意的类型.
<T> 写在返回值位置之前,表示定义了一个类型,这个类型是 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: 实现一个泛型方法,接受任意一个数组,颠倒数组中所有元素,方法逻辑相同,只是数据类型不同,这个时候使用泛型方法。
//创建一个Integer类型的数组 实现11和13位置交换
Integer[] arr1 = {10,11,12,13,14};
swapData(arr1,1,3);
//创建一个string类型的数组 实现 aa 和 ff 位置交换
String[] arr2 = {"aa","bb","cc","dd","ff"};
swapData(arr2,0,4);
public static <T> void swapData(T[] arr ,int a,int b) {
T temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
4、泛型在类上的使用(了解)
在一个类上定义一个类型,这个类型可以在类里面直接使用
public class TestDemo04<T> {
//在类里面可以直接使用T的类型
T aa;
public void test11(T bb) {
}
//写一个静态方法 在类上面定义的泛型,不能再静态方法里面使用
public static <A> void test12(A cc) {}
}
5、泛型擦除
首先泛型只是出现在源代码阶段,当编译之后泛型不存在了。
(*.java里有,*.class里面没有)
6、练习:实现一个泛型方法,接受任意类型的数组,颠倒数组中所有元素
代码
/*
* 基本思想:把第一个元素和最后一个元素交换位置,把第二个元素和倒数第二个元素交换位置。。。。
* 交换 长度/2 次
* */
public static <T> void reverses(T[] arr1) {
//遍历数组
for(int i=0;i<arr1.length/2;i++) {
T temp = arr1[i];
arr1[i] = arr1[arr1.length-i-1];
arr1[arr1.length-i-1] = temp;
}
}