Zusammenfassung häufig verwendeter integrierter Funktionen in Java8 (Codebeispiele)

Dieser Artikel bietet Ihnen eine Zusammenfassung (Codebeispiele) häufig verwendeter integrierter Funktionen in Java 8. Freunde in Not können darauf verweisen.

Häufig verwendete Funktionsschnittstellen werden zur späteren leichteren Bezugnahme aufgezeichnet

接口	参数	返回类型	说明
Predicate	T	boolean	输入某个值，输出boolean 值，用于对某值进行判定
Consumer	T	void	输入某值，无输出。用于消费某值
Function	T	R	输入某类型值，输出另种类型值，用于类型转化等
Supplier	None	T	无输入，输出某值，用于生产某值
UnaryOperator	T	T	输入某类型值，输出同类型值，用于值的同类型转化，如对值进行四则运算等
BinaryOperator	(T,T)	T	输入两个某类型值，输出一个同类型值，用于两值合并等

Prädikate

Prädikate sind eine boolesche Schnittstelle, die einen Parameter enthält. Es enthält einige Standardmethoden, und ihre Kombination kann komplexe Geschäftslogik implementieren (z. B.: und, oder, negieren). Der Beispielcode lautet wie folgt:

Predicate<String> predicate = (s) -> s.length() > 0;
 
predicate.test("foo");              // true
predicate.negate().test("foo");     // false
 
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
 
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();

Functions

Functions-Schnittstelle empfängt einen Parameter und erzeugt ein Ergebnis. Seine Standardmethode wird normalerweise verwendet, um mehrere Funktionen miteinander zu verketten (compose und andThen). Die

Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
 
backToString.apply("123");     // "123"

Suppliers

Suppliers-Schnittstelle generiert ein Ergebnis eines bestimmten Typs. Im Gegensatz zu Funktionen empfängt es keine Parameter.

Supplier<Person> personSupplier = Person::new;
personSupplier.get();   // new Person

Consumers

Consumers stellt die Ausführung einer Operation mit einem einzelnen Eingabeparameter dar.

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));

Komparatoren

Komparatoren werden von älteren Java-Versionen aktualisiert und fügen einige Standardmethoden hinzu.

Comparator<Person> 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

Gemeinsame Stream-Methoden

Stream erstellen

1. Vorhandene Datenstruktur in Stream konvertieren

Stream<Integer> s = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> s = Arrays.stream(arr);
Stream<Integer> s = aList.stream();

1. Durch Stream .generate ()-Methode:

// 这种方法通常表示无限序列
Stream<T> s = Stream.generate(SuppLier<T> s);
// 创建全体自然数的Stream
class NatualSupplier implements Supplier<BigInteger> {
    BigInteger next = BigInteger.ZERO;
    @Override
    public BigInteger get() {
        next = next.add(BigInteger.ONE);
        return next;
    }
}

1. gibt

Stream<String> lines = Files.lines(Path.get(filename))
...

durch andere Methoden zurück.

ordnet jeweils eine Operation einem Stream zu Element, wodurch die Konvertierung von einem Stream in einen anderen Stream abgeschlossen wird
Das von der Kartenmethode akzeptierte Objekt ist die Funktionsschnittstelle, bei der es sich um eine funktionale Schnittstelle handelt:

<R> Stream<R> map(Function<? super T, ? extends R> mapper);


@FunctionalInterface
public interface Function<T, R> {
    // 将T转换为R
    R apply(T t);
}

Verwendung:

// 获取Stream里每个数的平方的集合
Stream<Integer> ns = Stream.of(1, 2, 3, 4, 5);
ns.map(n -> n * n).forEach(System.out::println);

flatMap

Die Kartenmethode ist eine Eins-zu-eins-Zuordnung, und für alle Eingabedaten wird nur ein Wert ausgegeben.

flatMap-Methode ist eine Eins-zu-Viele-Zuordnung. Jedes Element wird weiterhin einem Stream zugeordnet, und dann werden die Elemente dieses untergeordneten Streams der übergeordneten Sammlung zugeordnet:

Stream<List<Integer>> inputStream = Stream.of(Arrays.asList(1), Arrays.asList(2, 3), Arrays.asList(4, 5, 6));
List<Integer> integerList = inputStream.flatMap((childList) -> childList.stream()).collect(Collectors.toList());
//将一个“二维数组”flat为“一维数组”
integerList.forEach(System.out::println);

Filtermethode

Die Filtermethode wird verwendet, um die Elemente im Stream zu filtern und einen neuen Stream mit qualifizierten Elementen zu generieren. Der von der
Filtermethode akzeptierte Parameter ist das Prädikatschnittstellenobjekt. Diese Schnittstelle ist eine funktionale Schnittstelle:

Stream<T> filter(Predicate<? super T>) predicate;


@FunctionInterface
public interface Predicate<T>   {
    // 判断元素是否符合条件
    boolean test(T t);
}

verwendet

// 获取当前Stream所有偶数的序列
Stream<Integer> ns = Stream.of(1, 2, 3, 4, 5);
ns.filter(n -> n % 2 == 0).forEach(System.out::println);

Limit und Skip

Limit Zugriff Die Anzahl der Ergebnisse ähnelt dem Limit in der Datenbank. Überspringen wird verwendet, um die ersten paar Ergebnisse auszuschließen.

sortiert

Die sortierte Funktion muss ein Objekt übergeben, das die Comparator-Funktionsschnittstelle implementiert. Die abstrakte Methode „compare“ dieser Schnittstelle empfängt zwei Parameter und gibt einen ganzzahligen Wert zurück , und andere Die gängigen Sortiermethoden sind dieselben.

distinct

distinct wird verwendet, um Duplikate zu entfernen, was mit der Verwendung von „distinct“ in der Datenbank übereinstimmt.

findFirst

Die findFirst-Methode gibt immer das erste Element zurück. Wenn kein Element vorhanden ist, ist der Rückgabewerttyp Optional Beachten Sie, dass dies ein optionaler Typ ist. Wenn es ein erstes Element gibt, ist der im optionalen Typ gespeicherte Wert vorhanden.

Stream<User> stream = users.stream();
Optional<String> userID = stream.filter(User::isVip).sorted((t1, t2) -> t2.getBalance() - t1.getBalance()).limit(3).map(User::getUserID).findFirst();
userID.ifPresent(uid -> System.out.println("Exists"));

min, max

min kann den Mindestwert des Ganzzahlstroms ermitteln und OptionalInt zurückgeben.

max kann den Maximalwert des Integer-Streams finden und OptionalInt zurückgeben.

Diese beiden Methoden sind Endoperationen und können nur einmal aufgerufen werden.

allMatch, anyMatch, noneMatch

allMatch: Alle Elemente im Stream stimmen mit dem eingehenden Prädikat überein und geben true zurück

anyMatch: Solange es ein Element im Stream gibt Stimmt mit dem eingehenden Prädikat überein, gibt es „true“ zurück

noneMatch: Keines der Elemente im Stream stimmt mit dem eingehenden Prädikat überein und gibt „true“ zurück

Reduziermethode

Die Reduzierungsmethode wendet jedes Element an eines Streams auf einmal in die BiFunction umwandeln und die Ergebnisse kombinieren.
Die von der Reduce-Methode akzeptierte Methode ist das BinaryOperator-Schnittstellenobjekt.

Optional<T> reduce(BinaryOperator<T> accumulator);


@FuncationalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
    // Bi操作，两个输入，一个输出
    T apply(T t, T u);
}

Verwendung:

// 求当前Stream累乘的结果
Stream<Integer> ns = Stream.of(1, 2, 3, 4, 5);
int r = ns.reduce( (x, y) -> x * y ).get();
System.out.println(r);

Das obige ist der detaillierte Inhalt vonZusammenfassung häufig verwendeter integrierter Funktionen in Java8 (Codebeispiele). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!