web-dev-qa-db-ger.com

Java-Sammlungen konvertieren eine Zeichenfolge in eine Liste von Zeichen

Ich möchte die Zeichenfolge, die abc enthält, in eine Liste von Zeichen und eine Hashmenge von Zeichen konvertieren. Wie kann ich das in Java machen? 

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

Sie müssen entweder eine Schleife verwenden oder einen Collection-Wrapper wie Arrays.asList erstellen, der für primitive Char-Arrays (oder direkt für Strings) funktioniert.

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

Hier ist ein Arrays.asList-ähnlicher Wrapper für 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); }
    };
}

Dies ist jedoch eine unveränderliche Liste. Wenn Sie eine veränderliche Liste wünschen, verwenden Sie diese mit einem 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;
       }
    };
}

Analog dazu können Sie dies für die anderen primitiven Typen implementierenBeachten Sie, dass die Verwendung dieser Option normalerweise nicht empfohlen wird, da Sie für jeden Zugriff eine Box- und Unboxing-Operation ausführen würden.

Die Guava-Bibliothek enthält ähnliche List-Wrapper-Methoden für mehrere primitive Array-Klassen wie Chars.asList und einen Wrapper für String in Lists.charactersOf (String) .

40
Paŭlo Ebermann

In Java8 können Sie Streams verwenden, die ich annehme . Liste der Character-Objekte:

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

Und das Set könnte auf ähnliche Weise erhalten werden:

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

Das Fehlen einer guten Methode zum Konvertieren zwischen einem primitiven Array und einer Sammlung des entsprechenden Wrapper-Typs wird durch einige Bibliotheken von Drittanbietern behoben. Guava, eine sehr häufige, hat eine bequeme Methode, um die Konvertierung durchzuführen :

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

Verwenden Sie eine Java 8 Stream.

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

Nervenzusammenbruch:

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>

(Ich habe absolut keine Ahnung, warum String#chars() eine IntStream zurückgibt.)

9
Moira

Am einfachsten ist es, eine for-Schleife zu verwenden, um Elemente zu einer neuen List hinzuzufügen:

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

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

Ähnlich für eine Set:

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

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

Vielleicht könnte das funktionieren - 

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

Sie können dies ohne Boxen tun, wenn Sie Eclipse Collections verwenden:

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

Da CharAdapter eine ImmutableCharList ist, wird beim Aufruf von collect eine ImmutableList zurückgegeben.

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

Wenn Sie eine geschachtelte List, Set oder Bag von Character zurückgeben möchten, funktioniert Folgendes:

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

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen.

1
Donald Raab

Mit Java 8 - Stream Funtion:

Konvertieren einer Zeichenfolge in eine Zeichenliste:

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

Konvertieren einer Zeichenliste in einen String:

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

Mit IntStream können Sie auf jedes Zeichen zugreifen und es der Liste hinzufügen. 

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