Java学习笔记---泛型

Java学习笔记—泛型

泛型的简介

为什么要使用泛型？

一般使用在集合上：比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值就失去了本身的类型，只能是object类型。这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误。如果想要解决这个问题，就可以是用泛型来解决。

在集合上如何使用泛型？

常用集合： list set map

泛型语法： 集合<对象> 比如：List<String> list = new ArrayList<String>();

在泛型里面写的是一个对象，e.g.String，但不能写基本的数据类型 e.g.int

泛型里只能写基本的数据类型对应的包装类

byte — Byte

short — Short

int — Integer

long — Long

float — Float

double — Double

char — Character

boolean — Boolean

在List上使用泛型

List 的三种实现 ArrayList linkedList Vector

代码：

//泛型在list上的使用
@Test
public void testList(){
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");

//遍历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 TestSetup(){
Set<String> set = new HashSet<String>();
set.add("www");
set.add("sss");
set.add("xxx");
//set.add("xxx");
//遍历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-value形式

代码：

//泛型在map上的使用
@Test
public void testMap(){
Map<String, String> map = new HashMap<String, String>();
map.put("name", "1");
map.put("age", "2");
map.put("sex", "3");

//遍历map 两种方式  （无序）
//获取所有的key，通过key得到value 使用get方法
//获取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 key = entry.getKey();
String value = entry.getValue();
System.out.println(key+":"+value);
}
}

泛型使用在方法上

定义一个数组，实现指定位置上数组元素的交换

一般在逻辑相同，只是数据类型不同方法上使用泛型方法

如下是一个逻辑相同的方法，没有用泛型方法，如果出现其它类型的数组，需要写更多的swap方法重载

public static void main(String[] args) {
//创建一个数组 实现11 和 13 的位置交换
int[] arr1 = {10,11,12,13,14};
//System.out.println(Arrays.toString(arr1));
swap(arr1,1,3);
//System.out.println(Arrays.toString(arr1));

//创建一个String类型的数组 实现mm和xx之间的位置交换
String[] arr2 = {"aa","mm","ww","xx","zz"};
System.out.println(Arrays.toString(arr2));
swap(arr2, 1, 3);
System.out.println(Arrays.toString(arr2));
}
private static void swap(String[] arr2, int i, int j) {
//定义一个中间变量
String temp = arr2[i];
arr2[i] = arr2[j];
arr2[j] = temp;

}
private static void swap(int[] arr1, int i, int j {
//定义一个中间变量
int temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;

}

如下泛型方法：

/* * 使用泛型方法 需要定义一个类型 使用大写字母来表示  e.g. T ：这个T表示任意的类型 写在返回值之前
* 表示定义了一个类型 这个类型是T 在下面就可以使用这个类型T了
* */
public static <T> void swap(T[] arr,int a,int b){
T temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

泛型在类上的使用

在类上定义一个泛型，这个泛型可以在类里直接使用

代码：

public class TestDemo<T>(){
//在类里面可以直接使用T类型
T aa;
public void test(T aa){}

//在类上定义的泛型，不能在静态方法里面使用。如需使用，需自行定义
public static <A> void test2(A bb){}
}

泛型擦除

泛型只是出现在源代码阶段，当编译之后泛型就不存在了

泛型实例：实现一个泛型方法，接受任意类型的数组，颠倒数组中所有的元素

import java.util.Arrays;

/**
*
* 实现一个泛型方法，接受任意类型的数组，颠倒数组中所有的元素
* @author Administrator
*
*/
public class TestDemo {
public static void main(String[] args) {
Integer[] arr1 = {10,12,14,16,25};
System.out.println(Arrays.toString(arr1));
//写方法实现颠倒
reverses(arr1);
System.out.println(Arrays.toString(arr1));

String[] arr2 = {"a","b","c","d","e"};
System.out.println(Arrays.toString(arr2));
reverses(arr2);
System.out.println(Arrays.toString(arr2));
}

public static <T> void reverses(T[] arr) {
/*
* 基本思想：把第一个元素和最后一个元素交换位置，第二个和倒数第二个......
* 交换次数  长度/2
* */
//遍历数组
for(int i = 0;i<arr.length/2;i++){
T temp = arr[i];
arr[i] = arr[arr.length-i-1];
arr[arr.length-i-1] = temp;
}
}
}