Guava之FluentIterable使用示例

FluentIterable 是guava集合类中常用的一个类，主要用于过滤、转换集合中的数据；FluentIterable是一个抽象类，实现了Iterable接口，大多数方法都返回FluentIterable对象，这也是guava的思想之一。

transform：对于ListenableFuture的返回值进行转换。
allAsList：对多个ListenableFuture的合并，返回一个当所有Future成功时返回多个Future返回值组成的List对象。注：当其中一个Future失败或者取消的时候，将会进入失败或者取消。
successfulAsList：和allAsList相似，唯一差别是对于失败或取消的Future返回值用null代替。不会进入失败或者取消流程。
immediateFuture/immediateCancelledFuture： 立即返回一个待返回值的ListenableFuture。
makeChecked: 将ListenableFuture 转换成CheckedFuture。CheckedFuture 是一个ListenableFuture ，其中包含了多个版本的get 方法，方法声明抛出检查异常.这样使得创建一个在执行逻辑中可以抛出异常的Future更加容易
JdkFutureAdapters.listenInPoolThread(future): guava同时提供了将JDK Future转换为ListenableFuture的接口函数。
addCallBack为Future增加回调

首先构造集合中的元素类型

public class User {
    private int age;
    private String name;

    public User() {
    }

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("User{");
        sb.append("age=").append(age);
        sb.append(", name='").append(name).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

常用方法

1.过滤(filter)元素

filter方法要接收Predicate接口

/**
  *    Returns the elements from this fluent iterable that satisfy a predicate. 
  * The resulting fluent iterable's iterator does not support remove().
 */
public final FluentIterable<E> filter(Predicate<? super E> predicate) {
  return from(Iterables.filter(getDelegate(), predicate));
}
  /**
 * Returns the elements from this fluent iterable that are instances of class type.
 *
 */
@GwtIncompatible // Class.isInstance
public final <T> FluentIterable<T> filter(Class<T> type) {
  return from(Iterables.filter(getDelegate(), type));
}

过滤出年龄是20岁的用户

public class Test {
    public static void main(String[] args) {
        List<User> userList = Lists.newArrayList();
        userList.add(new User(18, "zhangsan"));
        userList.add(new User(20, "lisi"));
        userList.add(new User(22, "wangwu"));
        FluentIterable<User> filter = FluentIterable.from(userList).filter(
                new Predicate<User>() {
                    @Override
                    public boolean apply(User user) {
                        return user.getAge() == 20;
                    }
        });
        for (User user : filter) {
            System.out.println(user);
        }
    }
}

打印效果：

User{age=20, name='lisi'}

这里有一个潜在的坑，在高版本(21.0++)的guava中Predicate接口继承了java 8中的java.util.function.Predicate

@FunctionalInterface
@GwtCompatible
public interface Predicate<T> extends java.util.function.Predicate<T>

2.转换(transform)集合类型，transform接收Function接口,一般在方法中采用new接口实现回调方法apply的方式。

/**
 * Returns a fluent iterable that applies function to each element of this fluent
 * iterable.
 *
 * <p>The returned fluent iterable's iterator supports remove() if this iterable's
 * iterator does. After a successful remove() call, this fluent iterable no longer
 * contains the corresponding element.
 */
public final <T> FluentIterable<T> transform(Function<? super E, T> function) {
  return from(Iterables.transform(getDelegate(), function));
}

public class Test {
    public static void main(String[] args) {
        List<User> userList = Lists.newArrayList();
        userList.add(new User(18, "zhangsan"));
        userList.add(new User(20, "lisi"));
        userList.add(new User(22, "wangwu"));
        FluentIterable<String> transform = FluentIterable.from(userList).transform(
                new Function<User, String>() {
                    @Override
                    public String apply(User user) {
                        return Joiner.on(",").join(user.getName(), user.getAge());
                    }
                });
        for (String user : transform) {
            System.out.println(user);
        }
    }
}

打印效果

zhangsan,18
lisi,20
wangwu,22

Function接口的定义

public interface Function<F, T>

From-->To

拿到所有用户的年龄

public class Test {
    public static void main(String[] args) {
        List<User> userList = Lists.newArrayList();
        userList.add(new User(18, "zhangsan"));
        userList.add(new User(20, "lisi"));
        userList.add(new User(22, "wangwu"));
        List<Integer> ages = FluentIterable.from(userList).transform(
                new Function<User, Integer>() {
                    @Override
                    public Integer apply(User input) {
                        return input.getAge();
                    }
        }).toList();
        System.out.println(ages);
    }
}

打印结果

[18, 20, 22]

public final class Test {

    public static <F, T> void main(String[] args) {
        List<F> fromList = new ArrayList<F>();
        List<T> result = FluentIterable.from(fromList).transform(new Function<F, T>() {
            @Override
            public T apply(F input) {
                // 可以根据需要写一个转换器
                // 将类型F转换成T
                return XXConverter.convert(input);
            }
        }).toList();
    }
}
class XXConverter<F, T> {

    public static <F, T> T convert(F f) {
        return null;
    }
}

 3.集合中的元素是否都满足某个条件

/**
 * Returns true if every element in this fluent iterable satisfies the predicate. If this
 * fluent iterable is empty, true is returned.
 */
public final boolean allMatch(Predicate<? super E> predicate) {
  return Iterables.all(getDelegate(), predicate);
}

public class Test {
    public static void main(String[] args) {
        List<User> userList = Lists.newArrayList();
        userList.add(new User(18, "zhangsan"));
        userList.add(new User(20, "lisi"));
        userList.add(new User(22, "wangwu"));
        boolean allMatch =  FluentIterable.from(userList).allMatch(
                new Predicate<User>() {
                    @Override
                    public boolean apply(User input) {
                        return input.getAge() >= 18;
                    }
        });
        //true
        System.out.println(allMatch);
    }
}

4.集合中的任何一个元素满足指定的条件即可

/**
 * Returns true if any element in this fluent iterable satisfies the predicate.
 */
public final boolean anyMatch(Predicate<? super E> predicate) {
  return Iterables.any(getDelegate(), predicate);
}

public class Test {
    public static void main(String[] args) {
        List<User> userList = Lists.newArrayList();
        userList.add(new User(18, "zhangsan"));
        userList.add(new User(20, "lisi"));
        userList.add(new User(22, "wangwu"));
        boolean allMatch =  FluentIterable.from(userList).anyMatch(
                new Predicate<User>() {
                    @Override
                    public boolean apply(User input) {
                        return input.getAge() >= 22;
                    }
        });
        //true
        System.out.println(allMatch);
    }
}

 

转载自：https://www.cnblogs.com/winner-0715/p/8412655.html

转载于:https://www.cnblogs.com/PengChengLi/p/11006000.html