Java学习记录Day6

1、 Collection中的常用方法

boolean add(E e); //向集合中添加元素
boolean contains(Object o); //判断是否包含指定对象
boolean remove(Object o); //从集合中删除对象
void clear(); //清空集合
int size(); //返回包含对象的个数
boolean isEmpty(); //判断是否为空
Object[] toArray(); //将集合转换成数组
Iterator<E> iterator(); //遍历集合中的元素
----boolean hasNext(); //如果仍有元素可以迭代，则返回true
----E next(); //返回迭代的下一个元素

2、List集合

java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序。该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类。

ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。

LinkedList类的底层是采用双向链表进行数据管理的，访问不方便，增删元素方便。

Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的数据结构，叫做栈(last in first out LIFO)。

Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的类，效率比较低。

注意：如果需要线程安全的List集合时，Collections.synchronizedList(List<T> list)或者CopyOnWriteArrayList<E>

常用方法：

void add(int index, E element);
boolean addAll(int index, Collection<? extends> c);
E get(int index); //从集合中获取指定位置元素
E set(int index, E element);
E remove(int index);
List<E> subList(int fromIndex, int toIndex); //获取子List，前闭后开

注意：subList获取的List与原List占有相同的存储空间，对子List的操作会影响到原List。

3、Queue集合

java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO)，该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势。

常用方法：

boolean add(E e); //将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功是返回true，如果当前没有可用的空间，则抛出IllegalStackException.
~boolean offer(E e); //将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于add(E)，后者可能无法插入元素，而只是抛出一个异常。
E element(); //获取，但不移除此队列的头
~E peek(); //获取，但不移除此队列的头，如果此队列为空，则返回null
~E poll(); //获取，且移除此队列的头，如果此队列为空，则返回null
E remove(); //获取，且移除此队列的头

4、Stack集合

Stack类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。

5、代码测试

package com.java;

import org.junit.Test;

import java.util.*;

public class CollectionTest {

    /**
     * Collection常用的方法测试
     */
    @Test
    public void collectionTest() {

        Collection collection = new ArrayList();
        System.out.println(collection); //[]
        //向集合中添加元素，该方法的形参要求是Object类型
        //toString的输出格式是[1, 2, 3]
        boolean b = collection.add("one");
        System.out.println(b); //true
        System.out.println(collection); //[one]
        collection.add(2); //[one, 2]
        collection.add('a'); //[one, 2, a]
        collection.add(3.14);
        collection.add("JJ Lin"); //[one, 2, a, 3.14, JJ Lin]
        System.out.println(collection);
        System.out.println("-----------------------------");
        //判断是否包含对象
        b = collection.contains("two");
        System.out.println(b); //false
        b = collection.contains("one");
        System.out.println(b); //true
        //判断是否为空
        b = collection.isEmpty();
        System.out.println(b); //false
        System.out.println("-----------------------------");
        b = collection.remove("one");
        System.out.println(b);
        System.out.println(collection);
        System.out.println("------------------------------");
        //集合-->数组
        Object[] objects = collection.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        //数组-->集合
        List objects1 = Arrays.asList(objects);
        System.out.println(objects1);
        System.out.println("------------------------------");
        //迭代器遍历集合中的元素_方式1
        Iterator iter = objects1.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }
        System.out.println("-----------------------------");
        //迭代器遍历集合中的元素_方式2
        for (Object o : objects1) {
            System.out.println(o);
        }
    }

    /**
     * List集合常用的方法
     */
    @Test
    public void listTest() {
        List list = new ArrayList();
        int size = list.size();
        System.out.println(size); //0
        System.out.println(list); //[]
        //向集合中添加元素
        list.add(0, "haha");
        list.add(1, "one");
        list.add(2, 2);
        list.add(3, 'a');
        list.add(4, 3.14);
        System.out.println(list); //[haha, one, 2, a, 3.14]
        List list1 = new ArrayList();
        list1.add("two");
        list1.add(10);
        list1.addAll(list);
        System.out.println(list1); //[two, 10, haha, one, 2, a, 3.14]
        System.out.println("-------------------------------");
        //根据下标查询集合中指定位置的元素
        Object o = list.get(3);
        System.out.println(o);
        //根据下标修改集合中指导位置的元素
        o = list.set(0, 1);
        System.out.println("被修改的元素为：" + o);
        System.out.println(list); //[1, one, 2, a, 3.14]
        //根据下标删除集合指定位置的元素
        o = list.remove(0);
        System.out.println("删除的元素为：" + o); //删除的元素为：1
        System.out.println(list); //[one, 2, a, 3.14]
        System.out.println("-----------------------");
        //subList获取的List与原List占有相同的存储空间，对子List的操作会影响到原List
        List list2 = list.subList(0, 3);
        System.out.println("list集合：" + list); //list集合：[one, 2, a, 3.14]
        System.out.println("子集合元素：" + list2); //子集合元素：[one, 2, a]
        list2.remove(0);
        System.out.println("子集合修改后list集合为：" + list); //子集合修改后list集合为：[2, a, 3.14]
        System.out.println("子集合修改后为：" + list2); //子集合修改后为：[2, a]
    }

    @Test
    public void collectionTest02() {
        Collection<String> collection = new ArrayList<>();
        collection.add("aa");
        collection.add("bb");
        collection.add("cc");
        System.out.println(collection);
    }

    @Test
    public void QueueTest() {
        //准备一个Queue集合
        Queue<Integer> queue = new LinkedList<>();
        //将数据11、22、33、44、55依次入队并打印
        // boolean offer(E e)--将指定元素插入此队列，优于 boolean add(E e)
        for (int i = 1; i <= 5; i++) {
            queue.offer(i * 11);
            System.out.println(queue);
        }
        //查看队首元素并打印
        // E peek()--获取但不移除此队列的头，若队列为空，则返回null
        // E element()--获取但不移除此队列的头
        Integer it = queue.peek();
        System.out.println("队首元素：" + it); //11
        //将队列中所有数据一次出队并打印
        // E poll()--获取并移除此队列的头，若队列为空，则返回null
        int len = queue.size();
        for (int i = 1; i <= len; i++) {
            Integer it1 = queue.poll();
            System.out.println(it1);
        }
    }

    @Test
    public void stackTest() {
        //实现将11、22、33、44、55依次入栈并打印
        Stack<Integer> stack = new Stack<>();
        for (int i = 1; i <= 5; i++) {
            stack.push(i * 11);
            System.out.println(stack);
        }
        //查看栈顶元素并打印
        // E peek()--查看堆栈顶部的对象，但不从堆栈中移除它
        Integer it = stack.peek();
        System.out.println("栈顶元素为：" + it);
        //然后依次出栈并打印
        int len = stack.size();
        for (int i = 1; i <= len; i++) {
            Integer it1 = stack.pop();
            System.out.println("出栈元素是：" + it1);
        }
    }
}