List集合的练习_list不存在新建

List子集

List子集的特点

ArrayList：

• 底层结构是数组，查询快，增删慢
• 线程不是安全的，效率高

ArrayList存储字符串并遍历代码举例：

ArrayList arr = new ArrayList();
 
        arr.add("hello");
        arr.add("world");
        arr.add("java");
 
        //遍历
        Iterator iterator = arr.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            String next1 = (String) next;
            System.out.println(next1);
        }
        System.out.println("*************");
        for(int i=0;i<arr.size();i++){
            Object o = arr.get(i);
            String o1 = (String) o;
            System.out.println(o1);
        }
 
    }
}
//hello
//world
//java
//*************
//hello
//world
//java

ArrayList存储自定义对象并遍历，代码举例：

 public static void main(String[] args) {
 
        ArrayList list = new ArrayList();
 
        Student s1 = new Student("张三", 21);
        Student s2 = new Student("李四", 22);
        Student s3 = new Student("王五", 23);
 
        list.add(s1);
        list.add(s2);
        list.add(s3);
 
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            Student next1 = (Student) next;
            System.out.println(next1.getName()+"---"+next1.getAge());
        }
        System.out.println("****************");
        for(int i=0;i<list.size();i++){
            Object o = list.get(i);
            Student o1 = (Student) o;
            System.out.println(o1.getName()+"---"+o1.getAge());
        }
    }
}
//张三---21
//李四---22
//王五---23
//****************
//张三---21
//李四---22
//王五---23

使用ArrayList去除集合中字符串的重复值（字符串的内容相同）

方式一：在不同的集合上操作

public static void main(String[] args) {
        //创建一个集合对象，添加元素
        //创建一个新的集合对象
        //遍历旧的集合对象，获取到每个元素
        //拿新的集合去找，看有没有，没有就加进去，有，就跳过
        //遍历新的集合
 
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("hello");
 
        ArrayList new_list = new ArrayList();
        //遍历旧的集合
        Iterator iterator = list.iterator();
        System.out.println("原来的集合：");
        while (iterator.hasNext()){
            Object next = iterator.next();
            String next1 = (String) next;
            System.out.println(next1);
            if(!new_list.contains(next1)){
                new_list.add(next1);
            }
        }
        System.out.println("去除集合中字符串的重复值之后的集合：");
        //遍历新的集合
        Iterator iterator1 = new_list.iterator();
        while (iterator1.hasNext()){
            Object next = iterator1.next();
            String next1 = (String) next;
 
            System.out.println(next1);
        }

方式二：在同一个集合上操作

public static void main(String[] args) {
 
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("spark");
        list.add("world");
        list.add("hello");
        list.add("spark");
        list.add("hello");
 
        //利用选择排序的思想
        for(int i=0;i<list.size();i++){
            for(int j=i+1;j<list.size();j++){
                if(list.get(i).equals(list.get(j))){
                    list.remove(j);
                    j--;
                }
            }
        }
 
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            String next1 = (String) next;
            System.out.println(next1);
        }
    }
}
//hello
//world
//spark

使用ArrayList去除自定义类中的重复值

class Student{
    private String name;
    private int age;
    Student(){}
    Student(String name,int age){
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}
 
public class ArrayListDemo5 {
    public static void main(String[] args) {
 
        ArrayList list = new ArrayList();
 
        Student s1 = new Student("张三",21);
        Student s2 = new Student("李四",22);
        Student s3 = new Student("王五",23);
        Student s4 = new Student("张三",21);
 
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
 
        //创建新的集合
        ArrayList list1 = new ArrayList();
 
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            Student next1 = (Student) next;
            if(!list1.contains(next1)){
                list1.add(next1);
            }
        }
 
        Iterator iterator1 = list1.iterator();
        while (iterator1.hasNext()){
            Object next = iterator1.next();
            Student next1 = (Student) next;
            System.out.println(next1.getName()+"---"+next1.getAge());
        }
 
    }
}
//张三---21
//李四---22
//王五---23
//张三---21

但这里我们发现一个问题，我们按照规定的思维，发现并没有去除重复的元素
通过查看源码我们发现，contain()的方法底层依赖的是equals()方法，由于我们的Student1类中并没有重写equals()方法，所以它默认调用的是父亲Object的equals()方法，而父亲的equals()方法比较的是地址值，每个学生对象被new出来的时候，地址值是一定不同的，所以比较地址值都是true，所以结果没有生效。

解决办法：
    重写equals方法，不需要我们重写，自动生效即可
建议：
    每次创建类的时候，都重写一些equals方法

LinkedList：
底层结构是链表，查询慢，增删快
线程是不安全的，效率高
LinkedList的特有功能
添加功能
void addFirst(E e) 在该列表开头插入指定元素
void addLast(E e) 将指定的元素追加到此列表的末尾
获取参数
E getFirst() 返回此列表中的第一个元素
E getLast() 返回此列表中的最后一个元素
删除功能
E removeFirst() 从此列表中删除并返回第一个元素
E removeLast() 从此列表中删除并返回最后一个元素

Vector：
底层结构是数组，查询快，增删慢
线程是安全的，效率低
Vector的特有功能
添加功能
void addElement(Object object)将指定组件添加到此向量的末尾，将其大小增加1

获取功能
Object elementAt(int index) 返回指定索引处的元素 --get()
Enumeration elements() 返回此向量的组件的容器。–list.iterator()
boolean hasMoreElements() 测试此容器是否包含更多元素。 --hasNext()
E nextElement() 如果此容器对象至少有一个要提供的元素，则返回此容器的下一个元素。–next()
代码举例：

public static void main(String[] args) {
 
        Vector vector = new Vector();
        vector.addElement("hello");
        vector.addElement("world");
        vector.addElement("java");
 
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            String o1 = (String) o;
            System.out.println(o1);
        }
    }
}
//hello
//world
//java

List子类面试题（List子类的特点）
ArrayList：
底层是数组，查询快，增删慢
线程不是安全的，效率高
Vector：
底层结构是数组，查询快，增删慢
线程是安全的，效率低
LinkedList：
底层结构是链表，查询慢，增删块
线程不是安全的，效率高
实际应用的时候，看实际需求：
需要线程安全：
Vector
不需要：ArrayList、Linkedlist
查询业务比较多：ArrayList
增删业务比较多：LinkedList
不知道选什么：ArrayList
感谢观看，我是酷酷的涛！！！