Praktiske klasser til at arbejde med strenge i Java

1. StringTokenizerklasse

Og nu et par mere almindelige scenarier, der involverer arbejde med strenge. Hvordan deler man en streng op i flere dele? Der er flere måder at gøre dette på.

split()metode

Den første måde at opdele en streng i flere dele er at bruge split()metoden. Et regulært udtryk, der definerer en speciel afgrænsende streng, skal sendes som et argument. Du vil lære, hvad et regulært udtryk er i Java Multithreading- quest.

Eksempel:

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

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

Simpelt, men nogle gange er denne tilgang overdreven. Hvis der er mange afgrænsningstegn (f.eks. mellemrum, linjeskifttegn, tabulatorer, punktum), så skal du konstruere et ret komplekst regulært udtryk. Den er svær at læse og derfor svær at ændre.

StringTokenizerklasse

Java har en speciel klasse, hvis hele opgave er at opdele en streng i understrenge.

Denne klasse bruger ikke regulære udtryk: I stedet sender du blot en streng, der består af skilletegn. Fordelen ved denne fremgangsmåde er, at den ikke knækker hele strengen i stykker på én gang, men i stedet bevæger sig fra start til slut et trin ad gangen.

Klassen har en konstruktør og to vigtige metoder. Vi sender konstruktøren en streng, som vi opdeler i dele, og en streng bestående af et sæt afgrænsende tegn.

String nextToken()

boolean hasMoreTokens()

Denne klasse minder på en eller anden måde om Scanner-klassen, som også har nextLine()og hasNextLine()metoder.

Du kan oprette et StringTokenizerobjekt med denne kommando:

StringTokenizer name = new StringTokenizer(string, delimiters);

Hvor stringskal strengen deles i dele. Og delimiterser en streng, og hvert tegn i den behandles som en afgrænsning. Eksempel:

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
!

Bemærk, at hvert tegn i strengen, der sendes som den anden streng til StringTokenizerkonstruktøren, betragtes som en separator.

2. String.format()metode og StringFormatterklasse

En anden interessant metode i String-klassen er format().

Lad os sige, at du har forskellige variabler, der lagrer data. Hvordan viser du dem på skærmen på én linje? For eksempel har vi nogle data (venstre kolonne) og ønsket output (højre kolonne):

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

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

Din kode vil sandsynligvis se sådan her ud:

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.}");

En sådan kode er ikke særlig læsbar. Og hvis variabelnavnene var længere, ville koden blive endnu sværere:

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.}");

Ikke særlig læseværdig, vel?

Men dette er en almindelig situation i programmer i den virkelige verden, så jeg vil gerne fortælle dig om en måde at skrive denne kode mere enkelt og mere kortfattet på.

String.format

String-klassen har en statisk format()metode: den lader dig angive et mønster til at samle en streng med data. Kommandoens generelle udseende er som følger:

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

Eksempel:

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ørste parameter er en formatstreng, der indeholder al den ønskede tekst sammen med specialtegn kaldet formatspecificatorer (såsom %dog %s) på de steder, hvor du skal indsætte data.

Metoden format()erstatter disse %sog %dformatspecifikationer med de parametre, der følger formatstrengen i parameterlisten. Hvis vi vil indsætte en streng, så skriver vi %s. Hvis vi vil indsætte et tal, så er formatspecifikationen %d. Eksempel:

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

Her er en kort liste over formatspecifikationer, der kan bruges inde i formatstrengen:

%s

%d

%f

%b

%c

%t

%%

Disse specifikationer angiver typen af ​​data, men der er også specifikationer, der angiver rækkefølgen af ​​dataene. For at få et argument ved dets nummer (nummereringen starter fra et), skal du skrive " " i stedet for " ". Eksempel:%1$d%d

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

%3$dfår det 3. argument, %2$dfår det andet argument og %dfår det allerførste argument. Angivelserne %sog %dformatet refererer til argumenter uanset specifikationer som %3$deller%2$s

3. String Pool

Hver streng angivet i kode som en streng-literal er gemt i et hukommelsesområde kaldet StringPoolmens programmet kører. StringPooler et specielt array til lagring af strenge. Dens formål er at optimere strenglagring:

For det første skal de strenge, der er angivet i koden, gemmes et sted, ikke? Kode består af kommandoer, men data (især store strenge) skal lagres i hukommelsen adskilt fra koden. Kun referencer til strengobjekter vises i kode.

For det andet skal alle identiske strengliteraler kun gemmes i hukommelsen én gang. Og sådan fungerer det bare. Når din klassekode indlæses af Java-maskinen, tilføjes alle strenge bogstaver til, StringPoolhvis de ikke allerede er der. Hvis de allerede er der, så bruger vi blot en strengreference fra StringPool.

Derfor, hvis du tildeler den samme literal til flere Stringvariabler i din kode, vil disse variable indeholde den samme reference. En bogstavelig vil blive tilføjet til den StringPooleneste ene. I alle andre tilfælde vil koden få en reference til den streng, der allerede er indlæst i StringPool.

Sådan fungerer det nogenlunde:

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

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

Det er derfor, variablerne aog bvil gemme de samme referencer.

intern()metode

Og det bedste er, at du programmæssigt kan tilføje enhver streng til StringPool. For at gøre dette skal du blot kalde Stringvariablens intern()metode.

Metoden intern()tilføjer strengen til, StringPoolhvis den ikke allerede er der, og returnerer en reference til strengen i StringPool.

Hvis to identiske strenge tilføjes til at StringPoolbruge intern()metoden, returnerer metoden den samme reference. Dette kan bruges til at sammenligne strenge ved reference. Eksempel:

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 er usandsynligt, at du bruger denne metode ofte, men folk elsker at spørge om det i interviews . Så det er bedre at vide om det end ikke at vide.