泛型使用在集合上
Jdk5.0的新特性
Jdk 1.1 1.2 1.3 1.4 5.0
**泛型
**枚举
**静态导入
**自动拆装箱
**增加for循环
**可变参数
**反射
5、泛型的简介
*为什么要使用泛型
——泛型一般使用在集合上
**比如我现在把一个字符的类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本来的类型，只能是object类型，这个时候，我们想要进行类型转化，倒是会出现错误，这个时候怎么解决，就用泛型来解决。
*泛型在集合上如何使用泛型
-常用的集合 list set map（下面分别介绍）
-泛型的语法 集合 例如 list
*在泛型<>里写的是一个对象，String是一个对象，但是不能写基本的数据类型，写数据类型的包装类
byte—Byte
short–Short
int—Integer
Long—Long
float-Float
double-Double
char—character
boolean-Boolean
*在list上使用泛型
List的三种实现：ArrayList InkedList Vector
作业： 三种实现的区别：ArrayList是数组 linkedlist是列表 vector是线程安全
ArrayList:
采用数组方式存储数据，可以存储null;
非线程安全集合；
读取数据时速度快；
适用于快速随机访问元素。
LinkedList:
采用双向链表存储数据；
非线程安全集合；
插入和删除数据时速度快；
适用于快速插入、删除元素。
Vector:
采用数组方式存储数据；
线程安全集合；
性能比ArrayList差。
遍历list集合 有三种方式：
普通for循环 迭代器 增强for循环
代码：
/**泛型在list上的使用
* @param args
*/
@Test
public void testList() {
// TODO Auto-generated method stub
List<String> list=new ArrayList<String>();//泛型是string类型
list.add("aaa");
list.add("bbb");
list.add("ccc");
//遍历list集合 有三种方式
//普通for循环 迭代器 增强for循环
for(int i=0;i<list.size();i++){
list.get(i);//string
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上使用泛型 遍历set有两种方式 增强for循环和迭代器
—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);
}
System.out.println("==================");
//迭代器
Iterator <String> it1=set.iterator();
while(it1.hasNext()){
System.out.println(it1.next());
}
System.out.println("=================");
}
*在map上使用泛型（￥￥￥）
—map的结构：key-value形式
—map的两种遍历方式：1.获取所有的key，通过key得到value 使用get的方法 2.获取key和value的关系
代码如下：
public class TestDomol02 {
//在map是哪个使用泛型
@Test
public void testMap(){
Map<String,String> map=new HashMap<String,String>();//导包。map的结构就是：key-value，所以两个string
map.put("aaa","111");
map.put("bbb","222");
map.put("ccc","333");
//遍历map的方法
//1.获取所有的key，然后通过key获得value，使用get的方法
//2.获取key和value的关系
//使用1，
//获取所有的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("=============");
//2.得到key和value的关系
Set<Entry<String, String>> sets1=map.entrySet();//导包 utli
//遍历sets1
for( Entry<String, String> entry:sets1){
//entry是key和value的关系
String keyv=entry.getKey();
String valuev=entry.getValue();
System.out.println(keyv+":"+valuev);
}
System.out.println("========================");
}
6.泛型使用在方法中
*建立一个数组，实现指定位置上数组元素的交换
*方法相同，只是数据类型不同，这个时候可以使用泛型的方法
原：
private static void swap1(String[] arr2, int i, int j) {
// TODO Auto-generated method stub
String temp1;
temp1=arr2[i];
arr2[i]=arr2[j];
arr2[j]=temp1;
}
private static void swap1(int[] arr1, int i, int j) {
// 定义一个中间变量 来实现交换
int temp;
temp=arr1[i];
arr1[i]=arr1[j];
arr1[j]=temp;
}
*使用泛型之后：//使用泛型方法 需要定义一个类型，使用大写字母来表示 T：这个T表示任何类型，写在返回值 即void之前 ，这就表示你定义了一个类型T
//在下面就可以使用这个类型了T（随便一个大写字母）
public static <T> void swap1(T[] arr,int a,int b){
T temp;
temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
** 作业2：实现一个泛型方法，接受任意一个数组，颠倒数组中所有的元素
7.泛型在类上的使用（了解）
*在一个类上定义一个类型，这个类型可以在类里面直接使用
public class TestDomo04 <T>{
//在类里面可以直接使用T类型
T aa;
public void test11(T bb){
}
//写一个静态方法,在类上定义的泛型不能在静态类型上使用 即T不能在static中使用，换一个泛型类型即可
public static <A> void test12(A cc){
}
}