List接口的实现类

当前位置博文首页 > 文章内容

最大化缩小

作者：栏目：未分类时间：2020-10-24 18:00:45

本站于2023年9月4日。收到“大连君*****咨询有限公司”通知
说我们IIS7站长博客，有一篇博文用了他们的图片。
要求我们给他们一张图片6000元。要不然法院告我们

为避免不必要的麻烦，IIS7站长博客，全站内容图片下架、并积极应诉
博文内容全部不再显示，请需要相关资讯的站长朋友到必应搜索。谢谢！

另祝：版权碰瓷诈骗团伙，早日弃暗投明。

相关新闻：借版权之名、行诈骗之实，周某因犯诈骗罪被判处有期徒刑十一年六个月

叹！百花齐放的时代,渐行渐远!

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());

View Code

　　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("\n--------------------------");
        //for循环遍历
        for (String val : list) {
            System.out.print(val);
        }
        System.out.println("\n--------------------------");
        //随机访问，通过list.get(i)获得索引值去遍历。
        for(int i=0;i<list.size();i++) {
            System.out.print(list.get(i));
        }
    }
}

View Code

　　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;        
    }
}

View Code

　　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 + "]";
    }

}

View Code

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());

View Code

　　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());

View Code

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

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

立即下载 - IIS7 站长工具包