StringBuilder

"Hälsningar, Amigo!"

"Hej Rishi!"

"Du kan nu tillräckligt mycket om strängar för att lära dig något intressant. Närmare bestämt en ny klass som liknar, men inte exakt samma som, strängklassen."

"Låter spännande, även om det inte är helt klart för mig hur vanliga strängar kommer till korta och varför andra strängliknande klasser behövs."

"Låt oss börja med det faktum att strängar är oföränderliga objekt i Java."

"Hur är det? Jag glömde... Eller jag visste aldrig till att börja med..."

"Låt mig påminna dig om att oföränderliga objekt är de vars tillstånd inte kan ändras efter att de har skapats."

"Ahhh... Varför är strängar oföränderliga i Java?"

"Detta gjordes för att göra String-klassen mycket optimerad och för att den ska kunna användas överallt. Till exempel rekommenderas endast oföränderliga typer för användning som nycklar i HashMap-samlingen .

"Men det uppstår ofta situationer när programmerare skulle tycka att det är bekvämare för String-klassen att vara föränderlig. De vill ha en klass som inte skapar en ny delsträng varje gång en av dess metoder anropas."

"Men vad är det bra för?"

"Tja, anta att vi har en mycket stor sträng och att vi ofta behöver lägga till något i slutet av den. I det här fallet kan till och med en samling tecken ( ) vara ArrayList<Character>effektivare än att ständigt återskapa och sammanfoga strängobjekt."

"Och det är därför vi behöver strängar som inte riktigt är strängklassen?"

"Exakt. Java-språket har lagt till en String-liknande typ som kan ändras. Den heter StringBuilder".

Skapa ett objekt

"För att skapa ett StringBuilderobjekt baserat på en befintlig sträng måste du köra en sats som:

StringBuilder name = new StringBuilder(string);

"För att skapa en tom föränderlig sträng, måste du använda ett uttalande så här:

StringBuilder name = new StringBuilder();

Lista över metoder

"Klassen StringBuilderhar två dussin användbara metoder. Här är de viktigaste:

StringBuilder append(obj)

StringBuilder insert(int index, obj)

StringBuilder replace(int start, int end, String str)

StringBuilder deleteCharAt(int index)

StringBuilder delete(int start, int end)

int indexOf(String str, int index)

int lastIndexOf(String str, int index)

char charAt(int index)

String substring(int start, int end)

StringBuilder reverse()

void setCharAt(int index, char)

int length()

"Och nu ska jag kort beskriva var och en av dessa metoder för dig.

Lägger till en sträng

"För att lägga till något till en föränderlig sträng ( StringBuilder), använd append()metoden. Exempel:

StringBuilder builder = new StringBuilder("Hi");
builder.append("Bye");
builder.append(123);

Konvertera till en standardsträng

"För att konvertera ett StringBuilderobjekt till ett String-objekt behöver du bara anropa dess toString()metod. Exempel

StringBuilder builder = new StringBuilder("Hi");
builder.append(123);
String result = builder.toString();
System.out.println(result);

Hur tar jag bort en karaktär?

"För att radera ett tecken i en föränderlig sträng måste du använda deleteCharAt()metoden. Exempel:

StringBuilder builder = new StringBuilder("Hello");
builder.deleteCharAt(2);
String result = builder.toString();
System.out.println(result);

Hur byter jag ut en del av en sträng med en annan sträng?

"För detta finns replace(int begin, int end, String str)metoden. Exempel:

StringBuilder builder = new StringBuilder("Mellow");
builder.replace(2, 5, "Hello!");
String result = builder.toString();
System.out.println(result);

"Låter bekvämt. Tack, Rishi."

"Nämn inte det. Vad sägs om det här, kan du vända ett snöre bakåt? Hur skulle du göra det?"

"Tja... jag skulle skapa en StringBuilder, lägga en sträng i den... Sedan skapa en ny sträng, och i en slinga från det sista tecknet till det första... Eller kanske en bitvis förskjutning...

"Inte illa. Men det kan vara snabbare. Det finns en speciell metod för att göra detta — reverse();Exempel:

String str = "Hello";
StringBuilder builder = new StringBuilder(str);
builder.reverse();
String result = builder.toString();
System.out.println(result);

"Förutom StringBuilderklassen har Java en annan strängliknande klass som heter . StringBufferDet är en analog till StringBuilderklassen, men dess metoder är markerade med synchronizedmodifieraren."

"Vad betyder det?"

"Det betyder att StringBufferobjektet kan nås samtidigt från flera trådar."

"Jag är inte så bekant med trådar än. Men 'kan nås från flera trådar' är klart bättre än 'kan inte nås från flera trådar'... Varför inte alltid använda StringBufferdå?"

"Eftersom det är mycket långsammare än StringBuilder. Du kan behöva en sådan klass när du börjar aktivt utforska multithreading i Java Multithreading- uppdraget.

"Det ska jag skriva till mitt minne för att inte glömma. Märkt "för framtiden".