Concaténation de plusieurs chaînes dans Arraylist qui peut avoir n'importe quelle valeur

Question

Mon exigence est que je dois écrire une méthode java dans ma classe qui acceptera un List<String> comme paramètre. Maintenant, je dois concaténer

public String encode(List<String> ls){ 
    StringBuffer sb = new StringBuffer(); 
    ListIterator<String> lis = ls.listIterator(); 
    while(lis.hasNext()){ 
     sb.append(lis.next()); 
     /*my code here 
     * sb.append(lis.next()); 
     * sb.append(some delim); 
     * 
     * 
     */ 
    } 
    //my code here 
    return sb.toString();  
} 

Maintenant les cordes dans la liste peut contenir toute valeur (char/num/char spécial etc), donc je ne peux pas utiliser délimiteurs communes comme ,/:/; etc. S'il vous plaît me suggérer la façon de faire la enchaîner.

Également à l'avenir, il se peut que je devrais diviser la même chaîne concaténée pour ma méthode différente. J'ai donc besoin d'utiliser un délimiteur ou une autre option qui peut être utilisée plus tard pour créer la liste une fois de plus.

Answer 1

cela peut ne pas être idéal mais une façon de le faire est de concaténer par une phrase aléatoire. Ainsi, pendant que vous itérez vous ajoutez une phrase ou un mot supplémentaire entre chaque chaîne .. et plus tard vous utilisez cette phrase comme délimiteur.

Answer 2

D'abord, si vous ne faites que sérialiser un objet à stocker/transférer, ne le faites pas. Utilisez l'annotation @Serializable et laissez l'API Java Serializing gérer cela pour vous. Si vous devez convertir une liste en chaîne et revenir en arrière pour des raisons, je vous recommande d'utiliser un délimiteur inhabituel (un ensemble de caractères comme <|>) ou d'être plus sûr, utilisez un délimiteur uuid et démarrez votre chaîne avec elle afin que vous puissiez l'identifier (comme <uuid>). Un uuid spécifique, par définition, ne devrait apparaître dans aucune liste que vous recevez. (sauf si vous réutilisez un uuid et rompez ce contrat) Le chemin UUID sera sûr, même lorsque vous manipulez des listes de listes (vous n'aurez donc pas besoin d'échapper à votre délimiteur ou de faire quelque chose de fou). Il est toutefois moins coûteux d'utiliser simplement <|> ou , comme délimiteur, puis de l'encoder/décoder en quelque chose d'autre lors de la conversion vers/depuis une chaîne. (Si la performance est en fait)

et enfin, je dois dire ...

public String encode(List<String> ls){ 
    StringBuffer sb = new StringBuffer(); 
    String delim = getDelimiter(); 
    for(String s : ls){ 
     sb.append(lis.next()); 
     sb.append(delim); 
    } 
    return sb.toString();  
} 

est tellement plus simple. Ne vous souciez pas d'obtenir un itérateur à moins que vous n'en ayez besoin (juste pour le garder simple), et si vous avez besoin d'un itérateur, assurez-vous de toujours vérifier "hasNext" avant de lire "next".