Supporting video tutorials
This article is a video tutorial for station B
The String class is located in Java Lang package has rich methods
Initialization method of string
/*
* String: a string of data composed of multiple characters. It can also be regarded as a character array.
* By looking at the API, we can know
* A:The string literal "abc" can also be regarded as a string object.
* B:The string is a constant and cannot be changed once it is assigned.
*
* Initialization method:
* public String():
* public String(String original):Convert string constant value to string
*
* String method:
* public int length(): Returns the length of this string.
*/
public class StringDemo {
public static void main(String[] args) {
// public String():
String s1 = new String();
System.out.println("s1:" + s1);
System.out.println("s1.length():" + s1.length());
System.out.println("--------------------------");
//s1:
//s1.length():0
//public String(String original): convert the string constant value into a string
String s6 = new String("abcde");
System.out.println("s6:" + s6);
System.out.println("s6.length():" + s6.length());
System.out.println("--------------------------");
//The string literal "abc" can also be regarded as a string object.
String s7 = "abcde";
System.out.println("s7:"+s7);
System.out.println("s7.length():"+s7.length());
}
}Characteristics of string: once assigned, it cannot be changed.
But references can change
public class StringDemo {
public static void main(String[] args) {
String s = "hello";
s += "world";
System.out.println("s:" + s); // helloworld
}
}
String s = new String("hello") and string s = "hello"; What's the difference?
The difference between a String literal object and an object created by a constructor
/*
* String s = new String("hello")And String s = "hello"; What's the difference?
* have The former creates 2 objects and the latter creates 1 object.
*
* ==:Comparing reference types compares whether the address values are the same
* equals:By default, the comparison reference type also compares whether the address values are the same, while the String class overrides the equals() method to compare whether the contents are the same.
*/
public class StringDemo2 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = "hello";
System.out.println(s1 == s2);// false
System.out.println(s1.equals(s2));// true
}
}
　String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);// String literal, directly from memory, so true
System.out.println(s5.equals(s6));// trueJudgment function of String class:
/*
* String Class judgment function:
* boolean equals(Object obj):Compare whether the contents of the string are the same, case sensitive
* boolean equalsIgnoreCase(String str):Compare whether the contents of the string are the same, ignoring case
* boolean contains(String str):Judge whether the large string contains the small string
* boolean startsWith(String str):Determines whether a string begins with a specified string
* boolean endsWith(String str):Determines whether a string ends with a specified string
* boolean isEmpty():Judge whether the string is empty.
*
* be careful:
* The string content is empty and the string object is empty.
* String s = "";//The object exists, so the method can be called
* String s = null;//Object does not exist, cannot call method
*/
public class StringDemo {
public static void main(String[] args) {
// Create string object
String s1 = "helloworld";
String s2 = "helloworld";
String s3 = "HelloWorld";
// boolean equals(Object obj): compare whether the contents of strings are the same, case sensitive
System.out.println("equals:" + s1.equals(s2));
System.out.println("equals:" + s1.equals(s3));
System.out.println("-----------------------");
// boolean equalsIgnoreCase(String str): compare whether the contents of strings are the same, ignoring case
System.out.println("equals:" + s1.equalsIgnoreCase(s2));
System.out.println("equals:" + s1.equalsIgnoreCase(s3));
System.out.println("-----------------------");
// boolean contains(String str): judge whether a large string contains a small string
System.out.println("contains:" + s1.contains("hello"));
System.out.println("contains:" + s1.contains("hw"));
System.out.println("-----------------------");
// boolean startsWith(String str): determines whether a string starts with a specified string
System.out.println("startsWith:" + s1.startsWith("h"));
System.out.println("startsWith:" + s1.startsWith("hello"));
System.out.println("startsWith:" + s1.startsWith("world"));
System.out.println("-----------------------");
// Exercise: boolean endsWith(String str): judge whether the string ends with a specified string, and play by yourself
// boolean isEmpty(): judge whether the string is empty.
System.out.println("isEmpty:" + s1.isEmpty());
String s4 = "";
String s5 = null;
System.out.println("isEmpty:" + s4.isEmpty());
// NullPointerException
// s5 objects do not exist, so methods cannot be called. Null pointer exception
// System.out.println("isEmpty:" + s5.isEmpty());
}
}Get function of String class
/*
* String Class
* int length():Gets the length of the string.
* char charAt(int index):Gets the character at the specified index position
* int indexOf(int ch):Returns the index of the first occurrence of the specified character in this string.
* Why is this type int instead of char?
* The reason is: 'a' and 97 can actually represent 'a'. If you write char in it, you can't write the number 97
* int indexOf(String str):Returns the index of the specified string at the first occurrence in this string.
* int indexOf(int ch,int fromIndex):Returns the index of the first occurrence of the specified character in this string from the specified position.
* int indexOf(String str,int fromIndex):Returns the index of the specified string where it first appears after the specified position.
* String substring(int start):Intercepts the string from the specified position, and defaults to the end.
* String substring(int start,int end):Intercept the string from the specified position to the end of the specified position.
*/
public class StringDemo {
public static void main(String[] args) {
// Define a string object
String s = "helloworld";
// int length(): get the length of the string.
System.out.println("s.length:" + s.length());//10
System.out.println("----------------------");
// char charAt(int index): gets the character of the specified index position
System.out.println("charAt:" + s.charAt(7));//
System.out.println("----------------------");
// int indexOf(int ch): returns the index of the first occurrence of the specified character in this string.
System.out.println("indexOf:" + s.indexOf('l'));
System.out.println("----------------------");
// int indexOf(String str): returns the index of the first occurrence of the specified string in this string.
System.out.println("indexOf:" + s.indexOf("owo"));
System.out.println("----------------------");
// int indexOf(int ch,int fromIndex): returns the index of the first occurrence of the specified character from the specified position in this string.
System.out.println("indexOf:" + s.indexOf('l', 4));
System.out.println("indexOf:" + s.indexOf('k', 4)); // -1
System.out.println("indexOf:" + s.indexOf('l', 40)); // -1
System.out.println("----------------------");
// Practice by yourself: int indexOf(String str,int)
// fromIndex): returns the index of the specified string where it first appears from the specified position in the string.
// String substring(int start): intercepts the string from the specified position, and defaults to the end. Contains the index start
System.out.println("substring:" + s.substring(5));
System.out.println("substring:" + s.substring(0));
System.out.println("----------------------");
// String substring(int start,intend): intercepts a string from the specified position to the end of the specified position.
//Include the start index but not the end index
System.out.println("substring:" + s.substring(3, 8));
System.out.println("substring:" + s.substring(0, s.length()));
}
}Analyze the date of birth according to the ID number
String traversal:
/*
* Requirement: traverse to get every character in the string
*
* analysis:
* A:How can I get every character?
* char charAt(int index)
* B:How do I know how many characters there are?
* int length()
*/
public class StringTest {
public static void main(String[] args) {
// Define string
String s = "helloworld";
for (int x = 0; x < s.length(); x++) {
System.out.println(s.charAt(x));
}
}
}Count the number of uppercase letters, lowercase letters and numbers in the string
/*
* Requirement: count the occurrence times of uppercase, lowercase and numeric characters in a string. (other characters are not considered)
* give an example:
* "Hello123World"
* result:
* Uppercase characters: 2
* Lowercase characters: 8
* Numeric characters: 3
*
* analysis:
* Premise: the string must exist
* A:Define three statistical variables
* bigCount=0
* smallCount=0
* numberCount=0
* B:Traverse the string to get each character.
* length()Combined with charAt()
* C:Judge which type the character belongs to
* Big: bigCount++
* Small: smallCount++
* Number: numberCount++
*
* The difficulty of this problem is how to judge whether a character is large, small or numeric.
* ASCII Code table:
* 0 48
* A 65
* a 97
* Although it is possible for us to make such a comparison according to the figures, we think too much, and there are simpler ones than this
* char ch = s.charAt(x);
*
* if(ch>='0' && ch<='9') numberCount++
* if(ch>='a' && ch<='z') smallCount++
* if(ch>='A' && ch<='Z') bigCount++
* D:Output results.
*
* Exercise: improve the way of giving a string to the way of entering a string with the keyboard.
*/
public class StringTest2 {
public static void main(String[] args) {
//Define a string
String s = "Hello123World";
//Define three statistical variables
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//Traverse the string to get each character.
for(int x=0; x<s.length(); x++){
char ch = s.charAt(x);
//Judge which type the character belongs to, and char type will be converted to int type
if(ch>='a' && ch<='z'){
smallCount++;
}else if(ch>='A' && ch<='Z'){
bigCount++;
}else if(ch>='0' && ch<='9'){
numberCount++;
}
}
//Output results.
System.out.println("capital"+bigCount+"individual");
System.out.println("Lowercase letters"+smallCount+"individual");
System.out.println("number"+numberCount+"individual");
}
}String conversion function:
/*
* String Conversion function of:
* byte[] getBytes():Converts a string to a byte array.
* char[] toCharArray():Converts a string to an array of characters.
* static String valueOf(char[] chs):Convert a character array into a string.
* static String valueOf(int i):Converts data of type int into a string.
* Note: the valueOf method of String class can convert any type of data into a String.
* String toLowerCase():Convert the string to lowercase.
* String toUpperCase():Convert string to uppercase.
* String concat(String str):Concatenate strings.
*/
public class StringDemo {
public static void main(String[] args) {
// Define a string object
String s = "JavaSE";
// byte[] getBytes(): converts a string into a byte array.
byte[] bys = s.getBytes();
for (int x = 0; x < bys.length; x++) {
System.out.println(bys[x]);
}
System.out.println("----------------");
// Convert character string to array [].
char[] chs = s.toCharArray();
for (int x = 0; x < chs.length; x++) {
System.out.println(chs[x]);
}
System.out.println("----------------");
// static String valueOf(char[] chs): convert the character array into a string.
String ss = String.valueOf(chs);
System.out.println(ss);
System.out.println("----------------");
// static String valueOf(int i): convert data of type int into a string.
int i = 100;
String sss = String.valueOf(i);
System.out.println(sss);
System.out.println("----------------");
// String toLowerCase(): convert the string to lowercase.
System.out.println("toLowerCase:" + s.toLowerCase());
System.out.println("s:" + s);
// System.out.println("----------------");
// String toUpperCase(): convert the string to uppercase.
System.out.println("toUpperCase:" + s.toUpperCase());
System.out.println("----------------");
// String concat(String str): concatenate strings.
String s1 = "hello";
String s2 = "world";
String s3 = s1 + s2;
String s4 = s1.concat(s2);
System.out.println("s3:"+s3);
System.out.println("s4:"+s4);
}
}Convert the first letter of a string to uppercase and the rest to lowercase. (only English uppercase and lowercase characters are considered)
/*
* Requirement: convert the first letter of a string to uppercase and the rest to lowercase. (only English uppercase and lowercase characters are considered)
* give an example:
* helloWORLD
* result:
* Helloworld
*
* analysis:
* A:Get the first character first
* B:Gets characters other than the first character
* C:Capitalize A
* D:Turn B to lowercase
* E:C Splice D
*/
public class StringTest {
public static void main(String[] args) {
// Define a string
String s = "helloWORLD";
// Get the first character first
String s1 = s.substring(0, 1);
// Gets characters other than the first character
String s2 = s.substring(1);
// Capitalize A
String s3 = s1.toUpperCase();
// Turn B to lowercase
String s4 = s2.toLowerCase();
// C splice D
String s5 = s3.concat(s4);
System.out.println(s5);
// Optimized code
// Chain programming
String result = s.substring(0, 1).toUpperCase()
.concat(s.substring(1).toLowerCase());
System.out.println(result);
}
}Other functions of String class:
Replacement function:
Remove two spaces in the string
Compares two strings in dictionary order
// Remove spaces at both ends of the string
String name = " ni hao ";
System.out.println(name.trim());
System.out.println(name.trim().length());
System.out.println(name);
System.out.println(name.length());
// Replacement function:
String str2 ="hello world hello kitty";
String strNew = str2.replace("hello","hehe");
System.out.println(strNew);
String strNewName = name.replace(" ","");
System.out.println(strNewName);
// Compares two strings in dictionary order
String s1 = "Lisi";
String s2 = "lisi";
System.out.println(s1.compareTo(s2));
if(s1.compareToIgnoreCase(s2) > 0)
{
System.out.println("da");
}
else
{
System.out.println("Small");
}
/*
* Requirement: splice the data in the array into a string according to the specified format
* give an example:
* int[] arr = {1,2,3};
* Output result:
* "[1, 2, 3]"
* analysis:
* A:Define a string object, but the content is empty
* B:First splice the string into a "["
* C:Traverse the int array to get each element
* D:First judge whether the element is the last one
* Yes: just splice the elements and "]"
* No: just splice elements and commas and spaces
* E:Output spliced string
*
* Implement the code with functions.
*/
public class StringTest2 {
public static void main(String[] args) {
// If the array already exists
int[] arr = { 1, 2, 3 };
// Write a function to achieve the result
String result = arrayToString(arr);
System.out.println("The end result is:" + result);
}
/*
* Two explicit: return value type: String parameter list: int[] arr
*/
public static String arrayToString(int[] arr) {
// Define a string
String s = "";
// First splice the string into a "["
s += "[";
// Traverse the int array to get each element
for (int x = 0; x < arr.length; x++) {
// First judge whether the element is the last one
if (x == arr.length - 1) {
// Just splice the elements and "]"
s += arr[x];
s += "]";
} else {
// Just splice elements and commas and spaces
s += arr[x];
s += ", ";
}
}
return s;
}
}String inversion
import java.util.Scanner;
/*
* String inversion
* Example: enter "abc" on the keyboard
* Output result: "cba"
*
* analysis:
* A:Enter a string on the keyboard
* B:Define a new string
* C:Traverse the string backwards to get each character
* a:length()Combined with charAt()
* b:Convert string to character array
* D:Concatenate each character with a new string
* E:Output new string
*/
public class StringTest3 {
public static void main(String[] args) {
// Enter a string on the keyboard
Scanner sc = new Scanner(System.in);
System.out.println("Please enter a string:");
String line = sc.nextLine();
String s = myReverse(line);
System.out.println("The result of realizing the function is:" + s);
}
/*
* Two explicit: return value type: string parameter list: String
*/
public static String myReverse(String s) {
// Define a new string
String result = "";
// Convert string to character array
char[] chs = s.toCharArray();
// Traverse the string backwards to get each character
for (int x = chs.length - 1; x >= 0; x--) {
// Concatenate each character with a new string
result += chs[x];
}
return result;
}
}String splitting
There is a paragraph of lyrics, each sentence ends with a space "". Please output each sentence of lyrics by line
The String class provides a split() method to split a String into substrings, and the result is returned as a String array
public class Lyric {
public static void main(String[] args) {
String words="The grass beside the ancient road outside the pavilion is green, and the evening wind holds the sound of willow flute, and the sunset is beyond the mountain";
String[ ] printword=new String[100];
System.out.println("***Original lyrics format***\n"+words);
System.out.println("\n***Split lyrics format***");
printword=words.split(" ");
for(int i=0;i<printword.length;i++){
System.out.println( printword[i] );
}
}
}Count the number of occurrences of large and small strings
/*
* Count the number of occurrences of large and small strings
* give an example:
* In the string "woaijavawozhenaijavawozheneaijavawozhendehnaijavaxinbuxinwoaijavagun"
* result:
* java Five times
*
* analysis:
* Premise: you already know the big string and the small string.
*
* A:Define a statistical variable with an initialization value of 0
* B:First, find the position where the small string appears for the first time in the large string
* a:If the index is - 1, it indicates that it does not exist, then the statistical variable is returned
* b:The index is not - 1, indicating that there is a statistical variable++
* C:Take the length of the index + small string as the starting position, intercept the last large string, return a new string, and re assign the value of the string to the large string
* D:Back to B
*/
public class StringTest5 {
public static void main(String[] args) {
// Define large string
String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
// Define small string
String minString = "java";
// Implementation of write function
int count = getCount(maxString, minString);
System.out.println("Java In the large string:" + count + "second");
}
/*
* Two explicit: return value type: int parameter list: two strings
*/
public static int getCount(String maxString, String minString) {
// Define a statistical variable with an initialization value of 0
int count = 0;
int index;
//Check, assign and judge first
while((index=maxString.indexOf(minString))!=-1){
count++;
maxString = maxString.substring(index + minString.length());
}
return count;
}
}Solution 2
// Define large string
String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
// Define small string
String minString = "java";
String[] array = maxString.split(minString);
System.out.println("Java In the large string:" + (array.length -1) + "second");StringBuffer and StringBuilder
When frequently modifying strings (such as string connection), using StringBuffer class can greatly improve the efficiency of program execution
StringBuffer declaration
StringBuffer sb = new StringBuffer();
StringBuffer sb = new StringBuffer("aaa");
Use of StringBuffer
sb.toString(); // Convert to String type
sb.append("aaa"); // Append string
Convert a number string into a comma separated number string, that is, every three numbers are separated by commas from the right
