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

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

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

}

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

List体系(ArrayList / LinkedList / Vector)

ListIterator(列表迭代器)

LinkedList

LinkedList 特有方法:

LinkedList 练习

ArrayList 练习

继续阅读

Java反射具体需求实现案例一

java编程思想_006短路现象

九、设计模式以及查找、排序算法

这是我见过最简单理解NIO的文章了

Map集合中get不存在的key值，返回值问题

每日一学（14）——（面向对象）抽象类作为方法参数与返回值

effective java-tagged class to hierarchy class

单点登录-CAS

集合练习题1

java 编程思想第四版学习随记

java之单用户登录

Java反射是什么，为什么要用反射

Double类parseDouble和valueOf方法的区别

java调用Windows命令行

java打印任意边长的菱形

java 8 Lamda 求 List 中 Bigdecimal类型的各种值求最大值求最小值求和求平均值