Ein String in einen anderen String "übergeben"

[Crusha]

Hi, ich bräuchte mal vielleicht "simple" Hilfe.

Ich möchte eine Datenbankverbindung zu einer Mysql Datenbank herstellen und das klappt auch wunderbar, aber ich möchte dies bisschen "schöner" programmieren das dies später dynamisch funktionieren soll.
Mein Problem ist, ich würde gerne wie unten steht alles einzeln und separat an einen String übergeben und diese Daten in "db url" übergeben, aber leider finde ich keine Lösung wie ich das bewerkstelligen könnte. Mit PHP ginge das wunderbar einfach, aber funktioniert diese Variante funktioniert bei Java nicht 😳 🙂

String ip = "XXX";
String port = "3306";
Strink db_name = "test_db";

String url = "jdbc:mysql://ip😛ort/db_name?";

 

[Joose]

String a = "Hello";
String b = "World";
String c = a + " " + b;

 

[Crusha]

Sorry, aber hilft mir echt nicht weiter wie ich 3 Strings in einen anderen String hineinbekomme indem dort noch ein ":" "/" und "?" enthalten sind.

String ip = "XXX";
String port = "3306";
Strink db_name = "test_db";

String url = "jdbc:mysql://ip:port/db_name?" +ip +port +db_name;

???

 

[kaoZ]

StringBuilder

+

append(String s);

 

[Crusha]

Ok alles klar danke hab es.

 

[Joose]

Sorry, aber hilft mir echt nicht weiter wie ich 3 Strings in einen anderen String hineinbekomme indem dort noch ein ":" "/" und "?" enthalten sind.

String ip = "XXX";
String port = "3306";
Strink db_name = "test_db";

String url = "jdbc:mysql://ip:port/db_name?" +ip +port +db_name;

???

:bahnhof: was ist an meinem Beispiel nicht zu verstehen?
Ich versuche es nochmal ausführlicher

String ip = "wunderwuzzi";
String port = "zahl";
String db = "datenherkunft";

String url = "jdbc:mysql://" + wunderwuzzi + zahl + "/" + datenherkunft;

Mehrere Strings kann man mit

+

verknüpfen.

 

[BlueHamster]

Generell sollte man Strings nicht mit + verbinden.
Da Strings unveränderbar sind, wird mit jedem + ein neuer String erzeugt!


Dafür gibt es wie oben schon erwähnt wurde die Klasse StringBuilder.

StringBuilder stringBuilder= new StringBuilder();
stringBuilder.append("Hallo").append(" ").append(":)").....;

 

[kaoZ]

Wie BlueHamster schon beschrieben hat, wenn du per + Operator einen String verkettest steht dort eigentlich

String s = "Hallo" + " " + "Welt";

// daraus resultiert :

String s = new String("Hallo").concat(new String(" ").concat(new String("Welt")))

Wie du siehst werden hier 3 uveränderliche (immutable) Objekte erzeugt und per

.concat();

aneinandergereiht, dies ergibt dann deine neues String Objekt

 

[fischefr]

Ich glaube, ihr habt die Frage falsch verstanden. Ich denke das Problem ist nicht die einfache Stringkonkenation, sondern die Maskierung. In Skriptsprachen heißt die gesuchte Funktion meinstens urlencode oder ähnlich.

Ich verweise mal an die api an der Stelle:
URLEncoder (Java 2 Platform SE 5.0)

Den zu übergebenden String zunächst an die Methode übergeben und den Rückgabewert dann in die jdbc-url einbetten.

Ich benutze immer ganz gerne für solche Dinge die Klasse Stringbuilder:

StringBuilder (Java Platform SE 7 )

 

[Ruzmanz]

Noch jemand der StringBuilder benutzt, weil er vor 100 Jahren im Internet gelesen hat, dass es angeblich performanter als eine Zeichenketten-Konkatenation (<- tolles Wort) sein soll? :bloed: Ich bin mal so "provokant" und lass die Lösung unbeantwortet, evtl. gehen ein paar Leuten die Lichter auf.

 

[kaoZ]

Ich finde es kommt immer auf die Situation an, erzeuge ich in einem loop einen bestimmten string nutze ich gern einen StringBuilder, für normale Bearbeitung reicht eine Verkettung per + / concat (); vollkommen aus, was der Performance angeht wird es denke ich, Wenn es auf Heutigen System überhaupt noch eine Rolle spielen sollte, dermaßen gering sein, dass es wahrscheinlich nichtmal messbar ist.

 

[Ruzmanz]

Es geht mir darum, dass + kein concat() ist. Nur in sehr sehr seltenten Fällen.

String s = "Hallo" + " " + "Welt";

optimiert der Compiler zu:

String s = "Hallo Welt";

In diesem speziellen Beispiel wäre der StringBuilder mit append sogar langsamer! Seien wir ehrlich, sowas kommt auch nie vor. Häufiger trifft man diesen Fall an:

String s0 = "schöne";
String s1 = " neue";
String s2 = "Hallo " + s0 + s1 + " Welt";

Dazu sagt der Compiler:

String s0 = "sch\366ne";
String s1 = " neue";
String s2 = (new StringBuilder()).append("Hallo ").append(s0).append(s1).append(" Welt").toString();

Okey, das ist einen "tick" langsamer. In diesem Fall steht die Lesbarkeit / Wartbarkeit noch deutlich über der Performance. Nun was passiert, wenn es komplizierter wird?

String s4 = "13543";
for(int i = 0; i < 100; i++) {
        s4 = "0" + s4;
}

Dazu sagt der Compiler:

String s4 = "13543";
for(int i = 0; i < 100; i++)
        s4 = (new StringBuilder()).append("0").append(s4).toString();

Ich gebe zu, das sieht sehr verdächtig unperformant aus. Es gibt aber immer noch den JIT-Compiler, der dieses Statement retten könnte. Jetzt müsste man noch prüfen, ob das der Fall ist und ab welchen i optimiert wird.

 

[fischefr]

@Ruzmanz hast du die Weisheit mit Löffeln gefressen, oder warum trittst du hier so arrogant auf?

Ich seh das so ähnlich wie koaZ.
Zum einen gibt es nicht DEN compiler, sondern verschiedene mit verschiedenen Ausprägungen was automatische Optimierung betrifft. Zum anderen kann es bei vielen aufeinander folgenden Stringkonkatenationen nicht schaden, diese explizit auszuführen. Den Blödsinn, viele hardkodierte Strings mit + zu verknüpfen meine ich damit ausdrücklich nicht.
Zum anderen kann es aber doch auch nicht schaden, einen Anfänger darauf hin zu weisen, dass es noch etwas anderes gibt als das klassische +.

 

[kaoZ]

Es geht mir darum, dass + kein concat() ist. Nur in sehr sehr seltenten Fällen.

Du hast recht, mein Fehler , so schaut die ein Auszug aus der JavaDoc aus :

 * The Java language provides special support for the string
 * concatenation operator ( + ), and for conversion of
 * other objects to strings. String concatenation is implemented
 * through the {@code StringBuilder}(or {@code StringBuffer})
 * class and its {@code append} method.

Hier die dazu gehörenden Konstruktoren

 public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
        }
    }

 public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
    }

Hier noch einmal concat(); , dies nutzt ein char Array zur realisierung

  public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }

Allerdings ist es wie schon gesagt meiner Meinung nach immer Situationsabhängig, grade wenn die String Konstrukte sehr unübersichtlich und komplex werden vermeide ich es eher dieser per + operator zu konkatenieren , und nutze lieber die Möglichkeit des StringBuilders , grade weil ich auch so die Möglichkeit besitze den String zu manipulieren, und sei es nur ihn rückwärts ausgeben zu lassen 😉

 

[Ruzmanz]

@Ruzmanz hast du die Weisheit mit Löffeln gefressen, oder warum trittst du hier so arrogant auf?

Ich seh das so ähnlich wie koaZ.
Zum einen gibt es nicht DEN compiler, sondern verschiedene mit verschiedenen Ausprägungen was automatische Optimierung betrifft. Zum anderen kann es bei vielen aufeinander folgenden Stringkonkatenationen nicht schaden, diese explizit auszuführen. Den Blödsinn, viele hardkodierte Strings mit + zu verknüpfen meine ich damit ausdrücklich nicht.
Zum anderen kann es aber doch auch nicht schaden, einen Anfänger darauf hin zu weisen, dass es noch etwas anderes gibt als das klassische +.

Es geht mir darum, dass man den StringBuilder als Selbstverständlichkeit betrachtet, obwohl die Compiler ab min. Java 5 bereits ein

+

zu einem

StringBuilder

wandeln. Das Argument, dass es noch andere Compiler gibt, lasse ich nicht gelten. Ganz objektiv betrachtet, macht es keinen Sinn den Compiler so zu programmieren, dass man ein

+

durch die Methode

concat()

ersetzt, wenn der Aufwand für die Implementierung von

Stringbuilder->append()

exakt so groß ist. Zudem sind einzelne bzw. sporadische Aufrufe uninteressant. Erst bei Schleifen lohnt es sich zu explizit optimieren. Und genau diese Informationen wurden dem Anfänger nicht vermittelt, sodass es in 5 Jahren die Leute immer noch nicht besser machen.