因为公司接口性能要求，检查发现性能瓶颈在于 for 循环的数量太大，循环体执行时间过长，导致性能变差。
如何优化这块性能，想到了最近看到的jdk8 的parallelStream ，考虑试下是否讲原来的串行换成并行，是否可以达到性能提升的目的。
考虑到也是刚刚接触parallelStream 相关的代码，先实现了简单的例子，确认for 循环的parallelStream 实现方法。
//原来strList [Test0, Test1, Test2, Test3, Test4]
//实现对象中的函数方法，map 有返回值，返回对应函数中的方法
List list0 = strList.parallelStream() .map(String::toUpperCase) .collect( Collectors.toList());
//List 中String 都实现toUpperCase，原来的List 不变，生成新的List
System.out.println("map 实现返回对象自带方法list0 "+list0.toString());// 输出值[TEST0, TEST1, TEST2, TEST3, TEST4]
System.out.println("map 实现返回对象自带方法strList "+strList.toString());// 输出值 [Test0, Test1, Test2, Test3, Test4]
//实现自定义的函数方法，List 中的对象作为入参，实现函数方法，map 有返回值，生成新的List,原来list不变
List list1 = strList.parallelStream().map(s->dealStr(s)).collect( Collectors.toList());
System.out.println("map 实现返回自定义的函数方法list1 "+list1.toString());// 输出值[Demo0, Demo1, Demo2, Demo3, Demo4]
System.out.println("map 实现返回自定义的函数方法原strList"+strList.toString());// 输出值 [Test0, Test1, Test2, Test3, Test4
//实现自定义的函数方法，List 中的对象和外部值作为入参，实现函数方法，map 有返回值，生成新的List,原来list不变
int index = 1;
List list2 = strList.parallelStream() .map(s->dealStr(s,index)).collect( Collectors.toList());
System.out.println("map 实现返回自定义的函数方法list2 "+list2.toString());// 输出值 [Demo01, Demo11, Demo21, Demo31, Demo41]
System.out.println("map 实现返回自定义的函数方法原strList"+strList.toString());// 输出值 [Test0, Test1, Test2, Test3, Test4]
//实现对象中的函数方法，peek 没有返回值，实现对应函数中的方法，原来List值不变
strList.parallelStream().peek(String::toUpperCase);
System.out.println("peek 实现返回对象自带方法strList "+strList.toString()); // 输出值[Test0, Test1, Test2, Test3, Test4]
//实现自定义的函数方法，peek 没有返回值，List 中的对象作为入参 ，改变了List 对象
strList.parallelStream().peek(s->dealStr(s));
System.out.println("peek 实现返回对象自带方法strList "+strList.toString()); // 输出值[Test0, Test1, Test2, Test3, Test4]
//不考虑硬件等条件，简单比较当前效率，
long time0 = System.currentTimeMillis();
List list3 =new ArrayList();
for(String str:strList){
list3.add(getHashCode(str));
}
long time1 = System.currentTimeMillis();
System.out.println("长度"+strList.size()+" for循环串行耗时: "+ (time1-time0));
List list4 = strList.parallelStream().map(s->getHashCode(s)).collect( Collectors.toList());
long time2 = System.currentTimeMillis();
System.out.println("长度"+strList.size()+" for循环并行耗时: "+ (time2-time1));
//输出值:
// 长度1000 for循环串行耗时: 1
// 长度1000 for循环并行耗时: 44
// 长度10000 for循环串行耗时: 2
// 长度10000 for循环并行耗时: 45
// 长度100000 for循环串行耗时: 13
// 长度100000 for循环并行耗时: 67
// 长度1000000 for循环串行耗时: 591
// 长度1000000 for循环并行耗时: 108
// 长度2000000 for循环串行耗时: 635
// 长度2000000 for循环并行耗时: 143
// 长度3000000 for循环串行耗时: 236
// 长度3000000 for循环并行耗时: 295
// 长度5000000 for循环串行耗时: 574
// 长度5000000 for循环并行耗时: 2371
// 长度10000000 for循环串行耗时: 4785
// 长度10000000 for循环并行耗时: 5574
//经过本地简单测试验证，发现并行性能不是一定优于串行，只是在一定数量的时候，并行性能会优于串行，少量数据时，串行性能还是高于并行
/**
*
下面是上文实现中简单额函数方法
*/
public static String dealStr (String s){
return s.replace( "Test","Demo" );
}
public static String dealStr (String s,int i){
return s.replace( "Test","Demo" )+i;
}
public static List map1212(String s,int d){
System.
out.println("ss "+ s+d);
List students =
new ArrayList();
students.add(
"ss "+ s +" "+d);
return students;
}
public static int getHashCode (String s){
int hash = 0;
int h = hash;
char value[] = s.toCharArray();
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h =
31 * h + val[i];
}
hash = h;
}
return hash;
}