Java基础知识 19（数据结构与算法，ArrayList集合，Vector集合，LinkedList集合，集合框架练习题）

Java基础知识 19

数据结构与算法

数据结构与算法：
数据结构：数据的存储方式。
常见的数据结构:栈 队列 数组 链表 二叉树 哈希表
栈的数据结构特点：先进后出，后进先出。弹夹就是典型的栈结构
队列的特点：先进的先出，后进的后出。

数组的特点：数组的元素都标有索引，查询快，增删慢。
链表的特点：查询慢，增删快。

list接口下的三个子类特点：
Arraylist集合：底层使用的是数组，查询快，增删慢。线程不安全，效率高。
Linkedlist集合：底层使用的是链表，查询慢，增删快。线程不安全，效率高。
Vector：底层使用的是数组，查询快，增删慢。线程安全，效率低。

ArrayList集合

ArrayList：底层使用的是数组，查询快，增删慢。此实现不是同步的，是线程不安全的，效率高。
（1）遍历方式有四种：
（1）Iterator iterator = list.iterator();//用hasNext和next方法
（2）ListIterator listIterator = list.listIterator();//自己特有的迭代器
（3）for循环，size()和get()方法
ArrayList集合新的迭代方法：
（4）JDK1.8之后提供了一种迭代方法。
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 Mytest {
    public static void main(String[] args) {
        //List接口的大小可变数组的实现，实现了所有可选列表操作，并允许包括null在内的所有元素。
        //ArrayList:底层使用的是数组，查询快，增删慢。注意：此实现不是同步的，是线程不安全的。效率高。
        //元素有序的(存取顺序一致) 元素编有索引，允许元素重复。
        ArrayList list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(null);
        //遍历方式有：两种迭代器
        Iterator iterator = list.iterator();//用hasNext和next方法
        ListIterator listIterator = list.listIterator();//自己特有的迭代器
        //for循环，size()和get()方法
        for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            System.out.println(obj);
        }
        System.out.println("---------------------");
        //JDK1.8之后提供了一种迭代方法。
        //void forEach(Consumer<? super E> action)
        //执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                //o就是集合中的元素
                System.out.println(o);
            }
        });
    }
}

（2）ArrayList集合新的排序方法
​ void sort (Comparator < ? super E > c)
​ 分类列表使用提供的 Comparator比较元素。
​ 排序 Comparator 比较器

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

public class Mytest3 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(50);
        list.add(40);
        list.add(30);
        list.add(20);
        list.add(10);
        list.add(1);
        /*void sort (Comparator < ? super E > c)
        分类列表使用提供的 Comparator比较元素。
        排序  Comparator 比较器*/
        list.sort(new Comparator() {
            @Override
            public int compare(Object num1, Object num2) {
                /*System.out.println(num1);
                System.out.println(num2);*/
                Integer a= (Integer) num1;
                Integer b= (Integer) num2;
                return a-b;
                //return 0;
            }
        });
        System.out.println(list);
    }
}

（3）ArrayList集合删除某些元素：
​ boolean removeIf (Predicate < ? super E > filter)
​ 删除满足给定谓词的这个集合的所有元素。
（4）判断集合为空的方法：isEmpty();

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

public class Mytest4 {
    public static void main(String[] args) {
        /*  boolean removeIf (Predicate < ? super E > filter)
        删除满足给定谓词的这个集合的所有元素。*/
        ArrayList list = new ArrayList();
        list.add(10);
        list.add(30);
        list.add(50);
        list.add(70);
        list.add(90);
        list.add(100);
        list.removeIf(new Predicate() {
            @Override
            public boolean test(Object obj) {
                Integer num= (Integer) obj;
                return num>50;
                //return true;返回true，就删除集合中的元素
                //return false;返回false，不删除集合中的元素
            }
        });
        System.out.println(list);
        System.out.println("------------------------");
        /*for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            Integer num= (Integer) obj;
            if (num>50){
                list.remove(num);
            }
        }
        System.out.println(list);*/
        list.clear();
        //判断集合为空的方法：isEmpty()
        boolean empty = list.isEmpty();
        System.out.println(empty);
        if(list.size()==0){
            System.out.println("list集合为空！");
        }
    }
}

Vector集合

vector集合的一些方法：
（1）添加元素---->vector.add(“ab”);
​ ----->vector.addelement(“cd”);
（2）遍历元素：vector.forEach(new Consumer() {
@Override
public void accept(Object obj) {
System.out.println(obj);
}
});
（3）取第一个元素：vector.firstElement();
​ 取最后一个元素：vector.lastElement();
​ 根据索引截取一个元素：vector.elementAt(2);

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

public class Mytest {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add("ab");
        vector.addElement("cd");
        vector.add("ef");
        vector.add("gh");
        vector.forEach(new Consumer() {
            @Override
            public void accept(Object obj) {
                System.out.println(obj);
            }
        });
        System.out.println(vector);
        System.out.println("-----------------");
        /*E firstElement ()
        返回此向量的第一个组件（位于索引 0)处的项）。
        E lastElement ()
        返回此向量的最后一个组件。*/
        Object obj = vector.firstElement();
        System.out.println(obj);
        Object obj2 = vector.lastElement();
        System.out.println(obj2);
        //elementAt根据索引截取一个元素
        Object obj3 = vector.elementAt(2);
        System.out.println(obj3);
    }
}

（4）Vector容器有一个自己的迭代器，可以遍历集合中的元素。
​ Enumeration elements()，返回此向量的组件的枚举。
​ Enumeration 迭代器 hasMoreElements()----->判断还有没有下一个元素
​ nextElement()----->获取下一个元素

import java.util.Enumeration;
import java.util.Vector;

public class Mytest2 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(200);
        vector.addElement(300);
        vector.addElement(400);
        vector.addElement(500);
        //Vector 集合中自己的一个迭代器，可以遍历集合中的元素
     /*   Enumeration<E> elements ()
        返回此向量的组件的枚举。*/
        /*Enumeration 迭代器
        hasMoreElements()  判断还有没有下个元素
        nextElement() 获取下一个元素*/
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            Object obj = elements.nextElement();
            System.out.println(obj);
        }
    }
}

LinkedList集合

LinkedList：底层数据结构是链表，查询慢，增删快，此实现不是同步的。线程不安全，效率高。
LinkedList集合中的方法：
（1）addFirst()：在首位置上增加元素
（2）addLast()：在末位置上增加元素
（3）getFirst()：返回此列表的第一个元素
（4）getLast()：返回此列表的最后一个元素
（5）removeFirst()：移除并返回此列表的第一个元素
（6）removeLast()：移除并返回此列表的最后一个元素

import java.util.LinkedList;

public class Mytest {
    public static void main(String[] args) {
        //LinkedList:底层数据结构是链表，查询慢，增删快，注意，此实现不是同步的。线程不安全，效率高
        LinkedList linkedList = new LinkedList();
        linkedList.add(200);
        //在首位置上增加元素
        linkedList.addFirst(100);
        linkedList.addFirst(50);
        linkedList.addFirst(20);
        //在末位置上增加元素
        linkedList.addLast(300);
        linkedList.addLast(400);
        linkedList.addLast(500);
        System.out.println(linkedList);
        System.out.println("-------------------------");
        /*E getFirst ()
        返回此列表的第一个元素*/
        Object first = linkedList.getFirst();
        System.out.println(first);
        /*E getLast ()
        返回此列表的最后一个元素。*/
        Object last = linkedList.getLast();
        System.out.println(last);
        System.out.println("-------------------------");
        /*E removeFirst ()
        移除并返回此列表的第一个元素。*/
        Object o = linkedList.removeFirst();
        System.out.println(o);
        System.out.println(linkedList);
        /*E removeLast ()
        移除并返回此列表的最后一个元素。*/
        Object o1 = linkedList.removeLast();
        System.out.println(o1);
        System.out.println(linkedList);
    }
}

（7）poll()：获取并移除此列表的头（第一个元素）
（8）pollFirst()：获取并移除此列表的第一个元素，如果此列表为空，则返回null
（9）pollLast()：获取并移除此列表的最后一个元素，如果此列表为空，则返回null

import java.util.LinkedList;

public class Mytest2 {
    public static void main(String[] args) {
        /*E poll ()
        获取并移除此列表的头（第一个元素）
        E pollFirst ()
        获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
        E pollLast ()
        获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。*/
        LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.add(200);
        linkedList.add(300);
        linkedList.add(400);
        linkedList.add(500);
        linkedList.add(600);
        Object poll = linkedList.poll();
        System.out.println(poll);
        System.out.println(linkedList);
        System.out.println("-----------------------");
        Object poll2 = linkedList.poll();
        System.out.println(poll2);
        System.out.println(linkedList);
        System.out.println("-----------------------");
        Object poll3 = linkedList.poll();
        System.out.println(poll3);
        System.out.println(linkedList);
        System.out.println("-----------------------");
        Object poll4 = linkedList.poll();
        System.out.println(poll4);
        System.out.println(linkedList);
        System.out.println("-----------------------");
        Object o = linkedList.pollFirst();
        System.out.println(o);
        System.out.println(linkedList);
        System.out.println("-----------------------");
        Object o1 = linkedList.pollLast();
        System.out.println(o1);
        System.out.println(linkedList);
    }
}

（10）pop()：从此列表所表示的堆栈处弹出第一个元素
（11）push()：将元素推入此列表所表示的堆栈

import java.util.LinkedList;

public class Mytest3 {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.add(200);
        linkedList.add(300);
        linkedList.add(400);
        linkedList.add(500);
        linkedList.add(600);
        //pop(),从此列表所表示的堆栈处弹出第一个元素
        Object pop = linkedList.pop();
        System.out.println(pop);
        System.out.println(linkedList);
        System.out.println("-------------------");
        pop = linkedList.pop();
        System.out.println(pop);
        System.out.println(linkedList);
        System.out.println("-------------------");
        //push(),将元素推入此列表所表示的堆栈
        linkedList.push(700);
        linkedList.push(800);
        System.out.println(linkedList);
    }
}

LinkedList集合框架练习题

public class Mytest2 {
    public static void main(String[] args) {
        /*A:
        案例演示:
        需求：请用LinkedList模拟栈数据结构的集合，并测试
        先进的后出，后进的先出*/
        MyList myList = new MyList();
        myList.addEle(100);
        myList.addEle(200);
        myList.addEle(300);
        myList.addEle(400);
        myList.addEle(500);
        Object ele = myList.getEle();
        System.out.println(ele);
        System.out.println("------------------");
        ele = myList.getEle();
        System.out.println(ele);
        System.out.println("------------------");
        ele = myList.getEle();
        System.out.println(ele);
        System.out.println("------------------");
        ele = myList.getEle();
        System.out.println(ele);
        System.out.println("------------------");
        ele = myList.getEle();
        System.out.println(ele);
        System.out.println("------------------");
    }
}
----------------------------------------
import java.util.LinkedList;

public class MyList {
    private final LinkedList linkedList;
    public MyList(){
        //创建linkedList
        linkedList = new LinkedList();
    }
    //1.添加元素的方法
    public void addEle(Object obj) {
        //调用linkedlist里面的方法，来添加元素。
        linkedList.addFirst(obj);
    }
    //2.取出元素的方法
    public Object getEle() {
        //把元素取出来
        Object pop = linkedList.pop();
        //再把元素加回去
        linkedList.addLast(pop);
        return pop;
    }
}

ArrayList集合框架练习题

import java.util.ArrayList;

public class Mytest2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("小红",23));
        list.add(new Student("小绿",24));
        list.add(new Student("小蓝",25));
        list.add(new Student("小紫",26));
        list.add(new Student("小清",27));
        list.add(new Student("小红",23));
        list.add(new Student("小绿",24));
        list.add(new Student("小蓝",25));
        list.add(new Student("小紫",26));
        list.add(new Student("小清",27));
        for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            Student student= (Student) obj;
            System.out.println(student);
        }
        System.out.println("------------------------");
        //去除重复元素
        ArrayList newList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            Student student= (Student) obj;
            //这里的contains内部采用的是equals方法，因此我们必须重写equals方法
            if(!newList.contains(student)){
                newList.add(student);
            }
        }
        for (int i = 0; i < newList.size(); i++) {
            Object obj = newList.get(i);
            Student student= (Student) obj;
            System.out.println(student);
        }
    }
}
---------------------------------------
import java.util.Objects;

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

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

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

练习题：

去除集合中的重复元素：要求两种方法：（1）不能创建新的容器，就在本容器中做
​ （2）创建一个新的容器

public class Mytest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(200);
        list.add(2);
        list.add(20);
        list.add(20);
        list.add(300);
        list.add(350);
        list.add(200);
        list.add(2);
        list.add(20);
        list.add(20);
        list.add(300);
        list.add(350);
        list.add(200);
        list.add(2);
        list.add(20);
        list.add(20);
        list.add(300);
        list.add(350);
        //去除集合中的重复元素，要求，不能重建新的容器来做，就在本容器中操作
        //采用选择排序法的思想：用第一个元素和后面的元素进行对比。
        for (int i = 0; i < list.size()-1; i++) {
            for (int j = i+1; j < list.size(); j++) {
                if(list.get(i).equals(list.get(j))){
                    list.remove(j);
                    //原来的1位置上的元素去除以后，下一个位置上就变成了1位置。
                    //但是咱们这时候有一个j++，j就从1变成了2.把此时的1位置就跳过了。直接到了2位置。
                    //就是这个j必须得和i是连着的。不能是中间跨了一个数。跨了一个数就把一个元素丢了
                    j--;//j必须--
                }
            }
        }
    }
}

import java.util.ArrayList;

public class Mytest {
    public static void main(String[] args) {
        /* A:
        案例演示
        需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
        思路：创建新集合方式*/
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        System.out.println(list);
        //思路：创建一个新集合
        ArrayList newList = new ArrayList();
        //遍历旧集合
        for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            //将旧集合中的元素取出来，放到新集合中，如果新集合中不包含这个元素，再往集合中加。
            if (!newList.contains(obj)){
                newList.add(obj);
            }
        }
        System.out.println(newList);
    }
}