phoenix
phoenix

Reputation: 3621

Java collections convert a string to a list of characters

I would like to convert the string containing abc to a list of characters and a hashset of characters. How can I do that in Java ?

List<Character> charList = new ArrayList<Character>("abc".toCharArray());

Upvotes: 82

Views: 225393

Answers (12)

waggledans
waggledans

Reputation: 1281

In Java, starting from Java 8, you can use streams. List of Character objects:

List<Character> chars = str.chars()
    .mapToObj(e->(char)e).collect(Collectors.toList());

And set could be obtained in a similar way:

Set<Character> charsSet = str.chars()
    .mapToObj(e->(char)e).collect(Collectors.toSet());

Upvotes: 88

ankit singh
ankit singh

Reputation: 1

We can convert List of String into Set of characters as below.

Set<Character> charSet = new HashSet<>();
List<String> strList = List.of("abc", "cde", "def", "afc");
strList.forEach(str -> {
                charSet.addAll(str.chars()
                                  .mapToObj(c -> (char) c)
                                  .collect(Collectors.toSet()));
            });

Output will be something like this.

[a, b, c, d, e, f]

Upvotes: 0

Bhakti Vora
Bhakti Vora

Reputation: 36

To get a list of Characters / Strings -

List<String> stringsOfCharacters = string.chars().
                                   mapToObj(i -> (char)i).
                                   map(c -> c.toString()).
                                   collect(Collectors.toList());

Upvotes: 0

Mathieu Allain
Mathieu Allain

Reputation: 359

List<String> result = Arrays.asList("abc".split(""));

Upvotes: 10

Donald Raab
Donald Raab

Reputation: 6706

You can do this without boxing if you use Eclipse Collections:

CharAdapter abc = Strings.asChars("abc");
CharList list = abc.toList();
CharSet set = abc.toSet();
CharBag bag = abc.toBag();

Because CharAdapter is an ImmutableCharList, calling collect on it will return an ImmutableList.

ImmutableList<Character> immutableList = abc.collect(Character::valueOf);

If you want to return a boxed List, Set or Bag of Character, the following will work:

LazyIterable<Character> lazyIterable = abc.asLazy().collect(Character::valueOf);
List<Character> list = lazyIterable.toList();
Set<Character> set = lazyIterable.toSet();
Bag<Character> set = lazyIterable.toBag();

Note: I am a committer for Eclipse Collections.

Upvotes: 1

Arpan Saini
Arpan Saini

Reputation: 5227

Using Java 8 - Stream Funtion:

Converting A String into Character List:

ArrayList<Character> characterList =  givenStringVariable
                                                         .chars()
                                                         .mapToObj(c-> (char)c)
                                                         .collect(collectors.toList());

Converting A Character List into String:

 String givenStringVariable =  characterList
                                            .stream()
                                            .map(String::valueOf)
                                            .collect(Collectors.joining())

Upvotes: 1

Sai
Sai

Reputation: 3967

Create an empty list of Character and then make a loop to get every character from the array and put them in the list one by one.

List<Character> characterList = new ArrayList<Character>();
char arrayChar[] = abc.toCharArray();
for (char aChar : arrayChar) 
{
    characterList.add(aChar); //  autoboxing 
}

Upvotes: 4

Paŭlo Ebermann
Paŭlo Ebermann

Reputation: 74800

You will have to either use a loop, or create a collection wrapper like Arrays.asList which works on primitive char arrays (or directly on strings).

List<Character> list = new ArrayList<Character>();
Set<Character> unique = new HashSet<Character>();
for(char c : "abc".toCharArray()) {
    list.add(c);
    unique.add(c);
}

Here is an Arrays.asList like wrapper for strings:

public List<Character> asList(final String string) {
    return new AbstractList<Character>() {
       public int size() { return string.length(); }
       public Character get(int index) { return string.charAt(index); }
    };
}

This one is an immutable list, though. If you want a mutable list, use this with a char[]:

public List<Character> asList(final char[] string) {
    return new AbstractList<Character>() {
       public int size() { return string.length; }
       public Character get(int index) { return string[index]; }
       public Character set(int index, Character newVal) {
          char old = string[index];
          string[index] = newVal;
          return old;
       }
    };
}

Analogous to this you can implement this for the other primitive types. Note that using this normally is not recommended, since for every access you would do a boxing and unboxing operation.

The Guava library contains similar List wrapper methods for several primitive array classes, like Chars.asList, and a wrapper for String in Lists.charactersOf(String).

Upvotes: 62

Vibodha Balalla
Vibodha Balalla

Reputation: 1

IntStream can be used to access each character and add them to the list.

String str = "abc";
List<Character> charList = new ArrayList<>();
IntStream.range(0,str.length()).forEach(i -> charList.add(str.charAt(i)));

Upvotes: 0

Salem
Salem

Reputation: 14967

Use a Java 8 Stream.

myString.chars().mapToObj(i -> (char) i).collect(Collectors.toList());

Breakdown:

myString
    .chars() // Convert to an IntStream
    .mapToObj(i -> (char) i) // Convert int to char, which gets boxed to Character
    .collect(Collectors.toList()); // Collect in a List<Character>

(I have absolutely no idea why String#chars() returns an IntStream.)

Upvotes: 17

Mark Peters
Mark Peters

Reputation: 81154

The lack of a good way to convert between a primitive array and a collection of its corresponding wrapper type is solved by some third party libraries. Guava, a very common one, has a convenience method to do the conversion:

List<Character> characterList = Chars.asList("abc".toCharArray());
Set<Character> characterSet = new HashSet<Character>(characterList);

Upvotes: 37

coobird
coobird

Reputation: 161022

The most straightforward way is to use a for loop to add elements to a new List:

String abc = "abc";
List<Character> charList = new ArrayList<Character>();

for (char c : abc.toCharArray()) {
  charList.add(c);
}

Similarly, for a Set:

String abc = "abc";
Set<Character> charSet = new HashSet<Character>();

for (char c : abc.toCharArray()) {
  charSet.add(c);
}

Upvotes: 8

Related Questions