String fester Länge

[Bastian]

Hallo,
ich habe folgendes Problem:
ich habe eine Methode, die einen String fester Länge zurückgeben soll (360
Zeichen).
Dieser String wird aus mehreren Strings, die der Methode übergeben werden,
erzeugt. Die übergebenden Stings haben zusammen max. 360 Zeichen, minimal 0
Zeichen. Der return-String soll aber immmer 360 Zeichen lang sein (und wenn
es Leerzeichen sind). Gibt es eine einfachere Lösung, als zum Schluss die
Stringlänge zu bestimmen und dann mit fehlenden Leerzeichen aufzufüllen?

Viele Dank für Eure Hilfe!

Grüße,
Bastian

[Ingo Menger]

Post by Bastian
Hallo,
ich habe eine Methode, die einen String fester Länge zurückgeben soll (360
Zeichen).
Dieser String wird aus mehreren Strings, die der Methode übergeben werden,
erzeugt. Die übergebenden Stings haben zusammen max. 360 Zeichen, minimal 0
Zeichen. Der return-String soll aber immmer 360 Zeichen lang sein (und wenn
es Leerzeichen sind). Gibt es eine einfachere Lösung, als zum Schluss die
Stringlänge zu bestimmen und dann mit fehlenden Leerzeichen aufzufüllen?
Viele Dank für Eure Hilfe!

Spontan fällt mir folgendes ein:

static String blanks = " ... 360 Leerzeichen ";

static String fillupto360(String x) {
return (x+blanks).substring(0,299);
}

Aber besser ist natürlich eine generelle Lösung (Auffüllen auf n
Zeichen) unter Verwendung von StringBuffer.

[Daniel Kräcker]

... vielleicht hilft Dir das :)

StringBuffer _buffer = new StringBuffer( 360 );
for( int i = 0, l=_buffer.capacity (); i < l; i++)
{
_buffer.insert (i, ' ');
}

_buffer.insert (0, "Test");
_buffer.insert (8, "Test");
_buffer.insert (16, "Test");

String _result = _buffer.toString ();

System.out.println (_result);
System.out.println ("length = " +_result.length ());

MfG Daniel

[Sascha Broich]

Post by Daniel Kräcker
... vielleicht hilft Dir das :)
StringBuffer _buffer = new StringBuffer( 360 );
for( int i = 0, l=_buffer.capacity (); i < l; i++)
{
_buffer.insert (i, ' ');
}
_buffer.insert (0, "Test");

Insert fügt aber ein und ersetzt nicht. Also ist am Ende der String zu
lang.

Besser wäre also:

StringBuffer buffer=new StringBuffer(360);
buffer.append("test");
buffer.append("text");
...
for(int i=buffer.length();i<360;i++)
{
buffer.append(' ');
}




Sascha Broich

[Stefan Ram]

Gibt es eine einfachere Lösung, als zum Schluss die Stringlänge
zu bestimmen und dann mit fehlenden Leerzeichen aufzufüllen?

public class Main
{
public static java.lang.String str10a( final java.lang.String source )
{ return String.format( "%10s", source ); }

public static java.lang.String str10b( final java.lang.String source )
{ return String.format( "%-10s", source ); }

public static void main( final java.lang.String[] args )
{ java.lang.System.out.println( "|" + str10a( "alpha" )+ "|" );
java.lang.System.out.println( "|" + str10b( "alpha" )+ "|" ); }}

| alpha|
|alpha |

[Michael Rauscher]

Post by Bastian
Hallo,
ich habe eine Methode, die einen String fester Länge zurückgeben soll (360
Zeichen).
Dieser String wird aus mehreren Strings, die der Methode übergeben werden,
erzeugt. Die übergebenden Stings haben zusammen max. 360 Zeichen, minimal 0
Zeichen. Der return-String soll aber immmer 360 Zeichen lang sein (und wenn
es Leerzeichen sind). Gibt es eine einfachere Lösung, als zum Schluss die
Stringlänge zu bestimmen und dann mit fehlenden Leerzeichen aufzufüllen?

Zwar nicht mit Leerzeichen aber mit \u0000: StringBuilder#setLength()

Gruß
Michael

[Daniel Kräcker]

Ich meinte eigentlich StringBuffer#replace

String _str = "Test";
_buffer.replace (8, 8 + _str.length (), _str);

:)
Daniel

[Sascha Broich]

Post by Daniel Kräcker
Ich meinte eigentlich StringBuffer#replace
String _str = "Test";
_buffer.replace (8, 8 + _str.length (), _str);

Ist aber aufwendig. Da musst du ja zusätzlich noch die aktuelle
Länge/Position mitschleppen. (Irgendwie finde ich da meine Version
eleganter.)


Sascha Broich

[Wanja Gayk]

Post by Bastian
Hallo,
ich habe eine Methode, die einen String fester Länge zurückgeben soll (360
Zeichen).
Dieser String wird aus mehreren Strings, die der Methode übergeben werden,
erzeugt. Die übergebenden Stings haben zusammen max. 360 Zeichen, minimal 0
Zeichen. Der return-String soll aber immmer 360 Zeichen lang sein (und wenn
es Leerzeichen sind). Gibt es eine einfachere Lösung, als zum Schluss die
Stringlänge zu bestimmen und dann mit fehlenden Leerzeichen aufzufüllen?

Also das Auffüllen wäre auch meine erste Idee gewesen, die sähe in etwa
so aus:

public String getConcatStringOfLength(final int length,
final List<String> strings){
final StringBuffer buffer = new StringBuffer(length);
for(final String str : strings){
buffer.append(str);
}
if(buffer.capacity() > length){
throw new IllegalArgumentException("strings too large: "
+buffer.capacity()+" > "+length);
}
return fillBlanksToMaxCapacity(buffer).toString();
}

private StringBuffer fillBlanksToMaxCapacity(final StringBuffer buffer){
while(buffer.length() < buffer.capacity()){
buffer.append(" ");
}
return buffer;
}


Ist aber leider etwas langsam, hab's ausprobiert.
Laut meiner Messung geht das hier schneller (je länger die Liste von
Strings, desto geringer der Unterschied):

public String getConcatStringOfLength(final int length,
final List<String> strings){
final char[] result = new char[length];
int pos = 0;
for(final String str : strings){
final int len = str.length();
str.getChars(0, len, result, pos);
pos+=len;
}
Arrays.fill(result, pos, length, ' ');
return new String(result);
}

Möglicherweise geht es noch fixer, aber das hier geht schnell genug,
würde ich sagen.

Gruß,
-Wanja-

[Alfred]

Post by Bastian
Hallo,
ich habe eine Methode, die einen String fester Länge zurückgeben soll (360
Zeichen).
Dieser String wird aus mehreren Strings, die der Methode übergeben werden,
erzeugt. Die übergebenden Stings haben zusammen max. 360 Zeichen, minimal 0
Zeichen. Der return-String soll aber immmer 360 Zeichen lang sein (und wenn
es Leerzeichen sind). Gibt es eine einfachere Lösung, als zum Schluss die
Stringlänge zu bestimmen und dann mit fehlenden Leerzeichen aufzufüllen?
Viele Dank für Eure Hilfe!

Du fängst an, dir für solche Dinge eine Util- bzw. Helper-Klasse zu
schreiben. Zum Bleistift:

public class Formatter {

public static final int ALIGN_LEFT = 0;
public static final int ALIGN_RIGHT = 1;
public static final int ALIGN_CENTER = 2;

/**
* Formatiert einen String auf fixe L&auml;nge und f&uuml;llt mit
* 'ch' auf. Die Ausrichtung kann links- oder rechtsb&uuml;ndig
* oder zentriert erfolgen.
* siehe: Formatter.ALIGN_LEFT, Formatter.ALIGN_RIGHT,
* Formatter.ALIGN_CENTER.
*
* @param str die zu formatierende Zeichenkette
* @param ch Zeichen mit dem aufgef&uuml;llt werden soll
* @param size die gew&uuml;nschte L&auml;nge
* @param mode die Ausrichtung der formatierten Zeichenkette,
* Standard = linksb&uuml;ndig
* @return String mit gew&uuml;nschter L&auml;nge und Formatierung
*/
public static String align(String str, char ch, int size, int mode)
{
int len = str.length();
if (len > size) {
return str.substring(0, size);
}
if (len == size) {
return str;
}
int i = 0;
int count = size - len;
StringBuffer buf = new StringBuffer();
switch (mode) {
case ALIGN_RIGHT:
while (i++ < count) {
buf.append(ch);
}
buf.append(str);
break;
case ALIGN_CENTER:
while (i++ < count / 2) {
buf.append(ch);
}
buf.append(str);
buf.append(ch);
break;
default :
buf.append(str);
break;
}
while (i++ < count) {
buf.append(ch);
}
return buf.toString();
}
}

Test:

System.out.println("|" +
Formatter.align("abcd", ' ', 15, Formatter.ALIGN_LEFT) + "|");
System.out.println("|" +
Formatter.align("123456",'A',15, Formatter.ALIGN_LEFT) + "|");
System.out.println("|" +
Formatter.align("abcd", ' ', 15, Formatter.ALIGN_RIGHT) + "|");
System.out.println("|" +
Formatter.align("123456",'A',15, Formatter.ALIGN_RIGHT) + "|");
System.out.println("|" +
Formatter.align("abdc", ' ', 15, Formatter.ALIGN_CENTER) + "|");
System.out.println("|" +
Formatter.align("123456",'A',15, Formatter.ALIGN_CENTER) + "|");
System.out.println("|" +
Formatter.align("12345", 'A', 4, Formatter.ALIGN_RIGHT) + "|");

Alfred