ArrayList-LinkedList-Vector

我就是我 2022-07-12 04:46 186阅读 0赞

# ArrayList #

ArrayList是List接口的一个实现类，ArrayList集合的底层是使用一个数组来保存元素，在增加或删除指定位置的元素时，会导致创建新的数组，效率比较低，因此不适合做大量的增删操作。但这种数组的结构允许程序通过索引的方式来访问元素，因此使用ArrayList集合查找元素很便捷。

构造方法

*  **ArrayList()**
 *  ArrayList(Collection< ? extends E> c)
 *  ArrayList(int initialCapacity)

方法

*  Object clone()
 *  void ensureCapacity(int minCapacity)
 *  protected void removeRange(int fromIndex,int toIndex)
 *  void trimToSize()

1.练习:去除ArrayList中重复字符串元素

package com.first;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class HelloWorld { 
    
        public static void main(String[] args) {
    
            ArrayList list=new ArrayList();
            list.add("a");
            list.add("a");
            list.add("b");
            list.add("b");
            list.add("a");
    
            ArrayList newList=getSingle(list);
            System.out.println(newList);
    
        }
    
        /* * 创建集合将重复元素去掉 * 1.明确返回值类型：ArrayList * 2.明确参数列表：ArrayList * 分析： * 1.创建新集合 * 2.根据传入的集合（老集合）获取迭代器 * 3.遍历老集合 * 4.通过新集合判断是否包含老集合中的元素，如果包含就不添加，如果不包含就添加 */
        private static ArrayList getSingle(ArrayList list) {
    
            ArrayList newList=new ArrayList();
            Iterator it=list.iterator();
    
            while (it.hasNext()) {
                Object obj=it.next();
                if (!newList.contains(obj)) {
                    newList.add(obj);
                }
            }
    
            return newList;
        }
    
    }

运行结果为

[a, b]

`System.out.println(newList);`可以将集合打印出来，是因为ArrayList的父类的父类AbstractCollection重写了toString()方法，这个方法又会调用每个元素的toString()方法，这里的元素是字符串，字符串默认已经重写了toString()方法。所以打印出来的不是其全类名@哈希值。

2.练习：ArrayList去除集合中自定义对象元素的重复值（对象的成员变量值相同）

package com.first;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class HelloWorld { 
    
        public static void main(String[] args) {
    
            ArrayList list=new ArrayList();
            list.add(new Student("张三",22));
            list.add(new Student("张三",22));
            list.add(new Student("李四",23));
            list.add(new Student("张三",22));
    
            ArrayList newList=getSingle(list);
            System.out.println(newList);
    
        }
    
        private static ArrayList getSingle(ArrayList list) {
    
            ArrayList newList=new ArrayList();
            Iterator it=list.iterator();
    
            while (it.hasNext()) {
                Object obj=it.next();
                if (!newList.contains(obj)) {
                    newList.add(obj);
                }
            }
    
            return newList;
        }
    
    }
    
    class Student {
        String name;
        int age;
    
        public 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;
        }
    
        @Override
        public String toString() {
            return "Student [name=" + name + ", age=" + age + "]";
        }
    
        @Override
        public boolean equals(Object obj) {
            Student s=(Student)obj;
            return this.name.equals(s.name)&&this.age==s.age;
        }
    }

运行结果为

[Student [name=张三, age=22], Student [name=李四, age=23]]

contains方法底层依赖的是equal方法

# LinkedList #

构造方法

*  **LinkedList()**
 *  LinkedList(Collection< ? extends E> c)

方法

*  **void addFirst(E e)**
 *  **void addLast(E e)**
 *  **E getFirst()**
 *  **E getLast()**
 *  **E removeFirst()**
 *  **E removeLast()**

用LinkedList模拟栈结构

package com.first;
    
    import java.util.LinkedList;
    
    public class HelloWorld { 
        public static void main(String[] args) {
            Stack s = new Stack();
            s.in("a");
            s.in("b");
            s.in("c");
            s.in("d");
    
            while (!s.isEmpty()) {
                System.out.println(s.out());
            }
    
        }
    }
    
    class Stack {
        private LinkedList list = new LinkedList();
    
        /* * 模拟进栈方法 */
        public void in(Object obj) {
            list.addLast(obj);
        }
    
        /* * 模拟出栈 */
        public Object out() {
            return list.removeLast();
        }
    
        /* * 模拟栈是否为空 */
        public boolean isEmpty() {
            return list.isEmpty();
        }
    }

# Vector #

没有集合前，用Vector，集合体系出现后，Vector已经完全不被重用了。

# List的三个子类的特点 #

ArrayList：

底层数据结构是数组，线程不安全，效率高。

Vector：

底层数据结构是数组，线程安全，效率低,无论增删改查都慢。

LinkedList：

底层数据结构是链表，线程不安全，效率高。

查询多用ArrayList

增删多用LinkedList

如果都多用ArrayList