Common classes in java
1. Object class
Object class features:
The Object class is the root of the class hierarchy, and all classes in Java fundamentally inherit from this class.
The Object class is the only class in Java that has no parent class.
All other classes, including standard container classes such as arrays, inherit methods from the Object class.
Second, the String class
- Some methods of the String class:
Obtain
Get the number (length) of string characters: int length();
Get character by position: char charAt(int index);
Get the position in the string according to the character; int indexOf(int ch);
Get a part of the string in the string, called substring: String substring(int beginIndex,int endIndex);
- Sample code :
class Demo
{
public static void main(String[] args)
{
String str="你好，世界！";
//输出字符串的长度
System.out.println("字符串的长度："+str.length());
//获取指定位置的字符
System.out.println("字符串的第1个字符是："+str.charAt(0));
//获取字符在字符串的位置（角标从0开始）
System.out.println("获取“好”在字符串的角标："+str.indexOf('好'));
//获取"你好"子字符串
System.out.println("获取“你好”子字符串："+str.substring(0,2));
}
}
convert
Turn a string into an array of strings (cutting of strings): String[] split(String regex);
Turn a string into a character array: char[] toCharArray();
Turn a string into an array of bytes: byte[] getBytes();
Convert the letters in the string to uppercase and lowercase: uppercase, String toUpperCase(); lowercase, String toLowerCase();
Replace the content of the string: String replace(char oldChar,char newCh);
Remove spaces from both ends of a string: String trim();
Concatenate strings: String concat();
class Demo
{
public static void main(String[] args)
{
String str="Hello World";
//将字符串中的字母全部转为小写
System.out.println(str.toLowerCase());
//将字符串中的字母全部转为大写
System.out.println(str.toUpperCase());
}
}
judge
Whether the contents of two strings are equal: bolean equals(Object obj);
Comparing string contents ignoring case: boolean equalsIgnoreCase(Object obj);
Whether the string contains the specified string: boolean contains(String str);
Whether the string starts with the specified character: boolean startsWith(String str);
Whether the string ends with the specified character: boolean endsWith(String str);
class Demo
{
public static void main(String[] args)
{
String str="boy";
String str1=new String("boy");
//判断字符串的类容是否相同
System.out.println(str.equals(str1));
}
}
Compare
int compareTo(String str): Returns a value of 0 if the argument string is equal to this string; returns a value less than 0 if this string is lexicographically less than the string argument; if this string is lexicographically greater than characters String parameter, returns a value greater than 0.
String intern(): When the intern method is called, if the pool already contains a string equal to this String object (determined by the equals(Object) method), the string in the pool is returned. Otherwise, add this String object to the pool and return a reference to this String object.
Three, StringBuffer and StringBuilder classes
StringBuffer class
StringBuffer : It is a string buffer, a container for storing data.
Features of StringBuffer:
The length is variable.
Different types of data can be stored.
In the end, it will be converted into a string for use.
Some methods of StringBuffer:
Add to
StringBuffer append(data); add data.
StringBuffer insert(index,data); Insert the specified data at the specified position.
delete
StringBuffer delete(int start, int end); includes header, not tail.
StringBuffer deleteCharAt(int index); Delete the element at the specified position.
find
char charAt(int index); Get the data at the specified position.
int indexOf(String str); Search from the head to get the position of the specified element.
int lastIndexOf(String str); Search from the end to get the position of the specified element.
Revise
StringBuffer replace(int start,int end,String str); Include the head, not the tail.
void setCharAt(int index, char ch); Modify the character at the specified position.
Other methods
void setLength(int newLength); set the length of the character sequence
public StringBuffer reverse(); replace the character sequence with its reversed form
StringBuilder class
StringBuilder: The function that appears after jdk1.5 is exactly the same as StringBuffer, which is StringBuilder.
The difference between StringBuffer and StringBuilder:
- StringBuffer is thread synchronized and is usually used for multithreading.
- StringBuilder is thread asynchronous, usually used for single thread, its appearance can improve program efficiency.
Fourth, the basic data type packaging class
Definition: encapsulate basic data types into objects, define properties and methods in objects
basic type –> string
Basic data value + "".
Use the static method ValueOf (basic type value) in the String class.
String –> base type
Use the static method xxx parseXxx("xxx") in the wrapper class ;
If the string is encapsulated by an Integer object, another non-static method, intValue, can be used. Converts an Integer object to a primitive data type value.
Integer in=new Integer(“123”); //The string is encapsulated by the Integer object
int i=in.intValue(); //Call the intValue method to convert the Integer type to int type
System.out.println(i+1 ) ;
- Use Integer's static method valueOf(String s): the return value is of type Integer .
Decimal -> other decimal methods
Convert to binary: String toBinaryString(int i);
Convert to octal: String toOctalString(int i);
Convert to hexadecimal: String toHexString(int i);
Convert to other bases according to radix (base): String toString(int i,int radix);
Other hexadecimal -> decimal method
- int parseInt(String s,int radix);
Five, Scanner class
Definition: A simple text scanner that can use regular expressions to parse basic types and strings, located in the java.util package, modified by final, this class cannot be inherited
Basic usage of Scanner:
Scanner(File source) //Constructs a new Scanner whose generated values are scanned from the specified file
Scanner(InputStream source) //Constructs a new Scanner that generates values scanned from the specified input stream.
Scanner(String source) //Constructs a new Scanner that generates values scanned from the specified string.
General methods of the Scanner class
hasNextXxx() judges whether there is the next input item, where Xxx can be Int, Double, etc. If you need to judge whether the next string is included, you can omit Xxx.
xxx nextXxx() Get the next input item. The meaning of Xxx is the same as Xxx in the previous method. By default, Scanner uses spaces, carriage returns, etc. as separators.
6. Enumeration class
Definition :
A class with a fixed and limited instance is called an enumeration class in Java. Java has added support for enumeration classes (the keyword enum has the same status as the class and interface keywords) since JDK1.5.Features:
Non-abstract enumerations are decorated with fianl by default, so enumerations cannot be subclassed.
The constructor of the enumeration class can only use private access control, if omitted, the default is private.
All its instances must be listed on the first line. The semicolon after the last enumeration item can be omitted, but if the enumeration class has other things, the semicolon cannot be omitted. It is recommended not to omit.
can be used in a switch statement
Common methods of enumerating classes
int ordinal() returns the ordinal of the enumeration constant (its position in the enumeration declaration where the initial constant ordinal is zero).
int compareTo(E o) Compares the order of this enumeration with the specified object.
String name() returns the name of this enum constant, declared in its enum declaration.
String toString() returns the name of the enum constant, which is included in the declaration.
T valueOf(Class type, String name) returns the enum constant of the specified enum type with the specified name.
values() This method is not found in the JDK documentation, but every enumeration class has this method, it is very convenient to traverse all the enumeration values of the enumeration class
7. Math class
Math : Provides methods for operating mathematical operations, all of which are static.
Common method:
ceil(): Returns the smallest integer greater than the argument.
floor(): Returns the largest integer less than the argument.
round(): Returns the rounded integer.
pow(a,b): a raised to the b power.
Example:
- Code:
import java.util.*;
class MathDemo
{
public static void main(String[] args)
{
double d1=Math.ceil(12.56);
double d2=Math.floor(12.56);
double d3=Math.round(12.56);
//输出大于12.56的最小整数
System.out.println(d1);
//输出小于12.56的最大整数
System.out.println(d2);
//输出12.56四舍五入的整数
System.out.println(d3);
}
}- Output result:
