标签: java-8

Java 8中的新Stream API非常好用,特别是对于并行处理功能.但是,我没有看到如何在Collections parallelStream方法之外应用并行处理.

例如,如果我从文件创建一个Stream,我使用以下内容:

Stream<String> lines = Files.lines(Paths.get("test.csv"));

但是,没有对应的parallelStream方法,就像在Collections中一样.看起来可能有一个线程抓住下一行,而可能有几个线程解析和处理这些行.

这可以通过StreamSupport.stream()来完成吗？

我正在尝试使用Java 8的parallelStream()并行执行几个长时间运行的请求(例如Web请求).简化示例:

List<Supplier<Result>> myFunctions = Arrays.asList(() -> doWebRequest(), ...)

List<Result> results = myFunctions.parallelStream().map(function -> function.get()).collect(...

因此,如果有两个函数分别阻塞2秒和3秒,我希望在3秒后得到结果.然而,它确实需要5秒钟 - 即似乎函数按顺序执行而不是并行执行.难道我做错了什么？

编辑:这是一个例子.当我想要它〜2000时,花费的时间是~4000毫秒.

    long start = System.currentTimeMillis();

    Map<String, Supplier<String>> input = new HashMap<String, Supplier<String>>();

    input.put("1", () -> {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "a";
    });

    input.put("2", () -> {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "b";
    });

    Map<String, String> results = input.keySet().parallelStream().collect(Collectors.toConcurrentMap(
            key -> key,
            key -> {
                return input.get(key).get();
            }));

    System.out.println("Time: " …

我想在java中开始编程,我正在使用ubuntu 14.04,我在下载

JDK-8u20-Linux的x64.tar.gz

在oracle网站上有一个安装它的命令,它是命令

%tar zxvf jdk-8uversion-linux-x64.tar.gz

在终端我得到了这个

bash:fg:%:没有这样的工作

任何人都帮我安装JDK.

我想将Id和Name存储到Java Collection中,如下所示:

121 Name_1
332 Name_9
334 Name_e
..........

我可以使用a HashMap但我需要能够使用更多值扩展集合,如下所示:

121 Name_1 1
332 Name_9 1
334 Name_e 3
............

是否有Java集合可以存储这些值而不使用Object？

这是一个小代码,应显示textarea并应显示我输入的内容.但我不知道它为什么不显示文字.当我按住任意键时,水平滚动条会移动,这意味着某些东西在那里,但没有任何东西显示出来.我正在使用JDK 1.8并在Windows 7 64位上使用记事本进行编辑.

public class tarea
{

    public static void main (String[] args)
    {
        Frame f = new Frame("My Frame");
        f.setLocation(100, 100);
        f.setSize(500, 500);    
        f.setLayout(null);
        f.setBackground(Color.BLACK);
        f.setTitle("My area");

        TextArea ta = new TextArea();
        ta.setBounds(10, 10, 400, 400);
        f.add(ta);

        f.setVisible(true);

    }
}

我正在使用以下简单代码进行一些性能测试(总计大约一百万个整数):

final int[] array = new int[1024 * 1024];

// populate values
for (int i = 0; i < array.length; i++) {
    array[i] = i % 100;
}

long start, end, sum = 0;

start = System.nanoTime();

// calculate sum
for (int i : array) {
    sum += i;
}

end = System.nanoTime() - start;

System.out.println(end);

平均执行时间约为1.8毫秒.

然后我决定改变测试结果的演示.我替换System.out.println(end)为以下语句(格式化字符串):

System.out.printf("Time in %dns, sum: %d\n", end, sum);

当我注意到我的平均执行时间大约是2.8毫秒时,这是非常令人惊讶的.它只有一毫秒(不是什么大不了),但另一方面它慢了约50%.更重要的是,测试结果表示(和格式化)位于结束时间测量之后,因此从理论上讲它不应该影响平均执行时间.

你知道为什么平均执行时间在添加System.out.printf语句后需要更多时间吗？它是由重新排序(在为end …

我正在检查一些简单的Lambda表达式,我在互联网上找到了以下示例,该示例应该可行.

可惜的是,它似乎的NetBeans 8.0.1不喜欢行的代码 (Person p) -> p.getAge() < 18)和.map((Person p) -> p.getName())

显示错误"lambda表达式中的不兼容参数类型".

任何人都有一个想法如何纠正这个问题？

public class Lambda {

    private enum Gender {

        MALE, FEMALE
    };

    public static class Person {

        private final String name;
        private final int age;
        private final Gender gender;

        public Person(String name, int age, Gender gender) {
            this.name = name;
            this.age = age;
            this.gender = gender;
        }

        public String getName() {
            return name;
        }


        public int getAge() {
            return age;
        }

        public Gender …

我曾经写过这样的函数的替代品:

 int[][] createMatrix(int height, int width) {
   int[][] matrix = new int[height][width];
   for (int i = 0; i < height; ++i) {
      for (int j = 0; j < width; ++j) {
         matrix[i][j] = i * width + j;
      }
   }
   return matrix;
}

但现在,我发现自己再也无法做到了.如何重构代码以在Java 8中使用流？

有人可以解释以下代码的行为吗？特别是为什么流中的forEach会更改原始列表？:

import java.util.ArrayList;
import java.util.List;

public class foreachIssue {
        class justanInt {   
        public int anint; 
        public justanInt(int t){
            anint=t;
        }
    }

    public static void main(String[] args){
        new foreachIssue();
    }
    public foreachIssue(){
        System.out.println("The Stream Output:"); 
        List<justanInt> lst = new ArrayList<>();
        justanInt j1=new justanInt(2);
        justanInt j2=new justanInt(5);
        lst.add(j1);lst.add(j2);
        lst.stream()
                .map((s)->{
                    s.anint=s.anint*s.anint;
                    return s;
                })
                .forEach((s)->System.out.println("Anything"));
        System.out.println(" lst after the stream:"); 
        for(justanInt il:lst)
            System.out.println(il.anint); 

        List<justanInt> lst1 = new ArrayList<>();
        justanInt j3=new justanInt(2);
        justanInt j4=new justanInt(5);
        lst1.add(j3);lst1.add(j4);
        lst1.stream()
                    .map((s)->{
                    s.anint=s.anint*s.anint;
                    return s;
                });
        System.out.println(" …

我想知道是否可以使用新的Streams API在一行中执行以下操作:

List<MyItem> arr = new ArrayList<>();

// MyItem has a single field, which is a value
arr.add(new MyItem(3));
arr.add(new MyItem(5));

// the following operation is the one I want to do without iterating over the array
int sum = 0;
for(MyItem item : arr){
  sum += item.getValue();
}

如果数组只包含ints,我可以做到这样的事情:

int sum = array.stream().mapToInt(Integer::intValue).sum();

但是,我可以将相同的想法应用于任意对象列表吗？