I den här handledningen lär vi oss om Java-strängar, hur man skapar dem och olika metoder för sträng med hjälp av exempel.
I Java är en sträng en sekvens av tecken. Till exempel är "hej" en sträng som innehåller en sekvens av tecken "h", "e", "l", "l" och "o".
Vi använder dubbla citat för att representera en sträng i Java. Till exempel,
// create a string String type = "Java programming";
Här har vi skapat en strängvariabel med namnet typ. Variabeln initialiseras med strängen Java Programming.
Obs : Strängar i Java är inte primitiva typer (som int, charetc). Istället är alla strängar objekt av en fördefinierad klass med namnet String.
Och alla strängvariabler är förekomster av Stringklassen.
Exempel: Skapa en sträng i Java
class Main ( public static void main(String() args) ( // create strings String first = "Java"; String second = "Python"; String third = "JavaScript"; // print strings System.out.println(first); // print Java System.out.println(second); // print Python System.out.println(third); // print JavaScript ) )
I ovanstående exempel har vi skapat tre strängar med namnet första, andra och tredje. Här skapar vi direkt strängar som primitiva typer.
Det finns dock ett annat sätt att skapa Java-strängar (med hjälp av newnyckelordet). Vi kommer att lära oss mer om det senare i den här handledningen.
Java-strängoperationer
Java String tillhandahåller olika metoder för att utföra olika operationer på strängar. Vi kommer att undersöka några av de vanliga strängoperationerna.
1. Få längd på en sträng
För att hitta längden på en sträng använder vi length()metoden för strängen. Till exempel,
class Main ( public static void main(String() args) ( // create a string String greet = "Hello! World"; System.out.println("String: " + greet); // get the length of greet int length = greet.length(); System.out.println("Length: " + length); ) )
Produktion
String: Hej! Världslängd: 12
I exemplet ovan length()beräknar metoden det totala antalet tecken i strängen och returnerar den. Om du vill veta mer besöker du Java-stränglängd ().
2. Gå med i två strängar
Vi kan gå med i två strängar i Java med concat()metoden. Till exempel,
class Main ( public static void main(String() args) ( // create first string String first = "Java "; System.out.println("First String: " + first); // create second String second = "Programming"; System.out.println("Second String: " + second); // join two strings String joinedString = first.concat(second); System.out.println("Joined String: " + joinedString); ) )
Produktion
Första sträng: Java andra sträng: programmering Sammanfogad sträng: Java programmering
I exemplet ovan har vi skapat två strängar som heter första och andra. Lägg märke till uttalandet,
String joinedString = first.concat(second);
Här concat()sammanfogar vi metoden första och andra och tilldelar den till variabeln joinedString.
Vi kan också gå med i två strängar med hjälp av +operatören i Java. För att lära dig mer, besök Java String concat ().
3. Jämför två strängar
I Java kan vi göra jämförelser mellan två strängar med equals()metoden. Till exempel,
class Main ( public static void main(String() args) ( // create 3 strings String first = "java programming"; String second = "java programming"; String third = "python programming"; // compare first and second strings boolean result1 = first.equals(second); System.out.println("Strings first and second are equal: " + result1); // compare first and third strings boolean result2 = first.equals(third); System.out.println("Strings first and third are equal: " + result2); ) )
Produktion
Strängar första och andra är lika: sanna Strängar första och tredje är lika: falska
I exemplet ovan har vi skapat tre strängar med namnet första, andra och tredje. Här använder vi equal()metoden för att kontrollera om en sträng är lika med en annan.
De equals()Metoden kontrollerar innehållet i strängar samtidigt jämföra dem. För att lära dig mer, besök Java String är lika med ().
Obs! Vi kan också jämföra två strängar med hjälp av ==operatören i Java. Detta tillvägagångssätt är dock annorlunda än equals()metoden. För att lära dig mer, besök Java String == vs equals ().
Metoder för Java-sträng
Förutom de som nämns ovan finns det olika strängmetoder i Java. Här är några av dessa metoder:
| Metoder | Beskrivning |
|---|---|
| substring () | returnerar strängens delsträng |
| byta ut() | ersätter det angivna gamla tecknet med det angivna nya tecknet |
| charAt () | returnerar tecknet som finns på den angivna platsen |
| getBytes () | konverterar strängen till en rad byte |
| index för() | returnerar positionen för det angivna tecknet i strängen |
| jämföra med() | jämför två strängar i ordbokens ordning |
| trim() | tar bort alla ledande och efterföljande vita utrymmen |
| formatera() | returnerar en formaterad sträng |
| dela() | bryter strängen i en rad strängar |
| toLowerCase () | konverterar strängen till gemener |
| toUpperCase () | konverterar strängen till versaler |
| värdet av() | returnerar strängrepresentationen för det angivna argumentet |
| toCharArray () | konverterar strängen till en charmatris |
Escape karaktär i Java Strings
Escape-karaktären används för att fly från några av de tecken som finns i en sträng.
Antag att vi måste inkludera dubbla citat i en sträng.
// include double quote String example = "This is the "String" class";
Since strings are represented by double quotes, the compiler will treat "This is the " as the string. Hence, the above code will cause an error.
To solve this issue, we use the escape character in Java. For example,
// use the escape character String example = "This is the "String " class.";
Now escape characters tell the compiler to escape double quotes and read the whole text.
Java Strings are Immutable
In Java, strings are immutable. This means, once we create a string, we cannot change that string.
To understand it more deeply, consider an example:
// create a string String example = "Hello! ";
Here, we have created a string variable named example. The variable holds the string "Hello! ".
Now suppose we want to change the string.
// add another string "World" // to the previous tring example example = example.concat(" World");
Here, we are using the concat() method to add another string World to the previous string.
It looks like we are able to change the value of the previous string. However, this is not true.
Let's see what has happened here,
- JVM takes the first string "Hello! "
- creates a new string by adding "World" to the first string
- assign the new string "Hello! World" to the example variable
- the first string "Hello! " remains unchanged
Creating strings using the new keyword
So far we have created strings like primitive types in Java.
Since strings in Java are objects, we can create strings using the new keyword as well. For example,
// create a string using the new keyword String name = new String("Java String");
In the above example, we have created a string name using the new keyword.
Here, when we create a string object, the String() constructor is invoked. To learn more about constructor, visit Java Constructor.
Note: The String class provides various other constructors to create strings. To learn more, visit Java String (official Java documentation).
Example: Create Java Strings using the new keyword
class Main ( public static void main(String() args) ( // create a string using new String name = new String("Java String"); System.out.println(name); // print Java String ) )
Create String using literals vs new keyword
Now that we know how strings are created using string literals and the new keyword, let's see what is the major difference between them.
In Java, the JVM maintains a string pool to store all of its strings inside the memory. The string pool helps in reusing the strings.
While creating strings using string literals, the value of the string is directly provided. Hence, the compiler first checks the string pool to see if the string already exists.
- Om strängen redan finns skapas inte den nya strängen. Istället pekar den nya referensen till den befintliga strängen.
- Om strängen inte finns skapas den nya strängen.
När du skapar strängar med det nya nyckelordet tillhandahålls dock inte strängens värde direkt. Därför skapas den nya strängen hela tiden.
