2020.11.21java集合迭代、泛型

1.集合迭代

1.for循环遍历
注意：删除元素后，集合长度发生了变化，i一直向后增长。
2.增强for循环，不允许遍历时对元素进行操作，如果进行操作（删除）会抛出异常ConcurrentModificationException;操作一次后必须break循环结束，否则会抛出异常。
3.迭代器（Iterator）

public static void main(String[] args) {
        //集合迭代
        ArrayList arr = new ArrayList();
        arr.add("a");
        arr.add("a");
        arr.add("a");
        arr.add("a");
        arr.add("b");
        arr.add("c");
        arr.add("s");
        arr.add("s");
        arr.add("s");
        //for循环遍历，注意：删除元素后，集合长度发生了变化  i一直向后增长
        /*for(int i=0;i<arr.size();i++){
            System.out.println(arr.get(i));
            arr.remove(i);
        }
        System.out.println(arr);//[a, a, c, s]

        *//*增强for循环，不允许遍历时对元素进行操作，如果进行操作（删除）会抛出异常ConcurrentModificationException
        * 操作一次后必须break结束循环，否则抛出异常ConcurrentModificationException*//*
        for(Object obj:arr){
            if(obj.equals("a")){
                arr.remove(obj);
                break;
            }
        }
        System.out.println(arr);//[a, c, s]*/

        //集合迭代器
        Iterator iterator = arr.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();//返回迭代器中的下一个元素
            /*System.out.print(obj);//aaaabcsss*/
            if(obj.equals("a")){
                iterator.remove();
            }
        }
        System.out.println(arr);//[b, c, s, s, s]
    }

2.泛型

1.如果使用Object作为类型可以存储任意类型的数据，具体操作时需要向下转型，这时类型会不匹配。

Object obj;

    public static void main(String[] args) {
        /*如果使用Object作为类型可以存储任意类型的数据
        * 具体操作时，需要向下转型，这时类型会不匹配*/
        /*TypeDemo t = new TypeDemo();
        t.obj = "a";
        t.obj = 1;
        t.obj = true;*/
        ArrayList list = new ArrayList();
        list.add("a");
        list.add(1);
        list.add(true);
        for(Object obj:list){
            String s = (String) obj;
            System.out.println(s);
            /*Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at com.ff.javalist.day3.TypeDemo.main(TypeDemo.java:20)*/
            /*if(obj instanceof String){
                System.out.println(obj);//a
            }
            if(obj instanceof Integer){
                System.out.println(obj);//1
            }
            if(obj instanceof Boolean){
                System.out.println(obj);//true
            }*/
        }

    }

2.泛型：泛指一种类型，类型不确定，可以以参数的形式传递，类型必须是类类型（引用类型），可以有多个，如果没有给具体的类型，默认为Object。

public class TypeDemo1<T> {
    T t;
    public T test(T t){
        return null;
    }
    public static void main(String[] args) {
        /*泛型：将类型参数化，泛指一种类型，类型不确定，可以以参数的形式传递，类型必须是类类型（引用类型），
        * 可以有多个，如果没有给具体的类型，默认为Oject*/
        /*TypeDemo1<String> t = new TypeDemo1<>();
        t.test("a");*/
        //t.test(1);//报错
        /*TypeDemo1<Integer> t1 = new TypeDemo1<>();
        t.test(1);*/

        ArrayList<String> alist = new ArrayList<>();
        alist.add("a");
        List<Integer> alist1 = new ArrayList<>();
        alist1.add(1);
    }
}