Java集合详情（Collection、List、Set）

一：Iterable 接口（collection接口继承）

1：Iterable 是一个超级接口 被collection所继承，它只有一个方法：Iterator<T> iterator();      //返回一个迭代器。

2：迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象。迭代器被称为‘轻量级’对象，因为创建代价小。

3：Java中的Iterator功能比较简单，并且只能单向移动：
　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
　　(2) 使用next()获得序列中的下一个元素。
　　(3) 使用hasNext()检查序列中是否还有元素。
　　(4) 使用remove()将迭代器新返回的元素删除。

4：Iterator是Java迭代器最简单的实现。像遍历集合就是迭代器的使用。

二：java中容器关系

 三：java容器详解

 1、Collection接口

 2、List接口

1.List是有序的，用户可以根据元素的索引访问元素；

2.List可以存储重复的数据；（可以根据元素索引查询）

3.List接口提供了特殊的迭代器——ListIterater，同时还允许Iterater接口提供正常操作外，ListIterater 还允许元素的插入和替换，以及双向访问。

4.List的实现类— —ArrayList、LinkedList、Vector

 1.ArrayList

特点：

1. 存在java.util包中；
2. 允许存放重复的元素；
3. 内部是用数组结构存放数据,封装数组的操作,每个对象都有下标；
4. 内部数组默认的初始容量是10,如果不够会以1.5倍的容量增长；
5. 查询快,增删数据效率会低；（当从ArrayList中间位置插入或删除元素时，需要对数组复制、移动、代价比较高，因此它适合随机查找和遍历，不适合插入和删除）
6. 线程不安全；

List的四种迭代方式：

package cn.tedu.collection;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**本类用于进一步测试List接口*/
public class TestList2 {
    public static void main(String[] args) {
        //1.创建List接口的多态对象
        List<String> list = new ArrayList<>();
        //2.向创建好list集合添加元素
        list.add("喜羊羊");
        list.add("美羊羊");
        list.add("懒羊羊");
        list.add("沸羊羊");
        list.add("小肥羊");
        list.add("肥羊卷");
        System.out.println(list);

        //3.测试集合的迭代
        /**集合的迭代方式：
         * 1.for循环
         * 2.高效for循环
         * 3.iterator
         * 4.listIterator
         * */
        //方式一：因为List集合是有序的，元素有下标的，所以可以根据下标进行遍历
        //从哪开始：0  到哪结束：list.size()-1  如何变化++
        for(int i = 0;i<list.size();i++){
            //根据本轮循环遍历到的索引值获取对应的集合元素
            System.out.println(list.get(i));
        }
        System.out.println("************方式一*************");

        //方式二：因为普通for循环遍历效率低，语法复杂，所以使用高效for来遍历
        //格式for(本轮遍历到的元素类型 元素名 ：要遍历的内容名){循环体}
        for( String s : list){
            System.out.println(s);
        }
        System.out.println("************方式二*************");

        //方式三：从父接口中继承过来的迭代器iterator
        //1.获取对应的迭代器对象
        Iterator<String> it = list.iterator();
        //2.通过刚刚获取到的迭代器循环迭代集合中的所有元素
        while(it.hasNext()){//判断是否仍有下一个元素可以迭代
            System.out.println(it.next());//打印当前获取到的元素
        }
        System.out.println("************方式三*************");
        /**方式四：listIterator属于List接口特有的迭代器
         * Iterator<E>--父接口--hasNext() next()
         * ListIterator<E>--子接口--除了父接口的功能以外
         * 还有自己的特有功能，比如逆序遍历，添加元素等等，但是不常用
         * public interface ListIterator<E>extends Iterator<E>
         * */
        ListIterator<String> it2 = list.listIterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
        System.out.println(list);
        System.out.println("listIterator的逆序遍历：");
        ListIterator<String> it3 = list.listIterator();
        while(it3.hasNext()){//判断是否有下一个元素可迭代
            System.out.println(it3.next());//打印当前迭代到的元素
            if(!it3.hasNext()){//直到迭代器没有下一个元素可迭代--到最后了
                System.out.println("开始逆序迭代：");
                while (it3.hasPrevious()){//判断是否有上一个元素可迭代
                    System.out.println(it3.previous());//打印获取到的上一个元素
                }
               break;//终止循环，不然会一直从头到尾，再从尾到头迭代
            }
        }
    }
}

2.LinkedList

特点：

1. 存在java.util包中；
2. 允许存放重复的元素；
3. 底层维护的是链表的结构.(LinkedList底层通过双向链表实现，双向链表的每个节点用内部类Node表示。LinkedList通过first和last引用分别指向链表的第一个和最后一个元素。当链表为空的时候first和last都指向null)
4. 线程不安全；
5. 是用双向链表结构存储数据的（线性的存储方式），很适合动态数据的添加和删除。随机访问和遍历速度比较慢。
6. 实现Deque接口，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

 常用方法：

void addFirst(E e) 将指定元素插入此列表的开头
void addLast(E e) 将指定元素添加到此列表的结尾
E getFirst() 返回此列表的第一个元素
E getLast() 返回此列表的最后一个元素
E removeFirst()移除并返回此列表的第一个元素
E removeLast() 移除并返回此列表的最后一个元素
E element() 获取但不移除此列表的头（第一个元素）
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

LinkedList测试

package cn.tedu.colletion;

import java.util.LinkedList;

/**本类用于测试LinkedList的相关测试*/
public class TestLinkedList {
	public static void main(String[] args) {
		//1.创建对象
		LinkedList<String> list = new LinkedList();
		//2.添加数据
		list.add("孙悟空");
		list.add("猪八戒");
		list.add("唐三藏");
		list.add("沙师弟");
		list.add("白龙马");
		System.out.println(list);
		
		//3.1自行测试从collection继承过来的共性方法测试
		
		//3.2 LinkedList特有方法测试
		list.addFirst("蜘蛛精");//添加首元素
		list.addLast("玉兔精");//添加尾元素
		System.out.println(list);
		
		System.out.println(list.getFirst());//获取首元素
		System.out.println(list.getLast());//获取尾元素
		
		System.out.println(list.removeFirst());//移除首元素,成功移除会返回移除的数据
		System.out.println(list);
		System.out.println(list.removeLast());//移除尾元素,成功移除会返回移除的数据
		System.out.println(list);
		
		//4.其他测试
		//4.1创建对象
		LinkedList<String> list2 = new LinkedList();
		//4.2添加数据
		list2.add("水浒传");
		list2.add("三国演义");
		list2.add("西游记");
		list2.add("红楼梦");
		System.out.println(list2);
		System.out.println(list2.element());//获取但不移除此列表的首元素(第一个元素)
		/**别名:查询系列*/
		System.out.println(list2.peek());//获取但不移除此列表的首元素(第一个元素)
		System.out.println(list2.peekFirst());//获取但不移除此列表的首元素(第一个元素)
		System.out.println(list2.peekLast());//获取但不移除此列表的尾元素(最后一个元素)
		
		/**别名:新增系列*/
		System.out.println(list2.offer("遮天"));//将指定元素添加到列表末尾
		System.out.println(list2.offerFirst("斗罗大陆"));//将指定元素插入列表开头
		System.out.println(list2.offerLast("斗破苍穹"));//将指定元素插入列表末尾
		System.out.println(list2);
		
		/**别名:移除系列*/
		System.out.println(list2.poll());//获取并且移除此列表的首元素(第一个元素),成功移除,返回移除元素
		System.out.println(list2.pollFirst());//获取并且移除此列表的首元素(第一个元素),成功移除,返回移除元素,如果此列表为空,则返回null
		System.out.println(list2.pollLast());//获取并且移除此列表的尾元素(最后一个元素),成功移除,返回移除元素,如果此列表为空,则返回null
		System.out.println(list2);
	}
}

3.Vector

1.也是通过数组实现，它支持线程的同步，线程安全，即某一个时刻只能有一个线程能够写Vector，避免多线程同时写入而引起的不一致性。

2.实现同步需要花费很高的代价， 因此，访问它比访问ArrayList慢。所以，现在已不常用。

3.Stack 类，Stock 是Vector 提供的一个子类，用于模拟 “栈” 这种数据结构（LIFO后进先出）

3、Set接口

1.Set接口继承了Collection接口，同样可以使用 Iterator 的迭代方式；

2.Set集合中的数据是无序的，且数据不可重复---（常用来给数据去重）；

3.Set 判断两个对象相同不是使用 == 运算符，而是用 equals方法；

1.HashSet集合

1.Set的实现类；底层是哈希表,包装了HashMap,相当于向HashSet中存入数据时,会把数据作为K存入内部的HashMap中,其中K不允许重复,允许使用null；

2.HashSet 使用HASH算法来存储集合中的元素，因此具有良好存储和查找性能。

2.TreeSet集合

1.可以对Set集合中的元素进行排序。是不同步i的；

2.判断元素唯一性的方式：根据比较方法的返回值来判断。是0（零）就存入集合，不是0就不存。因为Set集合是不能有重复的元素，无序；