List实现类

1、ArrayList

1、底层使用数组实现。查询快、增删慢。

2、线程不安全，运行效率快。

 

创建User用户类

public class User implements Serializable {

    private String name;

    private int age;

    public User(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 "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

实例化ArrayList对象

ArrayList arrayList = new ArrayList();

添加元素

User user1 = new User("小明", 18);
User user2 = new User("小红", 20);
arrayList.add(user1);
arrayList.add(user2);

删除元素

arrayList.remove(user1);
//正常来说是不能删除成功的，因为new就代表创建了一个新的对象，在Object底层去做比较时，比较的是对象的引用地址。而new出的对象指向一个新的引用地址，在arrayList中时不存在的，所以这里会删除失败。
arrayList.remove(new User("小明", 18));
//如果想要删除成功就需要在User类中重写equals()方法，比较具体的值。

@Override
    public boolean equals(Object obj) {
        //比较是否是同一个对象
        if (this == obj) {
            return true;
        }
        //判断obj是否是User对象
        if (obj instanceof User) {
            User u = (User) obj;
            if (this.name == u.name && this.age == u.age) {
                return true;
            }
        }
        return false;
    }

遍历元素

//1、迭代器Iterator
Iterator it = arrayList.iterator();
while (it.hasNext()) {
     System.out.println(it.next());
}
//2、列表迭代器ListIterator
ListIterator listIterator = arrayList.listIterator();
//正向遍历
while (listIterator.hasNext()) {
      System.out.println(listIterator.next());
  }
//反向遍历
 while (listIterator.hasPrevious()) {
      System.out.println(listIterator.previous());
}

 

2、Vector

1、底层使用数组结构，查询快，增删慢。

2、线程安全，运行效率慢。

 

实例化对象

Vector vector = new Vector();

添加元素

vector.add("苹果");
vector.add("西瓜");

删除元素

vector.remove("苹果");//根据元素内容删除
vector.remove(0);//根据索引删除

清空集合

vector.clear();

遍历集合

Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            System.out.println(elements.nextElement());
        }

获取元素

System.out.println("获取第一个元素：" + vector.firstElement());
System.out.println("获取最后一个元素：" + vector.lastElement());

 

3、LinkedList

1、底层基于链表实现，增删快，查询慢。

2、线程不安全。

 实例化LinkedList

LinkedList linkedList = new LinkedList();

添加元素

linkedList.add("苹果");
linkedList.add("香蕉");
linkedList.add("西瓜");

删除元素

//根据元素删除
linkedList.remove("苹果");
//根据索引删除
linkedList.remove(1);

//这里传递索引位置index，但是LinkedList底层其实是用for循环的方式去获取到的元素。

Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

清除元素

linkedList.clear();

遍历元素

        //1、使用for循环遍历元素
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println("for循环元素：" + linkedList.get(i));
        }
        //2、使用foreach(增强for)遍历元素
        for (Object o : linkedList) {
            System.out.println("foreach循环元素：" + o);
        }
        //3、使用迭代器Iterator遍历元素
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            System.out.println("iterator循环打印元素：" + iterator.next());
        }
        //4、使用列表迭代器ListIterator遍历元素
        ListIterator listIterator = linkedList.listIterator();
        //正向遍历
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
        //反向遍历
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }