int[] til string

ved at sige "" + intværdi

fx

int[] array = { 1,2,3,4,5,6 };
String[] stringArray = new String[array.length];
for( int i = 0; i < array.length; i++ )
  stringArray[i] = "" + array[i];

bemærk at der ikke ønskes en StringArray - men en String

så her en metode, som kan gøre arbejdet...

private String intArray2Str( int[] ints ) {
  StringBuffer sb = new StringBuffer();
  for( int i = 0; i < ints.length; ++i )
    sb.append(""+ints[i]);
  return sb.toString();
}

Bygget på ovenstående idé dog uden string array:

int[] array = { 1,2,3,4,5,6 };
String result="";
for( int i = 0; i < array.length; i++ )
  result += ("" + array[i]);

ah ja

repsak >> ved ikke om du kan appende på den måde - i hvert fald (hvis det virker), så er den møg-u-effektiv, da du hele tiden oprettet et nyt StringObjekt ... Hvis man ved, at man har en String, som der løbende skal ændres/tilføjes noget til, så bør man bruge StringBuffer...

bearhugx: det kan du

conehead >> var der noget, du kunne bruge

riversen >> det kan jeg jo egenligt godt se nu :-)) .. men det afholder mig dog ikke fra at sige, at "String=String+String"-appending er en resource-sluger i forhold til en StringBuffer :-)

bearhugx: ja, det er ikke nær så effektivt

til info er der en metode i StringBuffer der tager en int som parameter så "" + ints[i] er overflødigt.... append( ints[i] ) er fint

kommer til at tænke på om "" + ints[i] faktisk ikke også svarer til res += string1 + string2...det resulterer jo også i en ny streng

øh det var string=string1+string2 jeg mente

og dermed er næsten ligeså ineffektivt...

nej, det er vist ikke når man kigger på koden i StringBuffer

riversen ... tjooo ... du må have ret i at
  append( "" + int ) er (næsten lige så) ineffektivt ...

det, der sker er at
  "" + int
bliver evalueret og et String-objekt bliver oprettet, så derefter ser udstrykket således ud
  append ( string )

Så derfor er det da nok
  append( int )
man skal bruge, hvis man vil have det mest effektivt...

dvs
private String intArray2Str( int[] ints ) {
  StringBuffer sb = new StringBuffer();
  for( int i = 0; i < ints.length; ++i )
    sb.append( ints[i] );
  return sb.toString();
}

men int'en bliver også konveret til en string et eller andet sted, men hvordan det foregår har jeg ikke tjekket nærmere. Så vigtigt er det vist heller ikke :-)

i kildekoden for StringBuffer ser metoden append(int) således ud

    public StringBuffer append(int i) {
    return append(String.valueOf(i));
    }

så spørgsmålet ligger i om
  String.valueOf( int )

er bedre/mere effektivt end
  "" + int

/Søren

valueof laver noget i integer klasse...toString( 1, 10 )

hvis tallet er 1

Kigger lige i Integer klassen :-))

Hmmm det går sgu næsten i ring...

toString( int, 10 ) kalder toString( int ) hvis radix er 10 (hvilket den jo er :-)

Og den kode er en værre mobbedreng :

public static String toString(int i) {
  int q, r, charPos;
  charPos = 12 ;
  char buf [] = new char [charPos] ;
  char sign = 0 ;

  if (i == Integer.MIN_VALUE) {
    return "-2147483648";
  }
  if (i < 0) {
    sign = '-' ;
    i = -i ;
  }

  // Generate two digits per iteration
  while ( i >= 65536 ) {
    q = i / 100 ;
    // really: r = i - (q * 100) ;
    r = i - ((q << 6) + (q << 5) + (q << 2)) ;
    i = q ;
    buf [--charPos] = DigitOnes [r] ;
    buf [--charPos] = DigitTens [r] ;
  }

  // Fall thru to fast mode for smaller numbers
  // assert(i <= 65536, i);
  for (;;) {
    q = (i * 52429) >>> (16+3) ;
    r = i - ((q << 3) + (q << 1)) ;  // r = i-(q*10) ...
    buf [--charPos] = digits [r] ;
    i = q ;
    if (i == 0) break ;
  }
  if (sign != 0) {
    buf [--charPos] = sign ;
  }

  // Use the back-door private constructor -- we abandon the
  // char [].  This requires that we drop the "private" from the
  // java.lang.String: String (int Offset,int Count,char[]
  // Value) constructor.

  return new String ( charPos, 12 - charPos, buf ) ;
}


Alt i alt så sker følgende altså når man kalder
  StringBuffer.append( int );

kald    --> String.valueOf( int )
kald    --> Integer.toString( int, 10 )
process --> if( radix == 10 )
kald    --> Integer.toString( int )
process --> (en masse...)
kald    --> new String( int, int, char[] )


Det sjove er - at jeg ikke kan finde en metode på String som har signaturen
  int , int, char[]

kun en 
  char[], int, int

Undres!

Men måske er det "nemmere" at køre med ""+int - der er i hvert fald ikke så mange metodekald :-)))

er det ikke præcis den samme toString metode der implicit bliver kaldt når du siger ""+int

jakoba >> jeg må indrømme at jeg ikke ved det ---
for i modsætning til f.eks. C++ , hvor man kan gå ind og "se/ændre kode for '+'-operatoren, så ved jeg ikke hvordan Java, rent kodemæssigt, gør det

Hvad jeg ved er, at det så bliver StringBuffer.append( String ) som bliver kaldt

Hvad der sker i kaldene/processen fra
  ""+int
til
  String
ved jeg ikke -

Man kunne forestille sig, at den først opretter strengen "" og derefter bruger concat metoden til at føje int'en på - men det er ren spekulation

/Søren