Methode zum Auffüllen von Strings?
Christoph Happich
gibt es eine Standard-Methode in Java 1.4, die String vorne oder
hinten mit Zeichen auf eine bestimmte Länge auffüllt? Z.B. Nullen
vorne bei Zahlen?
Ich find hier nix, könnte mir aber gut vorstellen, dass zumindest für
das Umwandelt von Zahlen in Strings so etwas bereits existiert -- ich
könnte es aber auch für andere Sachen gut gebrauchen ...
Gruss, Christoph
Michael Borgwardt
Siehe java.text.NumberFormat.
bernd hohmann
> gibt es eine Standard-Methode in Java 1.4, die String vorne oder
> hinten mit Zeichen auf eine bestimmte Länge auffüllt? Z.B. Nullen
> vorne bei Zahlen?
nicht dass ich wüsste. ich behelfe mir immer damit:
public static String rset(String copyStr, int length, char
fillChar) {
int copyLen = copyStr.length();
if (copyLen > length)
copyLen = length;
char buffer[] = new char[length]
for (int i = 0; i < length - copyLen; i++)
buffer[i] = fillChar;
for (int i = 0; i < copyLen; i++)
buffer[i + length - copyLen] = copyStr.charAt(i);
return new String(buffer);
}
(geht sicherlich eleganter, aber die tut es)
bernd
Frank Theimer
"bernd hohmann" <hoh...@harddiskcafe.de> schrieb im Newsbeitrag
news:ubuznaauneqqvfxpns...@news.cis.dfn.de...
Ein bischen kompliziert, oder?
public static String rset (String copyStr, int length, char fillChar,
boolean end){
StringBuffer buf = new StringBuffer (copyStr);
while (buf.length()<length){
if (end) buf.append (fillChar);
else buf.insert (0, fillChar);
}
return new String (buf);
}
Ohne Garantie (nur so kurz hingeschrieben, ohne Test...)
je nach der Variablen end werden die Zeichen vorn oder hinten angefügt.
Gruss
Frank
bernd hohmann
> > nicht dass ich wüsste. ich behelfe mir immer damit:
[...]
> Ein bischen kompliziert, oder?
nö. meine variante hat den vorteil, dass sie recht flink ist wärend
der stringbuffer so seine tücken hat.
bernd
..
Boris Podolsky: James ?! Wie geht es dir, was machen die Ratten ?
James Moreland: Nun - zur Zeit sind es eher die Studenten, mit denen ich Experimentiere.
Kurt Gödel: Um Herrgottswillen, diese Labyrinthe müssen aber gross sein !
Christoph Happich
nur, dass man sowas doch eigendlich dauernd braucht und dass es
deshalb eigendlich eine Standard-Methode dafuer geben muesste ...
Naja, dann nicht :(
Gruss, Christoph
Roman Seibold
Auffüllen eines Strings direkt gibt es nicht, aber Du kannst
mal einen Blick darauf werfen:
char[] zeichen = new char[50];
java.util.Arrays.fill(zeichen,'0');
String gefuellt = new String (zeichen);
Wenn man jetzt einen String haben möchte, der exakt
50 Zeichen hat und bei Bedarf vorne aufgefüllt ist, dann
macht man einfach
(new String(zeichen) + stringhinten).substring(0,50)
[Für bessere Performance StringBuffer o.ä. verwenden...]
Das macht einen einfachen Dreizeiler aus der Geschichte.
Gruß,
Roman
--
________________________________________________________________________
Roman Seibold, Dipl.-Inform.
Haenchen & Partner, Beratungsgesellschaft fuer Wirtschaftsinformatik mbH
Calwer Str. 1, 71034 Boeblingen, Germany
Roman....@haenchen.softwarezentrum.de
http://www.haenchen.softwarezentrum.de
Phone: +49 (0)7031 2126 100
FAX: +49 (0)7031 2126 199
________________________________________________________________________
Frank Theimer
"Roman Seibold" <Roman....@haenchen.softwarezentrum.de> schrieb im
Newsbeitrag news:ar0kku$e0gi3$1...@ID-155655.news.dfncis.de...
>
> Auffüllen eines Strings direkt gibt es nicht, aber Du kannst
> mal einen Blick darauf werfen:
>
> char[] zeichen = new char[50];
> java.util.Arrays.fill(zeichen,'0');
> String gefuellt = new String (zeichen);
>
> Wenn man jetzt einen String haben möchte, der exakt
> 50 Zeichen hat und bei Bedarf vorne aufgefüllt ist, dann
> macht man einfach
>
> (new String(zeichen) + stringhinten).substring(0,50)
Hä? Da is aber ein Denkfehler drin...
Also ich würd darauf tippen, dass da jetzt ein 50 Zeichen langer String
rauskommt mit 50 gleichen Zeichen - und von stringhinten ist nix zu
sehen....;-)
Gruss
Frank
Frank Theimer
"bernd hohmann" <hoh...@harddiskcafe.de> schrieb im Newsbeitrag
news:ubuznaauneqqvfxpns...@news.cis.dfn.de...
>
> > > nicht dass ich wüsste. ich behelfe mir immer damit:
>
> [...]
>
> > Ein bischen kompliziert, oder?
>
> nö. meine variante hat den vorteil, dass sie recht flink ist wärend
> der stringbuffer so seine tücken hat.
Naja, da muss ich aber nochmal meinen Senf dazugeben ;-)...
<besserwissmodus>
Ein StringBuffer ist ja intern auch nichts anderes als (dein) char-Array.
Die einzige Möglichkeit wo meine Version Zeit verlieren könnte ist, wenn die
intern vordefinierte Grösse(=Länge) nicht ausreicht und per System.arraycopy
(was allerdings auch sehr schnell ist - jedenfalls schneller als
irgendwelche pur Java Schleifen) verdoppelt wird. Wenn dieser Fall nicht
eintritt sollte es eher flinker gehen...
Dafür spart meine Methode ja auch wieder eine Schleife ein im Vergleich zu
deiner - obs jetzt hier allerdings auf die Geschwindigkeit ankommt sei mal
dahingestellt... IMHO ist die Übersichtlichkeit hier mehr wert als
"rumzuoptimieren".
</besserwissmodus>
Viele Grüsse
Frank
Michael Borgwardt
> intern vordefinierte Grösse(=Länge) nicht ausreicht und per System.arraycopy
> (was allerdings auch sehr schnell ist - jedenfalls schneller als
> irgendwelche pur Java Schleifen) verdoppelt wird. Wenn dieser Fall nicht
Achtung - das ist nicht unbedingt der Fall. Zumindest habe ich mit Sun's 1.3.irgendwas
unter Linux mal die die Erfahrung gemacht, daß System.arraycopy für Arrays von nur ein
paar hundert Byte Länge *langsamer* war als "händisches" byte-für-byte Kopieren.
Ich vermute, daß es einen Wechsel in den Kernel und zurück erfordert, was einen ziemlich
hohen konstanten Aufwand reinbringt...
Roman Seibold
"Frank Theimer" <frank....@pixeldata.de> schrieb im Newsbeitrag
news:ar0pro$dalck$1...@ID-168629.news.dfncis.de...
>
> "Roman Seibold" <Roman....@haenchen.softwarezentrum.de> schrieb im
> Newsbeitrag news:ar0kku$e0gi3$1...@ID-155655.news.dfncis.de...
> >
> > Auffüllen eines Strings direkt gibt es nicht, aber Du kannst
> > mal einen Blick darauf werfen:
> >
> > char[] zeichen = new char[50];
> > java.util.Arrays.fill(zeichen,'0');
> > String gefuellt = new String (zeichen);
> >
> > Wenn man jetzt einen String haben möchte, der exakt
> > 50 Zeichen hat und bei Bedarf vorne aufgefüllt ist, dann
> > macht man einfach
> >
> > (new String(zeichen) + stringhinten).substring(0,50)
>
> Hä? Da is aber ein Denkfehler drin...
> Also ich würd darauf tippen, dass da jetzt ein 50 Zeichen langer String
> rauskommt mit 50 gleichen Zeichen - und von stringhinten ist nix zu
> sehen....;-)
Stimmt. Das war eine Mischung aus links auffüllen und
rechts abschneiden. Das kommt davon, wenn man im
Mail-Programm Java-Code entwickelt. Man sollte
natürlich über die Gesamtlänge gehen und davon abschneiden:
String gesamt = new String(zeichen) + stringhinten;
int laenge = gesamt.length();
return gesamt.substring(laenge-50);
Danke.
Roman
Christoph Maria Dahlen
> Hi,
>
> gibt es eine Standard-Methode in Java 1.4, die String vorne oder hinten
> mit Zeichen auf eine bestimmte Länge auffüllt? Z.B. Nullen vorne bei
> Zahlen?
Falls es Dir um Zahlen geht, existieren in java.text einige Formatierer,
z.B. java.text.NumberFormat.
In der Regel weiß ich um die Mindest- und Maximal-Länge und auch um die
Füllzeichen, so daß ich mir eine Konstante mit dem Füllzeichen in
Maximal-Länge anlege und die eingehenden Werte mit substring bearbeite
final String filler = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
String fill(String another, int length) {
if( (another == null) || (another.length() <= length) )
return length;
else
return another + filler.substring(length);
}
--
Christoph Dahlen
http://www.dahlen.org/
Paul Ebermann
Wir haben hier in der Newsgroup dazu mal ein paar
Untersuchungen angestellt. Zumindestens beim Füllen
eines Arrays mit einer Zahl war eine simple Schleife
auf großen Strecken schneller als ein arraycopy.
Such mal nach [JPEC] und arraycopy.
Paul