Java集合与泛型的理解

注：本人再次学习集合与泛型做作的总结。可以供自己以后回顾，也可以供大家参考！

一、泛型的概念

　　泛型就是类型参数化，处理的数据类型不是固定的，而是可以作为参数传入.
　　泛型的由来：由于早期使用Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况 ，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患.所以泛型因此而诞生.
　　如下声明了一个Student类的集合，引用了泛型.

List<Student> list = new ArrayList<>();

二、泛型的好处

1. 更好的安全性（将运行期的错误转变成编译期）.
2. 更好的可读性
3. 省去强转类型的麻烦

　　语言和程序设计的一个重要目标是将bug尽量消灭在摇篮里，能消灭在写代码的时候，就不要等到代码写完，程序运行的时候.
　　代码写错的时候，开发环境和编译器不能帮我们发现问题，看代码：

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);
		}
	}
}

九、三种迭代是否能够删除集合元素

        １、普通for循环，注意i--，不然会漏删连续的相同

　　２、迭代器删除，注意不能用集合的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);

３、增强版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);
            }
        }
    }