集合框架、泛型、迭代(java基础知识十六)

1.ArrayList存储自定义对象并遍历

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。* ArrayList存储自定义对象并遍历
            ArrayList<Person> list = new ArrayList<>();
            list.add(new Person("张三",23));
            list.add(new Person("李四",24));
            list.add(new Person("王五",25));
            迭代器
            //Iterator
            for ( Iterator<Person> i = list.iterator(); i.hasNext(); ) {
                Person p = i.next();
                System.out.println(p);//输出的是每个对象；
                System.out.println(p.getName()+","+p.getAge());//输出对象中的属性值
            }
            * 普通for
            for(int i = 0;i < list.size();i++){
                Person p = (Person)list.get(i);//强转
                System.out.println(p);//输出每个对象
                System.out.println(p.getName()+","+p.getAge());
            }

2.Vector的特有功能

* A:Vector类概述
* B:Vector类特有功能
    * public void addElement(E obj)//添加一个元素
    * public E elementAt(int index)//返回指定索引处的元素
    * public Enumeration elements()//迭代
* C:案例演示
    * Vector的特有功能演示
    *   Vector v = new Vector();
        v.addElement("my");
        v.addElement("girl");
        Object obj = v.elementAt(1);
        System.out.println(obj);//girl
        for(Enumeration e = v.elements();e.hasMoreElements();){
            System.out.println(e.nextElement());
        }

3.LinkedList的特有功能

* A:LinkedList类概述* 底层数据结构是链表，查找慢，删除快
* B:LinkedList类特有功能
    * public void addFirst(E e)及addLast(E e)//在头添加，在尾添加
    * public E getFirst()及getLast()//得到头元素，得到尾元素
    * public E removeFirst()及public E removeLast()//删除头元素，删除尾元素
    * LinkedList list = new LinkedList();
        list.addFirst("1");
        list.addFirst("2");
        System.out.println(list);//[2,1]
        list.addLast("3");
        list.addLast("4");
        System.out.println(list);//[2,1,3,4]
        Object obj = list.getFirst();
        System.out.println(obj);//2
        Object obj1 = list.getLast();
        System.out.println(obj1);//4
        Object obj2 = list.removeFirst();
        System.out.println(obj2);//2
        System.out.println(list);
        Object obj3 = list.removeLast();
        System.out.println(obj3);//4
        System.out.println(list);//[1,3]    

4.去除ArrayList中重复字符串元素方式

需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
        思路：创建新集合方式
        public static void main(String[] args) {
            ArrayList list = new ArrayList();
            list.add("a");
            list.add("a");
            list.add("b");
            list.add("b");
            list.add("c");
            list.add("c");
            ArrayList list2 = getSingle(list);
            System.out.println(list2);
        }
        public static ArrayList getSingle(ArrayList list){
            ArrayList list1 = new ArrayList();
            for(Iterator i = list.iterator();i.hasNext();){
                String str = (String)i.next();
                if(!list1.contains(str)){
                    list1.add(str);
                }
            }
            return list1;
        }

需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
        public static void main(String[] args) {
            ArrayList list = new ArrayList();
            list.add(new Person("张三",23));
            list.add(new Person("张三",23));
            list.add(new Person("李四",24));
            list.add(new Person("李四",24));
            list.add(new Person("王五",25));
            list.add(new Person("王五",25));
            ArrayList list2 = getSingle1(list);
            System.out.println(list2);//重写equals 方法
        }
        public static ArrayList getSingle1(ArrayList list){
            ArrayList list1 = new ArrayList();
            for(Iterator i = list.iterator();i.hasNext();){
                Person p = (Person)i.next();
                if(!list1.contains(p)){
                    list1.add(p);
                    System.out.println(p.getName()+","+p.getAge());
                }
            }
            return list1;
        }    

* B:注意事项
        重写equals()方法的
        @Override
        public boolean equals(Object obj) {
            Person p = (Person)obj;
            return this.name.equals(p.name) && this.age == p.age;
        }
    * contains() 和remove() 方法底层都是依赖于equals()方法，
    * 如果没有重写equals()方法，比较的都是地址值。

5.用LinkedList模拟栈数据结构的集合并测试

需求：请用LinkedList模拟栈数据结构的集合，并测试
        1.LinkedList list = new LinkedList();
            list.addLast("B");//从结尾添加元素，
            list.addLast("M");
            list.addLast("W");
            System.out.println(list);
          while(!list.isEmpty()){
            list.removeLast();//删除结尾的元素
            System.out.println(list);
            }
            System.out.println(list);
        2.测试类：
            LinkedList list = new LinkedList();
                list.addFirst("B");//从开头添加元素，
                list.addFirst("M");
                list.addFirst("W");
                System.out.println(list);
            while(!list.isEmpty()){
                list.removeFirst();//删除结尾的元素
                System.out.println(list);
            }
            System.out.println(list);
          运行类：
            public class Stack {
                private LinkedList list = new LinkedList();
                //进栈，只需要把元素放进去即可，不需要任何返回类型；
                //返回值类型为：void ，参数列表：Object obj--传入任意一个数
                public void in(Object obj){
                    list.addFirst(obj);
                }
                //出栈，返回的是一个数，类型为：Object ；参数无。
            public Object out(){
                return list.removeFirst);
            }
            //判空方法。返回值类型为boolean。
            public boolean isEmpty(){
                return list.isEmpty();
                }
            }

6.泛型概述和基本使用

* A:泛型概述 <T>，JDK1.5出现的
    *  <> 是泛型，里面放的是引用数据类型，因为集合只能存引用数据类型。
    *  <> 前面加 后面不加 是JDK1.7版本出现，叫做菱形泛型
* B:泛型好处
    * 把运行期的错误转换到运行期、不用强转
* C:泛型基本使用

7.ArrayList存储字符串并遍历泛型版

 ArrayList<String> list = new ArrayList<>();
        list.add("MY");
        list.add("B");
        list.add("M");
        list.add("W");
        //不使用泛型
        for(Iterator i = list.iterator();i.hasNext();){
            String s = (String)i.next();//此处的i.next()接收的是Object类型
            System.out.println(s);
        }
        /*使用泛型，不用强转类型
            for(Iterator<String> i = list.iterator();i.hasNext();){
            String s = i.next();//此处的i.next()接收的是String类型。
            System.out.println(s);
            //System.out.println(i.next());//俩句可以换成一句。
        }*/

ArrayList存储自定义对象并遍历泛型版
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三",23));//此处添加的.add()方法，提示的只接受Person类的对象。
        list.add(new Person("李四",24));
        list.add(new Person("王五",25));
        //非泛型。需要强转。
        for (Iterator i = list.iterator(); i.hasNext();) {
            Person p = (Person) i.next();
            System.out.println(p.getName()+","+p.getAge());
        }
        /* 泛型的情况。
        for (Iterator<Person> i  = list.iterator(); i.hasNext();) {
            Person p = i.next();//此处直接得到的就是person中的对象。
            System.out.println(p.getName()+","+p.getAge());
        }*/

8.泛型的由来、泛型类的概述及使用

* 泛型的由来:通过Object转型问题引入
    * 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

* A:泛型类概述
    * 把泛型定义在类上
* B:定义格式
    * public class 类名<泛型类型1,…>
    * public class Tool<W>{}
    * 泛型类型在创建对象时才有值。
* C:注意事项    
    * 泛型类型必须是引用类型

9.泛型方法的概述和使用

* A:泛型方法概述
    * 把泛型定义在方法上
    * 非静态的方法：public void show(W w){}
    * 静态的方法：public static <W>返回值类型 方法名(W w){},静态的方法直接可以用类名.调用，优于对象的创建。
* B:定义格式    
    * public <泛型类型> 返回类型 方法名(泛型类型 变量名)

10.泛型接口的概述和使用

* A:泛型接口概述
    * 把泛型定义在接口上
* B:定义格式
    * public interface 接口名<泛型类型>
    * interface Inter<T>{
    *         public abstract void show();
    *   }
    * 1.class Demo implements Inter<String>{//建议开发用,实现接口，已经确定是什么类型了。
    *         public void show(String s){
    *             System.out.println(s);
    *         }
    * }
    * 2.class Demo<T> implements Inter<T>{//Demo创建对象才实现T
    *         public void show(T t){
    *
    *         }
    * }

11.泛型高级之通配符

* A:泛型通配符<?>//不确定谁来用
    * 任意类型，如果没有明确，那么就是Object以及任意的Java类了
* B:? extends E
    * 向下限定，E及其子类
    * 可以添加E类型以及E的子类型，E是上边界（固定上边界）
* C:? super E
    * 向上限定，E及其父类

12.增强for的概述和使用

* A:增强for概述
    * 底层就是迭代器实现
    * 简化数组和Collection集合的遍历
* B:格式：
        for(元素数据类型 变量 : 数组或者Collection集合) {
            使用变量即可，该变量就是元素
        }
        for（临时变量：容器名）{
            输出临时变量；
        }

ArrayList存储字符串并遍历增强for版
        ArrayList<String> list = new ArrayList<>();
        list.add("MY");
        list.add("little");
        list.add("girl");
        for(String str : list){
            System.out.println(str);
        }

ArrayList存储自定义对象并遍历增强for版
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三",23));
        list.add(new Person("李四",24));
        list.add(new Person("王五",25));
        for (Person p : list) {
            //System.out.println(p);
            System.out.println(p.getName()+","+p.getAge());
        }

13.静态导入的概述和使用

* A:静态导入概述
    * 导入的是静态方法，只要是静态方法都能用静态导入，开发严重不推荐， 
* B:格式：
    * import static 包名….类名.方法名;
    * 可以直接导入到方法的级别
* C:注意事项
    * 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

14.可变参数的概述和使用

* A:可变参数概述
    * 其实就是一个可变的数组
    * 定义方法的时候不知道该定义多少个参数
* B:格式
    * 修饰符 返回值类型 方法名(数据类型…  变量名){}
* C:注意事项：
    * 这里的变量其实是一个数组
    * 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

15.Arrays工具类的asList()方法的使用
* A:案例演示
    * Arrays工具类的asList()方法的使用
    * 将数组转换成集合，转换后的集合不能添加删除里面的元素，
    * 必须是引用数据类型的数组，否则会将整个数组当成一个对象，

集合嵌套之ArrayList嵌套ArrayList
        ArrayList<ArrayList<Person>> list = new ArrayList<>();
        ArrayList<Person> list1 = new ArrayList<>();
        list1.add(new Person("张三",23));
        list1.add(new Person("李四",24));
        list1.add(new Person("王五",25));
        ArrayList<Person> list2 = new ArrayList<>();
        list2.add(new Person("小张",12));
        list2.add(new Person("小李",11));
        list2.add(new Person("小王",13));
        list.add(list1);//添加集合
        list.add(list2);
        for(ArrayList<Person>li : list){
            for(Person p : li){
                System.out.println(p);
            }
        }