List接口的实现类

1.简述

　　List是用的较多的集合类型，List是一个接口，具体使用List集合类型时，需要使用时实现类。List接口的每个实现类也都实现了不同的数据结构，各自具有不同的特征。

　　特点：

• 有序的，允许重复元素。顺序可以是自然排序或按对象加入到集合的顺序排序。因为List，所以它的对象可以被索引。ListIterator接口提供了迭代列表中元素的方法。抽象的List可以被随机的、通过数组、通过链接表或通过双向链接表进行访问。

　　List接口中有以下几个常用实现类：

• ArrayList：基于数组。每次增删都会创建新的数组，但数组有索引。ArrayList有查询快、增删慢的特点。
• LinkedList：基于链表(双向)实现。每个元素存储本身内存地址的同时，还会存储下一个元素的地址。所以LinkedList有查询慢、增删快的特点。
• Vector：基于数组，Vector和ArrayList用法上几乎相同，但Vector比较古老，一般不用。Vector是线程同步的，效率低。
  

2.ArrayList

　　ArrayList简述：

• ArrayList是一个数组队列，相当于动态数组。线程不安全。
• ArrayList继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
• ArrayList实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。
• ArrayList实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
• ArrayList实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

　　定义一个ArrayList的方式有如下几种：

//默认创建一个ArrayList集合
List<String> list = new ArrayList<>();
//创建一个初始化长度为50的ArrayList集合
List<String> initlist = new ArrayList<>(50);
//将其他类型的集合转为ArrayList
List<String> setList = new ArrayList<>(new HashSet());

　　ArrayList有很多常用方法，add、addAll、set、get、remove、size、isEmpty等，关于其他方法可以查看API。

　　ArrayList的遍历方式有如下几种：

public class Test {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
        list.add("F");
        //通过迭代器遍历
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()) {
            System.out.print(iterator.next());
        }
        System.out.println("
--------------------------");
        //for循环遍历
        for (String val : list) {
            System.out.print(val);
        }
        System.out.println("
--------------------------");
        //随机访问，通过list.get(i)获得索引值去遍历。
        for(int i=0;i<list.size();i++) {
            System.out.print(list.get(i));
        }
    }
}

　　ArrayList的去除重复数据的方式有如下几种：

public class Test {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
        list.add("B");
        System.out.println(Arrays.toString(removeDuplicate1(list).toArray()));
        System.out.println(Arrays.toString(removeDuplicate2(list).toArray()));
        System.out.println(Arrays.toString(removeDuplicate3(list).toArray()));
    }
    
    //1.循环list中所有的元素然后删除，有序
    public static ArrayList removeDuplicate1(ArrayList list){
        for(int i =0;i<list.size()-1;i++){
            for(int j=list.size()-1;j>i;j--){
                if(list.get(i).equals(list.get(j)))
                    list.remove(j);
            }
        }
        
        return list;        
    }
    
    //2.利用hashSet剔除重复元素，无序
    public static ArrayList removeDuplicate2(ArrayList list){
        HashSet set = new HashSet(list);
        //使用LinkedHashSet可以保证输入的顺序
        //LinkedHashSet<String> set2 = new LinkedHashSet<String>(list); 
        list.clear();        
        list.addAll(set);
        return list;        
    }
    
    //3.利用list的contains方法去重，无序
    public static ArrayList removeDuplicate3(ArrayList list){
        ArrayList tempList = new ArrayList(list.size());
        for(int i=0;i<list.size();i++){
            if(!tempList.contains(list.get(i)))
                tempList.add(list.get(i));
        }
        return tempList;        
    }
}

　　ArrayList的去除重复对象数据的方式如下：

public class Test {
    public static void main(String[] args) throws Exception {
        List<Person> list = new ArrayList<Person>();
        list.add(new Person("张三", "1"));
        list.add(new Person("张三", "2"));
        list.add(new Person("张三", "1"));
        list.add(new Person("张三", "4"));
        list.add(new Person("李四", "1"));
        list.add(new Person("李四", "2"));
        list.add(new Person("张三", "3"));
        list.add(new Person("李四", "1"));
        System.out.println(Arrays.toString(removeDuplicate1(list).toArray()));
        System.out.println(Arrays.toString(removeDuplicate2(list).toArray()));
    }
    
    //1.循环list中所有的元素然后删除
    public static List<?> removeDuplicate1(List<?> list){
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(i).equals(list.get(j))) {
                    list.remove(j);
                }
            }
        }
        return list;        
    }
    
    //3.利用list的contains方法去重
    public static List<Person> removeDuplicate2(List<Person> list){
        List<Person> temp = new ArrayList<Person>();
        Iterator<Person> iterator = list.iterator();
        while (iterator.hasNext()) {
            Person person = iterator.next();
            if (!temp.contains(person)) {
                temp.add(person);
            }
        }
        return temp;        
    }
}
class Person {
    private String name;
    private String id;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Person(String name, String id) {
        super();
        this.name = name;
        this.id = id;
    }

    /**当调用contains的时候它的底层会自动调用equals()，然后我们重写equals方法，由此来做判断，解决元素重复问题。
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Person)) {
            throw new ClassCastException();// 类型错误
        }
        Person person = (Person) obj;
        return this.getId().equals(person.getId()) && this.getName().equals(person.getName());
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", id=" + id + "]";
    }

}

3.LinkedList

　　LinkedList简述：

• LinkedList是一个双向列表，线程不安全。
• LinkedList是一个继承于AbstractSequentialList的双向循环链表。它也可以被当作堆栈、队列或双端队列进行操作。
• LinkedList实现List接口，能对它进行队列操作。
• LinkedList实现Deque接口，即能将LinkedList当作双端队列使用。
• LinkedList实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
• LinkedList实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

　　定义一个LinkedList的方式有如下几种：

//默认创建一个LinkedList集合
LinkedList<String> list = new LinkedList<>();
//将其他类型的集合转为LinkedList
LinkedList<String> setList = new LinkedList<>(new HashSet());

　　LinkedList有很多常用方法，add、addAll、set、get、remove、size、isEmpty等，关于其他方法可以查看API。

　　LinkedList的遍历、去除重复数据方式和ArrayList一样，就不在陈述了。

4.Vector

 　　Vector简述：

• Vector是矢量队列，线程安全的。
• Vector继承了AbstractList，实现了List。所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
• Vector实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象。这就是快速随机访问。
• Vector实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

　　定义一个Vector的方式有如下几种：

//默认创建一个Vector集合
Vector<String> vector = new Vector<>();
//创建一个初始化长度为50的Vector集合，当由于增加数据导致容量增加时，每次容量会增加一倍。
Vector<String> initVector = new Vector<>(50);
//创建一个初始化长度为50的Vector集合，当由于增加数据导致容量增加时，每次容量会增加30。
Vector<String> initVector2 = new Vector<>(50,30);
//将其他类型的集合转为Vector
Vector<String> setVector = new Vector<>(new HashSet());

　　Vector有很多常用方法，add、addAll、addElement、set、get、remove、removeElement、size、isEmpty等，关于其他方法可以查看API。

　　Vector的遍历、去除重复数据方式和ArrayList一样，就不在陈述了。