Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

introductio

Java 8 multas notas novas inducit, quarum notabiliores sunt locutiones Lambda et Fluvius API. Fluvius API methodum efficientem et concisam datam collectioni processus praebet, codicem brevius et lucidius faciens, ac promptam facilitatem et conservationem habet. Hic articulus in usum Iavae Streami API tradet, notiones praecipuas, operationes communes, processus parallelos, casus practicos, et exercitia optima.

Tabula contentorum

1. Quid est Fluvius API
2. Basic operationes Fluminis API
   • Create Stream
   • media res
   • Terminatio operatio
3. Provectus operationes Fluminis API
   • sort
   • filter
   • mapping
   • Statutum
   • collect
4. Stream parallel
5. Amnis API causa practica
   • Processus collectio data
   • File res
   • Database operationes
6. Optimus Exercitia pro Amnis APIs
7. Frequenter Interrogata et Solutiones
8. Summatim

Quid est Fluvius API

Fluvius API abstractio in Java 8 introducta est ad colligendas notitias dispensandas, quae notitias processus modo declarativo permittit (similis SQL declarationibus). Fluvius API multas operationes potentes praebet quae ad colum, genus, map, reducere et alias operationes in collectionibus adhiberi possunt, codicem valde simpliciorem reddunt.

Features

• declarativa programmatio: Flumine API utere ut modum declarativum codicem scribas, codicem boilerplate redigendo.
• torquem vocationis: Operationes Fluminis API in catena dici possunt, meliori bili codice.
• piger iudicium: Operationes mediae segniter perpenduntur et tantum aestimantur cum terminatio operatio exercetur.
• parallel processus: processui parallelo subsidia et CPUs multi-core plene utantur.

Basic operationes Fluminis API

Create Stream

Fluvius API varias vias ad Fluvium creandum praebet.

1. Create ex collectione：

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();
1
2

2. Create ex ordinata：

String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);
1
2

3. ususStream.of：

Stream<String> stream = Stream.of("a", "b", "c");
1

4. ususStream.generate：

Stream<Double> stream = Stream.generate(Math::random).limit(10);
1

5. ususStream.iterate：

Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(10);
1

media res

Operationes mediae adhibentur ad Flumen convertendum et segniter perpenduntur.

1. filter: ad elementa filter.

Stream<String> stream = list.stream().filter(s -> s.startsWith("a"));
1

2. map: Adsuesco assuesco ad describendam singula elementa ad eventum respondentem.

Stream<String> stream = list.stream().map(String::toUpperCase);
1

3. flatMap: Uniuscuiusque elementi ad rivum converti et in unum Stream mergere solebat.

Stream<String> stream = list.stream().flatMap(s -> Stream.of(s.split("")));
1

4. distinct: duplicates removere solebant.

Stream<String> stream = list.stream().distinct();
1

5. sorted: Propter genus.

Stream<String> stream = list.stream().sorted();
1

6. peek: Adsuesco assuesco singulas partes in processu videre.

Stream<String> stream = list.stream().peek(System.out::println);
1

Terminatio operatio

Operationes terminales ad calculum Fluminis incipere et eventum generale generare.

1. forEach: Operationem singulis elementis.

list.stream().forEach(System.out::println);
1

2. collect: converte rivus ad alias formas.

List<String> result = list.stream().collect(Collectors.toList());
1

3. reduce: reducere elementa in rivo in valorem.

Optional<String> result = list.stream().reduce((s1, s2) -> s1 + s2);
1

4. toArray: Converte Stream ad aciem.

String[] array = list.stream().toArray(String[]::new);
1

5. count: Numera elementorum.

long count = list.stream().count();
1

6. anyMatch、allMatch、noneMatch: Pro matching judicio.

boolean anyMatch = list.stream().anyMatch(s -> s.startsWith("a"));
boolean allMatch = list.stream().allMatch(s -> s.startsWith("a"));
boolean noneMatch = list.stream().noneMatch(s -> s.startsWith("a"));
1
2
3

7. findFirst、findAny: solebat invenire elementa.

Optional<String> first = list.stream().findFirst();
Optional<String> any = list.stream().findAny();
1
2

Provectus operationes Fluminis API

sort

usussortedMethodus Fluminis digerens ac comparator transire potest.

List<String> list = Arrays.asList("b", "c", "a");
List<String> sortedList = list.stream().sorted().collect(Collectors.toList());
// 逆序排序
List<String> sortedListDesc = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
1
2
3
4

filter

ususfilterMethodus elementa spargendi in Stream.

List<String> list = Arrays.asList("a", "b", "c");
List<String> filteredList = list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());
1
2

mapping

ususmapMethodus geographicarum elementorum in Stream.

List<String> list = Arrays.asList("a", "b", "c");
List<String> mappedList = list.stream().map(String::toUpperCase).collect(Collectors.toList());
1
2

Statutum

ususreduceMethodus reducendi elementa in Streo.

List<String> list = Arrays.asList("a", "b", "c");
String result = list.stream().reduce("", (s1, s2) -> s1 + s2);
1
2

collect

ususcollectMethodi amnis ad alias formas convertunt.

List<String> list = Arrays.asList("a", "b", "c");
List<String> collectedList = list.stream().collect(Collectors.toList());
Set<String> collectedSet = list.stream().collect(Collectors.toSet());
String joinedString = list.stream().collect(Collectors.joining(","));
1
2
3
4

Stream parallel

Stream parallelam plenam usum commoda multi-core CPUs emendare potest ad efficientiam datam processus.potestparallelStreamMethodus parallelas Streae gignit.

List<String> list = Arrays.asList("a", "b", "c");
List<String> parallelList = list.parallelStream().map(String::toUpperCase).collect(Collectors.toList());
1
2

Potest etiam esseparallelMethodus normalem Fluminis ad parallelum Fluminis convertit.

List<String> list = Arrays.asList("a", "b", "c");
List<String> parallelList = list.stream().parallel().map(String::toUpperCase).collect(Collectors.toList());
1
2

Notandum quod Fluvius parallelus non semper velocior est quam Stream Vide, et probandus est secundum situm specificum.

Amnis API causa practica

Processus collectio data

Case 1: Filter and transform collections

Data collectione chordarum, e chordis sparge quarum longitudo minor est quam 3 et reliquas chordas ad autocinetum converte.

List<String> list = Arrays.asList("a", "ab", "abc", "abcd");
List<String> result = list.stream()
    .filter(s -> s.length() >= 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());
System.out.println(result); // 输出：[ABC, ABCD]
1
2
3
4
5
6

Causa II: Adice mediocris

Statuto integrorum, omnium integrorum mediocris computa.

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
OptionalDouble average = list.stream()
    .mapToInt(Integer::intValue)
    .average();
average.ifPresent(System.out::println); // 输出：3.0
1
2
3
4
5

File res

Causa III, Read file content

Fluvius utens API

Legere tabella contenta et output ad consolatorium.

try (Stream<String> lines = Files.lines(Paths.get("example.txt"))) {
    lines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}
1
2
3
4
5

Causa IV: Numera verbi eventus

Lege tabella contenta et numerum eventuum cuiusque verbi numera.

try (Stream<String> lines = Files.lines(Paths.get("example.txt"))) {
    Map<String, Long> wordCount = lines
        .flatMap(line -> Arrays.stream(line.split("\W+")))
        .collect(Collectors.groupingBy(String::toLowerCase, Collectors.counting()));
    wordCount.forEach((word, count) -> System.out.println(word + ": " + count));
} catch (IOException e) {
    e.printStackTrace();
}
1
2
3
4
5
6
7
8

Database operationes

Casus 5: Processus datorum interrogationum proventus

Dicamus nos habere mensam databaseusersContinens agrosid、nameetage . Flumine API uti possumus, ut proventus interrogationis computetur.

List<User> users = queryDatabase();
List<String> names = users.stream()
    .filter(user -> user.getAge() > 18)
    .map(User::getName)
    .collect(Collectors.toList());
System.out.println(names);
1
2
3
4
5
6

Optimus Exercitia pro Amnis APIs

1. Ne necesse parallelization: Parallelus Fluvius non semper velocius est ac eligendus in casu-per-casu basis.
2. Proprius usus operationum mediarum et operationum terminalium: Operationes mediae segniter perpenduntur et tantum aestimantur cum terminatio operatio exercetur.
3. Attende ad rivi reusability: Fluvius semel consumptus, iterum adhiberi non potest. Si reus eam postulas, potes considerare ut Fluvium in collectionem convertas antequam eo utaris.
4. Utere iure collectori：CollectorsClassis varias collectores praebet, et convenientem collectorem secundum proprias necessitates eligere potest.
5. Exceptiones tractamus: Cum Stream API utens, exceptiones possibilium tractare debes, praesertim in operationibus fasciculi et operationibus datorum.

Frequenter Interrogata et Solutiones

Amnis clausa est

Fluvius semel consumptus, iterum adhiberi non potest. Si reus eam postulas, potes considerare ut Fluvium in collectionem convertas antequam eo utaris.

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();
stream.forEach(System.out::println);
stream.forEach(System.out::println); // 会抛出IllegalStateException
1
2
3
4

Euismod quaestiones

Fluvii paralleli non semper velociores sunt quam Vide rivi et opus est ut probentur in basi casu-by-casu.potestForkJoinPoolAd optimize paralleli Streae observantiam.

ForkJoinPool customThreadPool = new ForkJoinPool(4);
customThreadPool.submit(() ->
    list.parallelStream().forEach(System.out::println)
).get();
1
2
3
4

memoria Leak

Cum Streo API utens ad magnas notitiarum copias processuras, debes operam dare problema memoriae libero.potestclosemodum claudere Fluminis aut usustry-with-resourcesdicitur sponte claudit Stream.

try (Stream<String> lines = Files.lines(Paths.get("example.txt"))) {
    lines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}
1
2
3
4
5

Summatim

Hic articulus usum Javae Fluminis API in speciali introducit, inclusis operationibus fundamentalibus, operationibus provectis, processui parallelo, casibus practicis, et exercitiis optimis. Cum ratione utens Fluminis API, tincidunt codicem valde simpliciorem reddere possunt, faciliorem et conservabilitatem codicis emendare, ac etiam efficientiam datorum processus emendare. Spero articulum hunc profuturum esse usui Fluminis API in evolutione Javae.

Fluvius API Java instrumentum validum est ad colligendas notitias expediendas. Si Stream API nondum usus es, commendatur ut quamprimum hoc instrumentum potentem doceat ac perdas, et illud in consilio tuo applica ad efficientiam et qualitatem codicem emendandum.