String += String o StringBuilder.append(String)?

Sa artikulong ito, nais kong isaalang-alang, pag-aralan, sabihin at ipakita kung ano ang pagkakaiba sa pagitan ng paraan ng append mula sa klase StringBuilderat ng operator +=para sa String. Narito ang tanong ay hindi gaanong sa mga lugar ng aplikasyon tulad ng sa pag-optimize ng code. Oo, ang isang tao na walang alinlangan na hindi malalim sa tanong na ito ay sasabihin: "Bakit ko papalitan ang += operator sa pamamagitan ng paglikha ng isang bagong bagay ng isang ganap na naiibang klase, at pagkatapos ay tawagan din ang pamamaraan toString()? Anong uri ng pagiging mahusay tayo pinag-uusapan? Obvious naman ang choice, anong pinagsasabi mo?" at siya ay magiging ganap na mali. Isa sa mga problema ay Stringhindi ito primitive. String- isang bagay na tulad ng iba classsa Java, at tulad ng alam mo, sa Java walang bagay na overloading ng operator (Tulad ng sa C++, halimbawa), ang mga operator ay tinukoy lamang para sa mga primitive, at para sa anumang klase hindi namin ma-override ang anumang operator. Iyon ang dahilan kung bakit ang mga operator na " +" at " +=" ay isang uri ng "saklay" ng library ng Java, at ang saklay ay palaging nagkakaroon ng mga pagkalugi. Sa totoo lang, ihinto natin ang paghila sa buntot ng pusa at magpatuloy sa mga sukat. Narito ang isang simpleng programa na sumusukat sa oras na kinakailangan upang "magdikit" ng isang linya na may loop variable ng 100,000 beses.

public class MainClass
{
    private static long time;

    public static void main(String[] args)
    {

        saveTime();
        String s = "Hello";
        for(int i = 0; i < 100000; ++i)
        {
            s+=i;
        }
        printDiff();

    }
    private static void saveTime()
    {
        time = System.currentTimeMillis();
    }

    private static void printDiff()
    {
        System.out.println((System.currentTimeMillis() - time) + "ms");
    }
}

Sa aking computer, ang 6815ms ay ipinakita sa console. Ibig sabihin, kinailangan ng aking computer ng halos 7 segundo upang i-stitch ang linyang ito. Ngayon ay palitan natin ito ng StringBuilder at isama pa ang pamamaraan toString()sa mga sukat.

public class MainClass
{
    private static long time;

    public static void main(String[] args)
    {

        saveTime();
        StringBuilder sb = new StringBuilder("Hello");
        for(int i = 0; i < 100000; ++i)
        {
            sb.append(i);
        }
        String s = sb.toString();
        printDiff();

    }
    private static void saveTime()
    {
        time = System.currentTimeMillis();
    }

    private static void printDiff()
    {
        System.out.println((System.currentTimeMillis() - time) + "ms");
    }
}

Sinabi sa akin ng PC ko na 10ms. Ibig sabihin, 0.01 Seconds. Sa tingin ko ang pagkakaiba sa pagsasanay ay medyo halata; halos pagsasalita, ito ay gumana nang 700 beses na appendmas mabilis. Ito ay dahil sa katotohanan na malamang na ang " +" at " +=" ay maaari nilang tawagan ang parehong append, ngunit sa parehong oras na napunta sa mahabang paraan sa pamamagitan ng mga saklay ng wika upang maunawaan na ang naturang operator ay umiiral at kung ano ito. dapat gawin (ang huling talata ay hindi hihigit sa isang hula, hindi ako isang developer ng JVM at hindi ko alam kung ano ang naroroon at kung paano). Ito ay isang malinaw na halimbawa ng katotohanan na ang isang dagdag na bagay ay hindi palaging magastos. Oo, ang code ay magiging mas mahaba ng ilang linya, ngunit ang pagtitipid ng oras sa malalaking proyekto ay maaaring napakalaki. Pakitandaan na ang mga sukat ay hindi ginawa sa isang opisina ng PC na may isang prehistoric processor, ngunit ngayon isipin kung ano ang magiging pagkakaiba nito sa mismong computer na ito ng opisina, na halos hindi makahila ng scarf.