2020.8.5子类集合

01_ArraysList集合

说明：整个集合由接口Collection作为父类，Collection有两个子类分别是

接口List和接口Set

List有3个子类

ArrayList 底层数据结构是数组，查询快，增删慢，线程不安全，效率高
LinkedList底层数据结构是链表，查询慢，增删快 线程不安全 效率高
Vector 底层数据结构是数组，查询快，增删慢  线程安全 效率低

Set有3个子类

HashSet
TreeSet
LinkedHashSet

所以3个子类，同样继承了父类的所有方法。

01.1_ArrayList存储字符串并遍历

除了父类的方法ArrayList也有一个方法可以遍历（遍历数组，除了for循环、迭代器还有forEach）
void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 
Consumer
这是一个功能接口，因此可以作为赋值的目标一个lambda表达式或方法参考

普通for

//普通for
for (int i = 0; i < arrayList.size(); i++) {
    System.out.print(arrayList.get(i)+"\t");
}

迭代器

Iterator iterator = arrayList.iterator();
while (iterator.hasNext()) {
    Object obj = iterator.next();
    System.out.print(obj+"\t");
}

案例演示forEach

package ArrayListDemo01;

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

public class ArrayListTest01 {
    public static void main(String[] args) {
        // Collection  List  Set
        // List
        //  ArrayList 底层数据结构是数组，查询快，增删慢，线程不安全，效率高
        //  Vector  底层数据结构是数组，查询快，增删慢  线程安全 效率低
        //  LinkedList 底层数据结构是链表，查询慢，增删快 线程不安全 效率高
        //创建一个ArrayList集合
        ArrayList arrayList = new ArrayList();
        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(300);
        arrayList.add(400);
        //遍历数组，除了for循环、迭代器还有forEach
        /*  void forEach (Consumer < ? super E > action)
        执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。*/
        arrayList.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.print(o+"\t");//100 200    300    400
            }
        });
    }

}

02_Vector的特有功能

定义：Vector 类可以实现可增长的对象数组 , Vector 是同步的。

Vector类特有功能
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()

案例演示3个方法：

package VectorDemo01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Vector;

// Vector 类可以实现可增长的对象数组 , Vector 是同步的
public class VectorTest01 {
    public static void main(String[] args) {
    /*void addElement (E obj)
      添加指定的组件到这个向量的结束，增加其大小由一个。*/
        //创建一个ArrayList集合
        Vector vector = new Vector();
        vector.add(100);
        vector.add(200);
        vector.add(300);
        //添加元素到集合中
        vector.addElement(400);
        System.out.println(vector);
        // E elementAt(int index) 返回指定索引处的组件。
        System.out.println(vector.elementAt(2));//300
        //Enumeration<E> elements() 返回此向量的组件的枚举。
        System.out.println(vector.elements());//java.util.Vector$1@4554617c
        //迭代器
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            Object o = elements.nextElement();
            System.out.print(o+"\t");//100 200    300    400
        }
    }
}
E lastElement()
返回向量的最后一个组件。
boolean removeElement(Object obj)
从该向量中移除第一个（最低索引）发生的参数。
void removeElementAt(int index)
在指定的索引中删除组件。
void setElementAt(E obj, int index)
设置组件在指定的 index这个向量是指定的对象。

02.1_其他方法

案例演示

//E lastElement()
//返回向量的最后一个组件。
System.out.println(vector.lastElement());//400
//boolean removeElement(Object obj)
//从该向量中移除第一个（最低索引）发生的参数
System.out.println(vector.removeElement(100));//true
System.out.println(vector);//[200, 300, 400]
//void removeElementAt(int index)
//在指定的索引中删除组件。
vector.removeElementAt(2);
System.out.println(vector);//[200, 300]
//void setElementAt(E obj, int index)
//设置组件在指定的 index这个向量是指定的对象。
vector.setElementAt(300,0);
System.out.println(vector);//[300, 300]

03_LinkedList集合

03.1_定义

： List 接口的链接列表实现 , 此实现不是同步的

03.2_LinkedList类特有功能

public void addFirst(E e)及addLast(E e)
	public E getFirst()及getLast()
	public E removeFirst()及public E removeLast()

案例演示

package LinkedListDemo01;

import java.util.LinkedList;

public class LinkedListTest01 {
    public static void main(String[] args) {
        //创建LinkedList集合
        LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.add(200);
        linkedList.add(300);
        linkedList.add(400);
        // void addFirst(E e)在此列表的开始处插入指定的元素。
        linkedList.addFirst(50);
        //void addLast(E e)将指定的元素插入列表的结束。
        linkedList.addLast(500);
        System.out.println(linkedList);//[50, 100, 200, 300, 400, 500]
        //E getLast()返回此列表中的最后一个元素。
        System.out.println(linkedList.getLast());//500
        //E peek()检索，但不删除，此列表的头（第一个元素）。
        System.out.println(linkedList.peek());//50
        //E peekFirst()
        //检索，但不删除该列表的第一个元素，或返回 null如果这个列表是空的。
        System.out.println(linkedList.peekFirst());//50
        //E peekLast()
        //检索，但不删除该列表的最后一个元素，或返回 null如果这个列表是空的。
        System.out.println(linkedList.peekLast());//500
        //E poll()
        //检索并删除此列表的头（第一个元素）。
        linkedList.poll();
        System.out.println(linkedList);//[100, 200, 300, 400, 500]
        //E pollFirst()
        //检索并移除此列表的第一个元素，或返回 null如果这个列表是空的。
        //E pollLast()
        //检索并移除此列表的最后一个元素，或返回 null如果这个列表是空的。
        System.out.println("====================");
        //E pop()
        //从这个列表所表示的堆栈中弹出一个元素。
        System.out.println(linkedList.pop());//100
        //void push(E e)
        //将一个元素推到由该列表所表示的堆栈上。也就是说推到第一个
        linkedList.push(500);
        System.out.println(linkedList);//[500, 200, 300, 400, 500]
        //E removeLast()
        //移除并返回此列表中的最后一个元素。
        linkedList.removeLast();
        System.out.println(linkedList);//[500, 200, 300, 400]
        //E removeFirst()
        //移除并返回此列表中的第一个元素。
        linkedList.removeFirst();
        System.out.println(linkedList);//[200, 300, 400]

    }
}

案例演示：

package LinkedListDemo01;

import java.util.LinkedList;

public class LinkedListTest02 {
    public static void main(String[] args) {
         /*  A:
        案例演示:
        需求：请用LinkedList模拟栈数据结构的集合，并测试*/
        //栈的特点：先进的后出，后进的先出。
     /* //创建集合
        LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.add(200);
        linkedList.add(300);*/
        //要的结果是输出300 200 100
        //调用addFirst()方法
        //创建类的对象、
        MyLinkedList myLinkedList = new MyLinkedList();
        //添加元素
       myLinkedList.add(100);
        myLinkedList.add(200);
        myLinkedList.add(300);
        //调用方法

        Object obj = myLinkedList.get();
        System.out.println(obj);//300
        obj= myLinkedList.get();
        System.out.println(obj);//200
       obj = myLinkedList.get();
        System.out.println(obj);//100


    }
}
class MyLinkedList{
    //创建一个私有的变量
    private  LinkedList linkedList;
    //无参构造

    public MyLinkedList() {
        //创建对象
        linkedList = new LinkedList();
    }


    public void add(Object obj){
       linkedList.addFirst(obj);

    }
    public Object get(){
        //调用自身的addFirst
        Object first=linkedList.pop(); //从这个列表所表示的堆栈中弹出一个元素。
        linkedList.addLast(first);
        return first;
    }
}