Bekvämlighetsklasser för att arbeta med strängar i Java

1. StringTokenizerklass

Och nu några fler vanliga scenarier som involverar arbete med strängar. Hur delar man upp en sträng i flera delar? Det finns flera sätt att göra detta.

split()metod

Det första sättet att dela upp en sträng i flera delar är att använda split()metoden. Ett reguljärt uttryck som definierar en speciell avgränsande sträng måste skickas som ett argument. Du kommer att lära dig vad ett reguljärt uttryck är i Java Multithreading- uppdraget.

Exempel:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

Enkelt, men ibland är detta tillvägagångssätt överdrivet. Om det finns många avgränsare (till exempel mellanslag, nyradstecken, tabbar, punkter), måste du konstruera ett ganska komplext reguljärt uttryck. Den är svår att läsa och därför svår att modifiera.

StringTokenizerklass

Java har en specialklass vars hela jobb är att dela upp en sträng i delsträngar.

Den här klassen använder inte reguljära uttryck: istället skickar du bara in en sträng som består av avgränsare. Fördelen med detta tillvägagångssätt är att det inte bryter hela strängen i bitar på en gång, utan istället flyttas från början till slut ett steg i taget.

Klassen har en konstruktor och två viktiga metoder. Vi skickar konstruktorn en sträng som vi delar upp i delar, och en sträng som består av en uppsättning avgränsande tecken.

String nextToken()

boolean hasMoreTokens()

Den här klassen påminner på något sätt om klassen Scanner, som också har nextLine()och hasNextLine()metoder.

Du kan skapa ett StringTokenizerobjekt med detta kommando:

StringTokenizer name = new StringTokenizer(string, delimiters);

Var stringska strängen delas upp i delar. Och delimitersär en sträng, och varje tecken i den behandlas som en avgränsare. Exempel:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

Observera att varje tecken i strängen som skickas som den andra strängen till konstruktorn StringTokenizeranses vara en separator.

2. String.format()metod och StringFormatterklass

En annan intressant metod för String-klassen är format().

Låt oss säga att du har olika variabler som lagrar data. Hur visar du dem på skärmen på en rad? Till exempel har vi lite data (vänster kolumn) och önskad utdata (höger kolumn):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

Din kod kommer förmodligen att se ut ungefär så här:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

Sådan kod är inte särskilt läsbar. Och om variabelnamnen var längre, skulle koden bli ännu svårare:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

Inte särskilt läsvärd, eller hur?

Men det här är en vanlig situation i verkliga program, så jag vill berätta om ett sätt att skriva den här koden enklare och mer koncist.

String.format

Klassen String har en statisk format()metod: den låter dig specificera ett mönster för att sammanställa en sträng med data. Kommandots allmänna utseende är som följer:

String name = String.format(pattern, parameters);

Exempel:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

Metodens format()första parameter är en formatsträng som innehåller all önskad text tillsammans med specialtecken som kallas formatspecificerare (som %doch %s) på de platser där du behöver infoga data.

Metoden format()ersätter dessa %soch %dformatspecifikationer med parametrarna som följer formatsträngen i parameterlistan. Om vi ​​vill infoga en sträng så skriver vi %s. Om vi ​​vill infoga ett tal är formatspecifikationen %d. Exempel:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

Här är en kort lista över formatspecifikationer som kan användas i formatsträngen:

%s

%d

%f

%b

%c

%t

%%

Dessa specifikationer anger typen av data, men det finns också specifikationer som anger ordningen på data. För att få ett argument genom dess nummer (numreringen börjar från ett), måste du skriva " " istället för " ". Exempel:%1$d%d

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$dkommer att få det 3:e argumentet, %2$dkommer att få det andra argumentet och %dkommer att få det allra första argumentet. Formatspecifikationerna %soch %dhänvisar till argument oavsett specifikationer som %3$deller%2$s

3. String Pool

Varje sträng som anges i kod som en bokstavlig sträng lagras i ett minnesområde som kallas medan StringPoolprogrammet körs. StringPoolär en speciell array för att lagra strängar. Dess syfte är att optimera stränglagring:

Först måste strängarna som anges i koden lagras någonstans, eller hur? Koden består av kommandon, men data (särskilt stora strängar) måste lagras i minnet separat från koden. Endast referenser till strängobjekt visas i kod.

För det andra måste alla identiska strängliteraler endast lagras i minnet en gång. Och det är bara så det fungerar. När din klasskod laddas av Java-maskinen läggs alla strängliteraler till StringPoolom de inte redan finns där. Om de redan finns där använder vi helt enkelt en strängreferens från StringPool.

Följaktligen, om du tilldelar samma literal till flera Stringvariabler i din kod, kommer dessa variabler att innehålla samma referens. En bokstavlig kommer att läggas till StringPoolendast en gång. I alla andra fall kommer koden att få en referens till strängen som redan är laddad i StringPool.

Så här fungerar det ungefär:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

Det är därför variablerna aoch bkommer att lagra samma referenser.

intern()metod

Och det bästa är att du programmässigt kan lägga till vilken sträng som helst till StringPool. För att göra detta behöver du bara anropa Stringvariabelns intern()metod.

Metoden intern()lägger till strängen till StringPoolom den inte redan finns där, och returnerar en referens till strängen i StringPool.

Om två identiska strängar läggs till med StringPoolmetoden intern()returnerar metoden samma referens. Detta kan användas för att jämföra strängar genom referens. Exempel:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

Det är osannolikt att du använder den här metoden ofta, men folk älskar att fråga om det i intervjuer . Så det är bättre att veta om det än att inte veta.