一、泛型的概念
泛型就是类型参数化,处理的数据类型不是固定的,而是可以作为参数传入.泛型的由来:由于早期使用Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况 ,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患.所以泛型因此而诞生.
如下声明了一个Student类的集合,引用了泛型.
List<Student> list = new ArrayList<>();
二、泛型的好处
1. 更好的安全性(将运行期的错误转变成编译期).
2. 更好的可读性
3. 省去强转类型的麻烦
代码写错的时候,开发环境和编译器不能帮我们发现问题,看代码:
List list = new ArrayList();
Student stu = new Student();
stu.setSex("3");
stu.setUsername("zhangsan");
list.add(stu);
list.add(true);
list.add(123);
Iterator it = list.iterator();
while (it.hasNext()) {
Student stu = (Student)it.next();//向下转型获得Student对象
System.out.println(stu.getSex()+stu.getUsername());
}
看出问题了吗?写代码时,不小心,类型弄错了,不过,代码编译时是没有任何问题的,但,运行时,程序抛出了类型转换异常ClassCastException。 如果使用泛型,则不可能犯这个错误,如果这么写代码:
List<Student> list = new ArrayList<>();
Student stu = new Student();
stu.setSex("3");
stu.setUsername("zhangsan");
list.add(stu);
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
也就是说:
- 开发环境如Eclipse会提示你类型错误,即使没有好的开发环境,编译时,Java编译器也会提示你.这称之为类型安全,也就是说,通过使用泛型,开发环境和编译器能确保你不会用错类型,为你的程序多设置一道安全防护网.
- 使用泛型,还可以省去繁琐的强制类型转换,再加上明确的类型信息,代码可读性也会更好.
三、泛型基本使用
<>中放的必须是引用数据类型,像自定义的类,包装类等等.泛型集合中可以添加类和子类对象.
一个集合泛型的基本使用:
List<String> list = new ArrayList<>();//创建一个String类型的泛型集合类
list.add("a");
list.add("b");
Iterator<String> it = list.iterator();//获取指定泛型类的迭代器
while (it.hasNext()) {
System.out.println(it.next());
}
四、泛型使用注意事项
前后泛型必须一致,或者后面的泛型可以省略不写.数组也要保证前后数据类型一致.//泛型
List<Student> list = new ArrayList<Student>();//必须一致
List<Student> list = new ArrayList<>();//或者不写(1.7jdk版本之后,棱形泛型)
//数组
int[] arr = new int[5];//必须一致
//错误示范
List<Object> list = new ArrayList<Student>();
int[] arr = new byte[5];
五、泛型方法
静态方法是随着类加载而加载的,那时对象还不一定被创建.六、泛型接口
interface Xue<T> {
public void print(T t);
}
class Demo implements Xue<String> { //推荐使用这种
@Override
public void print(String t) {
System.out.println(t);
}
}
class Demo2<T> implements Xue<T> { //没有必要在实现接口的时候给自己类加泛型
@Override
public void print(T t) {
System.out.println(t);
}
}
七、泛型放置
?Extends E集合泛型父类可以添加子类集合,list1.addAll(list2);list2的泛型是list1的子类.
八、集合框架,增强for循环
增强for循环底层依赖迭代器(Iterator)快捷键 输入fore 按alt+/
3种迭代方法(普通for循环,迭代器Iterator,增强for循环)
代码示范
public class Test3 {
public static void main(String[] args) {
//数组
int[] arr = {1,2,3,4};
for (int a : arr) {
System.out.println(a);
}
//泛型集合
List<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");
for (String string : list) {
System.out.println(string);
}
}
}
九、三种迭代是否能够删除集合元素
1、普通for循环,注意i--,不然会漏删连续的相同
2、迭代器删除,注意不能用集合的list.remove,会出现并发修改异常。
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("1");
list.add("2");
for(Iterator<String> iterator = list.iterator() ; iterator.hasNext(); ) {
String string = iterator.next();
iterator.remove(); //迭代器删除,安全
System.out.println(string);
}
System.out.println(list);
输出正常,元素已经删除
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("1");
list.add("2");
for(Iterator<String> iterator = list.iterator() ; iterator.hasNext(); ) {
String string = iterator.next();
list.remove(string); //用集合删除,并发修改异常
System.out.println(string);
}
System.out.println(list);
3、增强版for循环不能删除,因为底层依赖迭代器,只能使用list.remove,会出现并发修改异常.
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("1");
list.add("2");
for (String string : list) {
System.out.println(string);
list.remove(string);
}
十、可变参数的使用
print(11,22,33);
}
public static void print(int y, int ... is) { //可变参数其实是一个数组,当然前面还可以加其他参数
for (int i : is) {
System.out.println(i);
}
十一、集合和数组转换
1. 数组转集合(转换后不能进行增加操作,但可以调用集合里面的其它方法)
//数组转集合
public static void sL() {
// int[] arr = {11,22,33};
// List list = Arrays.asList(arr);//基本数据类型转换成集合时,保存的是地址
Integer[] arr = {11,22,33};
List list = Arrays.asList(arr);//引用类型转换成集合,保存的是元素
System.out.println(list);
}
2. 集合转数组
//集合转数组
public static void sArr() {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
String[] str = list.toArray(new String[1]);//这里的new String[]长度可以随意指定,大于集合长度将会出现null元素
for (String string : str) {
System.out.println(string);
}
}
十二、集合嵌套集合的使用
//集合嵌套集合
public static void L() {
List<List<String>> list = new ArrayList<>();
List<String> str1 = new ArrayList<>();
str1.add("a");
str1.add("b");
List<String> str2 = new ArrayList<>();
str1.add("a");
str1.add("b");
list.add(str1);
list.add(str2);
for (List<String> string : list) {//迭代双层
for (String string2 : string) {
System.out.println(string2);
}
}
}
注:本人再次学习集合与泛型做作的总结。可以供自己以后回顾,也可以供大家参考!