web-dev-qa-db-fra.com

Les collections Java convertissent une chaîne en une liste de caractères

Je voudrais convertir la chaîne contenant abc en une liste de caractères et un hachage de caractères. Comment puis-je faire cela en Java? 

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

Vous devrez soit utiliser une boucle, soit créer un wrapper de collection tel que Arrays.asList qui fonctionne sur les tableaux de caractères primitifs (ou directement sur les chaînes).

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

Voici un Arrays.asList comme wrapper pour les chaînes:

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); }
    };
}

Celui-ci est une liste immuable, cependant. Si vous voulez une liste modifiable, utilisez-la avec un 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;
       }
    };
}

De manière analogue, vous pouvez implémenter ceci pour les autres types de primitifs .Notez que son utilisation n’est normalement pas recommandée, car pour chaque accès, vous feriez une opération de boxe et de déballage.

La bibliothèque Guava contient similaire Méthodes de wrapper pour plusieurs classes de tableaux primitifs , comme Chars.asList , et un wrapper pour String in Lists.charactersOf (String) .

40
Paŭlo Ebermann

En Java8, vous pouvez utiliser des flux, je suppose ... Liste des objets Character:

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

Et l'ensemble pourrait être obtenu de la même manière:

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

L'absence d'un bon moyen de convertir un tableau primitif en une collection du type d'enveloppe correspondant est résolue par certaines bibliothèques tierces. La goyave, très commune, a une méthode pratique pour effectuer la conversion :

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

Utilisez une version Stream de Java 8.

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

Panne:

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>

(Je ne sais absolument pas pourquoi String#chars() renvoie IntStream.)

9
Moira

La méthode la plus simple consiste à utiliser une boucle for pour ajouter des éléments à une nouvelle List:

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

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

De même, pour un Set:

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

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

Peut-être que cela pourrait marcher - 

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

Vous pouvez le faire sans boxer si vous utilisez Eclipse Collections :

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

Étant donné que CharAdapter est une ImmutableCharList, appeler collect dessus renverra une ImmutableList.

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

Si vous souhaitez renvoyer une boîte List, Set ou Bag sur Character, ce qui suit fonctionnera:

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

Remarque: je suis un partisan des collections Eclipse.

1
Donald Raab

IntStream peut être utilisé pour accéder à chaque caractère et les ajouter à la liste. 

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