StringBuilder සහ StringBuffer අතර වෙනස

StringBufferසහ අතර ඇති ප්‍රධාන වෙනස StringBuilderකුමක්ද? මේවායින් එකක් තීරණය කිරීමේදී කාර්ය සාධන ගැටළු තිබේද?

StringBufferසමමුහුර්ත කර ඇත, StringBuilderනැත.

StringBuilderStringBufferඑය එසේ නොවන නිසා වඩා වේගවත් වේsynchronized .

මෙන්න සරල මිණුම් සලකුණු පරීක්ෂණයක්:

public class Main {
    public static void main(String[] args) {
        int N = 77777777;
        long t;

        {
            StringBuffer sb = new StringBuffer();
            t = System.currentTimeMillis();
            for (int i = N; i --> 0 ;) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }

        {
            StringBuilder sb = new StringBuilder();
            t = System.currentTimeMillis();
            for (int i = N; i > 0 ; i--) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }
    }
}

ඒ ටෙස්ට් ලකුණු පිළිබඳ සංඛ්යා වල 2241 msසඳහා StringBufferඑදිරිව 753 msසඳහා StringBuilder.

මූලික වශයෙන්, StringBufferක්‍රම සමමුහුර්ත කර ඇති අතරStringBuilder වේ.

මෙහෙයුම් "පාහේ" සමාන වේ, නමුත් තනි නූල් එකක සමමුහුර්ත ක්‍රම භාවිතා කිරීම අතිරික්ත වේ.

ඒක ගොඩක් වටිනවා.

StringBuilder API වෙතින් උපුටා ගැනීම :

මෙම පන්තිය [StringBuilder] විසින් StringBuffer සමඟ අනුකූල API ලබා දෙයි, නමුත් සමමුහුර්තකරණය පිළිබඳ සහතිකයක් නොමැත . මෙම පන්තිය නිර්මාණය කර ඇත්තේ තනි නූල් එකකින් (සාමාන්‍යයෙන් මෙන්) නූල් බෆරය භාවිතා කරන ස්ථානවල ස්ට්‍රිං බෆර් වෙනුවට ඩ්‍රොප්-ඉන් ආදේශකයක් ලෙසය. හැකි සෑම අවස්ථාවකදීම, මෙම පන්තිය StringBuffer ට වඩා මනාපයෙන් භාවිතා කිරීම රෙකමදාරු කරනු ලැබේ.

එබැවින් එය ආදේශ කිරීම සඳහා සාදන ලදී.

Vectorසහ සිදු වූයේ ද එයමය ArrayList.

නමුත් උදාහරණයක උපකාරයෙන් පැහැදිලි වෙනසක් ලබා ගැනීමට අවශ්‍යද?

StringBuffer හෝ StringBuilder

StringBuilderඔබ නූල් අතර බෆරයක් බෙදා ගැනීමට උත්සාහ නොකරන්නේ නම් සරලව භාවිතා කරන්න. StringBuilderමුල් සමමුහුර්ත StringBufferපන්තියේ සමමුහුර්ත නොකළ (අඩු පොදු = වඩා කාර්යක්ෂම) බාල සහෝදරයා වේ .

StringBufferමුලින්ම ආවා. සෑම තත්වයක් යටතේම සූර්යයා නිරවද්‍යතාව ගැන සැලකිලිමත් වූ අතර, එම නිසා ඔවුන් එය සමමුහුර්ත කර එය නූල් ආරක්ෂිත බවට පත් කළේය.

StringBuilderපසුව ආවා. බොහෝ භාවිතයන්StringBuffer තනි නූල් සහ සමමුහුර්ත කිරීමේ පිරිවැය අනවශ්‍ය ලෙස ගෙවීමයි.

ඒ StringBuilderසඳහා අතහැර දැමීමේ ආදේශකයක් බැවින්StringBuffer සමමුහුර්ත තොරව, ඕනෑම අයෙකුට ඕනෑම උදාහරණ අතර වෙනස්කම් තිබිය නැත.

ඔබ නම් කරන නූල් අතර කොටස් උත්සාහ, ඔබ භාවිතා කළ හැකිය StringBuffer, නමුත් ඉහල මට්ටමේ සමමුහුර්ත අවශ්ය ද යන්න සලකා, උදා: සමහර විට StringBuffer භාවිතා කරනු වෙනුවට, ඔබ StringBuilder භාවිතා කරන ක්රම අතළොස්සට යුතුය.

පළමුවෙන්ම සමානකම් දැකීමට ඉඩ දෙන්න : StringBuilder සහ StringBuffer යන දෙකම විකෘති වේ. ඒ කියන්නේ ඔබට ඒවායේ අන්තර්ගතය එකම ස්ථානයකින් වෙනස් කළ හැකිය.

වෙනස්කම් : StringBuffer විකෘති වන අතර සමමුහුර්ත කර ඇත. StringBuilder විකෘති වන නමුත් පෙරනිමියෙන් සමමුහුර්ත කර නොමැත.

සමමුහුර්ත කිරීමේ තේරුම (සමමුහුර්තකරණය) : යම් දෙයක් සමමුහුර්ත කළ විට, බහු නූල් වලට ප්‍රවේශ විය හැකි අතර ඕනෑම ගැටළුවක් හෝ අතුරු ආබාධයකින් එය වෙනස් කළ හැකිය. StringBuffer සමමුහුර්ත කර ඇත, එබැවින් ඔබට ඕනෑම ගැටළුවක් නොමැතිව බහු නූල් භාවිතා කළ හැකිය.

කුමන විට භාවිතා කළ යුතුද? StringBuilder: ඔබට නූලක් අවශ්‍ය වූ විට එය වෙනස් කළ හැකි අතර එක් නූල් එකක් පමණක් එයට ප්‍රවේශ වීම සහ වෙනස් කිරීම සිදු කරයි. StringBuffer: ඔබට නූලක් අවශ්‍ය වූ විට එය වෙනස් කළ හැකි අතර බහු නූල් එයට ප්‍රවේශ වී වෙනස් කරයි.

සටහන : StringBuffer අනවශ්‍ය ලෙස භාවිතා නොකරන්න, එනම්, එක් නූල් එකක් පමණක් වෙනස් කර ප්‍රවේශ කරන්නේ නම් එය භාවිතා නොකරන්න, එයට සමමුහුර්තකරණය සඳහා අගුළු ඇරීමේ සහ අගුළු හැරීමේ කේත විශාල ප්‍රමාණයක් ඇති බැවින් අනවශ්‍ය ලෙස CPU කාලය ගතවනු ඇත. අවශ්‍ය නම් අගුල් භාවිතා නොකරන්න.

තනි නූල් වලදී , JVM ප්‍රශස්තිකරණයට ස්තූතිවන්ත වන පරිදි StringBuffer StringBuilder ට වඩා සැලකිය යුතු ලෙස මන්දගාමී නොවේ . බහුමාධ්‍ය කියවීමේදී ඔබට ආරක්ෂිතව StringBuilder භාවිතා කළ නොහැක.

මෙන්න මගේ පරීක්ෂණය (මිණුම් ලකුණක් නොවේ, පරීක්ෂණයක් පමණි):

public static void main(String[] args) {

    String withString ="";
    long t0 = System.currentTimeMillis();
    for (int i = 0 ; i < 100000; i++){
        withString+="some string";
    }
    System.out.println("strings:" + (System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuffer buf = new StringBuffer();
    for (int i = 0 ; i < 100000; i++){
        buf.append("some string");
    }
    System.out.println("Buffers : "+(System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuilder building = new StringBuilder();
    for (int i = 0 ; i < 100000; i++){
        building.append("some string");
    }
    System.out.println("Builder : "+(System.currentTimeMillis() - t0));
}

ප්‍රති Results ල : නූල්: 319740 ස්වාරක්ෂක
: 23
තනන්නා: 7!

එබැවින් ඉදි කරන්නන් බෆරයට වඩා වේගවත් වන අතර, නූල් සංයුක්තයට වඩා වේගවත් වේ. දැන් අපි බහු නූල් සඳහා ක්‍රියාත්මක කරන්නෙකු භාවිතා කරමු :

public class StringsPerf {

    public static void main(String[] args) {

        ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        //With Buffer
        StringBuffer buffer = new StringBuffer();
        for (int i = 0 ; i < 10; i++){
            executorService.execute(new AppendableRunnable(buffer));
        }
        shutdownAndAwaitTermination(executorService);
        System.out.println(" Thread Buffer : "+ AppendableRunnable.time);

        //With Builder
        AppendableRunnable.time = 0;
        executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        StringBuilder builder = new StringBuilder();
        for (int i = 0 ; i < 10; i++){
            executorService.execute(new AppendableRunnable(builder));
        }
        shutdownAndAwaitTermination(executorService);
        System.out.println(" Thread Builder: "+ AppendableRunnable.time);

    }

   static void shutdownAndAwaitTermination(ExecutorService pool) {
        pool.shutdown(); // code reduced from Official Javadoc for Executors
        try {
            if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                pool.shutdownNow();
                if (!pool.awaitTermination(60, TimeUnit.SECONDS))
                    System.err.println("Pool did not terminate");
            }
        } catch (Exception e) {}
    }
}

class AppendableRunnable<T extends Appendable> implements Runnable {

    static long time = 0;
    T appendable;
    public AppendableRunnable(T appendable){
        this.appendable = appendable;
    }

    @Override
    public void run(){
        long t0 = System.currentTimeMillis();
        for (int j = 0 ; j < 10000 ; j++){
            try {
                appendable.append("some string");
            } catch (IOException e) {}
        }
        time+=(System.currentTimeMillis() - t0);
    }
}

දැන් StringBuffers 100000 එකතු කිරීම් සඳහා 157 ms ගනී . එය එකම පරීක්ෂණය නොවේ, නමුත් පෙර 37 එම්එස් සමඟ සසඳන විට, බහු තෙරපුම් භාවිතයෙන් ස්ට්‍රිං බෆර්ස් එකතු කිරීම මන්දගාමී යැයි ඔබට ආරක්ෂිතව උපකල්පනය කළ හැකිය . හේතුව, අගුල් පරීක්ෂා කිරීමේ අවශ්‍යතාවයක් නොමැති බව අනාවරණය වූ විට JIT / හොට්ස්පොට් / සම්පාදක / යමක් ප්‍රශස්තිකරණය කරයි .

නමුත් StringBuilder සමඟ, ඔබට java.lang.ArrayIndexOutOfBoundsException ඇත , මන්ද සමගාමී නූල් එය නොකළ යුතු තැනක් එක් කිරීමට උත්සාහ කරයි.

නිගමනය නම් ඔබට StringBuffers පසුපස හඹා යා යුතු නැති බවයි. ඔබට නූල් ඇති තැන, නැනෝ තත්පර කිහිපයක් ලබා ගැනීමට උත්සාහ කිරීමට පෙර, ඔවුන් කරන්නේ කුමක්ද යන්න ගැන සිතා බලන්න.

StringBuilder ජාවා 1.5 හි හඳුන්වා දෙන ලදි, එබැවින් එය පෙර JVM සමඟ ක්‍රියා නොකරනු ඇත.

සිට Javadocs :

StringBuilder පන්තිය StringBuffer සමඟ අනුකූල API ලබා දෙයි, නමුත් සමමුහුර්තකරණය පිළිබඳ සහතිකයක් නොමැත. මෙම පන්තිය නිර්මාණය කර ඇත්තේ තනි නූල් එකකින් (සාමාන්‍යයෙන් මෙන්) නූල් බෆරය භාවිතා කරන ස්ථානවල ස්ට්‍රිං බෆර් වෙනුවට ඩ්‍රොප්-ඉන් ආදේශකයක් ලෙසය. හැකි සෑම අවස්ථාවකදීම, මෙම පන්තිය StringBuffer ට වඩා මනාපයෙන් භාවිතා කිරීම රෙකමදාරු කරනු ලැබේ.

හොඳ ප්‍රශ්නයක්

මෙන්න වෙනස්කම්, මම දැක ඇත්තෙමි:

StringBuffer: -

StringBuffer is  synchronized
StringBuffer is  thread-safe
StringBuffer is  slow (try to write a sample program and execute it, it will take more time than StringBuilder)

StringBuilder: -

 StringBuilder is not synchronized 
 StringBuilder is not thread-safe
 StringBuilder performance is better than StringBuffer.

පොදු දෙය: -

දෙදෙනාම එකම අත්සන් සහිත ක්‍රම ඇත. දෙකම විකෘති ය.

StringBuffer

• එබැවින් සමමුහුර්ත කර ඇත
• නූල් ආරක්ෂිත බැවින් මන්දගාමී වේ

StringBuilder

• ජාවා 5.0 හි හඳුන්වා දී ඇත
• අසමමුහුර්ත එබැවින් වේගවත් හා කාර්යක්ෂම වේ
• පරිශීලකයාට අවශ්‍ය නම් එය සමමුහුර්ත කිරීමට පැහැදිලිවම අවශ්‍ය වේ
• ඔබට StringBufferවෙනත් වෙනසක් නොමැතිව එය ප්‍රතිස්ථාපනය කළ හැකිය

StringBuilder නූල් ආරක්ෂිත නොවේ. නූල් බෆරය. වැඩි විස්තර මෙහි .

සංස්කරණය කරන්න: කාර්ය සාධනය සම්බන්ධයෙන් ගත් කල, හොට්ස්පොට් ආරම්භ වූ පසු , ජයග්‍රාහකයා වන්නේ ස්ට්‍රිංබිල්ඩර් ය. කෙසේ වෙතත්, කුඩා පුනරාවර්තන සඳහා, කාර්ය සාධන වෙනස නොසැලකිය.

StringBuilderහා StringBufferපාහේ සමාන වේ. වෙනස වන්නේ StringBufferඑය සමමුහුර්ත කර ඇති අතර StringBuilderඑසේ නොවේ. StringBuilderවඩා වේගවත් වුවද, StringBufferකාර්ය සාධනයේ වෙනස ඉතා අල්පය. StringBuilderSUN වෙනුවට ආදේශ කිරීමකි StringBuffer. එය සියලු පොදු ක්‍රම වලින් සමමුහුර්තකරණය වළක්වයි. ඒ වෙනුවට ඔවුන්ගේ ක්‍රියාකාරිත්වය සමාන වේ.

හොඳ භාවිතයේ උදාහරණය:

ඔබේ පෙළ වෙනස් වීමට යන්නේ නම් සහ බහු නූල් භාවිතා කරන්නේ නම්, එය භාවිතා කිරීම වඩා හොඳය StringBuffer. ඔබේ පෙළ වෙනස් වීමට යන්නේ නමුත් තනි නූල් භාවිතා කරන්නේ නම් භාවිතා කරන්න StringBuilder.

StringBuffer

StringBuffer යනු විකෘති වන අතර කෙනෙකුට වස්තුවේ වටිනාකම වෙනස් කළ හැකිය. StringBuffer හරහා නිර්මාණය කරන ලද වස්තුව ගොඩවල් තුළ ගබඩා වේ. StringBuffer හි StringBuilder හා සමාන ක්‍රම ඇත, නමුත් StringBuffer හි සෑම ක්‍රමයක්ම සමමුහුර්ත කර ඇති අතර එය StringBuffer නූල් ආරක්ෂිත වේ.

මේ නිසා එකම ක්‍රමයට එකවර ප්‍රවේශ වීමට නූල් දෙකකට ඉඩ නොදේ. සෑම ක්රමයක්ම වරකට එක් නූල් එකකින් ප්රවේශ විය හැකිය.

නූල් ආරක්ෂිත දේපල හේතුවෙන් ස්ට්‍රිං බෆරයේ ක්‍රියාකාරිත්වය වැඩි වන බැවින් නූල් ආරක්ෂිත වීම අවාසි ද ඇත. මේ අනුව එක් එක් පන්තියේ එකම ක්‍රම කැඳවීමේදී StringBuilder StringBuffer ට වඩා වේගවත් වේ.

StringBuffer අගය වෙනස් කළ හැකිය, එයින් අදහස් කරන්නේ එය නව අගයට පැවරිය හැකි බවයි. වර්තමානයේ එය වඩාත් සුලභ සම්මුඛ පරීක්ෂණ ප්‍රශ්නයකි, ඉහත පන්ති අතර වෙනස්කම්. ToString () ක්‍රමය භාවිතා කරමින් නූල් බෆරය නූල් බවට පරිවර්තනය කළ හැකිය.

StringBuffer demo1 = new StringBuffer(“Hello”) ;
// The above object stored in heap and its value can be changed .

demo1=new StringBuffer(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuffer

StringBuilder

StringBuilder යනු StringBuffer හා සමාන වේ, එනම් එය වස්තුව ගොඩවල් තුළ ගබඩා කරන අතර එය වෙනස් කළ හැකිය. StringBuffer සහ StringBuilder අතර ඇති ප්‍රධාන වෙනස නම් StringBuilder ද නූල් ආරක්ෂිත නොවේ. නූල් ආරක්ෂිත නොවන බැවින් StringBuilder වේගවත්ය.

StringBuilder demo2= new StringBuilder(“Hello”);
// The above object too is stored in the heap and its value can be modified

demo2=new StringBuilder(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuilder

සම්පත්: String Vs StringBuffer Vs StringBuilder

String වෙනස් කළ නොහැකි ය.

StringBuffer විකෘති හා සමමුහුර්තකරණයකි.

StringBuilder විකෘති වන නමුත් එය සමමුහුර්ත කර නොමැත.

මෙම javadoc වෙනස පැහැදිලි:

මෙම පන්තිය ස්ට්‍රිං බෆර් සමඟ අනුකූල API ලබා දෙයි, නමුත් සමමුහුර්තකරණය පිළිබඳ සහතිකයක් නොමැත. මෙම පන්තිය නිර්මාණය කර ඇත්තේ තනි නූල් එකකින් (සාමාන්‍යයෙන් මෙන්) නූල් බෆරය භාවිතා කරන ස්ථානවල ස්ට්‍රිං බෆර් වෙනුවට ඩ්‍රොප්-ඉන් ආදේශකයක් ලෙසය. හැකි සෑම අවස්ථාවකදීම, මෙම පන්තිය StringBuffer ට වඩා මනාපයෙන් භාවිතා කිරීම රෙකමදාරු කරනු ලැබේ.

StringBuilder (ජාවා 5 හි හඳුන්වා දී ඇත) සමාන වේ StringBuffer එහි ක්‍රම සමමුහුර්ත කර නොමැති . මෙයින් අදහස් කරන්නේ එය දෙවැන්නට වඩා හොඳ කාර්ය සාධනයක් ඇති නමුත් අවාසිය නම් එය නූල් ආරක්ෂිත නොවන බවයි.

වැඩි විස්තර සඳහා නිබන්ධනය කියවන්න .

StringBuffer සහ StringBuilder අතර වෙනස නිරූපණය කරන සරල වැඩසටහනක්:

/**
 * Run this program a couple of times. We see that the StringBuilder does not
 * give us reliable results because its methods are not thread-safe as compared
 * to StringBuffer.
 * 
 * For example, the single append in StringBuffer is thread-safe, i.e.
 * only one thread can call append() at any time and would finish writing
 * back to memory one at a time. In contrast, the append() in the StringBuilder 
 * class can be called concurrently by many threads, so the final size of the 
 * StringBuilder is sometimes less than expected.
 * 
 */
public class StringBufferVSStringBuilder {

    public static void main(String[] args) throws InterruptedException {

        int n = 10; 

        //*************************String Builder Test*******************************//
        StringBuilder sb = new StringBuilder();
        StringBuilderTest[] builderThreads = new StringBuilderTest[n];
        for (int i = 0; i < n; i++) {
            builderThreads[i] = new StringBuilderTest(sb);
        }
        for (int i = 0; i < n; i++) {
            builderThreads[i].start();
        }
        for (int i = 0; i < n; i++) {
            builderThreads[i].join();
        }
        System.out.println("StringBuilderTest: Expected result is 1000; got " + sb.length());

        //*************************String Buffer Test*******************************//

        StringBuffer sb2 = new StringBuffer();
        StringBufferTest[] bufferThreads = new StringBufferTest[n];
        for (int i = 0; i < n; i++) {
            bufferThreads[i] = new StringBufferTest(sb2);
        }
        for (int i = 0; i < n; i++) {
            bufferThreads[i].start();
        }
        for (int i = 0; i < n; i++) {
            bufferThreads[i].join();
        }
        System.out.println("StringBufferTest: Expected result is 1000; got " + sb2.length());

    }

}

// Every run would attempt to append 100 "A"s to the StringBuilder.
class StringBuilderTest extends Thread {

    StringBuilder sb;

    public StringBuilderTest (StringBuilder sb) {
        this.sb = sb;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sb.append("A");
        }

    }
}


//Every run would attempt to append 100 "A"s to the StringBuffer.
class StringBufferTest extends Thread {

    StringBuffer sb2;

    public StringBufferTest (StringBuffer sb2) {
        this.sb2 = sb2;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sb2.append("A");
        }

    }
}

වෙනස් වන අක්ෂර නූල් ගබඩා කිරීම සඳහා StringBuffer භාවිතා කරයි (සංගීත වස්තු වෙනස් කළ නොහැක). අවශ්‍ය පරිදි එය ස්වයංක්‍රීයව පුළුල් වේ. ආශ්‍රිත පන්ති: නූල්, චාර්සෙක්ස්.

StringBuilder ජාවා 5 හි එකතු කරන ලදි. එය සමමුහුර්ත කර නොමැති බව හැරෙන්නට එය StringBuffer ට සෑම ආකාරයකින්ම සමාන වේ, එයින් අදහස් වන්නේ එකවර බහු නූල් එයට ප්‍රවේශ වන්නේ නම් කරදර ඇතිවිය හැකි බවයි. තනි-නූල් වැඩසටහන් සඳහා, වඩාත් පොදු අවස්ථාව, සමමුහුර්තකරණයට ඉහළින් සිටීම වළක්වා ගැනීම, StringBuilder තරමක් වේගවත් කරයි.

StringBufferසමමුහුර්ත කර ඇත, නමුත් StringBuilderඑසේ නොවේ. ප්රති result ලයක් වශයෙන්, StringBuilderවඩා වේගවත් වේ StringBuffer.

StringBuffer විකෘති වේ. දිග හා අන්තර්ගතය අනුව එය වෙනස් විය හැකිය. StringBuffers යනු නූල්-ආරක්ෂිත වන අතර, එයින් අදහස් වන්නේ ප්‍රවේශය පාලනය කිරීම සඳහා සමමුහුර්ත ක්‍රම ඇති බැවින් එක වරකට StringBuffer වස්තුවක සමමුහුර්ත කේතයට ප්‍රවේශ විය හැක්කේ එක් නූල් එකකට පමණක් බවයි. මේ අනුව, StringBuffer වස්තු සාමාන්‍යයෙන් බහු නූල් සහිත පරිසරයක භාවිතා කිරීමට ආරක්ෂිත වන අතර එහිදී එකම නූල් බෆර වස්තුවට එකවර පිවිසීමට බහු නූල් උත්සාහ කළ හැකිය.

StringBuilder නූල් ආරක්ෂිත නොවන පරිදි එහි ප්‍රවේශය සමමුහුර්ත කර නොමැති බව හැර, StringBuilder පන්තිය StringBuffer ට බෙහෙවින් සමාන ය. සමමුහුර්ත නොකිරීමෙන්, StringBuilder හි ක්‍රියාකාරීත්වය StringBuffer ට වඩා හොඳ විය හැකිය. මේ අනුව, ඔබ වැඩ කරන්නේ තනි නූල් සහිත පරිසරයක නම්, StringBuffer වෙනුවට StringBuilder භාවිතා කිරීමෙන් කාර්ය සාධනය වැඩි විය හැකිය. StringBuilder දේශීය විචල්‍යයක් (එනම්, ක්‍රමයක් තුළ විචල්‍යයක්) වැනි වෙනත් අවස්ථාවන්හිදී ද මෙය සත්‍ය වේ, එහිදී එක් නූල් එකක් පමණක් StringBuilder වස්තුවකට ප්‍රවේශ වේ.

StringBuffer:

• බහු නූල්
• සමමුහුර්ත
• StringBuilder වලට වඩා සෙමින්

StringBuilder

• තනි නූල්
• සමමුහුර්ත කර නොමැත
• වෙන කවරදාටත් වඩා වේගවත්

නූල් සාදන්නා :

int one = 1;
String color = "red";
StringBuilder sb = new StringBuilder();
sb.append("One=").append(one).append(", Color=").append(color).append('\n');
System.out.print(sb);
// Prints "One=1, Colour=red" followed by an ASCII newline.

නූල්-බෆරය

StringBuffer sBuffer = new StringBuffer("test");
sBuffer.append(" String Buffer");
System.out.println(sBuffer);  

හැකි සෑම විටම StringBuilder භාවිතා කිරීම රෙකමදාරු කරනුයේ එය StringBuffer ට වඩා වේගවත් බැවිනි. කෙසේ වෙතත්, නූල් ආරක්ෂාව අවශ්‍ය නම්, හොඳම විකල්පය වන්නේ StringBuffer වස්තු ය.

වඩා හොඳ භාවිතය StringBuilderනිසා එය නොවේ සමමුහුර්ත නිසා වඩා හොඳ කාර්ය සාධනය සහ දීමනා. StringBuilderයනු පැරණි දේ වෙනුවට ආදේශ කිරීමකි StringBuffer.

StringBufferසමමුහුර්ත කර ඇති බැවින් , එයට අමතර වෑයමක් අවශ්‍ය වේ, එබැවින් සිදුරු මත පදනම්ව, එය ටිකක් මන්දගාමී වේ StringBuilder.

එහි අතර කිසිදු මූලික වෙනස්කම් StringBuilderහා StringBufferඔවුන් අතර වෙනස්කම් කීපයක් පමණක් පවතී. දී StringBufferක්රම සමමුහුර්ත කර ඇත. මෙයින් අදහස් කරන්නේ වරකට ඒවා ක්‍රියාත්මක කළ හැක්කේ එක් නූල් එකක් පමණක් බවයි. එක් නූල් එකකට වඩා තිබේ නම්, දෙවන නූල් පළමු එක අවසන් වන තෙක් බලා සිටිය යුතු අතර තුන්වන එක පළමු හා දෙවන එක අවසන් වන තෙක් බලා සිටිය යුතුය. මෙමඟින් ක්‍රියාවලිය ඉතා මන්දගාමී වන අතර එම නිසා කාර්ය සාධනය StringBufferඅඩු වේ.

අනෙක් අතට, StringBuilderසමමුහුර්ත කර නොමැත. මෙයින් අදහස් කරන්නේ වරකට එකම StringBuilderවස්තුවක් මත එකවර බහු නූල් ක්‍රියාත්මක විය හැකි බවයි. මෙමඟින් ක්‍රියාවලිය ඉතා වේගවත් වන අතර එම නිසා කාර්ය සාධනය StringBuilderඉහළ මට්ටමක පවතී.

A Stringයනු වෙනස් කළ නොහැකි වස්තුවකි, එයින් අදහස් වන්නේ අගය වෙනස් කළ නොහැකි අතර StringBufferවිකෘති වන බවයි.

මෙම StringBufferෙහයින්ද, ඒ නිසා නූල්-ආරක්ෂිත වෙළඳ පොළෙන් ඇත StringBuilderඑකම තනි-පොටවල් අවස්ථා සඳහා සුදුසු නොවන හා.

ප්‍රධාන වෙනස වන්නේ StringBufferසමමුහුර්ත කර ඇති නමුත් StringBuilderඑසේ නොවේ. ඔබට නූල් එකකට වඩා භාවිතා කිරීමට අවශ්‍ය නම්, StringBuffer නිර්දේශ කරනු ලැබේ.නමුත්, ක්‍රියාත්මක කිරීමේ වේගය StringBuilderඅනුව වේගවත් StringBufferවන බැවින් එය සමමුහුර්ත වී නොමැත.

සමමුහුර්ත එකතු කිරීමේ ක්‍රමයේ StringBufferසහ සමමුහුර්ත නොවන උපග්‍රන්ථයේ අභ්‍යන්තරය පරීක්ෂා කරන්න StringBuilder.

StringBuffer :

public StringBuffer(String str) {
    super(str.length() + 16);
    append(str);
}

public synchronized StringBuffer append(Object obj) {
    super.append(String.valueOf(obj));
    return this;
}

public synchronized StringBuffer append(String str) {
    super.append(str);
    return this;
}

StringBuilder :

public StringBuilder(String str) {
    super(str.length() + 16);
    append(str);
}

public StringBuilder append(Object obj) {
    return append(String.valueOf(obj));
}

public StringBuilder append(String str) {
    super.append(str);
    return this;
}

උපග්‍රන්ථය බැවින් synchronized, බහු-නූල්කරණ අවස්ථාවන්ට StringBufferසාපේක්ෂව කාර්ය සාධනය ඉහළින් පවතී StrinbBuilder. ඔබ බහු නූල් අතර බෆරය බෙදා නොගන්නා තාක් කල්, භාවිතා කරන්න StringBuilder, එය synchronizedඋපග්‍රන්ථ ක්‍රම නොමැති වීම නිසා වේගවත් වේ.

String vs StringBuffer vs StringBuilder සඳහා කාර්ය සාධන පරීක්ෂණ ප්‍රති result ලය මෙන්න . අවසානයේ ස්ට්‍රිංබිල්ඩර් ටෙස්ට් තරගය ජය ගත්තේය. පරීක්ෂණ කේතය සහ ප්‍රති .ල සඳහා පහත බලන්න.

කේතය :

private static void performanceTestStringVsStringbuffereVsStringBuilder() {
// String vs StringBiffer vs StringBuilder performance Test

int loop = 100000;
long start = 0;

// String
String str = null;
start = System.currentTimeMillis();
for (int i = 1; i <= loop; i++) {
  str += i + "test";
}
System.out.println("String - " + (System.currentTimeMillis() - start) + " ms");

// String buffer
StringBuffer sbuffer = new StringBuffer();
start = System.currentTimeMillis();
for (int i = 1; i <= loop; i++) {
  sbuffer.append(i).append("test");
}
System.out.println("String Buffer - " + (System.currentTimeMillis() - start) + " ms");

// String builder
start = System.currentTimeMillis();
StringBuilder sbuilder = new StringBuilder();
for (int i = 1; i <= loop; i++) {
  sbuffer.append(i).append("test");
}
System.out.println("String Builder - " + (System.currentTimeMillis() - start) + " ms");

  }

අයිඩියොන් මත මාව ක්‍රියාත්මක කරන්න

ප්‍රති ult ලය :

තනි පෙළක් එක් කිරීම සඳහා 100000 පුනරාවර්තනය

String - 37489 ms
String Buffer - 5 ms
String Builder - 4 ms

තනි පෙළක් එක් කිරීම සඳහා 10000 පුනරාවර්තනය

String - 389 ms
String Buffer - 1 ms
String Builder - 1 ms

• StringBuffer නූල්-ආරක්ෂිත නමුත් StringBuilder නූල් ආරක්ෂිත නොවේ.
• StringBuilder යනු StringBuffer ට වඩා වේගවත්ය.
• StringBuffer සමමුහුර්ත කර ඇති අතර StringBuilder සමමුහුර්ත කර නොමැත.

StringBuffer සමමුහුර්ත කර ඇති අතර නූල් ආරක්ෂිතයි, StringBuilder සමමුහුර්ත හා වේගවත් නොවේ.