标签: java-stream

我正在创建一个从200万开始的无限整数流,使用朴素素数测试实现过滤此流以生成负载并将结果限制为10.

Predicate<Integer> isPrime = new Predicate<Integer>() {
    @Override
    public boolean test(Integer n) {
        for (int i = 2; i < n; i++) {
            if (n % i == 0) return false;   
        }
        return true;
    }
};

Stream.iterate(200_000_000, n -> ++n)
    .filter(isPrime)
    .limit(10)
    .forEach(i -> System.out.print(i + " "));

这按预期工作.

现在,如果我在过滤之前添加对parallel()的调用,则不会产生任何内容并且处理无法完成.

Stream.iterate(200_000_000, n -> ++n)
    .parallel()
    .filter(isPrime)
    .limit(10)
    .forEach(i -> System.out.print(i + " "));

有人能指出我在这里发生的事情的正确方向吗？

编辑:我不是在寻找更好的素性测试实现(它旨在成为一个长期运行的实现),而是为了解释使用并行流的负面影响.

我将从Java 8中的Stream API开始.

这是我使用的Person对象:

public class Person {

    private String firstName;
    private String lastName;
    private int age;
    private double height;
    private double weight;

    public Person(String firstName, String lastName, int age, double height, double weight) {
      this.firstName = firstName;
      this.lastName = lastName;
      this.age = age;
      this.height = height;
      this.weight = weight;
    }

    public String getFirstName() {
      return firstName;
    }
    public String getLastName() {
      return lastName;
    }
    public int getAge() {
      return age;
    }
    public double getHeight() {
      return height;
    }
    public …

试着通过一个简单的例子来了解Java 8流语法.看看关于这个主题的其他类似问题,但找不到任何与我的例子相符的解决方案,并且对我有用.基本上我正在尝试使用两个嵌套循环重构以下代码段以使用新的流API:

List<Car> filteredCars = new ArrayList<>();

for (Car car : cars) {
    for (Wheel wheel : wheels) {
        if (car.getColor() == wheel.getColor() &&
                wheel.isWorking() == true ) {
            filteredCars.add(car);
            break;
        }
    }
}

return filteredCars;

管理得出这个返回void:

return cars.stream().forEach(
    car -> wheels.stream()
        .filter(wheel -> wheel.getColor() == car.getColor() &&
                    wheel.isWorking() == true)
        .collect(Collectors.toList()));

上面的流语法有什么问题,我错过了什么？

给定a Map<String, Object>,值是一个String或另一个Map<String, Object>,如何使用Java 8将地图展平为单个值列表？

例:

Map - "key1" -> "value1"
    - "key2" -> "value2"
    - "key3" -> Map - "key3.1" -> "value3.1"
                    - "key3.2" -> "value3.2"
                    - "key3.3" -> Map - "key3.3.1" -> "value3.3.1"
                                      - "key3.3.2" -> "value3.3.2" 

对于上面的例子,我想要以下列表:

value1
value2
value3.1
value3.2
value3.3.1
value3.3.2

我知道它可以这样做:

public static void main(String args[]) throws Exception {
    //Map with nested maps with nested maps with nested maps with nested......
    Map<String, Object> map = getSomeMapWithNestedMaps();

    List<Object> values = …

由于我有一个流Stream<T> stream = list.stream().filter(some predicate) ,其中列表是非常大的,它是更有效的检查流是否是通过做非空:stream.count() > 0或做:stream.findFirst().isPresent()？

如果我想在后台任务中并行运行Stream,是否可以以较低优先级运行它？如果是这样怎么样？

我是Java8的新手,我有一个场景,我需要从Map中检索与对象匹配的所有键.

想知道是否有办法获取所有密钥而不再从列表中重复它们.

Person.java
private String firstName;
private String lastName;
//setters and getters & constructor


MAIN Class.

String inputCriteriaFirstName = "john";   

Map<String, Person> inputMap = new HashMap<>();
Collection<Person> personCollection = inputMap.values();
List<Person> personList = new ArrayList<>(personCollection);
List<Person> personOutputList = personList.stream()
.filter(p -> p.getFirstName().contains(inputCriteriaFirstName ))
.collect(Collectors.toList());


//IS There a BETTER way to DO Below ??

Set<String> keys = new HashSet<>();
for(Person person : personOutputList) {
    keys.addAll(inputMap.entrySet().stream().filter(entry -> Objects.equals(entry.getValue(), person))
        .map(Map.Entry::getKey).collect(Collectors.toSet()));
}

我试图mkString在Java8中编写一个函数,一个Scala是有用的,mkString并遇到了两个问题,我可以使用一些帮助:

1. 我无法创建mkString泛型Collection引用的第一个参数,Collection<Object> c并且让调用者使用任何类型的集合调用.

2. 无法引用内联返回的结果reduce()来访问结果的长度以删除额外的前导分隔符.

这是代码:

public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    System.out.println(mkString(numbers, ","));

}

public static String mkString(Collection<Integer> c, String sep) {
    return c.stream()
            .map(e -> String.valueOf(e))
            .reduce("", (a, b) -> a + sep + b)
            .substring(1, <<>>.length);
}

我有一个整数列表，说list1，我想得到另一个列表list2，它将包含从开始到当前索引为止的累积总和。如何使用Stream API Java 8做到这一点？

List<Integer> list1 = new ArrayList<>();
list1.addAll(Arrays.asList(1, 2, 3, 4));
List<Integer> list2 = new ArrayList<>();
// initialization
list2.add(list1.get(0));
for(int i=1;i<list1.size();i++) {
// increment step
    list2.add(list2.get(i-1) + list1.get(i));
}

如何将上述命令式代码转换为声明式代码？

list2 should be [1, 3, 6, 10]

我试图将一个int数组转换为List，并且采取了使用Java 8 Stream的陌生路线，并提出了这个建议。

Arrays.stream(arr).boxed().collect(Collectors.toList());

我仍然很难完全理解这条线，

1. 为什么Collectors.toList()在这种情况下返回一个ArrayList<Integer>实现List接口？为什么不LinkedList<Integer>符合List接口的通用类呢？我找不到这事，除了简短提的ArrayList 这里，在API说明部分。

2. 的左面板是什么 Stream.collect()意思？显然R是通用返回类型（ArrayList<Integer>在我的代码中）。而且我认为<R, A>是该方法的泛型类型参数，但是如何指定它们呢？我查看了Collector界面文档，但无法吸收它。