pæn opstilling af udtryk

StringBuffer b = new StringBuffer();
b.append("SELECT k.kunstner, p.title ");
osv...
FROM kunstner k, plader p
WHERE k.kunst_id = p.kunst_id
  AND k.kunstner = \""+result+"\"
ORDER BY k.kunstner

ResultSet rs = d.select(b.toString());

eller evt blot:

ResultSet rs = d.select(
    "select k.kunstner, p.title "
  +"from kunstner k, plader p "
  +"where k.kunst_id = p.kunst_id "
  +"  and k.kunstner = \""+result+"\" "
  +"order by k.kunstner;"  );

  Koncatenering af strenge bliver ogte brugt som exempel på hvordan uigennemtænkt bruge af java's faciliteter kan give langsom og ineffektiv kode.
  I forhold til udgiften ved et database-kald er det dog nul og nix.

mvh JakobA

okay. Hvad er det bedste?

jakoba -> jeg forstod ikke dit budskab???

Mit eksempel er da både hurtigere, mere ressourcsbesparende og lette at overskue

Det er også mest en religiøs uenighed.

Repsak har helt ret i at hans metode er hurtigere og mere ressource besparende.

Jeg synes dog ikke den er 'mere overskuelig', og mener at min øgede overskuelighed er ressourcespildet værd i dette tilfælde.

mvh JakobA

okay :-)

Hvad er der galt med det her?

StringBuffer bu = new StringBuffer();
                    bu.append("select k.kunstner, p.cover_title, t.title_navn");
                    bu.append("from kunstner k, plader p, titler t, plade_title_relation pr");
                    bu.append("where k.kunst_id = p.kunst_id");
                    bu.append("and  pr.plade_id = p.plade_id");
                    bu.append("and  pr.title_id = t.title_id");
                    bu.append("and  k.kunstner like \""+result+"\"");
                   
        ResultSet rs = d.select(bu.toString());

Jeg har fundet ud af det :-) Det var bare nogle mellemrum som manglede

bu.append("from kunstner k, plader p, titler t, plade_title_relation pr");
skulle være
bu.append("from kunstner k, plader p, titler t, plade_title_relation pr ");

Stop.

Protest.

Generelt er det en performance mæssig fordel at bruge StringBuffer
append fremfor String +.

Men det gælder *ikke* i dette tilfælde.

Løsningen med String + performer bedre end StringBuffer append
i dette tilfælde.

De ville være langsommere hvis der runtime blev lavet temporære String
objekter, men det gør det ikke.

Compileren optimere de strenge og laver det om til en streng på compile
time.

Lad mig give et lille eksempel:

C:\>type C1.java
public class C1 {
  public static void main(String[] args) {
      String s = "aaaaaaaaaaaaaaaaaaaaa" +
                "bbbbbbbbbbbbbbbbbbbbb" +
                "ccccccccccccccccccccc";
      System.out.println(s);
  }
}

C:\>javap -c C1
Compiled from C1.java
public class C1 extends java.lang.Object {
    public C1();
    public static void main(java.lang.String[]);
}

Method C1()
  0 aload_0
  1 invokespecial #1 <Method java.lang.Object()>
  4 return

Method void main(java.lang.String[])
  0 ldc #2 <String "aaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbccccccccccccccccc
cccc">
  2 astore_1
  3 getstatic #3 <Field java.io.PrintStream out>
  6 aload_1
  7 invokevirtual #4 <Method void println(java.lang.String)>
  10 return

C:\>type C2.java
public class C2 {
  public static void main(String[] args) {
      StringBuffer sb = new StringBuffer("");
      sb.append("aaaaaaaaaaaaaaaaaaaaa");
      sb.append("bbbbbbbbbbbbbbbbbbbbb");
      sb.append("ccccccccccccccccccccc");
      System.out.println(sb.toString());
  }
}

C:\>javap -c C2
Compiled from C2.java
public class C2 extends java.lang.Object {
    public C2();
    public static void main(java.lang.String[]);
}

Method C2()
  0 aload_0
  1 invokespecial #1 <Method java.lang.Object()>
  4 return

Method void main(java.lang.String[])
  0 new #2 <Class java.lang.StringBuffer>
  3 dup
  4 ldc #3 <String "">
  6 invokespecial #4 <Method java.lang.StringBuffer(java.lang.String)>
  9 astore_1
  10 aload_1
  11 ldc #5 <String "aaaaaaaaaaaaaaaaaaaaa">
  13 invokevirtual #6 <Method java.lang.StringBuffer append(java.lang.String)>
  16 pop
  17 aload_1
  18 ldc #7 <String "bbbbbbbbbbbbbbbbbbbbb">
  20 invokevirtual #6 <Method java.lang.StringBuffer append(java.lang.String)>
  23 pop
  24 aload_1
  25 ldc #8 <String "ccccccccccccccccccccc">
  27 invokevirtual #6 <Method java.lang.StringBuffer append(java.lang.String)>
  30 pop
  31 getstatic #9 <Field java.io.PrintStream out>
  34 aload_1
  35 invokevirtual #10 <Method java.lang.String toString()>
  38 invokevirtual #11 <Method void println(java.lang.String)>
  41 return

Der er vist ingen tvivl om hvad der er hurtigst.

Så i dette tilfælde vil String + bære hurtigst (objektivt) og
pænest (subjektivt).

mikmakmuk -> du må nok hellere høre på arne_v. Mit indlæg byggede ikke på en så avenceret performancetest. Men normalt vil StringBuilder være at foretrække :-)

StringBuffer sb = new StringBuffer("");
for(int i = 0; i < 10000; i++) {
  sb.append("x");
}

er meget hurtigere end:

String s = "";
for(int i = 0; i < 10000; i++) {
  s += "x";
}

fordi der vil den lave 10000 objekter som også skal garbage collectes.

Og den kan ikke lave noget smart.

Det kan den imidlertid ved "..." + "..." + "...".

respekt arne_v :-) Jeg vel bare gerne lære :-)

vil

Jeg er mere end glad for alle svarerne :-)
Det endte med

StringBuffer bu = new StringBuffer();
                    bu.append("select k.kunstner, p.cover_title, t.title_navn ");
                    bu.append("from kunstner k, plader p, titler t, plade_title_relation pr ");
                    bu.append("where k.kunst_id = p.kunst_id ");
                    bu.append("and  pr.plade_id = p.plade_id ");
                    bu.append("and  pr.title_id = t.title_id ");
                    bu.append("and  k.kunstner like \""+result+"\"");
                   
        ResultSet rs = d.select(bu.toString());

Det kan godt være at det ikke er det bedste, men jeg er glad for det og jeg kan læse det :-)

resultatet kan ses her, hvis ellers min computer er tændt :-)

http://web-oasen.dk:8080/xmltest/xml6.html

mikmakmuk -> så længe at det ikke drejer sig om flere objekter er det ren religion, for om der bliver oprettet et par objekter mere eller mindre har ikke nogen praktisk betydning. Der er ren teori :-)

arne -> hvornår kan det så betale sig at bruge StringBuffer?

Som jeg skrev i mit 12/11-2003 20:00:02 indlæg: i de klassiske
eksempler med en løkke er StringBuffer hurtigere end String.

Man skal dog nok op på nogle appends førend forskellen kan mærkes.

bare der ikke er nogen som er sure så er jeg glad. Jeg syntes bare det er kanon at jeg kan få noget hjælp :-)

Jeg har ikke ord for hvor meget respekt jeg har for folk som jer.

Det er stort!!!!! Jeg kan gøre nogle ting som jeg ellers kun kunne drømme om fordi der er folk som gider hjælpe.

hva' arne burde du ikke lige få nogle af mine points så?

Det gider vi ikke bøvle med.