标签: java-stream

在尝试JDK 8 Streaming功能时,我决定尝试并行/串行流性能测试.我尝试使用在单位正方形上投掷随机飞镖来解决pi的值,并检查单位圆内有多少次着陆.我找到了apache-spark的例子.

这是代码.

    package org.sample;

    import java.util.concurrent.TimeUnit;
    import java.util.stream.IntStream;

    import org.openjdk.jmh.annotations.Benchmark;
    import org.openjdk.jmh.annotations.BenchmarkMode;
    import org.openjdk.jmh.annotations.Fork;
    import org.openjdk.jmh.annotations.Measurement;
    import org.openjdk.jmh.annotations.Mode;
    import org.openjdk.jmh.annotations.OutputTimeUnit;
    import org.openjdk.jmh.annotations.Param;
    import org.openjdk.jmh.annotations.Scope;
    import org.openjdk.jmh.annotations.State;
    import org.openjdk.jmh.annotations.Warmup;

    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
    @Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
    @Fork(1)
    @State(Scope.Benchmark)
    public class MyBenchmark {

        @Param({
            "1000000",
            "10000000"
        }) int MAX_COUNT;

        @Benchmark
        public double parallelPiTest() {
            long count = IntStream.range(1, MAX_COUNT).parallel().filter(i -> {
                double x= Math.random(); 
                double y= Math.random(); …

如何使用Java 8中的比较器和参数对集合进行排序？

这是一段代码:

    List<Point> sortedNeurons = neurons.parallelStream()
        .sorted((n1, n2) -> Double.compare(
            n1.getEuclideanDistanceFrom(inputVector),
            n2.getEuclideanDistanceFrom(inputVector)))
        .collect(Collectors.toList());

您将获得一个参数inputVector,该参数可以传递给返回原始double值的函数.如果应用于集合的元素,则返回一些数字.我希望通过此值对集合进行排序.类似于:通过getEuclideanDistanceFrom(inputVector,id)从神经元中选择id;

这里有三个问题:

1. nx.getEuclideanDistanceFrom(inputVector)重复两次.
2. 我想在使用order by子句时使用double类型的自然排序,而不是像在SQL查询中那样声明它.
3. 也许n1,n2 - > n1,n2可以用双冒号::符号代替.

PS我有一种强烈的感觉,它可以使用像双功能或双音素这样的东西来修复......但是无法弄清楚...

亲爱的,亲爱的

我有下面的简单代码

class App {
    public static void main(String[] args) {

        ArrayList<Integer> myList = new ArrayList<>();

        myList.add(7);
        myList.add(18);
        myList.add(10);
        myList.add(24);
        myList.add(17);
        myList.add(5);

        Stream<Integer> stream = myList.stream();

        stream = stream.filter(n -> n > 10); // it returns a stream of elements more than 10

        stream.forEach(n -> System.out.print(n + " "));


    }
}

这段代码的功能是它过滤调用流,然后打印所有超过10的元素.Predicate中的测试方法为我们做了..那没关系..但过滤器的实际实现在哪里()方法确实返回超过10的"STREAM"..那是我不明白的!! !! 这个问题在某种程度上也适用于forEach()方法..如何迭代抛出流..

由于filter()和forEach()方法在接口流中是抽象的,因此没有实现.

我需要一个解释..

我有以下列表integers(所有数字从0到999,999):

List<Integer> integers = new ArrayList<>();
for (int i = 0; i != 10_000_000; ++i) {
    integers.add(i);
}

我正在尝试将以下内容作为Java 8 Stream运行:

int sum = 0;
for (Integer i : integers) {
    sum = i % 2 == 0 ? i - sum : i + sum;
}
System.out.println(sum);

我期待以下输出:

0 - 0 = 0  
1 + 0 = 1  
2 - 1 = 1   
3 + 1 = 4  
4 - 4 = 0  
5 + 0 = …

我正在使用Java 8(build 1.8.0_25),Netbeans 8.0.2,并将一些Java 8功能集成到现有应用程序中.排序和.forEach不起作用,所以我创建了一些测试代码,以确保我理解lambdas等,并诊断问题.下面是新代码和代码的混合,以便与我的系统中的数据进行交互:

  public void test(Registration reg) {
/* new code */
    List<String> family = new ArrayList<>();
    family.add("Mom");
    family.add("Dad");
    family.add("Brother");
    family.add("Sister");

    family.forEach(p -> System.out.println(p));

    Collections.sort(family, (p1,p2) -> {
        System.out.println(p1 + " <==> "+ p2);
        return p1.compareToIgnoreCase(p2);
            });

    family.forEach(p -> System.out.println(p));

/* code to test with my system data */
    List<RegistrationItem> item = new ArrayList<>();
    List<RegistrationItem> regI = reg.getRegistrationItem();

    regI.forEach(p -> {
        System.out.println(p.toString());
        item.add(p);
            });

    Collections.sort(regI, (r1,r2) -> {
        System.out.println(r1.toString() + r2.toString());
        return r1.getId().compareTo(r2.getId());
    });

    for (RegistrationItem r : …

目前我正在阅读Java 8 Lambdas:实用功能编程(非常有趣且写得很好的书,没有.).

在第6章之后有一个练习:

代码将列表中的每个数字相乘,并将结果乘以5.这样可以顺序执行,但在并行运行时会出错.

public static int multiplyThrough(List<Integer> linkedListOfNumbers) {
    return linkedListOfNumbers.parallelStream()
                       .reduce(5, (acc, x) -> x * acc);
}

和解决方案:

public static int multiplyThrough(List<Integer> numbers) {
    return 5 * numbers.parallelStream()
                      .reduce(1, (acc, x) -> x * acc);
}

我不明白为什么第一种方法在并行模式中是错误的,并且书中没有解释.

请解释.

这是我的代码:

// assuming HashMap<String, Integer> hashmap
double sum = hashmap.values().stream()
    .reduce(.0, (i, v) -> i + Math.pow(v,2) + 0.5 );

在这种情况下,reduce应该采用(Integer i)和(double v)并将它们相加并将此reduce作为double返回.

相反,我得到这个错误:

- The method reduce(Integer, BinaryOperator<Integer>) in the type Stream<Integer> is not applicable for the arguments (double, (<no type> i, <no type> v) -> {})

- Type mismatch: cannot convert from double to Integer

降低,

但是,这个修复:

// assuming HashMap<String, Integer> hashmap
double sum = hashmap.values().stream()
    .map((t)->(double)t)
    .reduce(.0, (i, v) -> i + Math.pow(v,2) + 0.5 );

这样做有更优雅的方式吗？

如何将此代码转换为Java 8流？

String getFirst(String key) {
    for (Param p : params) {
        if (key.equals(p.getKey())) {
            if (!p.getValues().isEmpty()) {
                return p.getValues().get(0);
            }
        }
    }
    return "";
}

我有一个list List<String>(list1)和一个函数Integer foo(String s).使用Java 8的强大功能我希望通过应用于每个项目来转换list1为a .以下代码有效,但有一点问题:List<Integer>foolist1

List<Integer> list2 = list1.stream().mapToInt(s -> foo(s)).boxed().collect(Collectors.toList());

当foo回报null的一些元素list1一个NullPointerException被抛出.另外,我的解决方案看起来有点不方便.那么有更好的吗？

我有以下数组

ArrayList<Car> list = new ArrayList<>();

我想迭代它并抛出异常,如果它包含一定的值

即

如果至少有一个

list.stream.filter(x -> x.color.equals("Black"));

然后我想停止迭代并抛出异常.
有办法吗？