Java笔记day22

一、集合中迭代器注意事项
需求：
    给定一个集合，集合中有字符串类型的元素，现在要判断一下里面有没有"bigdata"这个字符串，
如果有，就添加一个"yes"

查看代码

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListQuestion {
    public static void main(String[] args) {
        //创建一个集合对象
        List list = new ArrayList();

        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("bigdata");
        list.add("hadoop");

        //获取迭代器对象
        Iterator iterator = list.iterator();

        while (iterator.hasNext()){
            String s = (String) iterator.next();
            if("bigdata".equals(s)){
                list.add("yes");
            }
        }
    /*此处运行时会报错
    ConcurrentModificationException:并发修改异常
    当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常。
    原因：
        迭代器是依赖于集合存在的，在遍历遍历迭代器元素的时候，当判断成功后，往集合
    中添加了一个元素，但是呢，迭代器这个时候并不知道已经添加了元素，所以就报错了。
    简单描述为：在迭代器遍历的时候，集合不能修改元素
    解决办法：
        1、迭代器遍历，迭代器修改
        2、集合遍历，集合修改
    */
        //1、迭代器遍历，迭代器修改
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            String s = (String) listIterator.next();
            if("bigdata".equals(s)){
                listIterator.add("yes");        //在迭代器元素"bigdata"后面添加
            }
        }

        //2、集合遍历，集合修改
        for(int i=0;i<list.size();i++){
            String s = (String) list.get(i);
            if("bigdata".equals(s)){
                list.add("yes"); //在集合尾部添加
            }
        }
        System.out.println(list);
    }
}

二、ArrayList（这里的例子用到的依然是上一篇中的Student()类）
1、ArrayList是List的一个实现类，里面的方法与之前学习的内容相近（底层数据结构是数组）
    举例
        使用ArrayList存储自定义对象并遍历

查看代码

import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo1 {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList arrayList = new ArrayList();

        //创建5个学生对象
        Student s1 = new Student("张楚岚", 23);
        Student s2 = new Student("冯宝宝", 22);
        Student s3 = new Student("王也", 20);
        Student s4 = new Student("诸葛青", 21);
        Student s5 = new Student("老天师", 80);

        //将学生对象添加到集合中
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        arrayList.add(s5);

        //遍历的第一种方式1：迭代器遍历
        //获取迭代器对象
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Student s = (Student) iterator.next();

            System.out.println(s.getName() + "---" + s.getAge());
        }
        System.out.println("============================================");

        //遍历的第一种方式1：get()和size()方法结合
        for (int i = 0; i < arrayList.size(); i++) {
            Student student = (Student) arrayList.get(i);
            System.out.println(student.getName() + "---" + student.getAge());
        }
    }
}

三、Vector
    Vector:
        底层数据结构是数组，查询快，增删慢
        线程安全的，效率低（虽然是线程安全的，以后我们也不使用它，
        后面会说一个线程安全的类替代它）

    Vector特有的方法：
    public void addElement(Object obj)
        将元素添加到集合的末尾 效果和add()一样
    public Object elementAt(int index)
        返回指定索引处的组件   get(int index)
    public Enumeration elements()
        返回此向量的组件的枚举

查看代码

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo1 {
    public static void main(String[] args) {
        //创建Vector集合对象
        Vector vector = new Vector();

        //向集合中添加元素
        vector.addElement("hello");
        vector.add("world");
        vector.addElement("java");

        //public Object elementAt(int index)
        Object o = vector.elementAt(0);
        System.out.println(o);
        System.out.println(vector.elementAt(1));
        System.out.println(vector.elementAt(2));
        //System.out.println(vector.elementAt(3));  报错

        //System.out.println(vector.get(0));

        //public Enumeration elements()
        Enumeration elements = vector.elements();

        while (elements.hasMoreElements()){
            Object o1 = elements.nextElement();
            System.out.println(o1);
        }

        System.out.println("=====================================");
        System.out.println(vector);
    }
}

四、LinkedList
    LinkedList:
    底层数据结构为链表，查询慢，增删快
    线程不安全的，效率高

    LinkedList特有的功能：
        1、添加功能：
            void addFirst(Object obj) 在该列表开头插入指定的元素。
            void addLast(Object obj) 将指定的元素追加到此列表的末尾。等同于add()方法
        2、获取功能：
            Object getFirst() 返回此列表中的第一个元素。
            Object getLast() 返回此列表中的最后一个元素。
        3、删除功能：
            Object removeFirst() 从此列表中删除并返回第一个元素。
            Object removeLast() 从此列表中删除并返回最后一个元素。

查看代码

import java.util.LinkedList;
public class LinkedListDemo1 {
    public static void main(String[] args) {
        //创建LinkedList集合对象
        LinkedList linkedList = new LinkedList();

        //添加元素到集合中
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        linkedList.add("hadoop");
        linkedList.add("hive");
        linkedList.add("spark");

        System.out.println(linkedList);
        System.out.println("=======================================");

        //void addFirst(Object obj) 在该列表开头插入指定的元素。
        linkedList.addFirst("flink");
        System.out.println(linkedList);
        //void addLast(Object obj) 将指定的元素追加到此列表的末尾。
        linkedList.addLast("Hbase");
        System.out.println(linkedList);

        //Object getFirst() 返回此列表中的第一个元素。
        Object first = linkedList.getFirst();
        System.out.println(first);
        System.out.println(linkedList);

        //Object getLast() 返回此列表中的最后一个元素。
        Object last = linkedList.getLast();
        System.out.println(last);
        System.out.println(linkedList);

        //Object removeFirst() 从此列表中删除并返回第一个元素。
        Object o = linkedList.removeFirst();
        System.out.println(o);
        System.out.println(linkedList);

        //Object removeLast() 从此列表中删除并返回最后一个元素。
        Object o1 = linkedList.removeLast();
        System.out.println(o1);
        System.out.println(linkedList);
    }
}

五、List集合练习
1、去除集合中字符串的重复值(字符串的内容相同)
    方式1：创建一个新的集合

查看代码

import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest1 {
    public static void main(String[] args) {
        //创建旧集合对象
        ArrayList list = new ArrayList();

        //向集合中添加字符串元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("hadoop");
        list.add("hive");
        list.add("hello");
        list.add("spark");
        list.add("java");

        System.out.println("去重之前的集合为："+list);

        //创建一个新的集合保存去重后的元素
        ArrayList list2 = new ArrayList();

        //遍历旧的集合
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            String s = (String) iterator.next();
            //获取到元素后，拿着这个元素去新的集合里面去找，如果找到说明重复
            //如果没有找到，就添加到新集合中
            if(!list2.contains(s)){
                list2.add(s);
            }
        }
        System.out.println("去重后的集合为："+list2);
    }
}

2、去除集合中自定义对象的重复值(对象的成员变量值都相同,姓名和年龄相同)

查看代码

import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        Student s1 = new Student("周润发", 18);
        Student s2 = new Student("刘德华", 19);
        Student s3 = new Student("周星驰", 20);
        Student s4 = new Student("周润发", 18);
        Student s5 = new Student("郭富城", 19);

        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);

        System.out.println(list);

        System.out.println("================================");

        ArrayList list2 = new ArrayList();

        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Student s = (Student) iterator.next();
            if(!list2.contains(s)){
                list2.add(s);
            }
        }

    /*这里逻辑是没有问题的但是输出是两个一模一样的集合
    为什么呢？
        经过一行一行的代码分析，我们发现问题出在判断语句中，也就是说contains()方法没有生效，
    打开源码发现contains()底层调用的是元素的equals方法，但是我们的Student类没有重写equals方法，
    所以调用的是父类Object类中的equals方法，比较的是地址值，所以contains()结果永远是true，
    if判断永远判断的是新集合不包含，就添加到新集合中，所以产生了没有去重的效果。

        解决办法：元素类重写equals()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
    */
        System.out.println(list2);
    }
}

3、请用LinkedList模拟栈数据结构的集合，并测试
    栈的特点：
        先进后出

查看代码

import java.util.Iterator;
import java.util.LinkedList;
public class LinkedListTest1 {
    public static void main(String[] args) {
        //创建集合
        LinkedList linkedList = new LinkedList();
//        linkedList.add("hello");
//        linkedList.add("world");
//        linkedList.add("java");
        linkedList.addFirst("hello");
        linkedList.addFirst("world");
        linkedList.addFirst("java");
        linkedList.addFirst("hadoop");

        System.out.println(linkedList);

        //遍历
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

    上面的代码虽然没问题，但是题目的真正意思是，自己写一个类，
    底层是LinkedList，调用自己写的方法实现栈数据结构
    正确写法

查看代码

import java.util.LinkedList;
public class MyStack {
    private LinkedList linkedList;

    MyStack(){
        linkedList = new LinkedList();
    }

    public void myAdd(Object object){
        linkedList.addFirst(object);
    }

    public Object myGet(){
        //return linkedList.getFirst();
        return linkedList.removeFirst();
    }

    public boolean myIsEmpty(){
        return linkedList.isEmpty();
    }
}

//测试类
public class MyStackTest {
    public static void main(String[] args) {
        //创建自己定义的集合类
        MyStack myStack = new MyStack();

        //添加元素
        myStack.myAdd("hello");
        myStack.myAdd("world");
        myStack.myAdd("java");
        myStack.myAdd("bigdata");

//        System.out.println(myStack.myGet());
//        System.out.println(myStack.myGet());
//        System.out.println(myStack.myGet());
//        System.out.println(myStack.myGet());
//        System.out.println(myStack.myGet()); //NoSuchElementException
        while (!myStack.myIsEmpty()){
            Object o = myStack.myGet();
            String s = (String) o;
            System.out.println(s);
        }
    }
}