关于容器（Collection）和迭代器（Iterator）

关于容器（Collection）

1.什么是容器

      容器，是用来容纳物体、管理物体。生活中,我们会用到各种各样的容器。如锅碗瓢盆、 箱子和包等。程序中的“容器”也有类似的功能，用来容纳和管理数据。

2.容器的结构

单例集合的话值的是单个值 双例集合指的是Key - Value

Collection接口继承了Iterator接口，实现了Iterator()方法，返回一个迭代器对象（先写这了）

        这个是接口继承和实现类的关系，可以看出单例容器其实是大同小异，同因为都是从Collection接口继承过来，所以该接口中的方法实现类都会实现，异是在继承的时候以及实现的时候自定义了别的方法。

3.Collection中的抽象方法

方法	说明
boolean add(Object element)	增加元素到容器中
boolean remove(Object element)	从容器中删除元素
boolean contains(Object element)	判断是否包含元素element
int size()	容器中元素的数量
boolean isEmpty()	判断容器是否为空
void clear()	清空容器
Iterator iterator()	获取迭代器对象
boolean containsAll(Collection c)	判断本容器是否包含容器c中所有元素
boolean addAll(Collection c)	把容器c中的所有元素添加到本容器(可重复)
boolean removeAll(Collection c)	移除本容器中和容器c都包含的元素
boolean retainAll(Collection c)	取本容器和容器 c 中都包含的元素，移除非交集元素
Object[] toArray()	转化成Object数组

JDK8 之后，Collection 接口新增的方法

方法	说明
removeIf	作用是删除容器中所有满足 filter 指定条件的元素
stream parallelStream	stream和parallelStream 分别返回该容器的Stream视图 表示，不同之处在于 parallelStream()返回并行的 Stream， Stream 是 Java 函数式编程的核心类。
spliterator	可分割的迭代器，不同以往的 iterator 需要顺序迭代， Spliterator 可以分割为若干个小的迭代器进行并行操作， 可以实现多线程操作提高效率

4.List接口

         有序：有序(元素存入集合的顺序和取出的顺序一致)。List 中每个元素都有索引标记。 可以根据元素的索引标记（在 List 中的位置）访问元素，从而精确控制这些元素。

         可重复：List 允许加入重复的元素。更确切地讲，List 通常允许满足 e1.equals(e2) 的 元素重复加入容器。

List 的常用方法

方法	说明
void add (int index, Object element)	在指定位置插入元素，以前元素全部后移一位
Object set (int index,Object element)	修改指定位置的元素
Object get (int index)	返回指定位置的元素
Object remove (int index)	删除指定位置的元素，后面元素全部前移一位
int indexOf (Object o)	返回第一个匹配元素的索引，如果没有该元素， 返回-1
int lastIndexOf (Object o)	返回最后一个匹配元素的索引，如果没有该元 素，返回-1

5.Array容器类

ArrayList 是 List 接口的实现类。是 List 存储特征的具体实现。 ArrayList 底层是用数组实现的存储。 特点：查询效率高，增删效率低，线程不安全。

方法就不细说了，具体方法的使用放在下面的代码中，都有测试，没有测就是不常用或者没有学。

import java.util.ArrayList;
import java.util.List;

public class ArrayListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        // 实现ArrayList中的两个add方法
        boolean flag = list.add("edg");// 这个方法是collection接口中的方法 add(String a) 有返回值是布尔类型
        list.add("fpx");
        list.add(1, "rng");//这个方法是子接口list接口定义的抽象方法
        //void 无返回值add(int index, String element)
        // 插入的索引不能大于元素的个数
        // 大于 报错  IndexOutOfBoundsException

        //实现ArrayList中的get,size方法 获得元素和 获得长度
        String s = list.get(0);
        System.out.println(s);
        //IndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index >= size() ）
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //实现ArrayList中的set方法 修改 指定位置的元素
        list.set(0, "tes");
        System.out.println(list.get(0));
        //实现ArrayList中的remove方法 删除元素
        //根据位置删除元素 返回被删除元素的值，并且后面的元素下标前移
        String remove = list.remove(0);
        System.out.println(remove);
        //删除指定元素（类型是Object）返回值是布尔 成功True 失败False
        boolean fpx = list.remove("fpx");
        System.out.println(fpx); // true
        //清空容器clear
        list.clear();
        // 判断容器是否为空 isEmpty
        boolean empty = list.isEmpty();
        System.out.println(empty);//true
        //判断容器中是否包含指定元素 contains
        list.add("ig");
        list.add("ug");
        list.add("ug");
        list.add("tg");
        boolean ig = list.contains("ig");
        System.out.println(ig);// true
        //查找元素的位置 不存在返回-1
        list.indexOf("ug");// 返回1 第一次出现的位置
        list.lastIndexOf("ug");// 返回2 最后一次出现的位置
        //单例集合转换为Object数组
        //不能强转为String[]类型数组 因为数组中每一个都是Object类型
//        String[] array = (String[])list.toArray();
        Object[] array = list.toArray();
        for (int i = 0; i < array.length; i++) {
            String o = (String) array[i];
            System.out.println(o);
        }
        System.out.println("-----------------------------");
        //单例集合转换泛型类型数组（常用）
        String[] strings = list.toArray(new String[list.size()]);
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        //集合合并，addAll 元素可以重复 (1+1=2) 注意：两个集合都不能为空
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        list1.add("a");
        list1.add("b");
        list2.add("c");
        list2.add("b");
/*        list1.addAll(list2);
        for (String t :
                list1) {
            System.out.println(t); // a b c b
        }*/
        //集合交集 retainAll
/*        list1.retainAll(list2);
        for (String t :
                list1) {
            System.out.println(t);// b
        }*/
        //集合差集 list.removeAll(list2) list中list2包含的元素会被移除
        list1.removeAll(list2);
        for (String t :
                list1) {
            System.out.println(t);// a
        }
    }
}

6.Stack容器（栈）

        Stack 栈容器，是 Vector 的一个子类，它实现了一个标准的后进先出(LIFO：Last In Frist Out) 的栈。

public class StackTest {
    public static void main(String[] args) {
        // 实例化对象
        Stack<String> stack = new Stack<>();

        // 将元素添加到栈中
        String edg = stack.push("edg");
        System.out.println(edg);
        stack.push("rng");

        //取元素 （弹栈）
        String pop = stack.pop();
        System.out.println(pop); // rng 后进先出

        // 判断栈容器是否为空
        boolean empty = stack.empty();
        System.out.println(empty);

        //查看栈顶元素
        String peek = stack.peek();
        System.out.println(peek);

        //返回元素在栈中的位置
        int edg1 = stack.search("edg");
        System.out.println(edg1); // 1 栈容器中查找元素位置初始是从栈顶开始，1 栈底最大

        // 判断元素的对称性
        StackTest stackTest = new StackTest();
        stackTest.FuHao();
    }
    public void FuHao(){
        String s = "...{.....[....(....)...]....}..(....)..[...]...";
        Stack<String> stack1 = new Stack<>();
        boolean flag = true;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '{'){
                stack1.push("}");
            }
            if (c == '['){
                stack1.push("]");
            }
            if (c == '('){
                stack1.push(")");
            }
            // 判断符号匹配
            if (c == ')' | c == ']' | c == '}'){
                if (stack1.empty()){
                    flag = false;
                    break;
                }
                char c1 = stack1.pop().charAt(0);
                if (c1 != c){
                    flag = false;
                    break;
                }
            }
        }
        if(!stack1.empty()){
            flag = false;
        }
        System.out.println(flag);
    }
}

7.Set接口

Set 特点：无序、不可重复。

无序指 Set 中的元素没有索引，我们只能遍历查找；

不可重复指不允许加入重复的元素。更确切地讲，新元素如果和 Set 中某个元素通过 equals() 方法对比为 true，则只能保留一个。 Set 常用的实现类有：HashSet、TreeSet 等，我们一般使用 HashSet。

和List大同小异，所以代码我就没有写，Map的话我也是稍微看了下，理解了单例集合，双例集合其实也就很好懂了，就跟数学一样，先搞清楚低维的（线性啊，平面）然后推广到高维。这个后面学期来再补充吧。。。时间紧张 = =

迭代器（Iterator）

1.Iterator 迭代器接口介绍

                Collection接口继承了Iterable接口，在该接口中包含一个名为iterator的抽象方法，所 有实现了Collection接口的容器类对该方法做了具体实现。iterator方法会返回一个Iterator 接口类型的迭代器对象，在该对象中包含了三个方法用于实现对单例容器的迭代处理。

方法	说明
boolean hasNext()	判断游标当前位置是否有元素,如果有返回true,否则返回false
Object next()	获取当前游标所在位置的元素,并将游标移动到下一个位置
void remove()	删除游标当前位置的元素，在执行完next后该操作只能执行一次

迭代器代码测试（迭代器是实现通用的，所以两个接口测试没什么区别）

基于List接口的代码测试

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

public class IteratorListTest {
    public static void main(String[] args) {
        //用ArrayList测试迭代器
        // 实例化对象
        List<String> list = new ArrayList<>();
        list.add("edg");
        list.add("rng");
        list.add("lng");
        //创建迭代器对象 因为Collection接口继承Iterator接口
        // 其中Iterator方法返回一个迭代器对象
        Iterator<String> iterator =list.iterator();
        //while 循环
        while (iterator.hasNext()){
            String value = iterator.next();
            System.out.println(value);
        }
        // for 循环
        // 注意： 这里for循环第一句重新获取了一个迭代器
        // 因为迭代器只能用一次 上面的while循环用完了 迭代器已经到头了
        // 再在for循环里用 是没有用的 iterator.hasNext();就是false 就停止了
        //for(;iterator.hasNext();) // 不创建新迭代器的写法，注意点是两个分号
        for(Iterator<String> iterator1 = list.iterator();iterator1.hasNext();){
             String value = iterator1.next();
            System.out.println(value);
        }
    }
}

基于Set接口代码的测试

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class IteratorSetTest {
    public static void main(String[] args) {
        //用HashSet测试迭代器
        // 实例化对象
        Set<String> set = new HashSet<>();
        set.add("edg");
        set.add("rng");
        set.add("lng");
        //创建迭代器对象 因为Collection接口继承Iterator接口
        // 其中Iterator方法返回一个迭代器对象
        Iterator<String> iterator =set.iterator();
        //while 循环
        while (iterator.hasNext()){
            String value = iterator.next();
            System.out.println(value);
        }
        // for 循环
        for(Iterator<String> iterator1 = set.iterator();iterator1.hasNext();){
            String value = iterator1.next();
            System.out.println(value);
        }
    }
}

在迭代器中删除元素

remove()方法，了解就行，尽量不要再迭代或者for遍历的时候去增加删除元素！！！

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

// 用迭代器删除元素 尽量不要用这种方法
public class IteratorRemoveTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        Iterator<String> it = list.iterator();//这句要放在add后面 否则创建的迭代器是空的
        for(; it.hasNext();){
            if("c".equals(it.next())){
                it.remove();
            }
        }
        System.out.println(list);
    }
}

Collections工具类

        Collections 是一个工具类，它提供了对 Set、List、Map 进行排序、填充、查找元素 的辅助方法。该类中所有的方法都为静态方法。（能用类直接调用）

方法	说明
void sort(list)	对 List 容器内的元素排序，排序的规则是按照升序进行排序
void shuffle(List)	对 List 容器内的元素进行随机排列。(洗牌)
void reverse(List)	对 List 容器内的元素进行逆续排列
void fill(List, Object)	用一个特定的对象重写整个 List 容器。
int binarySearch(List, Object)	对于顺序的 List 容器，采用折半查找的方法查找 特定对象。

import java.util.ArrayList;
import java.util.Collections;

//举例 实现Collections工具类中的sort方法 （从小到大排序）
public class CollectionsSortTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("e");
        list.add("d");
        list.add("c");
        System.out.println(list);//[a, b, e, d, c]
        Collections.sort(list);
        System.out.println(list);//[a, b, c, d, e]
    }
}

这里我只测试了 sort 方法，这里的排序规则是系统里的，当然也可以自己自定义规则，它目前是a,b,c...这么排的，自定义也可以成b在最小（最前面）之类的，这要实现Comparator接口中的一些比较方法 比较规则是自己写的 然后把这个Sort1定义的规则传入Sort即可。（这个我就不写了，以后有时间回来再补充一种排序规则吧）

class Sort1 implements Comparator<String>{

    @Override
    public int compare(String o1, String o2) {
        return 0;
    }
}

别的方法有兴趣的话，自己去测试一下吧~