从零学Java List集合

Java List集合

1 List 集合

特点：有序、有下标、元素可以重复。

• 有序: 添加与遍历的顺序是一致的;
• 有下标: 可以使用普通for循环;
• 元素可以重复的

常用方法：

• void add(int index, Object o) //在index位置插入对象o。
• boolean addAll(int index, Collection c) //将一个集合中的元素添加到此集合中的index位置。
• Object get(int index) //返回集合中指定位置的元素。
• List subList(int fromIndex, int toIndex) //返回fromIndex和toIndex之间的集合元素。

eg : 存储字符串(基础数据)

public class TestArrayList {
    public static void main(String[] args) {
        //创建List集合
        List list = new ArrayList();
        List list1 = new ArrayList();
        //1 添加单个元素
        list.add("苹果");
        list.add("葡萄");
        list.add("香蕉");
        list.add("橘子");
        list.add(0,"榴莲");
        list1.add("西瓜");
        list1.add("桃子");
        System.out.println("元素个数: "+list.size());
        System.out.println("打印: "+list);
        //1.1 添加整个List集合
        list.addAll(list1);
        System.out.println("添加整个List集合后元素个数: "+list.size());
        System.out.println("打印: "+list);
        //2 删除
        list.remove("苹果");
        list.remove(3);
        System.out.println("删除之后: "+list);
        //2.1 清空
        System.out.println("清空前: "+list1);
        list1.clear();
        System.out.println("清空后: "+list1);
        //3 遍历
        //3.1 增强for
        System.out.println("-----增强for-----");
        for (Object o : list) {
            System.out.println(o);
        }
        //3.2 普通for
        System.out.println("-----普通for-----");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //3.3 迭代器
        System.out.println("-----迭代器-----");
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            System.out.println(next);
        }
        /*
            3.4 列表迭代器
            可以从前向后,也可以从后向前
            可以添加,修改,删除元素
        */
        //创建列表迭代器, 初始指针在列表首位
        ListIterator lit = list.listIterator();
        System.out.println("-----列表迭代器-----");
        System.out.println("-----正向-----");
        while (lit.hasNext()) {
            System.out.println(lit.nextIndex() + "...." + lit.next());
        }
        //需要指针在列表最后
        //ListIterator lit = list.listIterator(list.szie());
        System.out.println("-----逆向-----");
        while (lit.hasPrevious()) {
            System.out.println(lit.previousIndex() + "...." + lit.previous());
        }
        //4 判断
        //4.1 查找目标元素, 返回boolean值
        System.out.println(list.contains("葡萄"));
        //4.2 判断列表是否为空, 返回boolean值
        System.out.println(list.isEmpty());
        //5 获取
        //5.1 获取下标
        System.out.println(list.indexOf("葡萄"));
        //5.2 获取子集, 指定开始位置和结束位置, 含头不含尾
        System.out.println(list.subList(2, 5));
    }
}

eg : 存储对象数据

public class TestList1 {
    //静态内部类
    static class Student {
        String name;
        int age;

        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
		//重写toString方法
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
		//重写equals方法
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (this == obj) {
                return true;
            }
            if (obj instanceof Student) {
                Student stu = (Student) obj;
                return this.name.equals(stu.name) && this.age == stu.age;
            }
            return false;
        }
    }

    public static void main(String[] args) {
        //创建List集合
        List list = new ArrayList();
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",26);
        Student s3 = new Student("王五",21);
        //1 添加元素
        list.add(s1);
        list.add(s2);
        list.add(s3);
        System.out.println("元素个数: "+ list.size());
        System.out.println("元素: "+list);
        //2 删除, 删除的依据是进行equals()方法
//        list.remove(s1);
//        list.remove(new Student("张三",18));
//        list.remove(0);
//        System.out.println("删除后: "+list);
//        list.clear();
        //3 遍历
        //3.1 增强for
        System.out.println("-----增强for-----");
        for (Object o : list) {
            System.out.println(o);
        }
        //3.2 普通for
        System.out.println("-----普通for-----");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //3.3 迭代器
        System.out.println("-----迭代器-----");
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            System.out.println(next);
        }
        /*
            3.4 列表迭代器
            可以从前向后,也可以从后向前
            可以添加,修改,删除元素
        */
        //创建列表迭代器, 初始指针在列表首位
        ListIterator lit = list.listIterator();
        System.out.println("-----列表迭代器-----");
        System.out.println("-----正向-----");
        while (lit.hasNext()) {
            System.out.println(lit.nextIndex() + "...." + lit.next());
        }
        //需要指针在列表最后
        System.out.println("-----逆向-----");
        while (lit.hasPrevious()) {
            System.out.println(lit.previousIndex() + "...." + lit.previous());
        }
        //4 判断, 根据equals()方法
        //4.1 查找目标元素, 返回boolean值
        System.out.println(list.contains(new Student("李四",26)));
        //4.2 判断列表是否为空, 返回boolean值
        System.out.println(list.isEmpty());
        //5 获取, 根据equals()方法
        //5.1 获取下标
        System.out.println(list.indexOf(s3));
        //5.2 获取子集, 指定开始位置和结束位置, 含头不含尾
        System.out.println(list.subList(0,2));
    }
}

2 List实现类

2.1 ArrayList【重点】

特点:

• 数组结构实现，查询快、增删慢；
• JDK1.2版本，运行效率快、线程不安全。

ArrayList源码分析:

• 如果没有向集合中添加任何元素时，容量0,添加一个元素之后，容量扩容为10
• 每次扩容大小是原来的1.5倍
• elementData存放元素的数组
• size 实际元素个数

2.2 LinkedList

特点:

• 双向链表结构实现，增删快(仅指针的变动)，查询慢。

结构图:

2.3 Vector (已废弃)

特点:

• 数组结构实现。
• JDK1.0版本，运行效率慢、线程安全。

3 数据结构: 栈, 队列

栈：是一种先进后出的数据结构。

• Stack类：继承Vector类
  • push方法入栈、pop方法出栈
• LinkedList也实现了栈结构

eg:

public class TestStack {
    public static void main(String[] args) {
        //栈, 是一种先进后出的数据结构
        //Stack stack = new Stack();
        LinkedList stack = new LinkedList();
        //进栈
        stack.push("aaa");
        stack.push("bbb");
        stack.push("ccc");

        //出栈
        int count = stack.size();
        for (int i = 0; i < count; i++) {
            System.out.println(stack.pop());
        }
    }
}

队列：是一种先进先出的数据结构。

• Queue接口：继承Collection接口
• offer方法入队、poll方法出队
• LinkedList实现了Queue接口

eg:

public class TestQueue {
    public static void main(String[] args) {
        //队列, 是一种先进先出的数据结构
        //创建队列
        Queue queue = new LinkedList();
        //进队
        queue.offer("aaa");
        queue.offer("bbb");
        queue.offer("ccc");
        //出队
        int count = queue.size();
        for (int i = 0; i < count; i++) {
            System.out.println(queue.poll());
        }
    }
}