Espace d'impression après chaque mot

Question

Qu'est-ce qu'un moyen simple/efficace de combiner un ensemble de mots avec un espace intermédiaire, mais pas d'espace avant ou après?

Je suppose qu'il est possible de supprimer l'espace après avoir tout combiné dans une boucle (quelque chose comme sum + = (term + "")) ... Je ne l'aime pas bien.

De préférence, codez en Java, Python ou Ruby.

Answer 1

Eh bien, en Python, il sera facile à l'aide rejoindre:

values = ["this", "is", "your", "array"] 
result = " ".join(values) 

Answer 2

Ce que vous voulez, c'est String.Join, mais puisque vous venez de dire que cela ne vous aidera probablement pas, voici quelques Join implementations in Java. Voici un string utility qui a une jointure pour Java.

Answer 3

Il ne faut pas oublier le bon vieux

for s in strArray do 
    print s 
    print " " 

Answer 4

Eh bien, je sais que Python a une fonction comme celui-ci, et je suppose que Ruby fait, et Java. La fonction join prend un tableau de chaînes (en fonction de la langue, il peut être d'autres types) et les joint avec un caractère (ou une autre chaîne) que vous choisissez.

code Python:

wordString = " ".join(["word", "another", "word"]) 

Sinon, vous pouvez parcourir, le tableau, en ajoutant le mot et un espace, et tester si elle est le dernier élément. Si c'est le cas, ajoutez simplement le mot, et non l'espace.

code Python à nouveau: (grâce à PTBNL pour la suggestion)

wordArray = ["word", "another", "word"] 
wordString = "" 
for i in range(0, len(wordArray) - 1): 
    wordString += wordArray[i] + " " 
wordString += wordArray[len(wordArray) - 1] 

Answer 5

Oui, voici ce qui a été fait pour join. Voici la version Ruby:

["word", "another", "word"].join(" ") 

<flamebait> Comme vous pouvez le voir, Ruby fait join une méthode sur Array au lieu de String, et est donc beaucoup plus sensible. </flamebait>

Answer 6

droite d'un de mes classes de utilz existantes

C: \ java \ home \ src \ KRC \ utilz \ Arrayz.java

package krc.utilz; 

/** 
* A bunch of static helper methods for arrays of String's. 
* @See also krc.utilz.IntArrays for arrays of int's. 
*/ 
public abstract class Arrayz 
{ 
    /** 
    * Concetenates the values in the given array into a string, seperated by FS. 
    * @param FS String - Field Seperator - Name borrowed from awk 
    * @param Object[] a - array to be concatentated 
    * @return a string representation of the given array. 
    */ 
    public static String join(String FS, Object[] a) { 
    if (a==null||a.length==0) return ""; 
    StringBuilder result = new StringBuilder(String.valueOf(a[0])); 
    for(int i=1; i<a.length; i++) { 
     result.append(FS); 
     result.append(String.valueOf(a[i])); 
    } 
    return result.toString(); 
    } 

    .... 

} 

Vive. Keith

---

EDIT

Voici une comparaison des performances sale & rapide, en utilisant java.util.Arrays comme base de référence.

Notez que le coût du hotspot est amorti sur 100 itérations, et devrait être (plus ou moins) le même pour les trois techniques ... krc.utilz.RandomString et krc.utilz.Arrayz sont tous deux disponibles sur demande, il suffit de demander .

package forums; 

import java.util.Arrays; 
import krc.utilz.Arrayz; 
import krc.utilz.RandomString; 

class ArrayToStringPerformanceTest 
{ 
    private static final int NS2MS = 1000000; // 1 millisecond (1/10^3) = 1,000,000 nanoseconds (1/10^9) 

    public static void main(String[] args) { 
    try { 
     String[] array = randomStrings(100*1000, 16); 
     long start, stop; 
     String result; 

     final int TIMES = 100; 
     long time1=0L, time2=0L, time3=0L; 

     for (int i=0; i<TIMES; i++) { 

     start = System.nanoTime(); 
     result = Arrays.toString(array); 
     stop = System.nanoTime(); 
     //System.out.println("Arrays.toString took "+(stop-start)+" ns"); 
     time1 += (stop-start); 

     start = System.nanoTime(); 
     result = Arrayz.join(", ", array); 
     stop = System.nanoTime(); 
     //System.out.println("Arrayz.join  took "+(stop-start)+" ns"); 
     time2 += (stop-start); 

     start = System.nanoTime(); 
     result = arrayToString(array, ", "); 
     stop = System.nanoTime(); 
     //System.out.println("arrayToString took "+(stop-start)+" ns"); 
     time3 += (stop-start); 

     } 
     System.out.format("java.util.Arrays.toString took "+(time1/TIMES/NS2MS)+" ms"); 
     System.out.format("krc.utilz.Arrayz.join  took "+(time2/TIMES/NS2MS)+" ms"); 
     System.out.format("arrayToString    took "+(time3/TIMES/NS2MS)+" ms"); 

    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
    } 

    public static String arrayToString(String[] array, String spacer) { 
    StringBuffer result = new StringBuffer(); 
    for (int i=0; i<array.length; i++) { 
     result.append(array[i] + ((i+1<array.length)?spacer:"")); 
    } 
    return result.toString(); 
    } 

    private static String[] randomStrings(int howMany, int length) { 
    RandomString random = new RandomString(); 
    String[] a = new String[howMany]; 
    for (int i=0; i<howMany; i++) { 
     a[i] = random.nextString(length); 
    } 
    return a; 
    } 

} 

/* 
C:\Java\home\src\forums>"C:\Program Files\Java\jdk1.6.0_12\bin\java.exe" -Xms512m -Xmx1536m -enableassertions -cp C:\Java\home\classes forums.ArrayToStringPerformanceTest 

java.util.Arrays.toString took 26 ms 
krc.utilz.Arrayz.join  took 32 ms 
arrayToString    took 59 ms 
*/ 

Voir aussi la suggestion de Doomspork, et mon commentaire à ce sujet.

Cheers. Keith

Answer 7

Java pourrait être accompli avec quelque chose comme ceci:

public static String arrayToString(String[] array, String spacer) { 
    StringBuffer result = new StringBuffer(); 
    for(int i = 0 ; i < array.length ; i++) { 
     result.append(array[i] + ((i + 1 < array.length) ? spacer : "")); 
    } 
    return result.toString(); 
} 

Answer 8

En Python, demandez-vous la rejoindre la chaîne-join une itérables de cordes:

alist= ["array", "of", "strings"] 
output= " ".join(alist) 

Si cette notation semble bizarre vous, vous pouvez faire la même chose dans une syntaxe différente:

output= str.join(" ", alist) 

Ceci fonctionne pour n'importe quel itérable (listes, tuples, dictionnaires, générateurs, expressions de générateur ...), tant que les articles sont toutes les chaînes (ou chaînes d'Unicode).

Vous pouvez remplacer unicode pour str (ou u' ' pour ' ') si vous voulez un résultat unicode.

Answer 9

Cela fonctionne en Ruby ainsi:

['a', 'list', 'of', 'words'] * " "