JavaSE基础自学-----集合框架--List体系(ArrayList / LinkedList / Vector)

List体系(ArrayList / LinkedList / Vector)

List : 元素是有序的, 元素可以重复, 因为该集合体系有索引(有角标)

---

List 集合判断元素是否相同 (contains) ,依据的是equals方法

---

List体系常见容器:(ArrayList / LinkedList / Vector)

• ArrayList : 底层使用的是数组数据结构,特点 : 查询速度快, 增删慢 ,线程不同步
• LinkedList : 底层使用的是链表数据结构, 特点: 查询慢 ,增删快
• Vector : 数组数据结构 , 线程同步(老版本容器)

List体系特有方法(凡是可以操作角标的方法都是list体系特有方法)

---

-增:

• add(int index, E element) ---- 指定角标位插入指定元素

• addAll(Collection<? extends E> c) ----在尾部插入集合

删:

• remove(index) -----移除指定角标位的元素

改:

• set(int index, E element) -----指定元素替换指定角标位元素

查:

• get(int index) -----返回此位置元素

• indexOf(Object o) ------返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

• subList(int fromIndex, int toIndex) ----返回指定的 fromIndex（包括 ）和toIndex（不包括）之间的元素

• listIterator(int index) -----返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始

代码演示-----

import java.util.*;  //导入集合类包
public class DEMO {
    public static void demo1() {

        ArrayList al = new ArrayList();

        //添加元素
        al.add("java1");
        al.add("java2");
        al.add("java3");
        al.add("java4");

        sop("原元素:" + al);

        al.add(1, "java5"); //指定位置添加元素
        sop("添加后元素:" + al);

        al.remove(2); //指定位置删除元素
        sop("删除后元素:" + al);

        al.set(3, "java-set"); //指定位置修改元素
        sop("修改后元素:" + al);

        sop("获取指定位置元素:" + al.get(0));

        sop("第一次出现位置" + al.indexOf("java1"));   //获取该元素第一次出现的位置
        sop("最后出现位置" + al.lastIndexOf("java-set"));   //获取该元素最后一次出现的位置

        sop("获取角标范围元素" + al.subList(0, 2));  //获取角标范围内的元素,不包括最后一位

        //使用迭代器对集合遍历一次
        Iterator it = al.iterator();
        while (it.hasNext()) {
            sop("迭代"+it.next());
        }
    }

---

ListIterator(列表迭代器)

• LIistIterator:List特有的迭代器,ListIterator是Iterator的子接口
• Iterator的方法是有限的,使用Iterator进行迭代时,不能使用集合对象的方法操作集合中的元素
• ListIterator中加入了增删改的方法,进行迭代时可以对集合中的元素进行操作
• ListIterator可以实现双向迭代
• ListIterator只能通过List集合的 listIterator() 方法获取

代码演示-----

    public static void demo3() {
        //创建一个ArrayList 集合容器对象 .
        ArrayList al = new ArrayList();

        //添加元素
        al.add("java1");
        al.add("java2");
        al.add("java3");
        al.add("java4");

        ListIterator it = al.listIterator(); //获取列表迭代器.用于取出集合中的元素.此时迭代器存放了集合的元素

        while (it.hasNext()) {   //如果仍有元素可以迭代，则返回 true。

            Object obj = it.next(); //it.next()获取的元素赋给 obj
            if (obj.equals("java3")) {
                it.set("java33");  //将java3修改成java33

                it.add("java3.5");  //在该元素后添加元素

//                it.remove();  // 移除该元素
            }
            sop("obj=" + obj);
        }
        sop("迭代后的集合:" + al);

        while (it.hasPrevious()) {     //反向迭代
            Object obj = it.previous();

            sop("反向迭代obj=" + obj);
        }
    }

---

LinkedList

LinkedList 特有方法:

addFirst(E e) -----将指定元素插入此列表的开头。
addLast(E e) -----将指定元素添加到此列表的结尾。
.
getFirst() getLast()
获取元素但不删除元素,如果集合中没有元素,会出现异常NoSuchElementException
.
removeFirst() removeLast
获取元素和删除元素,如果集合中没有元素,会出现异常NoSuchElementException
.
JDK1.6版本后出现了替代方法
offerFirst()
offerLast()
.
peekFirst()
peekLast()
获取元素但不删除元素,如果集合中没有元素,则返回null
.
pollFirst()
pollLast()
获取元素和删除元素,如果集合中没有元素,则返回null

LinkedList 练习

• 使用LinkedList模拟一个堆栈或队列数据结构
• 堆栈:先进后出
• 队列:先进先出

import java.util.*;  //导入集合类包

/*
 * 使用LinkedList模拟一个堆栈或队列数据结构
 * 堆栈:先进后出
 * 队列:先进先出:*/

class queue { //元素先进先出

    private LinkedList link;

    queue() {
        link = new LinkedList();
    }

    public void addElements(Object obj) {
        link.addFirst(obj);
    }

    public void getElements() {
        while (!(link.isEmpty())) {
            System.out.println(link.removeLast());  //从最后开始获取
        }
    }
}

class stack {  //元素先进后出

    private LinkedList link;

    stack() {
        link = new LinkedList();
    }

    public void addElements(Object obj) {
        link.addFirst(obj);
    }

    public Object getElements() {
        return link.removeFirst();    //从首位开始获取
    }

    public boolean isNull() {
        return link.isEmpty();
    }
}

public class DEMO {

    public static void main(String[] args) {
        queue q = new queue();
        q.addElements("java1");
        q.addElements("java2");
        q.addElements("java3");
        q.addElements("java4");
        q.getElements();

        System.out.println();

        stack s = new stack();
        s.addElements("java5");
        s.addElements("java6");
        s.addElements("java7");
        s.addElements("java8");

        while (!s.isNull()) {
            System.out.println(s.getElements());
        } }

运行结果-----
先进后出

java1 java2 java3 java4
java8 java7 java6 java5

---

ArrayList 练习

注:集合对象方法中,contains 此方法实际依赖的是元素的 equals 方法…remove 也是

本例需求 自定义对象,去除重复对象.
代码演示1-------

import java.util.*;  //导入集合类包
/*
自定义对象,去除ArrayList 集合中的重复元素
存入 "人对象",同名同年龄为重复元素

思路:
     1,对人进行描述
     2,定义容器将人对象存入
     3,定义新容器.将人对象过滤一遍,删除重复元素
     由于contains 依据的equals 方法,如果依据Object中的equals,只是比较两个对象的引用(地址值)
     而本例中需要比较的是名字年龄是否相同.所以需要重写equals方法,比较名字,年龄.,重新定义判断条件
 */

class Person {
    private String name;
    private int age;

    public boolean equals(Object obj) {  //重写equals定义判断条件

        if (!(obj instanceof Person)) {  //判断输入元素是否为Person,否则返回false
            return false;
        }
        Person p = (Person) obj;        //多态.向下转型才能调用子类成员

       // System.out.println(this.name+"     "+p.name);   //参考,,哪段代码调用了equals

        return this.name.equals(p.name) && this.age==p.age;  //定义判断条件:名字,年龄相同就返回true
    }

    Person(String name, int age) {
        this.age = age;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class DEMO {

    public static void main(String[] args) {
        ArrayList al = new ArrayList();

        al.add(new Person("java1", 15)); //Object obj=new Person() 此处为多态
        al.add(new Person("java2", 16));
        al.add(new Person("java3", 18));
        al.add(new Person("java1", 15));
        al.add(new Person("java1", 16));

        al = repeatRemove(al);
//        sop(al.remove(new Person("java1",15)));     //remove 也是依据的equals方法

        //迭代遍历元素
        Iterator it = al.iterator();
        while (it.hasNext()) {
            // Object obj=it.next();
            Person p = (Person) it.next();
            sop(p.getName() + "   " + p.getAge());
        }
    }

    public static ArrayList repeatRemove(ArrayList al) { //定义去除重复元素功能,返回一个数组集合
        ArrayList newAl = new ArrayList();     //定义新容器用于接收元素

        Iterator it = al.iterator();   //获取迭代器

        while (it.hasNext()) {      //进行迭代

            Object obj = it.next();

            if (!newAl.contains(obj)) {  //判断新集合里是否含有该元素:contains .依据的是元素的equals方法
                newAl.add(obj);
            }
        }
        return newAl;  //返回迭代 删除重复元素后的数组
    }

    public static void sop(Object object) {
        System.out.println(object);
    }

}