sløv ændring ved mange modifikationer i string - gælder samme

Både int og double er primitive typer, derfor er ændringer i deres værdier meget hurtige. Eller mener ud Double og Integer?

Det er mestendels når en streng bliver meget lang at den også bliver langsom at ændre.
int og double værdier har en fast størrelse der aldrig ændrer sig.

Problemet med strenge er at de er immutable, hvilket betyder at der skal allokeres nyt hukommelse(Samt deallokere det gamle), hvilket er forholdsvis dyrt.

Dette gælder ikke for primitiver siden de kan ændre værdi.

Når man ændre meget i sin streng bør man overveje at anvende StringBuilder i stedet for String.

Er Double og Integer samme koncept som String? At det bliver enormt dyrt at ændre mange gang i dem?

Det kan der svares ganske kort på: Nej.

jakob har faktisk en vigtig pointe

der er to effekter man skal tænke på:

1) overhead ved at new'e og gc'e objekter
2) overhead ved at flytte rundt på data fordi man ikke kan ændre data

#1 har alle reference typer (ikke simple data typer)
#2 har alle immutable reference typer

#2 betyder kun noget ved store data mængder

derfor må det gælde at:

type                                overhead #1                overhead #2

simple typer                          intet                      intet
int,double
mutable ref typer                      medium                      intet
StringBuilder
immutable ref typer små data          medium                      minimal
Integer,Duble,kort String
immutable ref typer stor data          medium                      huge
lang String

package june;

public class Objects {
    public static void main(String[] args) {
        int[] itest = { 10000000, 100000000, 1000000000 };
        for(int n : itest) {
          (new TestIntegerObject(n)).test();
          (new TestIntegerSimple(n)).test();
        }
        int[] stestfixedsize = { 1000000, 10000000, 100000000 };
        for(int n : stestfixedsize) {
            (new TestStringFixedSize(n)).test();
            (new TestStringBuilderFixedSize(n)).test();
        }
        int[] stestgrowing = { 100000, 1000000 };
        for(int n : stestgrowing) {
            (new TestStringGrowing(n)).test();
            (new TestStringBuilderGrowing(n)).test();
        }
    }
}

abstract class Test {
    private String name;
    protected int n;
    protected Object res;
    public Test(String name, int n) {
        this.name = name;
        this.n = n;
    }
    public void test() {
        long t1 = System.currentTimeMillis();
        runtest();
        long t2 = System.currentTimeMillis();
        System.out.println(n + " " + name + " : " + (t2 - t1));
    }
    public abstract void runtest();
}

class TestIntegerObject extends Test {
    public TestIntegerObject(int n) {
        super("Integer", n);
    }
    public void runtest() {
        Integer v = new Integer(0);
        for(int i = 0; i < n; i++) {
            v = v + 1;
        }
        res = v;
    }
}

class TestIntegerSimple extends Test {
    public TestIntegerSimple(int n) {
        super("int", n);
    }
    public void runtest() {
        int v = 0;
        for(int i = 0; i < n; i++) {
            v = v + 1;
        }
        res = v;
    }
}

class TestStringFixedSize extends Test {
    public TestStringFixedSize(int n) {
        super("String fixed size", n);
    }
    public void runtest() {
        String v = "*";
        for(int i = 0; i < n; i++) {
            if(i % 2 == 0) {
                v = v + "*";
            } else {
                v = v.substring(0, 1);
            }
        }
        res = v;
    }
}

class TestStringBuilderFixedSize extends Test {
    public TestStringBuilderFixedSize(int n) {
        super("StringBuilder fixed size", n);
    }
    public void runtest() {
        StringBuilder v = new StringBuilder("*");
        for(int i = 0; i < n; i++) {
            if(i % 2 == 0) {
                v.append("*");
            } else {
                v.delete(1, 2);
            }
        }
        res = v;
    }
}

class TestStringGrowing extends Test {
    public TestStringGrowing(int n) {
        super("String growing", n);
    }
    public void runtest() {
        String v = "*";
        for(int i = 0; i < n; i++) {
            v = v + "*";
            if(i % (n/100) == 0) {
                v = "*";
            }
        }
        res = v;
    }
}

class TestStringBuilderGrowing extends Test {
    public TestStringBuilderGrowing(int n) {
        super("StringBuilder growing", n);
    }
    public void runtest() {
        StringBuilder v = new StringBuilder("*");
        for(int i = 0; i < n; i++) {
            v.append("*");
            if(i % (n/100) == 0) {
                v = new StringBuilder("*");
            }
        }
        res = v;
    }
}

10000000 Integer : 203
10000000 int : 47
100000000 Integer : 3094
100000000 int : 516
1000000000 Integer : 34640
1000000000 int : 5047
1000000 String fixed size : 313
1000000 StringBuilder fixed size : 93
10000000 String fixed size : 2610
10000000 StringBuilder fixed size : 781
100000000 String fixed size : 26141
100000000 StringBuilder fixed size : 7562
100000 String growing : 438
100000 StringBuilder growing : 31
1000000 String growing : 33984
1000000 StringBuilder growing : 266

vi ser at både Integer og int er O(n) men at Integer tager ca. 6 gange så lang tid som int

forskellen er new og gc

vi ser at ved korte strenge af fast længde er både String og StringBuilder O(n), men
at String tager ca. 3 gange så lang tid som StringBuilder

forskellen er new og gc

vi ser at ved lange strenge hvor længden er proportional med antal operationer
(realistisk i mange situationer) så er StringBuilder O(n) men String er O(n*n)

overhead ved kopiering af data for String overskygger totalt effekten af new og gc

iøvrigt mener jeg at effekten af StringBuilder versus String tit overvurderes

det er meget vigtigt ved meget store strenge men i 98% af tilfældene i praktisk
kode betyder det ikke noget fordi strengene er små og det ikke laves alt for
mange gange

men eksempelt nævnes næsten altid som det første når man snakker optimering
af kode, så alle kender det

Tusind tak for svarene.

Mht StringBuilder bliver den brugt til en rimelig god lang streng hvor jeg hele tiden byggede videre på den, så der er en giga effekt (testede det tidligere).

Men dejlig information med de andre typer.

Tak til alle - point til arne for det gode eksempel.

jeg synes at du skal dele pointsene ud

Alright - alle smid et svar!

Ingen til mig :^)

giv dem til arne. for stort arbejde.

:) oi. Tak til alle.