commons-collections 之 Transformer

commons-collections 之 Transformer

说明：Transformer是一个接口，它定义了将输入转化为输出的一个流程

public interface Transformer<I, O> {

    /**
     * Transforms the input object (leaving it unchanged) into some output object.
     *
     * @param input  the object to be transformed, should be left unchanged
     * @return a transformed object
     * @throws ClassCastException (runtime) if the input is the wrong class
     * @throws IllegalArgumentException (runtime) if the input is invalid
     * @throws FunctorException (runtime) if the transform cannot be completed
     */
    O transform(I input);

}

之前记录的 commons-collections 之 LazyMap，内部就是通过 Transformer 进行的输入输出转换，从而实现需要时才去加载数据（如下）

    @Override
    public V get(final Object key) {
        // create value for key if key is not currently in the map
        if (map.containsKey(key) == false) {
            @SuppressWarnings("unchecked")
            final K castKey = (K) key;
            final V value = factory.transform(castKey);
            map.put(castKey, value);
            return value;
        }
        return map.get(key);
    }

一、简单转换

    @Test
    public void test() {
        //将input转化为大写
        Transformer<String, String> transformer = String::toUpperCase;
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        Collection<String> b = CollectionUtils.collect(list, transformer);
        System.out.println(b);
    }

输出：

[A, B, C, D, E]

二、详细介绍SwitchTransformer

Transformer implementation calls the transformer whose predicate returns true, like a switch statement.
当predicate返回true时Transformer的实现才会执行转换操作，如开关语句。

    @Test
    public void definedTransformer(){
        System.out.println("===自定义类型转换==");
        //判别式
        Predicate<Integer> buyCar = integer -> (50000 < integer) && (integer < 90000);
        Predicate<Integer> buyHouse = integer -> integer > 90000;


        Predicate[] pres ={buyCar, buyHouse};

        //转换
        Transformer<Integer,String> buyCarTrans = input -> "可以买车了";
        Transformer<Integer,String> buyHouseTrans = input -> "可以买房子了";

        @SuppressWarnings("rawtypes")
        Transformer[] trans ={buyCarTrans, buyHouseTrans};
//        Transformer[] trans ={buyHouseTrans, buyCarTrans};

        //二者进行了关联
        @SuppressWarnings("unchecked")
        Transformer<Integer, String> switchTrans =new SwitchTransformer<Integer, String>(pres, trans, null);

        //容器
        List<Integer> list =new ArrayList<>();
        list.add(56000);
        list.add(91000);
        list.add(1000);

        Collection<String> levelList = CollectionUtils.collect(list,switchTrans);
        //遍历容器
        System.out.println(levelList);
    }

返回结果：

===自定义类型转换==
[可以买车了, 可以买房子了, null]

现在修改

//Transformer[] trans ={buyCarTrans, buyHouseTrans}; 
Transformer[] trans ={buyHouseTrans, buyCarTrans};

执行结果：

===自定义类型转换==
[可以买房子了, 可以买车了, null]

结果表明：Predicate 和 Transform 的数量和顺序需要对应，不然没有意思或者会得到错误的输出

参考博客
博主地址

我的个人博客,有空来坐坐