Java8利用stream对集合的复杂操作（顺序处理，并行处理）

又是一个很平常的周六，习惯性地来到公司，中午看了会Java8实战，发现其中讲到Stream实现集合的复杂操作，于是自己动手写了个Demo，并测试了下效率。

结果是并行处理的效率远远高于顺序处理。可能与我在公司用的电脑有关（我用的是8核）。

话不多说，直接放代码：

package xie.test.stream;


import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


public class StreamTest {

private static List<Player> players = new ArrayList<>();

static void initPlayers(){
Player player1 = new Player("Jerry", 1, 250.0);
Player player2 = new Player("Lucy", 0, 365.0);
Player player3 = new Player("Herry", 0, 222.0);
Player player4 = new Player("Jack", 1, 11.0);
Player player5 = new Player("Ham", 1, 2.0);
Player player6 = new Player("Dem", 1, 21.0);
Player player7 = new Player("Roce", 0, 122.0);
Player player8 = new Player("Back", 1, 182.0);
players.add(player1);
players.add(player2);
players.add(player3);
players.add(player4);
players.add(player5);
players.add(player6);
players.add(player7);
players.add(player8);
}

/**
* 利用parallelStream筛选余额大于20的玩家，并根据性别进行分组（并行处理）
* @param players
* @return
*/
static Map<Integer,List<Player>> parallelStreamSort(List<Player> players){
return players.parallelStream().filter((Player p) -> p.getMoney() > 20).collect(Collectors.groupingBy(Player::getSex));
}
/**
* 利用stream筛选余额大于20的玩家，并根据性别进行分组（顺序处理）
* @param players
* @return
*/
static Map<Integer,List<Player>> streamSort(List<Player> players){
return players.stream().filter((Player p) -> p.getMoney() > 20).collect(Collectors.groupingBy(Player::getSex));
}

public static void main(String[] args) {
initPlayers();

long time = System.currentTimeMillis();
System.out.println(streamSort(players));
System.out.println("顺序处理时间："+(System.currentTimeMillis() - time));

long time1 = System.currentTimeMillis();
System.out.println(parallelStreamSort(players));
System.out.println("并行处理时间："+(System.currentTimeMillis() - time1));
}
}

 

该用例中，集合中只有8个元素，但通过多次运行结果显示，并行处理时间多次能达到0，少数为16毫秒，即秒过，而顺序处理的时间稳定在63毫秒左右。

按理想状态来说，并行处理效率应为顺序处理的8倍（前面提到我的电脑为8核CPU），即运行时间的1/8，但由于数据量少的原因，无法测出稳定性，于是，我把数据量增加到1000W，继续测试。

此时发现结果出现了惊天大逆转，顺序处理的效率远远超过了并行处理，大概为其五倍左右。

为什么会出现这种情况呢，我也很郁闷，我也是个新手啊，哥哥。然后我发现我的案例中是单线程的环境，诶，好像发现问题了。parallelStream是并行处理，在多线程的环境下可能会更好，但也只是猜想。

希望各位大佬看到这种问题能把正确的使用方式告诉我下呢！