Collection简述及List下的（LinkedList和ArrayList）_30

概述

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

集合的继承结构图

• Collection接口
  • List 接口: // 数据有序,可以重复
    • Arraylist 子类 :
    • LinkedList 子类:
  • Set 接口: // 数据无序,不可以存在重复值
    • HashSet子类
    • TreeSet 子类

集合Collection

下面包含了集合的简单用法,以及集合遍历和迭代

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

public class 集合collection {
    public static void main(String[] args) {
        Collection<String> s = new ArrayList<>();
        Collection<String> x = new ArrayList<>();
        s.add("ok");
        s.add("kebi");
        x.add("ok");
        x.add("dulante");

        for (String c:s){           //遍历集合s
            System.out.println(c);
        }

        //System.out.println(s.remove("ok")); //移除元素ok
        //boolean t = s.contains("ok");   //判断包含是否包含元素ok,返回布尔值的类型
        //int tt = s.size();              //返回集合的长度
        //s.addAll(x);                //将集合x的所有的元素添加到s中
        //System.out.println(s.containsAll(x));  //判断s中是否包含x的所有的元素
        //s.removeAll(x);                     //去除s中包含x的所有的元素
        //s.retainAll(x);                     //获得s与x的交集

        System.out.println(s.toString());

        //集合的迭代
        Iterator <String> it =s.iterator();//--Iterator是一个接口,专门用来迭代集合里的元素
        while (it.hasNext()){               //hasNext() 判断集合里是否有元素
            System.out.println(it.next());  //next()获取集合当前的元素
        }
    }

}

List 接口

概述

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与set 不同，列表通常允许重复的元素。如果列表本身允许 null 元素的话，通常它们允许多个 null 元素.。

特点

• 数据有序
• 允许存放重复的元素
• 元素有索引
• 可以存储多个null

测试常用方法

    private static void list() {
        List<Integer> list =new ArrayList<>();
        //继承 collection的方法 add()
        list.add(3);
        list.add(2);
        list.add(1);
        list.add(null);

        list.add(1,100);     // 往指定的下标处插入指定的元素
        System.out.println(list.get(1));    //获得指定下标处的元素
        System.out.println(list.lastIndexOf(1)); //获取元素1最后一次出现的位置索引值
        System.out.println(list.remove(1));   //去除位置索引值为1的元素
        System.out.println(list.set(1,100));        //将索引值为1的设置为100
        System.out.println(list.subList(1,3));      //截取下标[1,3)内的元素---含头不含尾
        System.out.println(list.toString());
        //迭代List集合方式一:按集合的顺序迭代
        Iterator<Integer> it = list.listIterator(); //创建迭代的对象
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //顺序迭代的第二种
//        for(Integer i:list){
//            System.out.println(i);
//        }
        // 顺序迭代的第三种
//        ListIterator<Integer> it2 =list.listIterator();
//        while (it2.hasNext()){
//            System.out.println(it2.next());
//        }

        //迭代List集合方式二:按集合的逆序迭代
        for (int i=list.size()-1;i>=0;i--){  //list.size 获取集合的个数
            System.out.println(list.get(i));    //list.get(i) 或许下标为i的集合元素
        }
    }

执行结果:

Arraylist 实现类

概述:

ArrayList是List接口的实现类,可以使用List的功能也可以使用Collection的功能

特点:

• 存在于java.util包中
• 内部用数组存放数据，封装了数组的操作，每个对象都有下标。
• 查询快，增删数据效率会降低
• 底层是一个数组的结构初始容量值为10,当容量不够时以1.5倍速扩大
  • List接口的大小可变数组的实现。每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。

测试:

方法同上面的Collection和List一致

LinkedList实现类

概述:

双向链表,两端效率高。底层就是数组和链表实现的。

特点:

• 底层维护了一个链表结构.空间不连续.也就造成查询业务效率低.
• 链表结构适用于新增或者删除业务.
• 链表上有两个高效节点:首元素和尾元素

特有方法:

	void addFirst(E e) 
      		将指定元素插入此列表的开头。 
	 void addLast(E e) 
	          将指定元素添加到此列表的结尾。 
	 E getFirst() 
	          返回此列表的第一个元素。 
	 E getLast() 
	          返回此列表的最后一个元素。 
	 E removeFirst() 
	          移除并返回此列表的第一个元素 
	 E removeLast() 
	          移除并返回此列表的最后一个元素。           
	boolean offer(E e) 
	          修改列表中的最后一个元素。 
	 boolean offerFirst(E e) 
	          。 
	 boolean offerLast(E e) 
	          在此列表末尾插入指定的元素。 
	 E peek() 
	          获取但不移除此列表的头（第一个元素）。 
	 E peekFirst() 
	          获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 
	 E peekLast() 
	          获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。 
	 E poll() 
	          获取并移除此列表的头（第一个元素） 
	 E pollFirst() 
	          获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 
	 E pollLast() 
	          获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 
	 E pop() 
	          从此列表所表示的堆栈处弹出一个元素。 

测试LinkedList的特有方法:(对收尾元素的操作)

private static void linkList() {
        LinkedList<Integer> linkedList =new LinkedList<>();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(99);
        linkedList.addFirst(100);       //addFirst() addLast()在首尾位置添加元素
        System.out.println(linkedList.getFirst());      // getFirst() getLast() 返回首尾的元素
        linkedList.removeFirst();         //removeFirst() removeLast()去除首尾元素
        linkedList.offerLast(222);     //offer() 和 offerLast()都一样是修改列表中的最后一个元素 offerFirst()修改列表中的第一个元素
        System.out.println(linkedList.peek());  //peek() or peekFirst()获取列表的首元素 peekLast()获取列表的尾元素
        linkedList.poll();              //  poll() or pollFirst() 移除列表中的首元素  pollLast() 移除列表中的尾元素
        System.out.println(linkedList.toString());
        System.out.println(linkedList.pop());       

    }

执行的结果：

总结：

ArrayList相当于在没指定initialCapacity时就是会使用延迟分配对象数组空间，当第一次插入元素时才分配10（默认）个对象空间。假如有20个数据需要添加，那么会分别在第一次的时候，将ArrayList的容量变为10，之后扩容会按照1.5倍增长。也就是当添加第11个数据的时候，Arraylist继续扩容变为10*1.5=15(如下图二)；当添加第16个数据时，继续扩容变为15 * 1.5 =22个。