Java basic learning String class

“This is the fifth day of my participation in the November Gwen Challenge. See details of the event: The Last Gwen Challenge 2021”.

Two ways to instantiate objects

We have learned the basic use of String before, which is to represent a String, so we used the form of direct assignment:

public class StringText{
	public static void main(String args[]){
	String str =new String( "Hello");     // constructorSystem.out.print(str); }}Copy the code

String must be a class, and STR should be the object of that class. This proves that the above assignment is actually instantiating the object of the String class.

But String is a class, so there must be constructors in the class.

public class StringText{
	public static void main(String args[]){
	String str =new String( "Hello");     // constructorSystem.out.print(str); }}Copy the code

You can now instantiate String objects using constructors, too.

String comparison

If you now have two int variables and want to know if they are equal, use “==” to verify.

public class StringText{
	public static void main(String args[]){
	int x = 10;
	int y = 10; System.out.print(x==y); }}Copy the code

With the String

public class StringText{
	public static void main(String args[]){
		String str1 = "Hello";
		String str2 = new String("Hello");
		String str3 = str2;     // Reference passing
		System.out.print(str1== str2);          //false
		System.out.print(str1== str3);          //false
		System.out.print(str2== str3);          //ture}}Copy the code

Now “==” is indeed used to complete the judgment of equality, but the final judgment is whether the two objects (the current object is a string) are equal, which belongs to the numerical judgment —— determines the value of the memory address of the two objects, and does not determine the content, but to complete the judgment of the content of the string, Public Boolean equals(String STR)(temporarily changed)

public class StringText{
	public static void main(String args[]){
		String str1 = "Hello";
		String str2 = new String("Hello");
		String str3 = str2;     // Reference passing
		System.out.print(str1.equals(str2));          //ture
		System.out.print(str2.equals(str3));          //ture
		System.out.print(str2.equals(str3));          //ture}}Copy the code

String constants are anonymous objects of String

If a String is defined in a program (using “”), then this represents a String object, because String data types are not defined in any language, and Java handles them simply, so it feels like there are String data types.

Example: Verify the notion that strings are objects

public class NiMing{
	public static void main(String args[]){
		String str = "Hello";
		System.out.print("Hello".equals(str));     // Call a method through a string}}Copy the code

An anonymous object can call methods and attributes in the class, and the string above can call equals(), so it must be an object.

Tip: String and string constant judgment

For example, in real work, there will be such an operation that asks the user to enter a content and then determine whether the content is the same as the specified content.

public class NiMing{
	public static void main(String args[]){
		String str = "Hello";
        if(str.equals("Hello")){
		    System.out.print("Condition met"); }}}Copy the code

However, since the data is entered by the user, it is possible that there is no input.

public class TestDemo1{
	public static void main(String args[]){
		String str = null;
        if(str.equals("Hello")){
		    System.out.print("Condition met"); }}}/ / an error
    Exception in thread "main" java.lang.NullPointerException
        at NiMing.main(TestDemo1.java:4)
// Now run the code in reverse:
        public class TestDemo1{
	public static void main(String args[]){
		String str = null;
        if("Hello".equals(str)){
		    System.out.print("Condition met"); }}}Copy the code

Because string constants are anonymous objects, anonymous objects cannot be NULL.

String the two instantiation methods are different

1. Analyze the direct assignment method

String str = "Hello";     // Define a string
Copy the code

It is found that only one heap and one stack are now allocated.

2. Constructor assignment

String  str = new String("Hello");
Copy the code

Using constructor assignment to open a string object actually opens up two Spaces, one of which is garbage.

public class TestDemo2{
public static void main(String args[]){
		String str1 = new String("Hello");
		String str2 = "Hello";   / / into the pool
		String str3 = "Hello";  // Use objects in the pool
		System.out.print(str1==str2);          //false
		System.out.print(str2==str3);          // ture 
		System.out.print(str1==str3);          // false}}Copy the code

As you can see from the above program, using a constructor to instantiate a String is not pooled. However, the String class provides a method called manual pooling for ease of operation: public String Intern ().

public class TestDemo2{
public static void main(String args[]){
		String str1 = new String("Hello").intern();    // Enter the pool manually
		String str2 = "Hello";   / / into the pool
		String str3 = "Hello";  // Use objects in the pool
	    System.out.print(str1==str2);          //ture System.out.print(str2==str3); //ture
		System.out.print(str1==str3);          //ture}}Copy the code

String constants cannot be changed

The operation nature of the string class makes it impossible for a string to modify its contents.

public class TestDemo3{
	public static void main(String args[]){
		String str = "Hello";
		str += "World";
		str += "!!!"; System.out.print(str); }}Copy the code

The above code can be found that the content of the string changes, actually changes the string object reference process, so the following code should be avoided:

public class TestDemo3{
	public static void main(String args[]){
		String str = "Hello";
		for(int x=0; x<1000;x++){
			str += x;
		}
		System.out.print(str);
	}       
}
Copy the code

• String assignment is done only in direct assignment mode
• String comparisons are implemented using equals()
• Don’t change strings too much without special cases

String must be used in development

The documentation for any class consists of the following parts

• Class, including the name of the class, which parent classes it has, and which interfaces it has.
• Class. Including basic use
• Member summary (Field) : A property is a member that lists the information items for all members
• Constructor, which lists information for all constructors
• Method information, all the methods defined in the class that can be used
• Details of members, constructs, and methods

Strings and character arrays

A String is just an array of characters, so in the String class there are methods for converting a String to a character array, and a character array to a String.

Method names	type	describe
public String(char[] value)	structure	Turns everything in a character array into a string
public String(char[] value, int offset, int count)	structure	Change the contents of the character array to the string offset- start count- number
public char charAt(int index)	ordinary	Char Returns the index of the specified character
public char[] toCharArray()	ordinary	Converts a string to a character array

CharAt method

public class TestDemo4{
	public static void main(String args[]){
		String str = "Hello";
		System.out.println(str.charAt(0));
		/ / now, more than the length of the string, will produce abnormal StringIndexOutOfBoundsException
		System.out.println(str.charAt(10)); }}Copy the code

Conversion of strings and character arrays is the focus

// The string is converted to an array of characters
public class TestDemo4{
	public static void main(String args[]){
		String str = "helloworld";
		char data [] = str.toCharArray();
		for(int i = 0; i < data.length; i++){
		data[i] -= 32;	// Switch to uppercase simplified mode to make it easier
			System.out.print(data[i] + "、"); }}}Copy the code

// The character array is converted to a string
public class TestDemo4{
	public static void main(String args[]){
		String str = "helloworld";
		char data [] = str.toCharArray();
		for(int i = 0; i < data.length; i++){
		data[i] -= 32;	// Switch to uppercase simplified mode to make it easier
			System.out.print(data[i] + "、");
		}
		System.out.println();
		System.out.println(new String(data));// All string arrays are converted to character arrays
		System.out.println(new String(data,1.4));// The string array part is converted to a character array}}Copy the code

Determines whether a string consists of numbers

public class TestDemo5{
	public static void main(String args[]){
		String str1 = "helloworld";
		String str = "1234567890";
		Judgenum(str);
		Judgenum(str1);
	}
	public static void Judgenum(String str){
		char data [] = str.toCharArray();
		boolean judge = true;
		for(int i = 0; i < data.length; i++){
			if(data[i]>= '0' && data[i]<= '9'){
				judge = false; }}if(judge){
			System.out.println(str+"It's made of letters.");
		}else
			System.out.println(str+"It's made of numbers."); }}Copy the code

Bytes and strings

Method names	type	describe
public String(byte[] bytes)	structure	Turns part of the byte array into a string
public String(byte[] bytes, int offset,int length)	structure	Change part of the byte array to a string bytes — the byte to decode into a character offset — the index length of the first byte to decode — the number of bytes to decode
public byte[] getBytes()	ordinary	Turns a string into a byte array
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException	ordinary	Code conversion code

// Uppercase the string via byte flow
public class TestDemo6{
	public static void main(String args[]){
		String str = "helloworld";
		byte data [] = str.getBytes();// The string is converted to a byte array
		for(int i = 0; i < data.length ; i++){
			System.out.print(data[i]+"、");
			data[i] -= 32;
		}
		System.out.println(new String(data));// The byte array is converted to a string}}Copy the code

In general, there are only two ways to manipulate byte arrays in a program:

1. Coding transformation is required;

2. When data is to be transmitted.

3. Binary files are suitable for byte processing

String comparison

Method names	type	describe
public boolean equals(String anObject)	ordinary	Case sensitive comparison
public boolean equalsIgnoreCase(String anotherString)	ordinary	Case insensitive comparison
public int compareTo(String anotherString)	ordinary	Compares the size relationship between two strings

If you now want to compare the size of two strings, you must do so using the comepareTo() method, which returns an int, which has three results: greater than (returns greater than 0), less than (returns less than 0), and equal (returns 0).

public class CompareTo{
	public static void main(String args[]){
	String str1 = "HELLO";
	String str2= "hello"; System.out.println(str1.compareTo(str2)); }}Copy the code

String lookup

Method names	type	describe
public boolean contains(String s)	ordinary	Checks whether a substring exists
public int indexOf(String str)	ordinary	Returns the index of the first occurrence of a string in a string
public int indexOf(String str, int fromIndex)	ordinary	Finds the location of the substring starting at the specified place
public int lastIndexOf(String str)	ordinary	Finds the position of the substring from back to front
public int lastIndexOf(String str, int fromIndex)	ordinary	Searches backwards from the specified location
public boolean startsWith(String prefix)	ordinary	Determine from scratch whether to start with a string
public boolean startsWith(String prefix,int toffset)	ordinary	Checks whether it starts with a string from the specified position
public boolean endsWith(String suffix)	ordinary	Check to end with a string

public class TestDemo7{
	public static void main(String args[]){
		String str = "helloworld";
		System.out.println(str.contains("world"));		//true
		// Use indexOf() for the search
		System.out.println(str.indexOf("world"));
		System.out.println(str.indexOf("java"));
		//JDK1,5 used this way before
		if(str.indexOf() ! = -1){
			System.out.println("The specified contents can be found."); }}}Copy the code

1. Basically all lookups are now done through the contains() method.
2. Note that if the content repeats indexOf() it can only return the first location searched.
3. When you do a search, you tend to judge the beginning or the end.

public class TestDemo7{
	public static void main(String args[]){
		String str = "**@@helloworld##";
		System.out.println(str.startsWith("* *"));	//true
		System.out.println(str.startsWith("@ @".2));	//true
		System.out.println(str.endsWith("# #"));	//true}}Copy the code

String substitution

Method names	type	describe
public String replaceAll(String regex,String replacement)	ordinary	Replace everything
public String replaceFirst(String regex,String replacement)	ordinary	Replace header

public class TestDemo7{
	public static void main(String args[]){
		String str = "**@@helloworld##";		
		System.out.println(str.replaceAll("l"."_"));	//**@@he__owor_d##}}Copy the code

String splitting

Method names	type	describe
public String[] split(String regex)	ordinary	Split the string completely
public String[] split(String regex,int limit)	ordinary	Split part of the string

public class TestDemo8{
	public static void main(String args[]){
		String str = "hello world hello zsr hello csdn";
		String result [] = str.split("");	// Split by Spaces
		//hello, world, hello, ZSR, hello, CSDN,
		for(int i = 0; i < result.length ; i++){
			System.out.print(result[i]+"、");	
		}
		System.out.println();
		// Part split
		String result1 [] = str.split("".3);	// Split by Spaces
		// The second argument does not split from the first position
		// ZSR hello CSDN,
		for(int i = 0; i < result1.length ; i++){
			System.out.print(result1[i]+"、"); }}}Copy the code

// Split IP addresses
public class TestDemo9{
// Wu found that the contents could not be split, so it needed to use "\\" to escape
	public static void main(String args[]){
	/ / 120
	/ / 11
	/ / 219
	/ / 223:57114
		String str = "120.11.219.223:57114";
		String result [] = str.split("\ \.");
		for(int i = 0; i < result.length ; i++){ System.out.println(result[i]); }}}Copy the code

Interception of a string

Method names	type	describe
public String substring(int beginIndex)	ordinary	Intercepts from the specified position to the end
public String substring(int beginIndex,int endIndex)	ordinary	Cut some content

public class TestDemo10{
	public static void main(String args[]){
		String str = "helloworld";
		//world
		System.out.println(str.substring(5));
		//hello
		System.out.println(str.substring(0.5)); }}Copy the code

Other operation methods

Method names	type	describe
Public String trim()	ordinary	Remove the left and right Spaces and keep the middle Spaces
public String toUpperCase()	ordinary	Uppercase all strings
public String toLowerCase()	ordinary	Turn all strings to lowercase
public String intern()	ordinary	The string is added to the object pool
public String concat()	ordinary	String conjunction

Consider:

1. Now given a string format as follows: “the name of | | name name: results: results: scores”, for example, a given string is: “Tom: 90 | Jerry: 80 | Tony: 89”, for the above data can be processed and displayed in the data according to the following: name: Tom, grade: 90;

public class Exam1{
	public static void main(String args[]){
		String str = "Tom:90|Jerry:80|tony:89";
		String data [] = str.split("\ \ |");
		for(int i = 0 ; i < data.length ; i++){
			String result [] = data[i].split(":");
			System.out.print("Name =" + result[0] + ",");
			System.out.println("年龄 = " + result[1]);
		}
		
		/* Name = Tom, Age = 90 Name = Jerry, age = 80 Name = Tony, age = 89*/}}Copy the code

2. If an email address is given, you can verify that it is correct. . The criteria are as follows:

1. The length of the email should not be shorter than 5

2. Do not start or end with @ and

3. The order of @ and. Should be defined

public class Exam2{
	public static void main(String args[]){
		String email = "1016942589.@qqcom";
		char date[] = email.toCharArray();
		if (date.length>5&&email.startsWith("@") = =false 
		&& email.startsWith(".") = =false && email.endsWith("@") = =false
		&&email.endsWith(".") = =false && email.indexOf(".") >email.indexOf("@"))
		{System.out.println("Right");
		}else{System.out.println("Error"); }}}Copy the code