Collectio集合，List《ArrayList,LinkedList》

集合:

Collection类

package com.collection.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

/**
 * 数组： 存储同一类型的元素组成集合，固定长度，数组中元素可以是基本数据，也可以是对象。
 * 集合: 存储不同类型对象的容器， 长度可变，集合中的元素必须是Object的子类，不能是基本数据类型。
 * 首字母大写都是对象
 * @author Administrator
 *
 */
public class CollectionDemo {
    /**
     *     boolean add(E o);
        boolean remove(Object o);
        int size();
        boolean contains(Object o);
        boolean isEmpty();
        void clear();
        Iterator<E> iterator();
        boolean addAll(Collection c);
        boolean retainAll(Collection c);
         boolean removeAll(Collection c);
     */

    public static void main(String[] args) {
        // 创建Collection对象
        Collection collection = new ArrayList();
        collection.add("AAA");
        collection.add(new Object());
        collection.add(1.0); // 自动装箱 new Integer(1); // 实体尽量使用包装类
        collection.add("AAA");
        System.out.println(collection); // 有一个学生

        // 获取集合元素个数
        System.out.println(collection.size());

        // 判断是否存在某个对象
        String obj = "AAA";
        boolean flag = collection.contains(obj);
        System.out.println(flag?"存在":"不存在");
        // 移除某个对象， 首次查找的对象会被移除
        flag =  collection.remove(obj);
        System.out.println(flag?"移除成功":"移除失败");

        // 遍历合中的元素
        Iterator it = collection.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println("\r\n");

        // 清空集合中的元素
        // collection.clear();
        // collection = null;

        // 判断集合是否为空，没有关心对象的本身是null
        // isEmpty() 判断size==0
        System.out.println(collection.isEmpty()?"为空":"不为空");

        // Arrays 数组操作的工具类，asList 把一个数组转换为一个集合

        // 批量添加一个集合到一个集合中
        Collection cl = Arrays.asList("BBB","CCC","DDD");
        collection.addAll(cl); // 添加的集合中每一个元素
        collection.add(cl); // 添加的是一个对象
        System.out.println(collection);

        // 批量移除
        Collection cl1 = Arrays.asList(new Double(1),"AAA","BBB");
        collection.removeAll(cl1);
        System.out.println(collection);

        // 获取2个集合之间交集
        collection.retainAll(Arrays.asList("CCC","DDD"));
        System.out.println(collection);
    }

}

List:

package com.collection.demo.list;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * List接口:
 * 特点： 元素是有序，可以包含重复元素,基于数组实现
 * @author Administrator
 *
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        List list = new ArrayList(2);
        // 添加元素
        list.add("AAA"); // 添加单个元素
        list.add("BBB"); // 添加单个元素
        list.add("CCC"); // 添加单个元素
        list.add(1, "BVV"); //插入单个元素
        // 批量添加集合
        list.addAll(Arrays.asList(1,1.1D,1.1F));
        // 批量插入集合
        list.addAll(3, Arrays.asList("VVC","BVC"));

        // 删除元素
        list.remove(0); // 通过对象的下标移除
        list.remove(new Integer(1)); // 根据对象移除
        list.removeAll(Arrays.asList("BBB","CCC")); // 批量移除

        System.out.println(list);
        // 判断元素对象是否存在
        boolean flag = list.contains("VVC");
        System.out.println(flag ? "存在":"不存在");

        // 批量判断是否存在
        flag = list.containsAll(Arrays.asList("VVC",1.1));
        System.out.println(flag ? "存在":"不存在");

        // 判断集合元素个数否为0
        System.out.println(list.isEmpty());

        // 获取单个指定下标元素
        System.out.println(list.get(3));

        // 遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println("\r\n");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next()+" ");
        }

        System.out.println("\r\n");
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.print(listIterator.next()+" ");
        }
        System.out.println("\r\n");
        System.out.println("====================");
        // 反向迭代。必须把游标移动到末尾
        ListIterator listIterator1 = list.listIterator(list.size());
        while (listIterator1.hasPrevious()) {
            System.out.print(listIterator1.previous()+" ");
        }
        System.out.println("\r\n");
        System.out.println("---------------------");
        // 增强for循环
        for (Object obj : list) {
            System.out.print(obj+" ");
        }

        // 查询 -> 下标
        // 查找 -> 下标

    }
}

package com.collection.demo.list;

import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

public class LinkedListDemo {
    public static void main(String[] args) {
        List list = new LinkedList();
        // 添加元素
        list.add("AAA"); // 添加单个元素
        list.add("BBB"); // 添加单个元素
        list.add("CCC"); // 添加单个元素
        list.add(1, "BVV"); // 插入单个元素
        // 批量添加集合
        list.addAll(Arrays.asList(1, 1.1D, 1.1F));
        // 批量插入集合
        list.addAll(3, Arrays.asList("VVC", "BVC"));

        // 删除元素
        list.remove(0); // 通过对象的下标移除
        list.remove(new Integer(1)); // 根据对象移除
        list.removeAll(Arrays.asList("BBB", "CCC")); // 批量移除

        System.out.println(list);
        // 判断元素对象是否存在
        boolean flag = list.contains("VVC");
        System.out.println(flag ? "存在" : "不存在");

        // 批量判断是否存在
        flag = list.containsAll(Arrays.asList("VVC", 1.1));
        System.out.println(flag ? "存在" : "不存在");

        // 判断集合元素个数否为0
        System.out.println(list.isEmpty());

        // 获取单个指定下标元素
        System.out.println(list.get(3));

        // 遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println("\r\n");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }

        System.out.println("\r\n");
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.print(listIterator.next() + " ");
        }
        System.out.println("\r\n");
        System.out.println("====================");
        // 反向迭代。必须把游标移动到末尾
        ListIterator listIterator1 = list.listIterator(list.size());
        while (listIterator1.hasPrevious()) {
            System.out.print(listIterator1.previous() + " ");
        }
        System.out.println("\r\n");
        System.out.println("---------------------");
        // 增强for循环
        for (Object obj : list) {
            System.out.print(obj + " ");
        }

        // 删除
        // 插入
    }

}

栈

package com.demo;

import java.util.Stack;

public class StackDemo {
    public static void main(String[] args) {
        // 先进后出来
        Stack stack = new Stack();

        // 压栈
        stack.push("AAAA");
        stack.push("BBBB");
        stack.push("CCCC");
        stack.push("DDDD");
        // 弹栈(从栈中移除该元素)
        System.out.println(stack.pop());
        // 获取栈顶元素(获取栈上面最先出来的元素)
        System.out.println(stack.peek());
        //
        System.out.println(stack);
    }
}

队列

package com.demo;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 队列结果
 * @author Administrator
 *
 */
public class QueueDemo {
    public static void main(String[] args) {
        // 先进先出
        Queue queue = new LinkedList();
        // 入列
        queue.offer("AAAA");
        queue.offer("BBBB");
        queue.offer("CCCC");
        queue.offer("DDDD");
        // 出列
        System.out.println(queue.poll());
        // 获取列头
        System.out.println(queue.peek());

        System.out.println(queue);
    }
}

模拟队列,栈

package com.demo;

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        // 模拟栈
        // 压栈
        linkedList.addFirst("AAAA");
        linkedList.addFirst("BBBB");
        linkedList.addFirst("CCCC");
        linkedList.addFirst("DDDD");
        // 弹栈
        System.out.println(linkedList.removeFirst());
        // 获取栈顶元素
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList);

        System.out.println("-------------------------------");
        LinkedList linkedList1 = new LinkedList();
        // 模拟栈
        // 压栈
        linkedList1.addLast("AAAA");
        linkedList1.addLast("BBBB");
        linkedList1.addLast("CCCC");
        linkedList1.addLast("DDDD");
        // 弹栈
        System.out.println(linkedList1.removeFirst());
        // 获取队列头元素
        System.out.println(linkedList1.getFirst());
        System.out.println(linkedList1);
    }
}