# Java 流映射

原文：http://zetcode.com/java/streammap/

Java 流映射教程显示了如何在 Java 流上执行映射操作。

## Java 流

Java 流是来自源的支持聚合操作的一系列元素。 流不存储元素。 元素是按需计算的。 元素是从数据源（如集合，数组或 I/O 资源）中消耗的。

流聚合操作类似于 SQL 操作。 我们可以对流应用过滤，映射，缩小，匹配，搜索或排序操作。 流允许链接多个流操作。 与使用外部迭代的集合不同，流在内部进行迭代。

## Java 流映射

我们可以将流元素更改为新的流； 原始来源未修改。 `map()`方法返回一个流，该流由将给定功能应用于流的元素的结果组成。 `map()`是一个中间操作。

## Java 流映射示例

在第一个示例中，我们将算术运算映射到值列表上。

`JavaStreamMapEx.java`

```java
package com.zetcode;

import java.util.Arrays;
import java.util.stream.IntStream;

public class JavaStreamMapEx {

    public static void main(String[] args) {

        var nums = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8);

        var squares = nums.map(e -> e * e).toArray();

        System.out.println(Arrays.toString(squares));
    }
}

```

在示例中，我们创建了一个整数流。 使用`map()`方法，我们对这些值进行算术运算，然后将它们转换为数组。

```java
[1, 4, 9, 16, 25, 36, 49, 64]

```

这是输出。

## Java 流映射示例 II

在下面的示例中，我们在一个流中使用`map()`和`mapToInt()`方法。

`JavaStreamMapEx2.java`

```java
package com.zetcode;

import java.util.Random;
import java.util.stream.Stream;

public class JavaStreamMapEx2 {

    public static void main(String[] args) {

        Stream.generate(new Random()::nextDouble)
                .map(e -> (e * 100))
                .mapToInt(Double::intValue)
                .limit(5)
                .forEach(System.out::println);
    }
}

```

该示例生成五个随机 double 值。 使用映射方法，将每个随机生成的值乘以 100 并转换为整数。

```java
66
25
18
35
47

```

这是一个示例输出。

## Java 流映射示例 III

在下一个示例中，我们将自定义方法映射到字符串流上。

`JavaStreamMapEx3.java`

```java
package com.zetcode;

import java.util.stream.Stream;

public class JavaStreamMapEx3 {

    public static void main(String[] args) {

        var words = Stream.of("cardinal", "pen", "coin", "globe");
        words.map(JavaStreamMapEx3::capitalize).forEach(System.out::println);
    }

    private static String capitalize(String word) {

        word = word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase();
        return word;
    }
}

```

该示例将流中的每个单词大写。

```java
Cardinal
Pen
Coin
Globe

```

这是输出。

## Java 流映射示例 IV

在下一个示例中，我们使用`map`方法将 CSV 文件中的值读取到列表中。

`src/resources/numbers.csv`

```java
2,3,5,6,1,0
9,5,6,3,2,1

```

在`numbers.csv`文件中有这些值。

`JavaStreamMapEx4.java`

```java
package com.zetcode;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collection;
import java.util.stream.Collectors;

public class JavaStreamMapEx4 {

    public static void main(String[] args) throws IOException {

        var lines = Files.readAllLines(Path.of("src/resources/numbers.csv"));

        var vals = lines.stream().map(line-> Arrays.asList(line.split(",")))
                .flatMap(Collection::stream).mapToInt(Integer::valueOf)
                .boxed().collect(Collectors.toList());

        System.out.println(vals);
    }
}

```

首先，我们将 CSV 文件读入字符串列表。 然后，我们从列表中创建一个流，并应用映射方法以最后获得一个整数列表。

```java
var lines = Files.readAllLines(Path.of("src/resources/numbers.csv"));

```

使用`Files.readAllLines()`，我们将文件的所有行读入字符串列表。

```java
var vals = lines.stream().map(line-> Arrays.asList(line.split(",")))
        .flatMap(Collection::stream).mapToInt(Integer::valueOf)
        .boxed().collect(Collectors.toList());

```

我们从列表中创建一个流，将字符串拆分为字符串编号列表。 列表被展平，转换为整数并收集到最终列表中。

```java
[2, 3, 5, 6, 1, 0, 9, 5, 6, 3, 2, 1]

```

这是输出。

## Java 流映射示例 V

在下一个示例中，我们对用户对象列表使用`map`操作。

`User.java`

```java
package com.zetcode;

public class User {

    private String name;
    private String occupation;

    public User(String name, String occupation) {
        this.name = name;
        this.occupation = occupation;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getOccupation() {
        return occupation;
    }

    public void setOccupation(String occupation) {
        this.occupation = occupation;
    }
}

```

这是`User`类。

`JavaStreamMapEx5.java`

```java
package com.zetcode;

import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class JavaStreamMapEx5 {

    public static void main(String[] args) {

        var users = List.of(new User("Peter", "programmer"),
                new User("Jane", "accountant"), new User("Robert", "teacher"),
                new User("Milan", "programmer"), new User("Jane", "designer"));

        var userNames = users.stream().map(user -> user.getName()).sorted()
                .collect(Collectors.toList());
        System.out.println(userNames);

        var occupations = users.stream().map(user -> user.getOccupation())
                .sorted(Comparator.reverseOrder()).distinct()
                .collect(Collectors.toList());

        System.out.println(occupations);

    }
}

```

该示例以相反的顺序从用户列表和唯一职业列表中创建排序名称列表。

```java
[Jane, Jane, Milan, Peter, Robert]
[teacher, programmer, designer, accountant]

```

这是输出。

在本教程中，我们已经使用 Java 流映射操作。 您可能也对相关教程感兴趣： [Java 流](/lang/java/streams/) ， [Java 流归约](/java/streamreduce/) ， [Java 流过滤器](/java/streamfilter/)， [Java8 `forEach`教程](/articles/java8foreach/)， 和[用 Java 过滤列表](/articles/javafilterlist/)。