Java API —— ArrayList类 & Vector类 & LinkList类

1、ArrayList类

    1）ArrayList类概述

        · 底层数据结构是数组，查询快，增删慢

        · 线程不安全，效率高

    2）ArrayList案例

        · 存储字符串并遍历

        · 存储自定义对象并遍历

 

2、Vecor类

    1）Vector类概述

       · 底层数据结构是数组，查询快，增删慢

       · 线程安全，效率低

    2）Vector类特有功能

        · public void addElement(E obj)：添加功能

        · public Object elementAt(int index)：返回指定索引处的组件

        · public Enumeration elements()：返回此向量的所有组件

    3）Vector案例

        · 存储字符串并遍历

        · 存储自定义对象并遍历

 

3、LinkedList类

    1）LinkedList类概述        

　　· 底层数据结构是链表，查询慢，增删快        

　　· 线程不安全，效率高    

　 2）LinkedList类特有功能        

　　· public void addFirst(Object e)及addLast(Object e)：在开头处或结尾处添加        

　　· public Object getFirst()及getLast()：获取第一个或最后一个元素        

　　· public Object removeFirst()及public Object removeLast()：移除第一个或最后一个元素并返回被删除的元素    

　 3）LinkedList案例

      · 存储字符串并遍历

      · 存储自定义对象并遍历

 

例子1：

package arraylistdemos;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * Created by gao on 15-12-15.
 */
/*
 * List的子类特点：
 *         ArrayList:
 *             底层数据结构是数组，查询快，增删慢
 *             线程不安全，效率高
 *         Vector:
 *             底层数据结构是数组，查询快，增删慢
 *             线程安全，效率低
 *         LinkedList:
 *              底层数据结构是链表，查询慢，增删快
 *             线程不安全，效率高
 *
 * 案例：
 *         使用List的任何子类存储字符串或者存储自定义对象并遍历。
 *
 * ArrayList的使用。
 *         存储字符串并遍历
 */
public class ArrayListDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList  arrayList = new ArrayList();
        //创建元素对象，并添加元素
        arrayList.add("believe ");
        arrayList.add("in ");
        arrayList.add("yourself ");
        //遍历
        Iterator it = arrayList.iterator();
        while(it.hasNext()){
            String s = (String)it.next();
            System.out.println(s);
        }
        System.out.println("----------------------");
        for(int x = 0; x < arrayList.size(); x++){
            String s = (String)arrayList.get(x);
            System.out.println(s);
        }
    }
}

例子2：

package arraylistdemos;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * Created by gao on 15-12-15.
 */
public class ArrayListDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList arrayList = new ArrayList();
        //创建学生对象
        Student s1 = new Student("武松", 30);
        Student s2 = new Student("鲁智深", 40);
        Student s3 = new Student("林冲", 36);
        Student s4 = new Student("杨志", 38);
        //添加元素
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        //遍历
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }
        System.out.println("------------");
        for (int x = 0; x < arrayList.size(); x++) {
            Student s = (Student) arrayList.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

　　 以上两个例子的添加和遍历方法对Vector和LinkedList都是可行的，下面讲解Vector特有的功能。

 

4、Vector的特有功能：

　　1）添加功能

　　　　public void addElement(Object obj) -- add()

　　2）获取功能

　　　　public Object elementAt(int index) -- get()

　　　　public Enumeration elements() -- Iterator iterator()

　　　　boolean hasMoreElements() -- hasNext()

　　　　Object nextElement() -- next()

  　3）JDK升级的原因：

   　　A:安全

   　　B:效率

  　　 C:简化书写

 

例子3：

package vectordemos;
import java.util.Enumeration;
import java.util.Vector;
/**
 * Created by gao on 15-12-15.
 */
public class VectorDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        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);
        }
        System.out.println("-------------");
        Enumeration e = v.elements();
        while(e.hasMoreElements()){
            String s = (String) e.nextElement();
            System.out.println(s);
        }
    }
}

5、LinkedList的特有功能：

        A:添加功能

            public void addFirst(Object e)

            public void addLast(Object e)

        B:获取功能

            public Object getFirst()

            public Obejct getLast()

        C:删除功能

            public Object removeFirst()

            public Object removeLast()

 

例子4：

package linklistdemos;
import java.util.LinkedList;
/**
 * Created by gao on 15-12-15.
 */
public class LinkListDemo01 {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedList link = new LinkedList();
        // 添加元素
        link.add("hello");
        link.add("world");
        link.add("java");
        // public void addFirst(Object e)
        link.addFirst("javaee");
        // public void addLast(Object e)
        link.addLast("android");
        // public Object getFirst()
        System.out.println("getFirst:"+link.getFirst());
        // public Obejct getLast()
        System.out.println("getLast:"+link.getLast());
        System.out.println("link:"+link);
        // public Object removeFirst()
        System.out.println("removeFirst:"+link.removeFirst());
        // public Object removeLast()
        System.out.println("removeLast:"+link.removeLast());
        // 输出对象名
        System.out.println("link:"+link);
    }
}

输出结果：

getFirst:javaee

getLast:android

link:[javaee, hello, world, java, android]

removeFirst:javaee

removeLast:android

link:[hello, world, java]

 

6、实例应用：ArrayList去除集合中字符串的重复值(字符串的内容相同)

方式一：创建新的集合

package exercisedemos;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * Created by gao on 15-12-15.
 */
/*
 * ArrayList去除集合中字符串的重复值(字符串的内容相同)
 *
 * 分析：
 *         A:创建集合对象
 *         B:添加多个字符串元素(包含内容相同的)
 *         C:创建新集合
 *         D:遍历旧集合,获取得到每一个元素
 *         E:拿这个元素到新集合去找，看有没有
 *             有：不搭理它
 *             没有：就添加到新集合
 *         F:遍历新集合
 */
public class Exercise01 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();
        // 添加多个字符串元素(包含内容相同的)
        array.add("hello");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("java");
        array.add("world");
        // 创建新集合
        ArrayList newArray = new ArrayList();
        // 遍历旧集合,获取得到每一个元素
        Iterator it = array.iterator();
        while(it.hasNext()){
            String s = (String) it.next();
            if(!newArray.contains(s)){
                newArray.add(s);
            }
        }
        Iterator it2 = newArray.iterator();
        while (it2.hasNext()){
            String s = (String) it2.next();
            System.out.println(s);
        }
    }
}

方式二：不能创建新的集合

package exercisedemos;
import java.util.ArrayList;
/**
 * Created by gao on 15-12-15.
 */
/*
 * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
 * 要求：不能创建新的集合，就在以前的集合上做。
 */
public class Exercise02 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();
        // 添加多个字符串元素(包含内容相同的)
        array.add("hello");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("java");
        array.add("world");
        // 由选择排序思想引入，我们就可以通过这种思想做这个题目
        // 拿0索引的依次和后面的比较，有就把后的干掉
        // 同理，拿1索引...
        for (int x = 0; x < array.size() - 1; x++) {
            for (int y = x + 1; y < array.size(); y++) {
                if (array.get(x).equals(array.get(y))) {
                    array.remove(y);
                    y--; //注意删除后会有一个替位
                }
            }
        }
        for (int x = 0; x < array.size(); x++) {
            String s = (String) array.get(x);
            System.out.println(s);
        }
    }
}

7、实例应用：去除集合中自定义对象的重复值(对象的成员变量值都相同)

Student类：（重写equals方法）

package exercisedemos;
/**
 * Created by gao on 15-12-9.
 */
public class Student {
    private String name;
    private int age;
    public Student() {
    }
    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 boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        if (age != student.age) return false;
        if (!name.equals(student.name)) return false;
        return true;
    }
}

测试类：

package exercisedemos;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * Created by gao on 15-12-15.
 */
/*
 * 需求：去除集合中自定义对象的重复值(对象的成员变量值都相同)
 *
 * 我们按照和字符串一样的操作，发现出问题了。
 * 为什么呢?
 *         我们必须思考哪里会出问题?
 *         通过简单的分析，我们知道问题出现在了判断上。
 *         而这个判断功能是集合自己提供的，所以我们如果想很清楚的知道它是如何判断的，就应该去看源码。
 * contains()方法的底层依赖的是equals()方法。
 * 而我们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法
 * Object()的equals()默认比较的是地址值，所以，它们进去了。因为new的东西，地址值都不同。
 * 按照我们自己的需求，比较成员变量的值，重写equals()即可。
 * 自动生成即可。
 */
public class Exercise03 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();
        // 创建学生对象
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("林志玲", 40);
        Student s3 = new Student("凤姐", 35);
        Student s4 = new Student("芙蓉姐姐", 18);
        Student s5 = new Student("翠花", 16);
        Student s6 = new Student("林青霞", 27);
        Student s7 = new Student("林青霞", 18);
        // 添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        array.add(s5);
        array.add(s6);
        array.add(s7);
        // 创建新集合
        ArrayList newArray = new ArrayList();
        Iterator it = array.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            if (!newArray.contains(s)) {
                newArray.add(s);
            }
        }
        for (int x = 0; x < newArray.size(); x++) {
            Student s = (Student)newArray.get(x);
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

输出结果：

林青霞---27

林志玲---40

凤姐---35

芙蓉姐姐---18

翠花---16

林青霞---18

 

8、实例应用：请用LinkedList模拟栈数据结构的集合，并测试

自定义Stack类：

package exercisedemos;
/**
 * Created by gao on 15-12-15.
 */
import java.util.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.getFirst();
        return link.removeFirst();
    }
    public boolean isEmpty(){
        return link.isEmpty();
    }
}

测试类：

package exercisedemos;
/**
 * Created by gao on 15-12-15.
 */
/*
 * MyStack的测试
 */
public class Exercise04 {
    public static void main(String[] args) {
        MyStack ms = new MyStack();
        ms.add("hello");
        ms.add("world");
        ms.add("java");
        while (!ms.isEmpty()){
            System.out.println(ms.get());
        }
    }
}

输出结果：

java

world

hello