Quick Answer
The simplest way to convert a List<String> to a string in modern Java is to use String.join(delimiter, list) for basic comma-style outputs, or list.stream().collect(Collectors.joining(delimiter)) for flexible delimiters and advanced reduction. For ordered, predictable results, prefer these over manual loops.
Core Methods to Convert a List to String
Choose the right approach based on your output format, Java version, and performance needs. Below are the most common, reliable patterns with short examples using a list containing "apple", "banana", and "cherry".
String.join (simple delimiter)
- Use case: Join with a single fixed delimiter (commas, semicolons, spaces).
- Example: String.join(", ", list) returns apple, banana, cherry
- Notes: Works with List<String>. Does not support transformation or filtering inline.
Collectors.joining with Stream
- Use case: Flexible delimiter, optional prefix/suffix, and integration with other stream steps.
- Example: list.stream().collect(Collectors.joining(", ")) returns apple, banana, cherry
- Notes: Works with List<String>. You can chain map to transform elements before joining.
StringBuilder in a loop (pre‑Java 8 or custom logic)
- Use case: Fine‑grained control, conditional appends, or avoiding streams in older codebases.
- Example: Iterate and append with delimiter handling; typically slightly less concise but very clear.
- Notes: Efficient for manual builds; avoids creating intermediate streams when not needed.
One‑liner utility (Apache Commons Lang)
- Use case: Concise, tested behavior with many options (e.g., overriding separator, handling nulls).
- Example: StringUtils.join(list, ", ") returns apple, banana, cherry
- Notes: Requires an external dependency. Well‑suited when you already use Apache Commons Lang.
Performance and Practical Guidance
Performance differences are usually negligible for small to medium lists; readability and correctness matter most. StringBuilder and joining streams are optimized for most everyday use cases. For very large lists, avoid repeated string concatenation (+), and consider initial capacity on StringBuilder when the total size is predictable.
Behavior with Non‑String Elements
If your list holds other types (for example, List<Integer>), map to strings first. With streams you can use list.stream().map(Object::toString).collect(Collectors.joining(", ")). With String.join, you must convert elements to Strings beforehand, since String.join expects List<String>.
Null Handling and Edge Cases
- Null elements: String.join treats null as "null". Streams with Collectors.joining pass null through mapToString; consider using Objects.toString or filtering if you need different behavior.
- Empty list: Both String.join and joining return an empty string.
- Single element: Output is that element without the delimiter unless you add a prefix/suffix with joining.
Delimiters and Formatting Options at a Glance
| Method | Delimiter Control | Prefix / Suffix | Element Transformation | Requires Extra Dependency |
|---|---|---|---|---|
| String.join | Single delimiter | No | No (input must be String) | No |
| Collectors.joining | Single delimiter | Yes | Yes (via map) | No |
| StringBuilder loop | Custom logic | Yes (manual) | Yes (manual) | No |
| StringUtils.join | Configurable | Configurable | Pre‑map required | Yes (Apache Commons Lang) |
Best Practices and Common Pitfalls
- Use String.join or Collectors.joining for most new code; they are concise and clearly express intent.
- Avoid " +" concatenation in loops for large lists; prefer StringBuilder or streams for efficiency.
- Check for nulls in the list when you need strict output formats; nulls are rendered as the literal string "null" by default.
- Prefer immutable results: the returned string is independent of the original list, so changes to the list do not affect the joined string.
- When order matters, all listed methods preserve the iteration order of the List implementation (e.g., ArrayList, LinkedList).
Java Version and API Notes
String.join became available in Java 8. Collectors.joining has been part of the Stream API since Java 8. If you are on older JDK versions, use StringBuilder or third‑party utilities. All examples here are compatible with Java 17 and later; they are also forward‑compatible with future Java releases.
Summary
Converting a List to a string in Java is straightforward and flexible. For most cases, String.join(delimiter, list) or list.stream().collect(Collectors.joining(delimiter)) provide clear, reliable, and concise solutions. Use StringBuilder for controlled iteration or when avoiding streams, and leverage StringUtils.join when you already depend on Apache Commons Lang. The approaches below cover simple delimiters, custom formatting, null handling, and performance considerations for both small and large lists.