"ื'ืืืื ืขืืืื ืืื - ืืื ืฉืื ืืชืืืืื ืืืืื ืืช ืื".
ืืจืืืื ืืืืื ืืืืื ืฉืื ื-Java 8. ืืืจืื ืื ืืขืืืจ ืืชืื ืฆืขื ืืืจ ืฆืขื ืืจื ืื ืืชืืื ืืช ืืืืฉืืช ืฉื ืืฉืคื. ืืืืฆืขืืช ืืืืืืืช ืงืื ืงืฆืจืืช ืืคืฉืืืืช, ืชืืื ืืืฆื ืืืฉืชืืฉ ืืฉืืืืช ืืจืืจืช ืืืืื ืฉื ืืืฉืง , ืืืืืื ืืืืื , ืฉืืืืช ืืชืืืืกืืช ืืืขืจืืช ืื ืืชื ืืช ืืืืจื . ืขื ืกืืฃ ืืืืืจ, ืชืืืจื ืืช ืืฉืื ืืืื ืืืืจืื ืื ืืืืฉืงื API ืืืื ืืจืืื, ืืืฉืงื ืคืื ืงืฆืืืช, ืืจืืืืช ืฉืืื ื-Date API ืืืืฉ. ืืื ืงืืจืืช ืฉื ืืงืกื ืืฉืขืื - ืจืง ืืืืจื ืฉื ืงืืขื ืงืื ืขื ืืขืจืืช. ืชืื ื!ืฉืืืืช ืืจืืจืช ืืืื ืขืืืจ ืืืฉืงืื
Java 8 ืืืคืฉืจืช ืื ื ืืืืกืืฃ ืฉืืืืช ืื ืืืคืฉืืืช ืืืืืฉืืืช ืืืืฉืง ืืืืฆืขืืช ืฉืืืืฉ ืืืืืช ืืืคืชื ืืืืืืจืช ืืืจืืจืช ืืืื . ืชืืื ื ืื ืืืืขื ืื ืืฉื ืฉืืืืช ืืจืืื . ืื ื ืืืืืื ืืจืืฉืื ื ืฉืื ื:interface Formula { double calculate(int a); default double sqrt(int a) { return Math.sqrt(a); } }
ืื ืืกืฃ ืืฉืืื ืืืืคืฉืืช
calculate , ืืืฉืง
ืืคืืจืืืื ืืืืืจ ืื ืฉืืืช ืืจืืจืช ืืืื
sqrt . ืืืืงืืช ืืืืืฉืืืช ืืช ืืืฉืง
ืื ืืกืื ืืืืฉืืืช ืจืง ืืช ืฉืืืช
ืืืืฉืื ืืืืคืฉืืช . ื ืืชื ืืืฉืชืืฉ ืืฉืืืช ืืจืืจืช ืืืืื
ืฉื sqrt ืืฉืืจืืช ืืืงืืคืกื.
Formula formula = new Formula() { @Override public double calculate(int a) { return sqrt(a * 100); } }; formula.calculate(100); // 100.0 formula.sqrt(16); // 4.0
ืืืืืืงื
ืื ืืกืื ืืืืฉื ืืืืืืืงื ืื ืื ืืื. ืืงืื ืื ืืจืฉืื: 6 ืฉืืจืืช ืงืื ืคืฉืื ืืืฉื
sqrt(a * 100) . ืืคื ืฉื ืจืื ืืกืขืืฃ ืืื, ืืฉ ืืจื ืืืจืงืืืืืช ืืืชืจ ืืืืฉื ืืืืืืงืืื ืฉื ืฉืืื ืืืืืช ื-Java 8.
ืืืืืื ืืืื
ื ืชืืื ืขื ืืืืื ืคืฉืืื ืืืฆื ืืืืื ืืขืจื ืฉื ืืืจืืืืช ืืืจืกืืืช ืืืงืืืืช ืฉื Java: ืฉืืืช ืืขืืจ ืืกืืืืกืืืช Collections.sort ืืืงืืช ืจืฉืืื ื-Comparator ืืื ืืืืื ืืช ืืืืื ืืื ืฉื ืืจืฉืืื ืื ืชืื ื. ืื ืฉืงืืจื ืืขืชืื ืงืจืืืืช ืืื ืฉืืชื ืืืฆืจ ืืฉืืืืืช ืื ืื ืืืืืช ืืืขืืืจ ืืืชื ืืฉืืืืช ืืืื. ืืืงืื ืืืฆืืจ ืืืืืืงืืื ืื ืื ืืืืื ืื ืืืื, Java 8 ื ืืชื ืื ืืช ืืืืืืช ืืืฉืชืืฉ ืืืจืื ืคืืืช ืชืืืืจ, ืืืืืื ืืืืื : ืืคื ืฉืืชื ืืืื ืืจืืืช, ืืงืื ืืจืื ืืืชืจ ืงืฆืจ ืืงื ืืืชืจ ืืงืจืืื. ืืื ืืื ืื ื ืืื ืขืื ืืืชืจ ืงืฆืจ: ืืฉืืื ืฉื โโืฉืืจื ืืืช, ืืชื ืืืื ืืืืคืืจ ืืืกืืืจืื ืืืชืืืชืืื {} ืืืืืช ืืืคืชื ืืืืจื . ืืื ืืื ืืงืื ืืชืงืฆืจ ืขืื ืืืชืจ: ืืืืจ ื'ืืืื ืืืืข ืืกืืื ืืคืจืืืจืื, ืื ืฉืืชื ืืืื ืื ืืืฉืืืจ ืืืชื ืืืืฅ. ืขืืฉืื ืืืื ื ืฆืืื ืืขืืืง ืืืฆื ื ืืชื ืืืฉืชืืฉ ืืืืืืื ืืืืื ืืืืื ืืืืืชืืื.List
names = Arrays.asList("peter", "anna", "mike", "xenia"); Collections.sort(names, new Comparator
() { @Override public int compare(String a, String b) { return b.compareTo(a); } });
Collections.sort(names, (String a, String b) -> { return b.compareTo(a); });
Collections.sort(names, (String a, String b) -> b.compareTo(a));
Collections.sort(names, (a, b) -> b.compareTo(a));
ืืืฉืงืื ืคืื ืงืฆืืื ืืืื
ืืืฆื ืืืืืื ืืืืื ืืชืืืืื ืืืขืจืืช ืืกืื Java? ืื ืืืืื ืืชืืืื ืืกืื ื ืชืื ืืืืืืจ ืขื ืืื ืืืฉืง. ืืืืืฉืง ืืคืื ืงืฆืืื ืื ืืืืืื ืืืื ืืืืื ืืืืืง ืฉืืื ืืืคืฉืืช ืืืช ืืืฆืืจืช. ืื ืืืืื ืืืืื ืืกืื ื ืชืื ืืชืืื ืืฉืืื ืืืคืฉืืช ืื. ืืืืืื ืฉืฉืืืืช ืืจืืจืช ืืืืื ืืื ื ืฉืืืืช ืืืคืฉืืืช, ืืชื ืืืคืฉื ืืืืกืืฃ ืฉืืืืช ืืจืืจืช ืืืื ืืืืฉืง ืืคืื ืงืฆืืื ืื ืฉืื. ืื ื ืืืืืื ืืืฉืชืืฉ ืืืืฉืง ืฉืจืืจืืชื ืืืืืื ืืืืื, ืืชื ืื ืฉืืืืฉืง ืืืื ืจืง ืฉืืื ืืืคืฉืืช ืืืช. ืืื ืืืืืื ืฉืืืืฉืง ืฉืื ืขืืื ืืชื ืืื ืืื, ืขืืื ืืืืกืืฃ ืืช ืืืขืจื @FunctionalInterface . ืืืืืจ ืืงืื ืืืืข ืขื ืืื ืืืืืจ ืื ืฉืืืืฉืง ืืืื ืืืืื ืจืง ืฉืืื ืืืช, ืืื ืืื ืืชืงื ืืฉืืื ืืืคืฉืืช ืฉื ืืื ืืืืฉืง ืื, ืืื ืืืจืืง ืฉืืืื. ืืืืื: ืืืืจ ืฉืงืื ืื ืืืื ืืืงื ืื ืื ืืืขืจื @FunctionalInterface ืื ืืืืจืื.@FunctionalInterface interface Converter
{ T convert(F from); }
Converter
converter = (from) -> Integer.valueOf(from); Integer converted = converter.convert("123"); System.out.println(converted); // 123
ืืคื ืืืช ืืฉืืืืช ืืื ืืื
ื ืืชื ืืคืฉื ืขืื ืืืชืจ ืืช ืืืืืื ืฉืืืขืื ืขื ืืื ืฉืืืืฉ ืืืคื ืื ืืฉืืื ืกืืืืกืืืช: Java 8 ืืืคืฉืจืช ืื ืืืขืืืจ ืืคื ืืืช ืืฉืืืืช ืืืื ืืื ืืืืฆืขืืช :: ืกืืื ืืืืช ืืืคืชื . ืืืืืื ืืขืื ืืจืื ืืืฆื ื ืืชื ืืืฉืชืืฉ ืืฉืืืืช ืกืืืืกืืืืช. ืืื ืื ืื ื ืืืืืื ืื ืืืชืืืืก ืืฉืืืืช ืขื ืืืืืืงืืื: ืืืื ื ืกืชืื ืืืฆื ืืฉืืืืฉ ื-: ืขืืื ืขืืืจ ืื ืืื. ืจืืฉืืช, ืืื ื ืืืืจ ืืืืื ืขื ืื ืืื ืฉืื ืื: ืืืืจ ืืื, ื ืืืืจ ืืช ืืืฉืง ืืืคืขื ืฉื PersonFactory ืืืฆืืจืช ืืืืืืงืื ืืื ืืืฉืื :Converter
converter = Integer::valueOf; Integer converted = converter.convert("123"); System.out.println(converted); // 123
class Something { String startsWith(String s) { return String.valueOf(s.charAt(0)); } }
Something something = new Something(); Converter
converter = something::startsWith; String converted = converter.convert("Java"); System.out.println(converted); // "J"
class Person { String firstName; String lastName; Person() {} Person(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } }
interface PersonFactory
{ P create(String firstName, String lastName); }
ืืืงืื ืืืืฉื ืืช ืืืคืขื ืืืืคื ืืื ื, ืื ื ืงืืฉืจืื ืืื ืืื ืืืืฆืขืืช ืืคื ืื ืฉื ืงืื ืกืืจืืงืืืจ: ืื ื ืืืฆืจืื ืืคื ืื ืืื ืื ืฉื ืืืืืงื Person ืืืืฆืขืืช Person::new . ืืืืจ Java ืืงืจื ืืืืืืืืช ืืื ืื ืืืชืืื ืขื ืืื ืืฉืืืืช ืืืชืืื ืฉื ืืื ืืื ืขื ืืืชืืื ืฉื ืฉืืืช PersonFactory.create . PersonFactory
ืืืืจ ืืืื
ืืจืืื ืืืฉื ืืืฉืชื ื ืืืงืฃ ืืืฆืื ื ืืืืืืื ืืืืื ืืืื ืืืืฉื ืืืืืืืงื ืื ืื ืืื. ืืชื ืืืื ืืืฉืช ืืืฉืชื ืื ืกืืคืืื ืืืืืงืฃ ืืืงืืื, ืืื ืื ืืฉืืืช ืืืคืขืื ืืืฉืชื ืื ืืฆืืืจืื.ืืืฉื ืืืฉืชื ืื ืืงืืืืื
ืื ื ืืืืืื ืืงืจืื ืืฉืชื ื ืืงืืื ืขื ืืฉืื ืื ืืกืืคื ืืชืื ืืืืงืฃ ืฉื ืืืืื ืืืืื: ืืื ืื ืืืื ืืืืืืืงืืื ืื ืื ืืืืื, ืืื ืฆืืจื ืืืืจืื ืขื ืืฉืชื ืื ืืกืืคืืื ืืื ืืืืืช ื ืืืฉืื ืืืืืื ืืืืื . ืื ืืงืื ืืื ื ืืื: ืขื ืืืช, ืืืฉืชื ื num ืืืื ืืืืฉืืจ ืืืชื ื ืืชื ืืฉืื ืื, ืืืืืจ. ืืืืืช ืกืืคื ืืจืืื ืขืืืจ ืืืืืจ ืงืื. ืืงืื ืืื ืื ืืงืืคื: ืฉืื ืืืื ื-num ืืชืื ืืืืื ืืืืื ืื ืืื ื ืืืชืจืื.final int num = 1; Converter
stringConverter = (from) -> String.valueOf(from + num); stringConverter.convert(2); // 3
int num = 1; Converter
stringConverter = (from) -> String.valueOf(from + num); stringConverter.convert(2); // 3
int num = 1; Converter
stringConverter = (from) -> String.valueOf(from + num); num = 3;
ืืืฉื ืืฉืืืช ืืืคืข ืืืฉืชื ืื ืกืืืืกืืืื
ืื ืืืื ืืืฉืชื ืื ืืงืืืืื, ืื ื ืืืืืื ืืงืจืื ืืืฉื ืืช ืฉืืืช ืืืคืขืื ืืืฉืชื ืื ืกืืืืกืืืื ืืชืื ืืืืืื ืืืืื. ืื ื ืืืืจืื ืืช ืืืชื ืืืืช ืืื ืืืคืฆืื ืื ืื ืืืืื.class Lambda4 { static int outerStaticNum; int outerNum; void testScopes() { Converter
stringConverter1 = (from) -> { outerNum = 23; return String.valueOf(from); }; Converter
stringConverter2 = (from) -> { outerStaticNum = 72; return String.valueOf(from); }; } }
ืืืฉื ืืฉืืืืช ืืจืืจืช ืืืื ืฉื ืืืฉืงืื
ืืืืจืื ืืช ืืืืืื ืขื ืืืคืข ืื ืืกืื ืืืกืขืืฃ ืืจืืฉืื? ืืืฉืง ืืคืืจืืืื ืืืืืจ ืฉืืืช ืืจืืจืช ืืืื sqrt ืฉื ืืชื ืืืฉืช ืืืื ืืื ืืืคืข ืฉื ื ืืกืื , ืืืื ืืืืืืงืืื ืื ืื ืืืืื. ืื ืื ืขืืื ืขื ืืืืืื ืืืืื. ืื ื ืืชื ืืืฉืช ืืฉืืืืช ืืจืืจืช ืืืื ืืชืื ืืืืืื lambda. ืืงืื ืืื ืืื ื ืงืืืคืืืฆืื:Formula formula = (a) -> sqrt( a * 100);
ืืืฉืงืื ืคืื ืงืฆืืื ืืืื ืืืื ืื
ื-API ืฉื JDK 1.8 ืืืื ืืืฉืงืื ืคืื ืงืฆืืื ืืืื ืืืื ืื ืจืืื. ืืืงื ืืืืจืื ืืืื ืืืืจืกืืืช ืงืืืืืช ืฉื Java. ืืืฉื Comparator ืื Runnable . ืืืฉืงืื ืืื ืืืจืืืื ืื ืฉืืืืื ืชืืืืช lambda ืืืืฆืขืืช ืืืขืจื @FunctionalInterface . ืืื ื-API ืฉื Java 8 ืืื ืื ืืืืฉืงืื ืคืื ืงืฆืืื ืืืื ืืืฉืื ืฉืืงืื ืขืืืื ืืช ืืืืื. ืืืง ืืืืืฉืงืื ืืืื ืืืืจืื ืืืื ืืกืคืจืืืช ืืืืืืื ืฉื ืืืื . ืื ืื ืืชื ืืืืจ ืืช ืืกืคืจืืื ืืื, ืืืื ืฉืชืกืชืื ืืงืจืื ืขื ืืืคื ืืจืืื ืฉื ืืืฉืงืื ืืื, ืขื ืืื ืฉืืืืช ืืจืืื ืฉืืืืฉืืืช.ืคืจืืืงืืื
ืคืจืืืงืืื ืื ืคืื ืงืฆืืืช ืืืืืื ืืืช ืขื ืืจืืืื ื ืืื. ืืืืฉืง ืืืื ืฉืืืืช ืืจืืจืช ืืืื ืฉืื ืืช ืืืฆืืจืช ืืืืืืื ืืืืืื ืืืจืืืื (ืืื, ืฉืืืื) ืืืืฆืขืืช ืคืจืืืงืืืPredicate
predicate = (s) -> s.length() > 0; predicate.test("foo"); // true predicate.negate().test("foo"); // false Predicate
nonNull = Objects::nonNull; Predicate
isNull = Objects::isNull; Predicate
isEmpty = String::isEmpty; Predicate
isNotEmpty = isEmpty.negate();
ืคืื ืงืฆืืืช
ืคืื ืงืฆืืืช ืืืงืืืช ืืจืืืื ื ืืื ืืืคืืงืืช ืชืืฆืื. ื ืืชื ืืืฉืชืืฉ ืืฉืืืืช ืืจืืจืช ืืืื ืืื ืืฉืื ืืกืคืจ ืคืื ืงืฆืืืช ืืื ืืฉืจืฉืจืช ืืืช (ืืืืืจ, ืืืืืจ ืืื).Function
toInteger = Integer::valueOf; Function
backToString = toInteger.andThen(String::valueOf); backToString.apply("123"); // "123"
ืกืคืงืื
ืืกืคืงืื ืืืืืจืื ืชืืฆืื (ืืืคืข) ืืกืื ืื ืื ืืืจ. ืื ืืืื ืืคืื ืงืฆืืืช, ืกืคืงืื ืื ืืืงืืื ืืจืืืื ืืื.Supplier
personSupplier = Person::new; personSupplier.get(); // new Person
ืฆืจืื ืื
ืฆืจืื ืื ืืืืฆืืื ืฉืืืืช ืืืฉืง ืขื ืืจืืืื ื ืืืื.Consumer
greeter = (p) -> System.out.println("Hello, " + p.firstName); greeter.accept(new Person("Luke", "Skywalker"));
ืืฉืืืื
ืืฉืืืื ืืืืจืื ืื ื ืืืจืกืืืช ืงืืืืืช ืฉื Java. Java 8 ืืืคืฉืจ ืื ืืืืกืืฃ ืฉืืืืช ืืจืืจืช ืืืื ืฉืื ืืช ืืืืฉืงืื.Comparator
comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName); Person p1 = new Person("John", "Doe"); Person p2 = new Person("Alice", "Wonderland"); comparator.compare(p1, p2); // > 0 comparator.reversed().compare(p1, p2); // < 0
ืืืคืฆืืื ืืืื
ืืืฉืง ืืืืคืฆืืื ืื ืืื ื ืคืื ืงืฆืืื ืื, ืื ืืื ืืื ืขืืจ ื ืืืจ ืืื ืืขืช NullPointerException . ืืืื ื ืงืืื ืืฉืืื ืืกืขืืฃ ืืื, ืื ืืืื ื ืกืชืื ืืืืืจืืช ืขื ืืื ืืืืฉืง ืืื ืขืืื. ืืืืฉืง ืืืืคืฆืืื ืื ืืื ืืืื ืคืฉืื ืืขืจืืื ืฉืืืืืื ืืืืืช null ืื ืื null. ืชืืจื ืืขืฆืืื ืฉืฉืืื ืืืืื ืืืืืืจ ืขืจื ืื ืืืื. ื-Java 8, ืืืงืื ืืืืืืจ null , ืืชื ืืืืืจ ืืืคืข ืืืคืฆืืื ืื .Comparator
comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName); Person p1 = new Person("John", "Doe"); Person p2 = new Person("Alice", "Wonderland"); comparator.compare(p1, p2); // > 0 comparator.reversed().compare(p1, p2); // < 0
ืืจื
java.util.Stream ืืื ืจืฆืฃ ืฉื ืืืื ืืื ืฉืขืืืื ืืชืืฆืขืช ืคืขืืื ืืืช ืื ืจืืืช. ืื ืคืขืืืช ืืจื ืืื ืืื ืืื ืื ืืกืืฃ. ืคืขืืืืช ืืจืืื ื ืืืืืจืืช ืชืืฆืื ืืกืื ืืกืืื, ืืขืื ืฉืคืขืืืืช ืืื ืืื ืืืืืจืืช ืืช ืืืืืืงื ืืืจื ืขืฆืื, ืืืืคืฉืจืืช ืืืฆืืจ ืฉืจืฉืจืช ืงืจืืืืช ืืืชืืื. Stream ืืื ืืืฉืง, ืืื java.util.Collection ืขืืืจ ืจืฉืืืืช ืืกืืื (ืืคืืช ืืื ื ื ืชืืืืช).ืื ืคืขืืืช Stream ืืืืื ืืืชืืฆืข ืืจืฆืฃ ืื ืืืงืืื. ืืืื ื ืกืชืื ืขื ืืื ืคืืขื ืืืจื. ืจืืฉืืช, ื ืืฆืืจ ืงืื ืืืืืื ืืฆืืจื ืฉื ืจืฉืืืช ืืืจืืืืช: ืืืกืคืื ื-Java 8 ืืฉืืคืจืื ืื ืฉืชืืื ืืืฆืืจ ืืจืืื ืื ืคืฉืื ืขื ืืื ืงืจืืื ื- Collection.stream() ืื Collection.parallelStream() . ืืกืขืืฃ ืืื ืืกืืืจ ืืช ืคืขืืืืช ืืืจื ืืืฉืืืืช ืืืคืฉืืืืช ืืืืชืจ.List
stringCollection = new ArrayList<>(); stringCollection.add("ddd2"); stringCollection.add("aaa2"); stringCollection.add("bbb1"); stringCollection.add("aaa1"); stringCollection.add("bbb3"); stringCollection.add("ccc"); stringCollection.add("bbb2"); stringCollection.add("ddd1");
ืึฐืกึทื ึตื
ืืกื ื ืืงืื ืคืจืืืงืืื ืืกืื ืื ืื ืจืืืื ืืืจื. ืคืขืืื ืื ืืื ืืื ืืื, ืื ืฉืืืคืฉืจ ืื ื ืืงืจืื ืืคืขืืืืช ืืจื ืืืจืืช (ืืืฉื forEach) ืขื ืืชืืฆืื ืืืชืงืืืช (ืืืกืื ื ืช). ForEach ืืงืื ืคืขืืื ืฉืชืชืืฆืข ืขื ืื ืจืืื ืฉื ืืืจื ืฉืืืจ ืืกืื ื. ForEach ืืื ืคืขืืื ืืกืืฃ. ืืชืจ ืขื ืื, ืืชืงืฉืจืืช ืืคืขืืืืช ืืืจืืช ืืื ืืืชื ืืคืฉืจืืช.stringCollection .stream() .filter((s) -> s.startsWith("a")) .forEach(System.out::println); // "aaa2", "aaa1"
ืึฐืืึผืึธื
ืืืืื ืืื ืคืขืืืช ืืื ืืื ืฉืืืืืจื ืืืฆืื ืืืืื ืฉื ืืจื. ืืืืื ืืื ืืืืื ืื ืืกืืจ ืื ืืื ืืื ืื ืชืฆืืื ืืช ื-Comparator ืฉืื .stringCollection .stream() .sorted() .filter((s) -> s.startsWith("a")) .forEach(System.out::println); // "aaa1", "aaa2"
ืืืืจ ืฉืืืื ืืืฆืจ ืืืฆืื ืืืืื ืฉื ืืจื ืืืื ืืืฉืคืืข ืขื ืืืืกืฃ ืขืฆืื. ืืกืืจ ืฉื ืจืืืื
stringCollection ื ืืชืจ ืืื ืฉืื ืื:
System.out.println(stringCollection); // ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
ืึทืคึผึธื
ืคืขืืืช ืืคืช ืืืื ืืื ืืืืจื ืื ืืืื ื ืืืืืืืงื ืืืจ ืืืืฆืขืืช ืืคืื ืงืฆืื ืืืชืงืืืช. ืืืืืื ืืืื ืืืืจื ืื ืืืจืืืช ืืืืจืืืช ืจืืฉืืืช. ืืื ืืชื ืืืื ืื ืืืฉืชืืฉ ืืืคื ืืื ืืืืืจ ืื ืืืืืืงื ืืกืื ืืืจ. ืกืื ืืืืืืงืื ืืืจื ืืืชืงืืืื ืชืืื ืืกืื ืืคืื ืงืฆืื ืฉืืชื ืืขืืืจ ืืืืคืื.stringCollection .stream() .map(String::toUpperCase) .sorted((a, b) -> b.compareTo(a)) .forEach(System.out::println); // "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
ืืชืืื
ื ืืชื ืืืฉืชืืฉ ืืคืขืืืืช ืืชืืื ืฉืื ืืช ืืื ืืืืืง ืืช ืืืืช ืฉื ืคืจืืืงื ืืกืืื ืืืืก ืืืจื. ืื ืคืขืืืืช ืืืชืืื ืื ืกืืคื ืืืช ืืืืืืจืืช ืชืืฆืื ืืืืืื ืืช.boolean anyStartsWithA = stringCollection .stream() .anyMatch((s) -> s.startsWith("a")); System.out.println(anyStartsWithA); // true boolean allStartsWithA = stringCollection .stream() .allMatch((s) -> s.startsWith("a")); System.out.println(allStartsWithA); // false boolean noneStartsWithZ = stringCollection .stream() .noneMatch((s) -> s.startsWith("z")); System.out.println(noneStartsWithZ); // true
ืืกืคืืจ
ืกืคืืจื ืืื ืคืขืืืช ืืจืืื ื ืฉืืืืืจื ืืช ืืกืคืจ ืจืืืื ืืืจื ืืืจืืื .long startsWithB = stringCollection .stream() .filter((s) -> s.startsWith("b")) .count(); System.out.println(startsWithB); // 3
ืึฐืึทืคืึดืืช
ืืืื ืคืขืืืช ืืจืืื ื ืืืงืฆืจืช ืืช ืจืืืื ืืืจืืื ืืืืฆืขืืช ืืคืื ืงืฆืื ืฉืขืืจื. ืืชืืฆืื ืชืืื ืืืคืฆืืื ืื ืืืืื ืืช ืืขืจื ืืืงืืฆืจ.Optional
reduced = stringCollection .stream() .sorted() .reduce((s1, s2) -> s1 + "#" + s2); reduced.ifPresent(System.out::println); // "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"
ืืจืืื ืืงืืืืื
ืืคื ืฉืืืืืจ ืืขืื, ืืจืืื ืืืืืื ืืืืืช ืขืืงืืื ืื ืืงืืืืื. ืคืขืืืืช ืืจื ืจืฆืืฃ ืืืืฆืขืืช ืขื ืืื ืืืจื, ืืขืื ืฉืคืขืืืืช ืืจื ืืงืืื ืืืืฆืขืืช ืขื ืืกืคืจ ืืืืื ืืงืืืืื. ืืืืืื ืืืื ืืืืืื ืืืฆื ืืืืืื ืืงืืืช ืืช ืืืืฆืืขืื ืืืืฆืขืืช ืืจื ืืงืืื. ืจืืฉืืช, ืืืื ื ืืฆืืจ ืจืฉืืื ืืืืื ืฉื ืืืื ืืื ืืืืืืืื: ืืขืช ื ืงืืข ืืช ืืืื ืืืืฉืงืข ืืืืื ืืืจื ืฉื ืืืืกืฃ ืืื.int max = 1000000; List
values = new ArrayList<>(max); for (int i = 0; i < max; i++) { UUID uuid = UUID.randomUUID(); values.add(uuid.toString()); }
ืืจื ืกืืจืชื
long t0 = System.nanoTime(); long count = values.stream().sorted().count(); System.out.println(count); long t1 = System.nanoTime(); long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0); System.out.println(String.format("sequential sort took: %d ms", millis)); // sequential sort took: 899 ms
ืืจื ืืงืืื
long t0 = System.nanoTime(); long count = values.parallelStream().sorted().count(); System.out.println(count); long t1 = System.nanoTime(); long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0); System.out.println(String.format("parallel sort took: %d ms", millis)); // parallel sort took: 472 ms
ืืคื ืฉืืชื ืืืื ืืจืืืช, ืฉื ื ืืฉืืจืื ืืืขื ืืืื, ืืื ืืืืื ืืืงืืื ืืืืจ ืืืชืจ ื-50%. ืื ืื ืฉืืชื ืฆืจืื ืืื ืืฉื ืืช
ืืช stream() ื-
parallelStream() .
ืึทืคึผึธื
ืืคื ืฉืืืจ ืฆืืื, ืืคืืช ืืื ื ืชืืืืืช ืืืจืืื. ืืืงืื ืืืช, ืืคื ืืืื ืืชืืื ืืฉืืืืช ืืืฉืืช ืืฉืืืืฉืืืช ืืคืชืจืื ืืขืืืช ื ืคืืฆืืช. ืืงืื ืืืขืื ืฆืจืื ืืืืืช ืืื ืืืืืืืื: putIfAbsent ืืืืืจ ืืืชื ื ืืืืชืื ืืืืงืืช null ื ืืกืคืืช. forEach ืืงืื ืคืื ืงืฆืื ืืืืฆืืข ืขืืืจ ืื ืืื ืืขืจืื ืืืคื. ืืืืื ืื ืืจืื ืืืฆื ืืชืืฆืขืืช ืคืขืืืืช ืขื ืขืจืื ืืคื ืืืืฆืขืืช ืคืื ืงืฆืืืช: ืืืืจ ืืื, ื ืืื ืืืฆื ืืืกืืจ ืขืจื ืขืืืจ ืืคืชื ื ืชืื ืจืง ืื ืืื ืืืืคื ืืขืจื ื ืชืื: ืฉืืื ืืืื ื ืืกืคืช: ืืืืื ืขืจืื ืืคื ืืื ืื ืงื: ืืืืื ืื ืฉืชืื ืืก ืืช ืืืคืชื/ืืขืจื ืืืคื , ืื ืืื ืขืจื ืขืืืจ ืืืคืชื ืื ืชืื, ืื ืฉืชืงืจื ืคืื ืงืฆืืืช ืืืืืื, ืฉืชืฉื ื ืืช ืืขืจื ืฉื ืืขืจื ืืงืืื.Map
map = new HashMap<>(); for (int i = 0; i < 10; i++) { map.putIfAbsent(i, "val" + i); } map.forEach((id, val) -> System.out.println(val));
map.computeIfPresent(3, (num, val) -> val + num); map.get(3); // val33 map.computeIfPresent(9, (num, val) -> null); map.containsKey(9); // false map.computeIfAbsent(23, num -> "val" + num); map.containsKey(23); // true map.computeIfAbsent(3, num -> "bam"); map.get(3); // val33
map.remove(3, "val3"); map.get(3); // val33 map.remove(3, "val33"); map.get(3); // null
map.getOrDefault(42, "not found"); // not found
map.merge(9, "val9", (value, newValue) -> value.concat(newValue)); map.get(9); // val9 map.merge(9, "concat", (value, newValue) -> value.concat(newValue)); map.get(9); // val9concat
GO TO FULL VERSION