Java基础（19）数据结构概述、ArrayList集合、Vector集合、LinkedList集合、集合框架练习

1. 数据结构概述

1. 数据结构的概述：数据结构就是数据存储的方式
2. 常见数据结构：栈，队列，数组，链表，二叉树，哈希表
3. 栈和队列
（1）栈：先进后出，后进先出
（2）队列：先进先出，后进后出
4. 数组和链表
（1）数组：查询快，增删慢
（2）链表：查询慢，增删快
5. List的三个子类的特点
（1）ArrayList：底层采用数组，查询快，增删慢。线程不安全，效率高
（2）Vector：底层采用数组，查询快，增删慢。线程安全，效率低
（3）LinkedList：底层采用链表，查询慢，增删快。线程不安全，效率高

2. ArrayList集合

1. ArrayList集合概述：

• List接口的可调整大小的数组实现。实现了所有的可选列表操作，并允许所有的元素，包括 null
• ArrayList:底层使用使用的是数组。查询快，增删慢。线程不安全，效率高
• 元素有序的（存取顺序一致），元素编有索引，允许重复元素

2. 遍历ArrayList的方法：

• void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.function.Consumer;

public class TestDemo01 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(11);
        arrayList.add(22);
        arrayList.add("java");
        arrayList.add(null);

        //遍历方法1：两种迭代器
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object o = iterator.next();
            System.out.println(o);
        }

        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()) {
            Object o = listIterator.next();
            System.out.println(o);
        }

        //遍历方法2：for循环
        for (int i = 0; i < arrayList.size(); i++) {
            Object o = arrayList.get(i);
            System.out.println(o);
        }

        //遍历方法3：void forEach(Consumer<? super E> action)
        arrayList.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
    }
}

3. ArrayList排序的方法：

• void sort (Comparator < ? super E > c)：分类列表使用提供的 Comparator比较元素。
• Comparator：比较器

import java.util.ArrayList;
import java.util.Comparator;

public class TestDemo02 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(11);
        arrayList.add(22);
        arrayList.add(33);
        arrayList.add(44);
        arrayList.add(55);

        /**
         * 前-后：从小往大排序
         * 后-前：从大往小排序
         */
        arrayList.sort(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer a = (Integer) o1;
                Integer b = (Integer) o2;
                return a - b;
            }
        });

        System.out.println(arrayList);  //[11, 22, 33, 44, 55]
    }
}

4. ArrayList中的删除方法：

• boolean removeIf (Predicate < ? super E > filter)：删除满足给定谓词的这个集合的所有元素

import java.util.ArrayList;
import java.util.function.Predicate;

public class TestDemo03 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(11);
        arrayList.add(22);
        arrayList.add(33);
        arrayList.add(44);
        arrayList.add(55);

        //删除集合中大于25的元素
        arrayList.removeIf(new Predicate() {
            @Override
            public boolean test(Object o) {
                Integer i = (Integer) o;
                return i > 25;
            }
        });

        System.out.println(arrayList);   //[11, 22]
    }
}

3. Vector集合

1. Vector类的概述：Vector类可以实现可增长的对象数组，Vector是同步的
2. Vector类特有的功能：

• public void addElement(E obj)：将指定的组件添加到此向量的末尾，将其大小增加 1（等同于add()）
• public void forEach(Consumer<? super E> action)：遍历该集合
• public E firstElement()：返回此向量的第一个组件（位于索引 0) 处的项）
• public E lastElement()返回此向量的最后一个组件
• public E elementAt(int index)：返回指定索引处的组件（等同于get(int index)方法）
• public Enumeration elements()：集合中自己的一个迭代器，可以遍历集合中的元素

import java.util.Enumeration;
import java.util.Vector;
import java.util.function.Consumer;

public class TestDemo01 {
    public static void main(String[] args) {
        Vector vector = new Vector();

        //public void addElement(E obj)：将指定的组件添加到此向量的末尾，将其大小增加 1（等同于add()）
        vector.addElement(11);
        vector.addElement(22);
        vector.addElement(33);
        vector.addElement(44);
        System.out.println(vector);   //[11, 22, 33, 44]

        //public void forEach(Consumer<? super E> action)：遍历该集合
        vector.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });        //11   22    33    44

        //public E firstElement()：返回此向量的第一个组件（位于索引 0) 处的项）
        Object o1 = vector.firstElement();
        System.out.println(o1);    //11

        //public E lastElement()返回此向量的最后一个组件
        Object o2 = vector.lastElement();
        System.out.println(o2);    //44

        //public E elementAt(int index)：返回指定索引处的组件（等同于get(int index)方法）
        Object o3 = vector.elementAt(2);
        System.out.println(o3);     //33

        //public Enumeration elements()：集合中自己的一个迭代器，可以遍历集合中的元素
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            Object obj = elements.nextElement();
            System.out.println(obj);
        }      //11   22    33    44
    }
}

4. LinkedList集合

1. LinkedList类概述：List接口的链表实现，此实现不是同步的
2. LinkedList类的特有功能

• public void addFirst(E e)：将指定元素插入此列表的开头
• public void addLast(E e)：将指定元素插入此列表的结尾
• public E getFirst()：获取列表开头的元素
• public E getLast()：获取列表结尾的元素
• public E removeFirst()：移除并返回此列表的第一个元素
• public E removeLast()：移除并返回此列表的最后一个元素
• public E poll ()：获取并移除此列表的头（第一个元素）
• public E pollFirst ()：获取并移除此列表的第一个元素；如果此列表为空，则返回 null
• public E pollLast ()：获取并移除此列表的最后一个元素；如果此列表为空，则返回 null

import java.util.LinkedList;

public class TestDemo02 {
    public static void main(String[] args) {
        LinkedList linkedList1 = new LinkedList();
        linkedList1.add(11);
        linkedList1.add(22);
        linkedList1.add(33);
        //public void addFirst(E e)：将指定元素插入此列表的开头
        linkedList1.addFirst("java");
        System.out.println(linkedList1);   //[java, 11, 22, 33]

        //public void addLast(E e)：将指定元素插入此列表的结尾
        linkedList1.addLast("lol");
        System.out.println(linkedList1);   //[java, 11, 22, 33, lol]

        //public E getFirst()：获取列表开头的元素
        Object o1 = linkedList1.getFirst();
        System.out.println(o1);    //java

        //public E getLast()：获取列表结尾的元素
        Object o2 = linkedList1.getLast();
        System.out.println(o2);   //lol

        //public E removeFirst()：移除并返回此列表的第一个元素
        Object o3 = linkedList1.removeFirst();
        System.out.println(o3);    //java
        System.out.println(linkedList1);    //[11, 22, 33, lol]

        //public E removeLast()：移除并返回此列表的最后一个元素
        Object o4 = linkedList1.removeLast();
        System.out.println(o4);    //lol
        System.out.println(linkedList1);    //[11, 22, 33]

        LinkedList linkedList2 = new LinkedList();
        linkedList2.add("java");
        linkedList2.add(11);
        linkedList2.add(22);
        linkedList2.add(33);
        linkedList2.add("lol");
        //public E poll ()：获取并移除此列表的头（第一个元素）
        Object obj1 = linkedList2.poll();
        System.out.println(obj1);   //java
        System.out.println(linkedList2);    //[11, 22, 33, lol]

        //public E pollFirst ()：获取并移除此列表的第一个元素；如果此列表为空，则返回 null
        Object obj2 = linkedList2.pollFirst();
        System.out.println(obj2);    //11
        System.out.println(linkedList2);    //[22, 33, lol]

        //public E pollLast ()：获取并移除此列表的最后一个元素；如果此列表为空，则返回 null
        Object obj3 = linkedList2.pollLast();
        System.out.println(obj3);   //lol
        System.out.println(linkedList2);    //[22, 33]
    }
}

• public E pop()：从此列表所表示的堆栈处弹出一个元素
• public void push(E e)：将元素推入此列表所表示的堆栈

import java.util.LinkedList;

public class TestDemo03 {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add("java");
        linkedList.add(11);
        linkedList.add(22);
        linkedList.add(33);
        linkedList.add("lol");
        System.out.println(linkedList);   //[java, 11, 22, 33, lol]

        linkedList.push("abc");
        linkedList.push(999);
        System.out.println(linkedList);   //[999, abc, java, 11, 22, 33, lol]

        Object o1 = linkedList.pop();
        System.out.println(o1);    //999
        System.out.println(linkedList);   //[abc, java, 11, 22, 33, lol]

        Object o2 = linkedList.pop();
        System.out.println(o2);    //abc
        System.out.println(linkedList);    //[java, 11, 22, 33, lol]
    }
}

5. 集合框架的练习题

1. 去除ArrayList中重复Integer(字符串)元素

//去除ArrayList中重复Integer元素
public class TestDemo01 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(11);
        arrayList.add(22);
        arrayList.add(33);
        arrayList.add(44);
        arrayList.add(55);
        arrayList.add(11);
        arrayList.add(33);
        System.out.println(arrayList);    //[11, 22, 33, 44, 55, 11, 33]

        //创建新集合完成需求
        ArrayList newList = new ArrayList();
        for (int i = 0; i < arrayList.size(); i++) {
            Object o = arrayList.get(i);
            //取出旧集合中的元素往新集合里面装，判断新集合中不包含这个元素，再往里面加
            if(!(newList.contains(o))){
                newList.add(o);
            }
        }
        System.out.println(newList);    //[11, 22, 33, 44, 55]

    }
}

==============================================================

import java.util.ArrayList;

public class TestDemo02 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(11);
        arrayList.add(22);
        arrayList.add(33);
        arrayList.add(44);
        arrayList.add(55);
        arrayList.add(11);
        arrayList.add(33);
        System.out.println(arrayList);    //[11, 22, 33, 44, 55, 11, 33]

        //不创建新集合
        //可以使用选择排序的原理，每次拿一个元素跟后面的元素去比较相等。如果相等就删掉
        for (int i = 0; i < arrayList.size(); i++) {
            for (int j = i + 1; j < arrayList.size(); j++){
                if(arrayList.get(i).equals(arrayList.get(j))){
                    arrayList.remove(j);
                    j--;
                }
            }
        }
        System.out.println(arrayList);   //[11, 22, 33, 44, 55]
    }
}

2. 去除ArrayList中重复自定义对象【重写equals()方法！】

import java.util.ArrayList;
import java.util.Objects;

public class TestDemo03 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new LOL("EZ",18));
        arrayList.add(new LOL("VN",22));
        arrayList.add(new LOL("EZ",18));
        arrayList.add(new LOL("MF",24));
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }
        /**
         * LOL{name='EZ', age=18}
         * LOL{name='VN', age=22}
         * LOL{name='EZ', age=18}
         * LOL{name='MF', age=24}
         */

        System.out.println("=======================");

        ArrayList newArrayList = new ArrayList();

        //这里面contains()底层源码比较的是地址值。
        //所以需要在LOL类中重写equals()方法，才可以比较对象的姓名和年龄，才能完成需求
        for (int i = 0; i < arrayList.size(); i++) {
            Object o = arrayList.get(i);
            LOL lol = (LOL) o;
            if(!(newArrayList.contains(lol))){
                newArrayList.add(lol);
            }
        }

        for (int i = 0; i < newArrayList.size(); i++) {
            System.out.println(newArrayList.get(i));
        }

        /**
         * LOL{name='EZ', age=18}
         * LOL{name='VN', age=22}
         * LOL{name='MF', age=24}
         */
    }
}

class LOL{
    private String name;
    private int age;

    public LOL() {
    }

    public LOL(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 String toString() {
        return "LOL{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        LOL lol = (LOL) o;
        return age == lol.age &&
                Objects.equals(name, lol.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}

3. 请用LinkedList模拟栈数据结构的集合，并测试

import java.util.LinkedList;

public class TestDemo04 {
    public static void main(String[] args) {
        MyList myList = new MyList();
        myList.addEle(11);
        myList.addEle(22);
        myList.addEle(33);
        myList.addEle(44);
        myList.addEle(55);

        Object ele1 = myList.getEle();
        System.out.println(ele1);   //55

        Object ele2 = myList.getEle();
        System.out.println(ele2);   //44

        Object ele3 = myList.getEle();
        System.out.println(ele3);   //33

        Object ele4 = myList.getEle();
        System.out.println(ele4);   //22

        Object ele5 = myList.getEle();
        System.out.println(ele5);    //11

    }
}

class MyList{
    private final LinkedList linkedList;

    public MyList(){
        linkedList = new LinkedList();
    }

    //添加元素的方法
    public void addEle(Object obj){
        linkedList.addFirst(obj);
    }

    //取出元素的方法
    public Object getEle(){
        Object pop = linkedList.pop();
        //再把它加回去
        linkedList.addLast(pop);
        return pop;
    }
}