讓我們的產品負責人想象一下有一天會發瘋，并要求您執行以下操作：

From a set of Strings as follows :

“ marco_8”，“ john_33”，“ marco_1”，“ john_33”，“ thomas_5”，“ john_33”，“ marco_4”，...。

給我一個逗號分隔的字符串，其中只包含marco的數字，并且數字需要按順序排列。

預期結果的示例：“ 1,4,8”

我將以4種不同的方式實現此邏輯，并且將對其中的每一種進行微基準測試。 我要實現邏輯的方法是：

• 傳統的Java與循環和所有。
• 可與番石榴一起使用
• 可與Java 8流一起使用
• 與Java 8 parallelStream一起使用

代碼在下面或

package com.marco.brownbag.functional; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; import java.util.stream.Collectors; import com.google.common.base.Function; import com.google.common.base.Joiner; import com.google.common.base.Predicates; import com.google.common.collect.Collections2; import com.google.common.collect.Ordering; public class MicroBenchMarkFunctional {private static final int totStrings = 2;public static void main(String[] args) {Set<String> someNames = new HashSet<String>();init(someNames);for (int i = 1; i < totStrings; i++) {someNames.add("marco_" + i);someNames.add("someone_else_" + i);}System.out.println("start");run(someNames);}private static void run(Set<String> someNames) {System.out.println("========================");long start = System.nanoTime();int totalLoops = 20;for (int i = 1; i < totalLoops; i++) {classic(someNames);}System.out.println("Classic ? ? ? ? : " + ((System.nanoTime() - start)) / totalLoops);start = System.nanoTime();for (int i = 1; i < totalLoops; i++) {guava(someNames);}System.out.println("Guava ? ? ? ? ? : " + ((System.nanoTime() - start)) / totalLoops);start = System.nanoTime();for (int i = 1; i < totalLoops; i++) {stream(someNames);}System.out.println("Stream ? ? ? ? ?: " + ((System.nanoTime() - start)) / totalLoops);start = System.nanoTime();for (int i = 1; i < totalLoops; i++) {parallelStream(someNames);}System.out.println("Parallel Stream : " + ((System.nanoTime() - start)) / totalLoops);System.out.println("========================");}private static void init(Set<String> someNames) {someNames.add("marco_1");classic(someNames);guava(someNames);stream(someNames);parallelStream(someNames);someNames.clear();}private static String stream(Set<String> someNames) {return someNames.stream().filter(element -> element.startsWith("m")).map(element -> element.replaceAll("marco_", "")).sorted().collect(Collectors.joining(","));}private static String parallelStream(Set<String> someNames) {return someNames.parallelStream().filter(element -> element.startsWith("m")).map(element -> element.replaceAll("marco_", "")).sorted().collect(Collectors.joining(","));}private static String guava(Set<String> someNames) {return Joiner.on(',').join(Ordering.from(String.CASE_INSENSITIVE_ORDER).immutableSortedCopy(Collections2.transform(Collections2.filter(someNames, Predicates.containsPattern("marco")), REPLACE_MARCO)));}private static Function<String, String> REPLACE_MARCO = new Function<String, String>() {@Overridepublic String apply(final String element) {return element.replaceAll("marco_", "");}};private static String classic(Set<String> someNames) {List<String> namesWithM = new ArrayList<String>();for (String element : someNames) {if (element.startsWith("m")) {namesWithM.add(element.replaceAll("marco_", ""));}}Collections.sort(namesWithM);StringBuilder commaSeparetedString = new StringBuilder();Iterator<String> namesWithMIterator = namesWithM.iterator();while (namesWithMIterator.hasNext()) {commaSeparetedString.append(namesWithMIterator.next());if (namesWithMIterator.hasNext()) {commaSeparetedString.append(",");}}return commaSeparetedString.toString();} }

在深入研究性能之前，有兩點：

忘記init（）方法，那只是初始化jvm中的對象，否則數字簡直是瘋了。

Java 8函數樣式看起來比番石榴更好，而且比以傳統方式開發的更加干凈！

性能：

在具有4核的mac上運行該程序，結果如下：

======================== Classic??????? ?: 151941400 Guava???????????: 238798150 Stream???????? ?: 151853850 Parallel Stream : 55724700 ========================

并行流快3倍 。 這是因為Java會將作業拆分為多個任務（任務的總數取決于您的計算機，內核等），并將并行運行它們，最后匯總結果。

經典Java和Java 8流具有大致相同的性能。

番石榴更寬松。

這太了不起了，所以有人會想： “太酷了，我可以一直使用parallelStream，到年底我將獲得豐厚的回報”。

但是生活絕非易事。 當您將這組字符串從200.000減少到20時，會發生以下情況：

======================== Classic?????????: 36950 Guava???????????: 69650 Stream???????? ?: 29850 Parallel Stream : 143350 ========================

并行流變得非常慢。 這是因為parallelStream在初始化和管理多任務以及組合結果方面有很大的開銷。

現在，Java 8流看起來是贏家，而其他2種則勝出。

好的，在這一點上，有人可以這樣說： “對于具有很多元素的集合，我使用parallelStream，否則我使用stream。”

那將很容易獲得，但是當我再次將Set從20減少到2時會發生什么呢？
這個 ：

======================== Classic??????? ?: 8500 Guava????????? ?: 20050 Stream???????? ?: 24700 Parallel Stream : 67850 ========================

經典的Java循環使用很少的元素會更快。

因此，在這一點上，我可以回到瘋狂的產品所有者手中，詢問他認為該輸入集合中有多少個String。 20嗎 減？ 更多？ 多得多？

就像木匠說的： 兩次測量，切一次！

翻譯自: https://www.javacodegeeks.com/2014/09/friday-benchmarking-functional-java.html

總結

以上是生活随笔為你收集整理的星期五基准功能Java的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。