标签: java-stream

采取以下示例代码行:

Set<String> someSet = someColletion.stream().map(p -> p.toString()).collect(Collectors.toSet());

我想要一个HashSet.把调试器带到代码中,我确实得到了一个HashSet.我看了看java.util.stream.Collectors.toSet()下面的代码:

public static <T> Collector<T, ?, Set<T>> toSet() {
    return new CollectorImpl<>((Supplier<Set<T>>) HashSet::new, Set::add,
                               (left, right) -> { left.addAll(right); return left; },
                               CH_UNORDERED_ID);
}

合同保证 a Set,实施决定a HashSet; 看似合理.但是,我的实现需要由a保证的恒定时间查找HashSet,而不仅仅是任何旧的查找Set.如果执行toSet()决定使用say a FooSet,这完全在其权利范围内,那么我的实现就会受到影响.

这个问题的最佳实践解决方案是什么？

我有以下表达式:

scheduleIntervalContainers.stream()
        .filter(sic -> ((ScheduleIntervalContainer) sic).getStartTime() != ((ScheduleIntervalContainer)sic).getEndTime())
        .collect(Collectors.toList());

... scheduleIntervalContainers元素类型在哪里ScheduleContainer:

final List<ScheduleContainer> scheduleIntervalContainers

是否可以在过滤器之前检查类型？

假设有一个Obj类

class Obj{

  int field;
}

并且你有一个Obj实例列表,即List<Obj> lst.

现在,我如何在Java8中找到流中过滤标准下field列表中对象的int字段值的总和lst(例如,对象o,标准是o.field > 10)？

谈论Streams,当我执行这段代码时

public class Main {
    public static void main(String[] args) {
        Stream.of(1,2,3,4,5,6,7,8,9)
        .peek(x->System.out.print("\nA"+x))
        .limit(3)
        .peek(x->System.out.print("B"+x))
        .forEach(x->System.out.print("C"+x));
    }
}

我得到了这个输出

A1B1C1
A2B2C2
A3B3C3

因为将我的流限制为前三个组件会强制执行动作A,B和C三次.

尝试使用skip()方法对最后三个元素执行类似的计算,显示了不同的行为:这

public class Main {
    public static void main(String[] args) {
        Stream.of(1,2,3,4,5,6,7,8,9)
        .peek(x->System.out.print("\nA"+x))
        .skip(6)
        .peek(x->System.out.print("B"+x))
        .forEach(x->System.out.print("C"+x));
    }
}

输出这个

A1
A2
A3
A4
A5
A6
A7B7C7
A8B8C8
A9B9C9

在这种情况下,为什么执行A1到A6的操作？它必须与limit是一个短路状态中间操作这一事实有关,而skip不是,但我不明白这个属性的实际含义.是不是"在跳过之前的所有动作都被执行而不是每个人都在限制之前"？

我想在一个带有Optional的前缀中添加一个流.既然Stream.concat只能连接Streams我有这个问题:

如何将Optional <T>转换为Stream <T>？

例:

Optional<String> optional = Optional.of("Hello");
Stream<String> texts = optional.stream(); // not working

我正在学习新的Java 8功能,在尝试使用streams(java.util.stream.Stream)和收集器时,我意识到流不能使用两次.

有没有办法重复使用它？

在Java 8中使用FP习惯用法时,异常(尤其是已检查的异常)会严重中断程序逻辑的流程.以下是一个任意示例:

String s1 = "oeu", s2 = "2";
Stream.of(s1, s2).forEach(s -> 
    System.out.println(Optional.of(s).map(Integer::parseInt).get()));

当不可解析的字符串出现异常时,上面的代码会中断.但是说我只想用默认值替换它,就像我可以用Optional:

Stream.of(s1, s2).forEach(s -> 
   System.out.println(Optional.of(s)
                              .map(Integer::parseInt)
                              .orElse(-1)));

当然,这仍然失败因为Optional只处理nulls.我想要的东西如下:

Stream.of(s1, s2).forEach(s ->
    System.out.println(
        Exceptional.of(s)
                   .map(Integer::parseInt)
                   .handle(NumberFormatException.class, swallow())
                   .orElse(-1)));

注意:这是一个自我回答的问题.

我有地图Map<Type, Long> countByType,我希望有一个列表,它按相应的值排序(最小到最大)键.我的尝试是:

countByType.entrySet().stream().sorted().collect(Collectors.toList());

但是这只是给我一个条目列表,如何在不丢失订单的情况下获得类型列表？

为了尝试深入理解java流和分裂器,我对spliterator特性有一些微妙的问题:

Q1:Stream.empty()vsStream.of()(没有args的Stream.of())

• Stream.empty():SUBSIZED,SIZED
• Stream.of(): SUBSIZED,IMMUTABLE,SIZED,ORDERED

为什么Stream.empty()没有相同的特征Stream.of()？请注意,与Stream.concat()(特别是没有ORDERED)一起使用时会产生影响.我会说不Stream.empty()应该只有IMMUTABLE和ORDERED,还有DISTINCT和NONNULL.也很有意义Stream.of()仅具有一个参数DISTICT.

Q2:LongStream.of()没有NONNULL

刚注意到NONNULL不可用LongStream.of.不是NONNULL所有LongStreams,IntStreams和DoubleStreams 的主要特征吗？

Q3:LongStream.range(,)vsLongStream.range(,).boxed()

• LongRange.range(,):SUBSIZED,IMMUTABLE,NONNULL,SIZED,ORDERED,SORTED ,DISTINCT
• LongStream.range(,).boxed():SUBSIZED,SIZED,ORDERED

为什么.boxed()失去所有这些特征？它不应该失去任何.

我明白.mapToObj()可以失去NONNULL,IMMUTABLE和DISTICT,但.boxed()......没有意义.

Q4:.peek()输掉IMMUTABLE和NONNULL

LongStream.of(1): …

我有一个第三方图书馆给了我一个Enumeration<String>.我想懒洋洋地与枚举工作作为Java 8 Stream,呼叫之类的东西filter,map并flatMap在其上.

是否有现有的库？我已经引用了Guava和Apache Commons,所以如果其中任何一个都有理想的解决方案.

或者,是什么把一个最好/最简单的方式Enumeration进入Stream,同时保留所有的懒惰天性？