关于Java Stream的总结

1 年 ago

雅, 悟

6 minutes

我觉得Stream很方便，所以我想把它们整理在一起。

创建流

需要通过适当的教育和培训来培养孩子们的创造力和创新能力。

返回Stream。
还可以对元素进行类型指定。

// 直接作成
Stream stream = Stream.of("a", "b", "c", "d", "e");
IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
DoubleStream doubleStream = DoubleStream.of(1.0, 2.0, 3.0, 4.0, 5.0);
LongStream longStream = LongStream.of(1, 2, 3, 4, 5);

转换

将主要类型转换为流。

// Listから変換
List<String> list = Arrays.asList("a", "b", "c", "d", "e");
Stream listStrem = list.stream();

// Mapから変換
Map<Integer, String> map = new HashMap<>();
map.put(1, "A");
map.put(2, "B");
map.put(3, "C");
Stream<Map.Entry<Integer, String>> mapStream = map.entrySet().stream();

// 文字列から変換
String str = "ABCDE";
IntStream strStream = str.chars();

建筑师

返回 Stream 的构建器。

Stream.Builder<Integer> sb = Stream.builder();
sb.add(10);
sb.add(20);
Stream<Integer> buildStream =sb.build();
buildStream.forEach(System.out::println);

10
20

产生

返回一个无序的无限顺序流。

Stream<Integer> stream = Stream.generate(() -> 1);
stream.limit(3).forEach(System.out::println);

1
1
1

需要在生成随机值的情况下使用。
示例：返回0〜9之间的5个随机值。

Stream.generate(Math::random).limit(5).map(s -> Math.floor(s * 10)).mapToInt(Double::intValue).forEach(System.out::println);

迭代

返回一个有序的无限顺序流。

Stream<Integer> stream = Stream.iterate(1, x -> x * 2);
        stream.limit(5).forEach(System.out::println);

连接

合并流。

Stream<String> stream1 = Stream.of("a", "b");
Stream<String> stream2 = Stream.of("c", "d", "e");
Stream.concat(stream1,stream2).forEach(System.out::println);

a
b
c
d
e

空的 de)

创建一个空的Stream。

Stream<?> emptyList =  Stream.empty();
emptyList.forEach(System.out::println);

No OutPut

获取要素

使用Lambda表达式和方法引用可以写得更简洁。对于字符串，由于返回类型是IntStream类型，所以需要使用mapToObj方法进行类型转换。


        // Stream型
        // ラムダ式
        Stream.of("a", "b", "c", "d", "e").forEach(s -> System.out.println(s));
        // メソッド参照
        Stream.of("a", "b", "c", "d", "e").forEach(System.out::println);

        //List
        Arrays.asList(1, 2, 3, 4, 5).stream().forEach(System.out::println);

        //Map
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "A");
        map.put(2, "B");
        map.put(3, "C");
        map.entrySet().stream().forEach(s -> System.out.println("key: " + s.getKey() + " value: " + s.getValue()));

        //文字列
        String str = "ABCDE";
        str.chars().mapToObj(s -> (char)s)
                .forEach(System.out::println);

数值范围 –

范围

// 末尾を含まない
IntStream.range(1,5).forEach(System.out::println);

闭区间

// 末尾を含む
IntStream.rangeClosed(1,5).forEach(System.out::println);

操作進展

转变要素

地图

可以使用Lambda编写处理代码。

Stream.of(1, 2, 3, 4, 5).map(s -> s * 2).forEach(System.out::println);

转为整数地映射

mapToLong和mapToDouble的用法相同。

Stream.of("1", "2", "3", "4", "5")  // Stream<String>
        .mapToInt(s -> Integer.parseInt(s)) // IntStream
        .map(s -> s * 2)
        .forEach(System.out::println);

flatMap 扁平化

可以进行1对N的转换。

// flatMap
Stream<String> stream1 = Stream.of("A", "BB", "CCC", "DDDD", "EEEEE");
stream1.flatMap(s -> Stream.of(s, s.length(), s.toLowerCase())).forEach(System.out::print);

A1aBB2bbCCC3cccDDDD4ddddEEEEE5eeeee

精简要素

过滤

Stream.of(10, 20, 30, 40, 50).filter(s -> s <= 30).forEach(System.out::println);

10
20
30

跳过和限制

跳过 guò)

Stream.of(10, 20, 30, 40, 50).skip(2).forEach(System.out::println);

30
40
50

限制

Stream.of(10, 20, 30, 40, 50).limit(2).forEach(System.out::println);

10
20

通过组合使用“跳过”和“限制”来指定范围。

Stream.of(10, 20, 30, 40, 50).skip(2).limit(2).forEach(System.out::println);

30
40

独特的

去除重复项。

Stream.of("A", "A", "B", "B", "B", "C").distinct().forEach(System.out::println);

A
B
C

重新排列要素

分类整理

// sorted
Stream.of(13, 52, 34, 6, 28).sorted((s1, s2) -> s1 - s2).forEach(System.out::println);
// Comparatorオブジェクトを使用
Stream.of(13, 52, 34, 6, 28).sorted(Comparator.comparingInt(s -> s)).forEach(System.out::println);

调试

偷看

用于调试输出的方法。对于流不产生任何影响。

List<String> numbers =  Stream.of("one", "two", "three", "four")
                        .filter(e -> e.length() > 3)
                        .peek(e -> System.out.println("Filtered value: " + e))
                        .map(String::toUpperCase)
                        .peek(e -> System.out.println("Mapped value: " + e))
                        .collect(Collectors.toList());

Filtered value: three
Mapped value: THREE
Filtered value: four
Mapped value: FOUR

终端操作

输出结果

对于每一个元素进行遍历

可以进行重复处理。可以使用Lambda表达式来编写操作。

我尝试写了下面的示例，但是可以用map来重新编写它…。

Stream.of(10, 20, 30, 40 ,50).forEach(s -> {
    int intResult = s / 10;
    System.out.println(intResult);
});

逐个顺序执行

使用parallelStream()可以并行处理流。这样可以保证按照顺序输出数据。而使用forEach会以随机顺序输出数据。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
System.out.println("--------forEach---------");
list.parallelStream().filter(s -> s > 1).forEach(System.out::println);
System.out.println("--------forEachOrdered---------");
list.parallelStream().filter(s -> s > 1).forEachOrdered(System.out::println);

forEach与forEachOrdered的不同在于，forEach是随机输出，而forEachOrdered是按照列表的顺序输出。

--------forEach---------
3
5
4
2
--------forEachOrdered---------
2
3
4
5

提取结果 (extract results)

收集

以各种不同的类型返回结果。

列出

// list型で返却
List<String> list = Stream.of("A", "B", "C", "D", "E").collect(Collectors.toList());
System.out.println(list);

[A, B, C, D, E]

字符串

//String型で返却
String join1 = Stream.of("A", "B", "C", "D", "E").collect(Collectors.joining());
System.out.println(join1);

String join2 = Stream.of("A", "B", "C", "D", "E").collect(Collectors.joining(","));
System.out.println(join2);

ABCDE
A,B,C,D,E

地图 (dì tú)

可以通过Map返回已进行Group化的内容。

//最低限のモデルクラス
public class Score {
    private String name;
    private int score;

    public Score(String name, int score){
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }
}

// scoreListを作成
List<Score> scoreList = new ArrayList<>();
scoreList.add(new Score("Tanaka", 90));
scoreList.add(new Score("Suzuki", 80));
scoreList.add(new Score("Nakamura", 100));
scoreList.add(new Score("Ito", 90));
scoreList.add(new Score("Hamanaka", 100));
//グループ分け
Map<Integer, List<Score>> map = scoreList.stream().collect(Collectors.groupingBy(Score::getScore));
//Mapの要素を出力
map.entrySet().stream().forEach(s -> System.out.println("Key: " + s.getKey() + ", Value:" + s.getValue()));
//scoreが100点のスコアデータを表示
List<Score> score100 = map.get(100);
score100.forEach(s -> System.out.println("name: " + s.getName() + ", score: " + s.getScore()));

返回的Map已经分组，并且相应值的Stream已被列为列表。

# Mapの要素を出力
Key: 80, Value:[com.example.javalearn.qiita.stream.Score@446cdf90]
Key: 100, Value:[com.example.javalearn.qiita.stream.Score@799f7e29, com.example.javalearn.qiita.stream.Score@4b85612c]
Key: 90, Value:[com.example.javalearn.qiita.stream.Score@277050dc, com.example.javalearn.qiita.stream.Score@5c29bfd]
# scoreが100点のスコアデータを表示
name: Nakamura, score: 100
name: Hamanaka, score: 100

将其转换为数组

将流(stream)转换为数组。

String[] toArray = Stream.of("a", "b", "c", "d", "e").toArray(String[]::new);
for(String s:toArray){
    System.out.println(s);
}

a
b
c
d
e

减少

累积结果。

int total = Stream.of(1, 2, 3, 4, 5).reduce((a,b) -> a + b).get();
System.out.println(total);

//メソッド参照も可能
int total1 = Stream.of(1, 2, 3, 4, 5).reduce(Integer::sum).get();

作为正在进行的事情，可以列举以下内容。

1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15

筛选结果

找到第一个

取出列表的第一个元素。

String findFirst = Stream.of("A", "B", "C", "D", "E").findFirst().orElse("null");
System.out.println(findFirst);

最大

Integer max = Stream.of(1, 2, 3, 4, 5).max(Comparator.naturalOrder()).orElse(0);
System.out.println(max);

翻译：敏

Integer min = Stream.of(1, 2, 3, 4, 5).min(Comparator.naturalOrder()).orElse(0);
System.out.println(min);

求和

Integer sum = IntStream.of(1, 2, 3, 4, 5).sum();
System.out.println(sum);

统计

Long count = Stream.of(1, 2, 3, 4, 5).count();
System.out.println(count);

平均

Double average = IntStream.of(1, 2, 3, 4, 5).average().orElse(0);
System.out.println(average);

3.0

搜索结果

任何匹配

部分相符

Boolean anyMatch1 = Stream.of(1, 2, 3, 4, 5).anyMatch(s -> s > 2);
Boolean anyMatch2 = Stream.of(1, 2, 3, 4, 5).anyMatch(s -> s < 0);
System.out.println(anyMatch1);
System.out.println(anyMatch2);

true
false

全匹配

完全相同

Boolean allMatch1 = Stream.of("one", "two", "three", "four").allMatch(s -> s.length() <= 5);
Boolean allMatch2 = Stream.of("one", "two", "three", "four").allMatch(s -> s.length() <= 4);
System.out.println(allMatch1);
System.out.println(allMatch2);

true
false

noneMatch – 没有匹配

完全不同意规模完全不一样完全不相符完全不吻合全然不相同完全不相似

Boolean noneMatch1 = Stream.of("one", "two", "three", "four").noneMatch(s -> s.length() <= 2);
Boolean noneMatch2 = Stream.of("one", "two", "three", "four").noneMatch(s -> s.length() <= 4);
System.out.println(noneMatch1);
System.out.println(noneMatch2);

true
false

请您查阅

流（Java平台SE8）