JavaSE——集合（二）List（ArrayList,LinkedList,Vector）

List接口

概述

元素有序，并且每个元素都存在一个索引，元素可以重复。

List集合特有功能

void add(int index,E element):	在指定索引处添加元素
E remove(int index):移除指定索引处的元素  返回的是移除的元素
E get(int index):获取指定索引处的元素，可以用户集合遍历
E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素

案例演示

package com.westmo.demo9;
import java.util.List;
import java.util.ArrayList;
public class MyDemo1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(0,200);//给集合指定位置添加元素
        list.add(100);
        list.add(1,150);
        list.add(300);
        System.out.println(list);
        Object remove = list.remove(1);//移除指定位置的元素，并返回移除元素
        System.out.println(remove);
        Object o = list.get(1);//获取指定位置的元素
        System.out.println(o);
        Object set = list.set(0, 500);//更改指定位置的元素，返回被替换的元素
        System.out.println(set);
        System.out.println(list);
    }
}

List集合的遍历（三种方式）

package com.westmo.demo9;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class MyDemo2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(0,100);
        list.add(1,200);
        list.add(2,300);
        //方式1：for循环（推荐）
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
        //方式2：迭代器
        Iterator iterator = list.iterator();
        System.out.println(iterator);
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
        //方式3：List集合自己的迭代器
        ListIterator listIterator = list.listIterator();
        System.out.println(listIterator);
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }
    }
}

集合List中的反向迭代

package com.westmo.demo9;

import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class MyDemo4 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
        }
        //注意要进行反向迭代前，要先进行正向迭代。
        while (listIterator.hasPrevious()) {//hasPrevious()方法判断有没有上一个元素
            Object previous = listIterator.previous();//pervious()获取上一个元素
            System.out.println(previous);
        }
    }
}

集合中的并发修改异常问题

需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。

package com.westmo.demo9;
import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class MyDemo3 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add("NO");
        list.add("World");
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            if (next=="World") {
                list.add("javase");
            }
            System.out.println(next);
        }
    }
}

就像上述代码这种，在使用迭代器对集合进行遍历的时候，修改集合。运行程序就会报ConcurrentModificationException的错误。

原因分析：当我们往集合中添加好了元素之后，获取迭代器，那么迭代器已经知道了元素的个数。而在遍历时，我们使用List集合的add方法来添加元素的，那么迭代器就不会同意（不知道），所以就报错了。
解决办法：
（1）集合遍历元素（不用迭代器），集合修改元素。
（2）迭代器迭代元素，迭代器修改元（ListIterator的特有功能add来进行）。

package com.westmo.demo9;
import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class MyDemo3 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add("NO");
        list.add("World");
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            if (next=="World") {
                listIterator.add("javase");
            }
            System.out.println(next);
        }
    }
}

List的三个实现类的特点

ArrayList：

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

LinkedList

底层数据结构是链表，查询慢，增删快，线程不安全，效率高

Vector

底层数据结构是数组，查询慢，增删快，线程安全，效率低

ArrayList

ArrayList存储自定义对象并遍历

package com.westmo.demo9;
import java.util.ArrayList;
public class MyDemo5 {
    public static void main(String[] args) {
        Student1 student1 = new Student1("李明", 12, '男');
        Student1 student2 = new Student1("小花", 15, '女');
        Student1 student3 = new Student1("小李", 18, '女');
        ArrayList list = new ArrayList();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        for (int i = 0; i < list.size(); i++) {
            Student1 student = (Student1) list.get(i);
            System.out.println(student);
        }
    }
}

package com.westmo.demo9;
public class Student1 {
    private String name;
    private int age;
    private char sex;
    public Student1(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}

Vector的特有功能

功能

public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()

案例演示

package com.westmo.demo9;
import java.util.Enumeration;
import java.util.Vector;
public class MyDemo6 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        //添加元素
        vector.addElement(100);
        vector.addElement(200);
        vector.addElement(300);
        //返回指定索引处的组件
        Object o = vector.elementAt(1);
        System.out.println(o);
        //Vector集合自己的迭代器
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            Object o1 = elements.nextElement();
            System.out.println(o1);
        }
    }
}

LinkedList的特有功能

功能

public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()

案例演示

package com.westmo.demo9;
import java.util.LinkedList;
public class MyDemo7 {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.addFirst(100);        //在列表的开始处插入指定元素
        linkedList.addLast(200);//在列表的末尾处插入指定元素
        linkedList.addFirst(300);
        linkedList.addLast(400);
        Object first = linkedList.getFirst();//返回列表中的第一个元素
        System.out.println(first);
        Object last = linkedList.getLast();//返回列表中的最后一个元素
        System.out.println(last);
        Object o = linkedList.removeFirst();//移除并返回列表中的第一个元素
        System.out.println(o);
        Object o1 = linkedList.removeLast();//移除并返回列表中的最后一个元素
        System.out.println(o1);
    }
}

案例演示

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

//栈数据结构的特点：先进后出，后进先出
package com.westmo.demo9;
import java.util.LinkedList;
public class MyLinkedList {
    private LinkedList linkedList=null;
    public MyLinkedList() {
        linkedList = new LinkedList();
    }
    public void add(Object object){
        linkedList.addFirst(object);
    }
    public Object get(){
        Object first = linkedList.getFirst();
        linkedList.poll();//移除列表中第一个元素
        return first;
    }
}

package com.westmo.demo9;
public class MyDemo8 {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.add(100);
        myLinkedList.add(200);
        myLinkedList.add(300);
        myLinkedList.add(400);
        Object o = myLinkedList.get();
        System.out.println(o);
        Object o1 = myLinkedList.get();
        System.out.println(o1);
        Object o2 = myLinkedList.get();
        System.out.println(o2);
        Object o3 = myLinkedList.get();
        System.out.println(o3);
    }
}

2.去除ArrayList集合中重复字符串元素

package com.westmo.demo9;
import java.util.ArrayList;
public class MyDemo9 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("q");
        arrayList.add("123");
        arrayList.add("wet");
        arrayList.add("123");
        arrayList.add("wet");
        arrayList.add("hel");
        ArrayList arrayList1 = new ArrayList();//创建一个新的集合来完成
        for (int i = 0; i < arrayList.size(); i++) {
            Object o = arrayList.get(i);
            if (!arrayList1.contains(o)) {
                arrayList1.add(o);
            }
        }
        System.out.println(arrayList1);
    }
}

3.去除ArrayList集合中重复自定义对象元素

package com.westmo.demo9;
import  java.util.ArrayList;
public class MyDemo10 {
    public static void main(String[] args) {
        Student student1 = new Student("李三", 12);
        Student student2 = new Student("张四", 24);
        Student student3 = new Student("李三", 12);
        Student student4 = new Student("张四", 12);
        ArrayList list = new ArrayList();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        ArrayList arrayList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            Student student=(Student) list.get(i);
            if (!arrayList.contains(student)) {
                arrayList.add(student);
            }
        }
        for (int i = 0; i < arrayList.size(); i++) {
            Object o = arrayList.get(i);
            System.out.println(o);
        }
    }
}
package com.westmo.demo9;
import java.util.Objects;
public class Student {
    private String name;
    private 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 o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
}

锦鱼不忘旧时晨

发布了58 篇原创文章 · 获赞 13 · 访问量 1887

私信关注

JavaSE——集合（二）List（ArrayList,LinkedList,Vector）

List接口

概述

List集合特有功能

案例演示

List集合的遍历（三种方式）

集合List中的反向迭代

集合中的并发修改异常问题

List的三个实现类的特点

ArrayList：

LinkedList

Vector

ArrayList

Vector的特有功能

LinkedList的特有功能

案例演示

猜你喜欢