जबकि उच्चतम उत्तोलित उत्तर बिल्कुल जावा जावा 8 का सबसे अच्छा उत्तर है, यह प्रदर्शन के मामले में बिल्कुल खराब है। यदि आप वास्तव में खराब प्रदर्शन करने वाले आवेदन चाहते हैं, तो आगे बढ़ें और इसका उपयोग करें। व्यक्ति के नाम का एक अनूठा सेट निकालने की सरल आवश्यकता "केवल प्रत्येक" और एक "सेट" द्वारा प्राप्त की जाएगी। अगर सूची 10 के आकार से ऊपर है तो चीजें और भी खराब हो जाती हैं।
विचार करें कि आपके पास 20 वस्तुओं का संग्रह है, जैसे:
public static final List<SimpleEvent> testList = Arrays.asList(
new SimpleEvent("Tom"), new SimpleEvent("Dick"),new SimpleEvent("Harry"),new SimpleEvent("Tom"),
new SimpleEvent("Dick"),new SimpleEvent("Huckle"),new SimpleEvent("Berry"),new SimpleEvent("Tom"),
new SimpleEvent("Dick"),new SimpleEvent("Moses"),new SimpleEvent("Chiku"),new SimpleEvent("Cherry"),
new SimpleEvent("Roses"),new SimpleEvent("Moses"),new SimpleEvent("Chiku"),new SimpleEvent("gotya"),
new SimpleEvent("Gotye"),new SimpleEvent("Nibble"),new SimpleEvent("Berry"),new SimpleEvent("Jibble"));
जहाँ आप वस्तु SimpleEventइस तरह दिखती है:
public class SimpleEvent {
private String name;
private String type;
public SimpleEvent(String name) {
this.name = name;
this.type = "type_"+name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
और परीक्षण करने के लिए, आपके पास इस तरह का जेएमएच कोड है, (कृपया ध्यान दें, स्वीकार किए गए उत्तर में उल्लिखित एक ही अलग-अलग उपयोग करके im करें ):
@Benchmark
@OutputTimeUnit(TimeUnit.SECONDS)
public void aStreamBasedUniqueSet(Blackhole blackhole) throws Exception{
Set<String> uniqueNames = testList
.stream()
.filter(distinctByKey(SimpleEvent::getName))
.map(SimpleEvent::getName)
.collect(Collectors.toSet());
blackhole.consume(uniqueNames);
}
@Benchmark
@OutputTimeUnit(TimeUnit.SECONDS)
public void aForEachBasedUniqueSet(Blackhole blackhole) throws Exception{
Set<String> uniqueNames = new HashSet<>();
for (SimpleEvent event : testList) {
uniqueNames.add(event.getName());
}
blackhole.consume(uniqueNames);
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(MyBenchmark.class.getSimpleName())
.forks(1)
.mode(Mode.Throughput)
.warmupBatchSize(3)
.warmupIterations(3)
.measurementIterations(3)
.build();
new Runner(opt).run();
}
फिर आपके पास बेंचमार्क परिणाम इस तरह होंगे:
Benchmark Mode Samples Score Score error Units
c.s.MyBenchmark.aForEachBasedUniqueSet thrpt 3 2635199.952 1663320.718 ops/s
c.s.MyBenchmark.aStreamBasedUniqueSet thrpt 3 729134.695 895825.697 ops/s
और जैसा कि आप देख सकते हैं, जावा 8 स्ट्रीम की तुलना में, थ्रूपुट में एक साधारण For- 3 अधिक बेहतर है और त्रुटि स्कोर में कम है।
उच्चतर थ्रूपुट, बेहतर प्रदर्शन
Function<? super T, ?>, नहींFunction<? super T, Object>। यह भी ध्यान दिया जाना चाहिए कि समानांतर धारा के लिए यह समाधान गारंटी नहीं देता है कि कौन सी वस्तु निकाली जाएगी (सामान्य के विपरीतdistinct())। इसके अलावा अनुक्रमिक धाराओं के लिए CHM (जो @nosid समाधान में अनुपस्थित है) का उपयोग करने पर अतिरिक्त ओवरहेड है। अंत में यह समाधानfilterपद्धति के अनुबंध का उल्लंघन करता है जो कि जावाडॉक में बताए अनुसार अनिवार्य होना चाहिए। फिर भी उखाड़ा गया।