集合-List的子类

最新推荐文章于 2021-11-23 21:01:11 发布

星空物语2016

最新推荐文章于 2021-11-23 21:01:11 发布

阅读量477

点赞数

分类专栏： Java基础文章标签： ArrayList

本文链接：https://blog.csdn.net/u011301372/article/details/80215666

版权

Java基础专栏收录该内容

33 篇文章 0 订阅

订阅专栏

ArrayList类

JDK1.2
java.util.ArrayList

public class ArrayList<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

特点：

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

存储字符串并遍历

//创建集合对象
ArrayList array = new ArrayList();
//创建元素对象，并添加元素
array.add("hello");
array.add("world");
array.add("jaja");
//遍历
Iterator it = array.iterator();
while(it.hasNext()){
    String s = (String) it.next();
    System.out.println(s);
}
//普通for循环
for(int x=0;x<array.size();x++){
    String s=(String) array.get(x);
    System.out.println(x);
}

Vector类

public class Vector<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

特有功能

添加功能
public void addElement(Object obj)—add()
获取功能
public Object elementAt(int index)—get()
public Enumeration elements()—Iterator iterator()

boolean hasMoreElements();–hasNext()
Object nextElement();—next()

JDK升级原因

安全
效率
简化书写

//创建集合对象
Vector v = new Vector();

//添加功能
v.addElement("hello");
v.addElement("world");
v.addElement("java");

//遍历
for(int x =0;x<v.size();x++){
    String s =(String) v.elementAt(x);
    System.out.println(s);
}

Enumeration on = v.elements();//返回实现类的对象
while(on.hasMoreElements()）{
    String s=(String)on.nextElement();
    System.out.println(s);
}

LinkedList类

JDK 1.2

java.util.LinkedList<E>
public class LinkedList<E> extends Abstract SequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable

特点

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

特有功能

添加功能
public void addFirst(Object e):可以实现先进后出
public void addLast(Object e)
获取功能
public Object getFirst();
public Object getLast();
删除功能
public Object removeFirst();
public Object removeLast();

集合的toString方法

Collection c = new ArrayList();
这是多态，输出c的toString方法，其实是输出ArrayList的toString 方法
看ArrayList的toString 的方法
在ArrayList里面没有toString方法，则应该在其父类中
toSTring方法的源码

public String toString(){
    Iterator<E> it = this.iteraor();//集合本身调用迭代器方法，得到集合迭代器对象
    if(! it.hasNext()){
        return "[]";
    }
    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for(;;){
        E e = it.next();
        ab.append(e==this? "(this Collection)" : e);
        if(! it.hasNext()){
            return sb.append(']').toString();
        }
        sb.append(','.append(' '));
    }
}

案例

去除ArrayList集合中的重复字符串
分析

创建集合对象
添加多个字符串元素（包含内容相同的）
创建新集合
遍历旧集合，获取每一个元素
拿这个元素到新集合中找，看有么有

有，不处理
没有，添加到新集合
遍历新集合

//创建集合对象
ArrayList list = new ArrayList();
//添加集合元素
list.add("hello");
list.add("world");
list.add("hello");
list.add("java");
list.add("world");
list.add("hello");
list.add("java");
list.add("hello");
//创建新集合
ArrayList list2 = new ArrayList();
//遍历旧集合获取每一个元素
Iterator it = list.iterator();
while(it.hasNext()){
    String s = (String)it.next();
    if(!list2.contains(s)){
        list2.add(s);
    }
}
//遍历旧集合
iterator it2 = list2.iterator();
while(it2.hasNext()){
    String s = (String)it2.next();
    System.out.println(s);
}

需求2：不创建新集合

选择排序实现

拿0索引依次和后面的比较，有就把后面的删除
…

for(int x=0;x<list.size()-1;x++){
    for(int y=x+1;y<list.size();y++){
        if(list.get(x).equals( list.get(y))){
            list.remove(y);
            y--;//注意：删除后，y 的索引发生变化
        }

    }
}
//遍历集合
iterator it = list.iterator();
while(it.hasNext()){
    String s = (String)it.next();
    System.out.println(s);
}

去除ArrayList集合中的重复的自定义对象

//创建集合对象
        ArrayList array = new ArrayList();
        //创建学生对昂
        Student s1 = new Student("林青霞",27);
        Student s2 = new Student("林志玲",26);
        Student s3 = new Student("朱茵",25);
        Student s4 = new Student("杨澜",27);
        Student s5 = new Student("董洁",17);
        Student s6 = new Student("邓婕",17);
        Student s7 = new Student("杨澜",37);
        Student s8 = new Student("杨澜",37);
        Student s9 = new Student("林青霞",27);
        //此处的判断功能,contains 方法的底层是equals方法，而学生类中默认没有equals方法，使用的是父类Object的方法，其默认比较的是地址值，所以，她们都被添加了，因为new的东西，地址值都不同。
        //添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        array.add(s5);
        array.add(s6);
        array.add(s7);
        array.add(s8);
        array.add(s9);

        //创建新集合
        ArrayList newArray = new ArrayList();
        //遍历旧集合，获取每一个元素
        Iterator it = array.iterator();
        while(it.hasNext()){
            Student s= (Student) it.next();
            //拿这个元素到新集合中查找
            if(!newArray.contains(s)){
            //此处的判断功能,contains 方法的底层是equals方法，而学生类中默认没有equals方法，使用的是父类Object的方法，其默认比较的是地址值，所以，她们都被添加了，因为new的东西，地址值都不同。
                newArray.add(s);
                //按照需求，比较成员变量的值，这里需要重写equals方法。
            }
        }
        //遍历新集合
        for(int x = 0 ;x<newArray.size();x++){
            Student s = (Student) newArray.get(x);
            System.out.println(s.getName()+"   "+s.getAge());

        }

contains方法源码
contains方法的底层依赖于equals方法

public boolean contains(Object o){
    return indexOf(o)>=0;
}
public int indexOf(Object o){
    if(o==null){
        for(int i=0;i<size;i++){
            if(elementData[i]==null){
                return i;   
            }   
        }
    }else{
        for(int i=0;i<size;i++){
            if(o.equals(elementData[i])){
                return i;   
            }
        }
    }
    return -1;
}

用LinkedList模拟栈数据结构的集合
自己定义一个集合，在这个集合内部可以使用LinkedList模拟

public class MyStack {
    private LinkedList link;
    public MyStack(){
        link = new LinkedList();
    }
    public void add(Object obj){
        link.addFirst(obj);
    }
    public Object get(){
        return link.removeFirst();
    }
    public boolean isEmpty(){
        return link.isEmpty();
    }

}

public static void main(String[] args) {
//      //LinkedListDemo的特有添加功能 addFirst（）
//      //栈的特点先进后出
//      
//      //创建集合对象
//      LinkedList  link = new LinkedList();
//      //添加元素
//      link.addFirst("hello");
//      link.addFirst("world");
//      link.addFirst("java");
//      
//      //遍历
//      Iterator it = link.iterator();
//      while(it.hasNext()){
//          String s = (String) it.next();
//          System.out.println(s);
//      }

//      
        //创建集合对象
        MyStack ms = new MyStack();
        //添加元素
        ms.add("hello");
        ms.add("world");
        ms.add("java");
        //遍历
        while(!ms.isEmpty()){
            System.out.println(ms.get());
        }

    }