TOC

Verbinden Sie ein Array von Primitiven mit einem Trennzeichen in Java

1. Einleitung

In diesem kurzen Lernprogramm erfahren Sie, wie Sie ein Array von Primitiven mit einem Einzelzeichen-Trennzeichen in Java verknüpfen. In unseren Beispielen betrachten wir zwei Arrays: ein Array von int und ein Array von char .

2. Problem definieren

Beginnen wir mit der Definition eines Arrays von int und eines Arrays von char für die Beispiele sowie des Trennzeichens, das wir verwenden, um deren Inhalt zu verknüpfen: 

int[]intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9};
char[]charArray = {'a', 'b', 'c', 'd', 'e', 'f'};
char separatorChar = '-';
String separator = String.valueOf(separatorChar);

Beachten Sie, dass wir ein char - und String -Trennzeichen enthalten, da ** einige der Methoden, die wir zeigen, ein char -Argument erfordern, während andere ein String -Argument benötigen

Die Ergebnisse der Verbindungsoperation enthalten "1-2-3-4-5-6-7-8-9" für das int -Array und "a-b-c-d-e-f" für das char -Array.

3. Collectors.joining ()

Beginnen wir mit einer der verfügbaren Methoden der Java 8 Stream API - Collectors.joining () .

Zuerst erstellen wir einen Stream aus einem Array von Grundelementen mit der Arrays.stream () - Methode, die im java.util -Paket gefunden wird. Als Nächstes ordnen wir jedes Element String zu. Zum Schluss verknüpfen wir die Elemente mit unserem angegebenen Trennzeichen.

Beginnen wir mit unserem int -Array: 

String joined = Arrays.stream(intArray)
  .mapToObj(String::valueOf)
  .collect(Collectors.joining(separator));

  • Wenn Sie unser char -Array mit dieser Methode verbinden, müssen Sie das char -Array zuerst in CharBuffer einwickeln und dann erneut auf char projizieren.

  • Leider bietet die Java Stream API keine native Methode zum Umschließen eines Stream von char . **

Verbinden wir unser char -Array: 

String joined = CharBuffer.wrap(charArray).chars()
  .mapToObj(intValue -> String.valueOf((char) intValue))
  .collect(Collectors.joining(separator));

4. StringJoiner

Ähnlich wie Collectors.joining () verwendet dieser Ansatz die Stream-API. Statt Elemente zu sammeln, werden Elemente durchlaufen und einer StringJoiner -Instanz hinzugefügt: 

StringJoiner intStringJoiner = new StringJoiner(separator);
Arrays.stream(intArray)
  .mapToObj(String::valueOf)
  .forEach(intStringJoiner::add);
String joined = intStringJoiner.toString();

  • Wieder müssen wir unser char -Array in CharBuffer ** umschließen, wenn Sie die Stream-API verwenden: 

StringJoiner charStringJoiner = new StringJoiner(separator);
CharBuffer.wrap(charArray).chars()
  .mapToObj(intChar -> String.valueOf((char) intChar))
  .forEach(charStringJoiner::add);
String joined = charStringJoiner.toString();

5. Apache Commons Lang

Die Bibliothek Apache Commons Lang bietet einige praktische Methoden in den Klassen StringUtils und ArrayUtils , die wir zum Verbinden unserer primitiven Arrays verwenden können.

Um diese Bibliothek verwenden zu können, müssen wir die https://search.maven.org/classic/#search%7Cga%7C1%7Cg%3A%22org.apache.commons%22%20AND%20a%3A%22commons hinzufügen -lang3% 22[commons-lang3] https://search.maven.org/classic/#search%7Cga%7C1%7Cg%3A%22org.apache.commons%22%20AND%20a%3commons-lang3 % 22[Abhängigkeit]zu unserer pom.xml : 

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.8.1</version>
</dependency>

Bei der Arbeit mit einem String -Separator verwenden wir sowohl StringUtils als auch ArrayUtils .

Lassen Sie uns diese zusammen verwenden, um unser int -Array zu verbinden: 

String joined = StringUtils.join(ArrayUtils.toObject(intArray), separator);

Wenn Sie einen primitiven char -Typ als Trennzeichen verwenden, können Sie einfach schreiben 

String joined = StringUtils.join(intArray, separatorChar);

Die Implementierungen für das Hinzufügen unseres char -Arrays sind ziemlich ähnlich: 

String joined = StringUtils.join(ArrayUtils.toObject(charArray), separator);

Und bei Verwendung eines char -Separators: 

String joined = StringUtils.join(charArray, separatorChar);

6. Guave

Die Bibliothek Google’s Guava enthält die Joiner -Klasse, mit der wir unsere Arrays verbinden können. Um Guava in unserem Projekt verwenden zu können, müssen Sie https://search.maven.org/classic/#search%7Cga%7C1%7Cg%3A%22com.google.guava%22%20AND%20a%3A% hinzufügen. 22guava% 22[die guava Maven Abhängigkeit]: 

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>27.0.1-jre</version>
</dependency>

Lassen Sie uns unser int -Array mit der Joiner -Klasse verbinden: 

String joined = Joiner.on(separator).join(Ints.asList(intArray));

In diesem Beispiel haben wir auch die Methode Ints.asList () von Guava verwendet, die das Array von Primitiven in eine List von Integer umwandelt.

Guava bietet eine ähnliche Methode zum Konvertieren eines char -Arrays in eine List of Character. . Daher sieht das Verbinden unseres char -Arrays sehr ähnlich dem obigen Beispiel aus, das das int -Array verwendet: 

String joined = Joiner.on(separator).join(Chars.asList(charArray));

7. StringBuilder

  • Wenn wir weder Java 8-Bibliotheken noch Bibliotheken von Drittanbietern verwenden können, können Sie ein Array von Elementen manuell mit StringBuilder ** verknüpfen. In diesem Fall ist die Implementierung für beide Arten von Arrays identisch: 

if (array.length == 0) {
    return "";
}
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < array.length - 1; i++) {
    stringBuilder.append(array[i]);
    stringBuilder.append(separator);
}
stringBuilder.append(array[array.length - 1]);
String joined = stringBuilder.toString();

8. Fazit

Dieser kurze Artikel beschreibt eine Reihe von Möglichkeiten, um ein Array von Grundelementen mit einem bestimmten Trennzeichen oder einer Zeichenfolge zu verbinden. Wir zeigten Beispiele mit nativen JDK-Lösungen sowie zusätzliche Lösungen mit zwei Drittanbieter-Bibliotheken - Apache Commons Lang und Guava.

Der in diesem Artikel verwendete vollständige Code ist wie immer verfügbar: over auf GitHub .

Related