Java 8 流 |带有示例的 Collectors.joining() 方法

Java中 Collectors 类的 join ()方法用于将字符或字符串组的各种元素连接成单个字符串对象。此方法使用流来执行此操作。 Collector 类中存在多种连接方法的重载。

类层次结构：

java.lang.Object
  ↳ java.util.stream.Collectors

加入（）

Java.util.stream.Collectors.joining()是最简单的加入方法，不带任何参数。它返回一个收集器，该收集器按照出现的顺序将输入流连接或连接成字符串。

句法：

public static Collector joining()

下面是如何使用 join() 方法的说明：

程序 1：使用带有字符数组的 join() ：

在下面的程序中，在 'ch' 中创建了一个字符数组。然后使用 Stream.of() 将该数组输入以转换为 Stream。然后使用 map() 将结果流映射为顺序序列。最后，使用 Collectors.joining() 方法将包含字符数组的顺序流连接成一个字符串。它存储在“chString”变量中。

// Java Program to demonstrate the working
// of the Collectors.joining() method
  
import java.util.stream.Collectors;
import java.util.stream.Stream;
  
public class GFG {
    public static void main(String[] args)
    {
        // Create a character array
        char[] ch = { 'G', 'e', 'e', 'k', 's',
                      'f', 'o', 'r',
                      'G', 'e', 'e', 'k', 's' };
  
        // Convert the character array into String
        // using Collectors.joining() method
        String chString = Stream.of(ch)
                              .map(arr -> new String(arr))
                              .collect(Collectors.joining());
  
        // Print the concatenated String
        System.out.println(chString);
    }
}

输出：

GeeksforGeeks

程序 2：使用带有字符列表的 join() ：

在下面的程序中，在“ch”中创建了一个字符列表。然后使用 ch.stream() 方法将此列表输入以转换为 Stream。然后使用 map() 将结果流映射为顺序序列。最后，使用 Collectors.joining() 方法将包含字符列表的顺序流连接成一个字符串。它存储在“chString”变量中。

// Java Program to demonstrate the working
// of the Collectors.joining() method
  
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.Arrays;
import java.util.List;
  
public class GFG {
    public static void main(String[] args)
    {
        // Create a character list
        List ch = Arrays.asList('G', 'e', 'e', 'k', 's',
                                           'f', 'o', 'r',
                                           'G', 'e', 'e', 'k', 's');
  
        // Convert the character list into String
        // using Collectors.joining() method
        String chString = ch.stream()
                              .map(String::valueOf)
                              .collect(Collectors.joining());
  
        // Print the concatenated String
        System.out.println(chString);
    }
}

输出：

GeeksforGeeks

程序 3：使用带有 n 个字符串列表的 join() ：

在下面的程序中，在“str”中创建了一个字符串列表。然后使用 str.stream() 方法将此列表输入以转换为 Stream。然后使用 map() 将结果流映射为顺序序列。最后，使用 Collectors.joining() 方法将包含字符列表的顺序流连接成一个字符串。它存储在“chString”变量中。

// Java Program to demonstrate the working
// of the Collectors.joining() method
  
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.Arrays;
import java.util.List;
  
public class GFG {
    public static void main(String[] args)
    {
        // Create a character list
        List str = Arrays.asList("Geeks", "for", "Geeks");
  
        // Convert the character list into String
        // using Collectors.joining() method
        String chString = str.stream()
                              .map(String::valueOf)
                              .collect(Collectors.joining());
  
        // Print the concatenated String
        System.out.println(chString);
    }
}

输出：

GeeksforGeeks

加入（分隔符）

Java.util.stream.Collectors.joining(CharSequence delimiter)是 join() 方法的重载，它以 delimiter 作为参数，类型为 CharSequence。定界符是用于将单词彼此分隔的符号或 CharSequence。例如，在每个句子中，空格“ ”默认用作其中单词的分隔符。它返回一个收集器，该收集器按照出现的顺序将输入元素连接或连接成字符串，由分隔符分隔。

句法：

public static Collector joining(CharSequence delimiter)

下面是如何使用 join(delimiter) 方法的说明：

程序 1：使用带有字符列表的连接（分隔符）：

在下面的程序中，在“ch”中创建了一个字符列表。然后使用 ch.stream() 方法将此列表输入以转换为 Stream。然后使用 map() 将结果流映射为顺序序列。最后，使用 Collectors.joining() 方法将包含字符列表的顺序流连接成一个字符串，其中“,”作为分隔符传递。它存储在“chString”变量中。

// Java Program to demonstrate the working
// of the Collectors.joining() method
  
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.Arrays;
import java.util.List;
  
public class GFG {
    public static void main(String[] args)
    {
        // Create a character list
        List ch = Arrays.asList('G', 'e', 'e', 'k', 's',
                                           'f', 'o', 'r',
                                           'G', 'e', 'e', 'k', 's');
  
        // Convert the character list into String
        // using Collectors.joining() method
        // with, as the delimiter
        String chString = ch.stream()
                              .map(String::valueOf)
                              .collect(Collectors.joining(", "));
  
        // Print the concatenated String
        System.out.println(chString);
    }
}

输出：

G, e, e, k, s, f, o, r, G, e, e, k, s

程序 2：使用 join(delimiter) 和字符串列表：

在下面的程序中，在“str”中创建了一个字符串列表。然后使用 str.stream() 方法将此列表输入以转换为 Stream。然后使用 map() 将结果流映射为顺序序列。最后，使用 Collectors.joining() 方法将包含字符列表的顺序流连接成一个字符串，其中“,”作为分隔符传递。它存储在“chString”变量中。

// Java Program to demonstrate the working
// of the Collectors.joining() method
  
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.Arrays;
import java.util.List;
  
public class GFG {
    public static void main(String[] args)
    {
        // Create a character list
        List str = Arrays.asList("Geeks", "for", "Geeks");
  
        // Convert the character list into String
        // using Collectors.joining() method
        String chString = str.stream()
                              .map(String::valueOf)
                              .collect(Collectors.joining(", "));
  
        // Print the concatenated String
        System.out.println(chString);
    }
}

输出：

Geeks, for, Geeks

加入（分隔符、前缀、后缀）

Java.util.stream.Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)是join() 方法的重载，它以CharSequence 类型的分隔符、前缀和后缀为参数。

定界符是用于将单词彼此分隔的符号或 CharSequence。前缀是在字符串的第一个元素的开头连接的符号或 CharSequence。然后 suffix 也是一个 CharSequence 参数，但它是在字符串的最后一个元素之后加入的。即最后。

例如，在每个 {Geeks, for, Geeks} 中，空格“ ”默认用作其中单词的分隔符。 '{' 是前缀，'}' 是后缀。它返回一个收集器，该收集器按照出现的顺序将输入元素连接或连接成字符串，由分隔符分隔。

句法：

public static Collector joining(CharSequence delimiter. 
                                                       CharSequence prefix,
                                                       CharSequence suffix))

下面是如何使用join(delimiter, prefix, suffix)方法的说明：

程序 1：使用带有字符列表的 join() ：

在下面的程序中，在“ch”中创建了一个字符列表。然后使用 ch.stream() 方法将此列表输入以转换为 Stream。然后使用 map() 将结果流映射为顺序序列。最后，使用 Collectors.joining() 方法将包含字符列表的顺序流连接成一个字符串，其中“,”作为分隔符传递，“[”作为前缀，“]”作为后缀。它存储在“chString”变量中。

// Java Program to demonstrate the working
// of the Collectors.joining() method
  
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.Arrays;
import java.util.List;
  
public class GFG {
    public static void main(String[] args)
    {
        // Create a character list
        List ch = Arrays.asList('G', 'e', 'e', 'k', 's',
                                           'f', 'o', 'r',
                                           'G', 'e', 'e', 'k', 's');
  
        // Convert the character list into String
        // using Collectors.joining() method
        // with, as the delimiter
        String chString = ch.stream()
                              .map(String::valueOf)
                              .collect(Collectors.joining(", ", "[", "]"));
  
        // Print the concatenated String
        System.out.println(chString);
    }
}

输出：

[G, e, e, k, s, f, o, r, G, e, e, k, s]

程序 2：使用 join() 和字符串列表：

在下面的程序中，在“str”中创建了一个字符串列表。然后使用 str.stream() 方法将此列表输入以转换为 Stream。然后使用 map() 将结果流映射为顺序序列。最后，使用 Collectors.joining() 方法将包含字符列表的顺序流连接成一个字符串，其中“,”作为分隔符传递，“{”作为前缀，“}”作为后缀。它存储在“chString”变量中。

// Java Program to demonstrate the working
// of the Collectors.joining() method
  
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.Arrays;
import java.util.List;
  
public class GFG {
    public static void main(String[] args)
    {
        // Create a character list
        List str = Arrays.asList("Geeks", "for", "Geeks");
  
        // Convert the character list into String
        // using Collectors.joining() method
        String chString = str.stream()
                              .map(String::valueOf)
                              .collect(Collectors.joining(", ", "{", "}"));
  
        // Print the concatenated String
        System.out.println(chString);
    }
}

输出：

{Geeks, for, Geeks}