标签: java-stream

我有一个静态方法，它使用 java 8 流从集合中识别匹配类型。

而不是使用.filterand .findAny，我想使用类似于 lodash 的_.find的方法，即“迭代集合的元素并返回第一个元素谓词返回真值。”

“查找”类型的方法大概会使代码更加高效和简洁

public static List<Class> types = Arrays.asList(
    Contact.class,
    Response.class,
    Request.class   
);

public static Optional<Class> resolveTypeFromFieldNames(Set<String> itemFields) {
    return types
        .stream()
        .filter(itemType -> {
            Set<String> fields = Arrays.stream(itemType.getDeclaredFields())
                    .filter(f -> !f.isSynthetic())
                    .map(Field::getName)
                    .collect(Collectors.toSet());
            return itemFields.equals(fields);
        })
        .findAny();
}

有没有办法collect()从 a获取通用项目stream？

这就是我想做的...

private <T extends Data> List<Response<T>> validateAndGetResponses(List<Response> responses, Class<T> clazz) {
        Supplier<List<Response<T>>> supplier = LinkedList::new;

        List<Response<T>> list = responses.stream().filter(
                response -> clazz.isInstance(getData(response))).collect(Collectors.toCollection(supplier));
        return list;

}

这不起作用，我明白了

no suitable method found for collect(....)

所以我有一个 json 输入，如下所示：

{
    "a":"something",
    "b":"something2"
}

此输入可以有两种其他形式：

{
    "a":"something",
    "b":""
}

和

{
    "a":"something"
}

我有一个这样的输入类，我将它存储在：

public class Foo {
    private String a;
    private Optional<String> b;
}

在后两种情况下，我想将 b 存储为 Optional.empty()。我已经想出了如何使用这行代码在第 3 种情况下做到这一点：

Optional.ofNullable(inputNode.get("b")).map(node -> node.asText())

这适用于第 3 种情况。它返回 Optional.empty。但对于第二种情况并没有那么多，因为b最终只是一个空字符串。我试图在.reduce之前和之后使用，.map但由于某种原因它不会让我在任何地方使用它。

以及如何实现我想要的想法？

好的，这是作业。我已经尝试了几件事，但无法让它发挥作用。指令是——编写一个程序，将 30 个随机字母插入到一个列表中。执行以下操作并显示结果： a) 按升序对列表进行排序。b) 按降序对列表进行排序。c) 按升序显示列表并删除重复项。我已经完成了最简单的部分，但是当涉及到排序时，我不知道从哪里开始。公共类随机字符{

// 私有静态列表 randomCharacters;

public static void main(String[] args) {


    //Create List of Char type
    List<Character> randomCharacters = new ArrayList<>();
    //Character[] randChars = new Character[30];

    //generate random letters and add to the list
    for(int i = 0; i<30; i++){
        int num = (int) (26* Math.random());
        //randChars[i] = (char) (num + 'a');
        char letter = (char) (num + 'a');
        randomCharacters.add(letter);
        //System.out.println(letter);
    }
    //System.out.println( "Unsorted list= " + Arrays.asList(randChars));
    System.out.println( "Unsorted list= " + randomCharacters);


    System.out.println("Ascending …

我的任务是订购作为字符串数组给出的 BigDecimals。我的想法是使用BigDecimal的String参数构造函数，然后排序，然后用forEach打印出来。这是代码部分：

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String[] s = new String[n + 2];
for (int i = 0; i < n; i++) {
    s[i] = sc.next();
}
Stream.of(s)
    .map(i -> new BigDecimal(i))
    .sorted((bg1, bg2) -> bg1.compareTo(bg2))
    .forEach(System.out::println);            //line 22

但是我为 forEach 行得到了这个 NullPointerException：

Exception in thread "main" java.lang.NullPointerException
    at java.math.BigDecimal.<init>(BigDecimal.java:806)
    at Solution.lambda$main$1(Solution.java:20)
    at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)
    at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)
    at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
    at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
    at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)
    at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174)
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
    at java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:418)
    at Solution.main(Solution.java:22)

我期待收到来自流专家的消息。
谢谢！

我想创建一个对流执行一些复杂操作的方法（例如替换第 7 个元素， 删除最后一个元素， 删除相邻的重复项等）而不缓存整个流。

但是什么流 api 让我插入这个方法？我是否必须创建自己的收集器，以便在收集时将项目发送到其他流？但这会改变数据流的方向，从拉到推，对吧？

这种方法的可能签名是什么？

Stream<T> process(Stream<T> in)

可能是不可能的（在单线程代码中），因为只有在收集整个输入流后才能返回结果

另一个想法：

void process(Stream<T> in, Stream<T> out)

似乎也有点缺陷，因为 java 不允许发出将项目插入现有流（作为out参数提供）。

那么我如何在java中进行一些复杂的流处理？

我想重构我的方法，它过滤 AssetLink 对象，获取作为 AssetLink 目标的 Content 对象，然后根据 Content 对象设置 ContentLinkMetadata 对象的字段。我的新方法是这样的：

private List<ContentLinkMetadata> getAndFillInternalLinks(final Lesson lesson) {
    List<ContentLinkMetadata> internalLinks = new ArrayList<>();
        lesson.getAssetLinks().stream()
        .filter(linkAsAssetLink -> ALLOWED_INTERNAL_LINK_TYPES.contains(linkAsAssetLink.getTargetType()))
        .map(linkAsAssetLink -> {
            Content link = contentProvider.getLazyById(linkAsAssetLink.getTargetId());
            ContentLinkMetadata internalLink = new ContentLinkMetadata();

            internalLink.setDescription(link.getDescription());
            internalLink.setId(link.getId());
            internalLink.setTitle(link.getTitle());
            internalLink.setFriendlyUrl(friendlyUrlResolver.makeUrl(link));
            internalLink.setTypeId(link.getTypeId());

            internalLinks.add(internalLink);
        });

        return internalLinks;
}

但是我在 .map 上遇到错误，它说“Stream 类型中的方法映射不适用于参数（noType linkAsAssetLink），我不明白这一点。为什么它说 linkAsAssetLink 是“noType”它实际上是 AssetLink我可以在 contentProvider 的方法中使用它的方法。你能告诉我我在哪里做错了吗？

我的问题有点复杂（我认为），所以我会尝试使用一个例子。希望你能理解我的问题。

设置说我有一个用户列表：

List<User> users;

在哪里：

public class User{
    private List<Car> cars;
}

public class Car{
    private String code;
    private List<Feature> features;
}

public class Feature{
    private String code;
}

我想要实现的是从用户列表中获取汽车列表但是我也希望这个列表是不同的（没有具有相同代码的汽车）但是我希望单个 Car 对象具有来自不同汽车的所有功能相同的代码，这就是我失败的地方。

现在我有

List<Car> cars = users
        .stream()
        .flatMap(user -> user.getCars())
        .???

我知道我可以使用 Predicate 通过代码过滤汽车，但我很难为我要离开的汽车添加功能。有没有一种干净的方法来处理流？

我正在尝试使用 实现以下场景，Stream API但没有成功。

我有以下图表。键是人的名字，集合是人的朋友的名字（键）。

Map<String, Set<String>> fooGraph

我想根据一个人的朋友数量（受欢迎程度）来排序 ArrayList。

例如，

这是fooGraph它的价值观

x -> a,b,c

y -> a

z -> a,b,c,d,e,f

t -> a,b,c,d

归根结底，我想要一个基于一个人的受欢迎程度的列表。该列表应如下所示

z, t, x, y

如何实现Stream API？

我有Stream<SortedSet<String>>，而且我只想拥有一个Stream<String>. 我尝试使用flatMap()但它没有用，因为它不能平面 Sortedset 流。

String productName = "p1";
Set<Product> products = new HashSet<>();
products.add(new Product(productName));
Stream<SortedSet<String>> sortedSetStream = products.stream().map(p -> Util.getProductNames(p) );