# 用 Java8 的`StringJoiner`连接字符串

原文：http://zetcode.com/articles/java8stringjoiner/

在本文中，我们介绍了用于连接字符串的新 Java8 API。 Java 多年来缺乏用于简单字符串连接的 API。 在 Java8 中，引入了`StringJoiner`。

`StringJoiner`用于构造由定界符分隔的字符序列，并可选地以提供的前缀开始并以提供的后缀结束。

`StringJoiner`也由`String`类的`join()`方法在内部使用。

## 使用`StringJoiner`

下面的示例将数字与`StringJoiner`类相连。

`Java8StringJoinEx.java`

```java
package com.zetcode;

import java.util.StringJoiner;

public class Java8StringJoinEx {

    public static void main(String[] args) {

        StringJoiner join = new StringJoiner(",");
        join.add("1");
        join.add("2");
        join.add("3");
        join.add("4");
        join.add("5");

        System.out.println(join);
    }
}

```

该示例连接了五个数字，并将最终字符串输出到控制台。

```java
StringJoiner join = new StringJoiner(",");

```

将创建`StringJoiner`类的新实例。 逗号字符用作分隔符。

```java
join.add("1");
join.add("2");
join.add("3");
join.add("4");
join.add("5");

```

`add()`方法添加了五个值。

```java
System.out.println(join);

```

`StringJoiner`转换为字符串并打印到控制台。

```java
$ java com.zetcode.Java8StringJoinEx 
1,2,3,4,5

```

这是示例的输出。

## `String.join()`方法

在第二个示例中，我们使用`String.join()`方法连接字符串。

`Java8StringJoinEx2.java`

```java
package com.zetcode;

public class Java8StringJoinEx2 {

    public static void main(String[] args) {

        String join = String.join("/", "2016", "8", "5");
        System.out.println(join);
    }
}

```

`String.join()`方法在内部使用`StringJoiner`。

```java
String join = String.join("/", "2016", "8", "5");

```

日期与`String.join()`方法连接在一起。

```java
$ java com.zetcode.Java8StringJoinEx2 
2016/8/5

```

This is the output of the example.

## 连接列表

第三个示例连接列表的元素。

`Java8StringJoinEx3.java`

```java
package com.zetcode;

import java.util.Arrays;
import java.util.List;

public class Java8StringJoinEx3 {

    public static void main(String[] args) {

        List<String> list = Arrays.asList("Today", "is", "a", "beautiful", "day");
        String joined = String.join(" ", list); 

        System.out.println(joined);
    }
}

```

可以将列表作为参数传递给`String.join()`方法。

```java
String joined = String.join(" ", list); 

```

列表中的元素以单个空格字符连接。

```java
$ java com.zetcode.Java8StringJoinEx3 
Today is a beautiful day

```

列表中的元素被连接起来以创建一个句子。

## 读取 CSV 文件

以下示例从 CSV 文件中读取数字，然后将其与`StringJoiner`结合在一起。 我们使用 Gradle 构建工具构建示例。

```java
$ tree
.
├── build.gradle
└── src
    └── main
        ├── java
        │   └── com
        │       └── zetcode
        │           └── Java8StringJoinEx4.java
        └── resources
            └── numbers.csv

6 directories, 3 files

```

该示例具有他的项目结构。 我们将要读取的数字位于`resources`目录中。

`build.gradle`

```java
version '1.0'

apply plugin: 'java'
apply plugin: 'application'

sourceCompatibility = 1.8

mainClassName = "com.zetcode.Java8StringJoinEx4"

```

这是 Gradle 构建文件。

`numbers.csv`

```java
13,24,35,16,50

```

这是`numbers.csv`文件。

`Java8StringJoinEx4.java`

```java
package com.zetcode;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.StringJoiner;

public class Java8StringJoinEx4 {

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

        Scanner scanner = new Scanner(new File("src/main/resources/numbers.csv"));
        scanner.useDelimiter(",");

        StringJoiner join = new StringJoiner("|");

        while (scanner.hasNext()) {

            join.add(scanner.next());
        }

        scanner.close();

        System.out.println(join);
    }
}

```

该示例读取包含数字的 CSV 文件，并使用其他定界符将它们与`StringJoiner`结合在一起。

```java
Scanner scanner = new Scanner(new File("src/main/resources/numbers.csv"));
scanner.useDelimiter(",");

```

使用`Scanner`类读取值。 数字之间用逗号分隔，因此我们使用`useDelimiter()`方法设置逗号分隔符。

```java
StringJoiner join = new StringJoiner("|");

```

`StringJoiner`类用“ |”实例化。 定界符。

```java
while (scanner.hasNext()) {

    join.add(scanner.next());
}

```

我们使用扫描器检索值并将其与连接器连接。

```java
$ gradle build
:compileJava
:processResources
:classes
:jar
:startScripts
:distTar
:distZip
:assemble
:compileTestJava UP-TO-DATE
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test UP-TO-DATE
:check UP-TO-DATE
:build

BUILD SUCCESSFUL

```

我们使用`gradle build`命令构建项目。

```java
$ gradle run
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:run
13|24|35|16|50

```

我们使用`gradle run`命令运行该应用。 最后一行是我们应用的输出。

## 编写 CSV 文件

下一个示例将数字写入 CSV 文件。

```java
$ tree
.
├── build.gradle
└── src
    └── main
        └── java
            └── com
                └── zetcode
                    └── Java8StringJoinEx5.java

```

该示例具有他的项目结构。 我们将在当前工作目录中创建一个新文件。

`build.gradle`

```java
version '1.0'

apply plugin: 'java'
apply plugin: 'application'

sourceCompatibility = 1.8

mainClassName = "com.zetcode.Java8StringJoinEx5"

```

This is the Gradle build file.

`Java8StringJoinEx5.java`

```java
package com.zetcode;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringJoiner;

public class Java8StringJoinEx5 {

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

        StringJoiner join = new StringJoiner(",");
        join.add("21");
        join.add("43");
        join.add("54");
        join.add("76");
        join.add("98");

        File newFile = new File("numbers2.csv");
        newFile.createNewFile();

        PrintWriter pw = new PrintWriter(newFile);
        pw.write(join.toString());
        pw.close();
    }
}

```

该示例将五个数字与`StringJoiner`结合在一起，然后将所包含的字符串写入 CSV 文件。

```java
StringJoiner join = new StringJoiner(",");
join.add("21");
join.add("43");
join.add("54");
join.add("76");
join.add("98");

```

五个数字与`StringJoiner`连接在一起。 数字用逗号分隔。

```java
File newFile = new File("numbers.csv");
newFile.createNewFile();

```

在当前工作目录中创建一个新的文件对象。

```java
File newFile = new File("numbers.csv");
newFile.createNewFile();

```

A new file object is created in the current working directory.

```java
PrintWriter pw = new PrintWriter(newFile);
pw.write(join.toString());
pw.close();

```

合并的值将写入文件。

```java
$ gradle build run

```

我们构建并运行该应用。

```java
$ cat numbers2.csv 
21,43,54,76,98

```

我们显示创建文件的内容。

## `Collectors.joining()`

Java8 还在新的流 API 中引入了`Collectors.joining()`方法。 该方法返回一个`Collector`，它按遇到顺序连接由指定定界符分隔的输入元素。

`Java8CollectorJoiningEx.java`

```java
package com.zetcode;

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Java8CollectorJoiningEx {

    public static void main(String[] args) {

        Stream<String> stream = Stream.of("Jan", "Peter", "Robert");

        String names = stream.collect(Collectors.joining(" "));

        System.out.println(names);
    }
}

```

该示例使用流 API 连接三个名称。

```java
$ java com.zetcode.Java8CollectorJoiningEx 
Jan Peter Robert

```

This is the output of the example.

在本文中，我们使用了 Java8 中引入的新类`StringJoiner`。我们还添加了一个小示例，显示了来自流 API 的新`Collectors.joining()`。

您可能也对以下相关教程感兴趣： [Java 教程](/lang/java/)， [Java8 `forEach`教程](/articles/java8foreach/)，[Google Guava 简介](/articles/guava/)，[在 Java 中过滤列表](/articles/javafilterlist/)或 [Android 教程](/mob/android/)。