006-guava 集合-集合工具类-集合扩展工具类

一、概述

　　需要实现自己的集合扩展。也许你想要在元素被添加到列表时增加特定的行为，或者你想实现一个Iterable，其底层实际上是遍历数据库查询的结果集

二、使用

2.1、ForwardingList装饰器

　　针对所有类型的集合接口，Guava都提供了Forwarding抽象类以简化装饰者模式的使用。

　　Forwarding抽象类定义了一个抽象方法：delegate()，你可以覆盖这个方法来返回被装饰对象。所有其他方法都会直接委托给delegate()。例如说：ForwardingList.get(int)实际上执行了delegate().get(int)。

示例：为null设置默认值

    class ListWithDefault<E> extends ForwardingList<E> {
        final E defaultValue;
        final List<E> delegate;

        ListWithDefault(List<E> delegate, E defaultValue) {
            this.delegate = delegate;
            this.defaultValue = defaultValue;
        }

        @Override
        protected List delegate() {
            return delegate;
        }

        @Override
        public E get(int index) {
            E v = super.get(index);
            return (v == null ? defaultValue : v);
        }

        @Override
        public Iterator<E> iterator() {
            final Iterator<E> iter = super.iterator();
            return new ForwardingIterator<E>() {
                @Override
                protected Iterator<E> delegate() {
                    return iter;
                }

                @Override
                public E next() {
                    E v = super.next();
                    return (v == null ? defaultValue : v);
                }
            };
        }
    }

    @Test
    public void testListWithDefault() {
        List<String> names = new ListWithDefault<>(
                Arrays.asList("Alice", null, "Bob", "Carol", null),
                "UNKNOWN"
        );
        names.forEach(p -> System.out.print(p + ",")); //Alice,UNKNOWN,Bob,Carol,UNKNOWN,
        System.out.println();
        System.out.println(names);//[Alice, null, Bob, Carol, null]
    }

注意： toString（）方法仍然返回委托的 toString（），它不知道默认值。还有一些其他方法必须 @Override 以及更完整的实现。

2.2、PeekingIterator　　

　　Iterators提供一个Iterators.peekingIterator(Iterator)方法，来把Iterator包装为PeekingIterator，这是Iterator的子类，它能让你事先窥视[peek()]到下一次调用next()返回的元素。

　　注意：Iterators.peekingIterator返回的PeekingIterator不支持在peek()操作之后调用remove()方法。

示例、复制一个List，并去除连续的重复元素。

    @Test
    public void testpeekingIterator() {
        List<String> source = Lists.newArrayList("a","b","b","c","a");
        List<String> result = Lists.newArrayList();

        System.out.println(source);//[a, b, b, c, a]
        PeekingIterator<String> iter = Iterators.peekingIterator(source.iterator());

        while (iter.hasNext()) {
            String current = iter.next();
            while (iter.hasNext() && iter.peek().equals(current)) {
                //跳过重复的元素
                iter.next();
            }
            result.add(current);
        }
        System.out.println(result);//[a, b, c, a]
    }

2.3、AbstractIterator

实现你自己的Iterator

示例：包装一个iterator以跳过空值

    public Iterator<String> skipNulls(final Iterator<String> in) {
        return new AbstractIterator<String>() {
            protected String computeNext() {
                while (in.hasNext()) {
                    String s = in.next();
                    if (s != null) {
                        return s;
                    }
                }
                return endOfData();
            }
        };
    }
    @Test
    public void testAbstractIterator() {
        List<String> list=Lists.newArrayList("0","a",null);
        Iterator<String> iterator = skipNulls(list.iterator());
        iterator.forEachRemaining(p-> System.out.print(p+","));//0,a,
    }

实现了computeNext()方法，来计算下一个值。如果循环结束了也没有找到下一个值，请返回endOfData()表明已经到达迭代的末尾。

注意：AbstractIterator继承了UnmodifiableIterator，所以禁止实现remove()方法。如果你需要支持remove()的迭代器，就不应该继承AbstractIterator。

2.4、AbstractSequentialIterator

代器用其他方式表示会更简单。AbstractSequentialIterator 就提供了表示迭代的另一种方式。

示例

    @Test
    public void testAbstractSequentialIterator() {
        Iterator<Integer> powersOfTwo = new AbstractSequentialIterator<Integer>(1) { // 注意初始值1!
            protected Integer computeNext(Integer previous) {
                return (previous == 1 << 12) ? null : previous * 2;
            }
        };

        powersOfTwo.forEachRemaining(p -> System.out.print(p + ","));//1,2,4,8,16,32,64,128,256,512,1024,2048,4096,
    }

在这儿实现了computeNext(T)方法，它能接受前一个值作为参数。

注意，你必须额外传入一个初始值，或者传入null让迭代立即结束。因为computeNext(T)假定null值意味着迭代的末尾——AbstractSequentialIterator不能用来实现可能返回null的迭代器。