首页 > 其他分享 >String，StringBuilder，StringBuffer

String，StringBuilder，StringBuffer

时间：2024-08-06 09:55:01浏览次数：10  
标签：String int StringBuilder System StringBuffer 字符串 public out

目录

String类

创建字符串

创建字符串最简单的方式如下:

String str = "Runoob";

在代码中遇到字符串常量时，这里的值是 "Runoob"，编译器会使用该值创建一个 String 对象。

和其它对象一样，可以使用关键字和构造方法来创建 String 对象。

用构造函数创建字符串：

String str2=new String("Runoob");

String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

String s1 = "Runoob";              // String 直接创建 String s2 = "Runoob";              // String 直接创建 String s3 = s1;                    // 相同引用 String s4 = new String("Runoob");   // String 对象创建 String s5 = new String("Runoob");   // String 对象创建

img

String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:

public class StringDemo{ 
public static void main(String args[]){  
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};      String helloString = new String(helloArray);        System.out.println( helloString );  
		}
}

以上实例编译运行结果如下：

runoob

注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（详看笔记部分解析）。如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。

字符串长度

用于获取有关对象的信息的方法称为访问器方法。

String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。

下面的代码执行后，len 变量等于 14:

StringDemo.java 文件代码：

public class StringDemo {  
public static void main(String args[]) {        String site = "www.runoob.com";     
int len = site.length();      
System.out.println( "菜鸟教程网址长度 : " + len ); 
	} 
}

以上实例编译运行结果如下：

菜鸟教程网址长度 : 14

连接字符串

String 类提供了连接两个字符串的方法：

string1.concat(string2);

返回 string2 连接 string1 的新字符串。也可以对字符串常量使用 concat() 方法，如：

"我的名字是 ".concat("Runoob");

更常用的是使用'+'操作符来连接字符串，如：

"Hello," + " runoob" + "!"

结果如下:

"Hello, runoob!"

下面是一个例子:

public class StringDemo {   
public static void main(String args[]) {             String string1 = "菜鸟教程网址：";             System.out.println("1、" + string1 + "www.runoob.com");   
		} 
}

以上实例编译运行结果如下：

1、菜鸟教程网址：www.runoob.com

创建格式化字符串

我们知道输出格式化数字可以使用 printf() 和 format() 方法。

String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。

String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。

如下所示：

System.out.printf("浮点型变量的值为 " +                  "%f, 整型变量的值为 " +            
" %d, 字符串变量的值为 " +        
"is %s", floatVar, intVar, stringVar);

你也可以这样写

String fs; fs = String.format(
"浮点型变量的值为 " +                 
"%f, 整型变量的值为 " +        
" %d, 字符串变量的值为 " +         
" %s", floatVar, intVar, stringVar);

image-20240805162531465

字符串常量池

在Java语言中，字符串常量池（String Pool）是一个特殊的存储区域，用于存储字符串常量。Java中的字符串是不可变的，这意味着一旦创建，字符串的内容就不能被改变。字符串常量池的主要目的是优化内存使用，避免重复创建相同的字符串值。

以下是关于Java字符串常量池的一些要点：

  1. 存储位置：在Java 7及之前的版本中，字符串常量池位于永久代（PermGen），从Java 8开始，字符串常量池被移动到了堆内存中。

  2. 创建字符串：当你使用双引号创建一个字符串时，如 String s = "Hello";，这个字符串会被存储在字符串常量池中。

  3. 字符串字面量：如果字符串常量池中已经存在相同的字符串字面量，则不会创建新的字符串对象，而是直接引用常量池中的字符串。

  4. 使用 new 关键字：如果你使用 new 关键字创建字符串，如 String s = new String("Hello");，即使字符串常量池中已经存在相同的字符串，也会在堆内存中创建一个新的字符串对象。

  5. 字符串连接：使用 + 运算符进行字符串连接时，每次连接都会创建一个新的字符串对象，这可能会导致大量的内存消耗。

  6. intern() 方法：String.intern() 方法可以将一个字符串对象放入字符串常量池中，如果池中已经存在相同的字符串，则返回池中的字符串引用。

  7. 性能考虑：虽然字符串常量池可以节省内存，但滥用 intern() 方法可能会导致性能问题，因为它会占用更多的内存空间。

  8. 垃圾回收：字符串常量池中的对象是受垃圾回收机制影响的，如果常量池中的字符串不再被引用，它们可以被垃圾回收器回收。

字符串常量池是Java中的一个重要概念，了解和合理使用它可以帮助你写出更高效、更节省内存的代码。

常见方法

charAt(int index)

charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。

语法

public char charAt(int index)

参数

  • index -- 字符的索引。

返回值

返回指定索引处的字符。

实例

public class Test {    
public static void main(String args[]) {        String s = "www.runoob.com";    
char result = s.charAt(6);        System.out.println(result); 
	} 
}

以上程序执行结果为：

n

indexOf()

indexOf() 方法有以下四种形式：

  • public int indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
  • public int indexOf(int ch, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
  • int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
  • int indexOf(String str, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

语法

public int indexOf(int ch )

或

public int indexOf(int ch, int fromIndex)

或

int indexOf(String str)

或

int indexOf(String str, int fromIndex)

参数

  • ch -- 字符，Unicode 编码。
  • fromIndex -- 开始搜索的索引位置，第一个字符是 0 ，第二个是 1 ，以此类推。
  • str -- 要搜索的子字符串。

img

返回值

查找字符串，或字符 Unicode 编码在字符串出现的位置:

实例

public class Main {
    public static void main(String args[]) {
        String string = "aaa456ac";  
        //查找指定字符是在字符串中的下标。在则返回所在字符串下标；不在则返回-1.  
        System.out.println(string.indexOf("b")); // indexOf(String str); 返回结果：-1，"b"不存在  

        // 从第四个字符位置开始往后继续查找，包含当前位置  
        System.out.println(string.indexOf("a",3));//indexOf(String str, int fromIndex); 返回结果：6  
     
        //（与之前的差别：上面的参数是 String 类型，下面的参数是 int 类型）参考数据：a-97,b-98,c-99  
     
        // 从头开始查找是否存在指定的字符  
        System.out.println(string.indexOf(99));//indexOf(int ch)；返回结果：7  
        System.out.println(string.indexOf('c'));//indexOf(int ch)；返回结果：7  
     
        //从fromIndex查找ch，这个是字符型变量，不是字符串。字符a对应的数字就是97。  
        System.out.println(string.indexOf(97,3));//indexOf(int ch, int fromIndex); 返回结果：6  
        System.out.println(string.indexOf('a',3));//indexOf(int ch, int fromIndex); 返回结果：6  
    }

}

输出结果为：

-1
6
7
7
6
6

startWith()

startsWith() 方法用于检测字符串是否以指定的前缀开始。

语法

public boolean startsWith(String prefix, int toffset)

或

public boolean startsWith(String prefix)

参数

  • prefix -- 前缀。
  • toffset -- 字符串中开始查找的位置。

返回值

如果字符串以指定的前缀开始，则返回 true；否则返回 false。

实例

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.runoob.com");

        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("www") );
     
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("runoob") );
     
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("runoob", 4) );
    }

}

以上程序执行结果为：

返回值 :true
返回值 :false
返回值 :true

endsWith

endsWith() 方法用于测试字符串是否以指定的后缀结束。

语法

public boolean endsWith(String suffix)

参数

  • suffix -- 指定的后缀。

返回值

如果参数表示的字符序列是此对象表示的字符序列的后缀，则返回 true；否则返回 false。注意，如果参数是空字符串，或者等于此 String 对象（用 equals(Object) 方法确定），则结果为 true。

实例

public class Test {   
public static void main(String args[]) {        String Str = new String("菜鸟教程：www.runoob.com");        boolean retVal;       
retVal = Str.endsWith( "runoob" );        System.out.println("返回值 = " + retVal );         retVal = Str.endsWith( "com" );        System.out.println("返回值 = " + retVal ); 
	}
}

以上程序执行结果为：

返回值 = false
返回值 = true

substring()

substring() 方法返回字符串的子字符串。

语法

public String substring(int beginIndex)

或

public String substring(int beginIndex, int endIndex)

参数

  • beginIndex -- 起始索引（包括）, 索引从 0 开始。
  • endIndex -- 结束索引（不包括）。

img

返回值

子字符串。

实例

public class RunoobTest {   
public static void main(String args[]) {        String Str = new String("This is text");         System.out.print("返回值 :" );        System.out.println(Str.substring(4) );         System.out.print("返回值 :" );        System.out.println(Str.substring(4, 10) );  
	}
}

以上程序执行结果为：

返回值 : is text
返回值 : is te

replace()

replace() 方法通过用 newChar 字符替换字符串中出现的所有 searchChar 字符，并返回替换后的新字符串。

语法

public String replace(char searchChar, char newChar)

参数

  • searchChar -- 原字符。
  • newChar -- 新字符。

返回值

替换后生成的新字符串。

实例

以下实例对字符串 Runoob 中的字符进行替换：

实例

**public** **class** Main {
  **public** **static** **void** main(String args[]) {
    String Str = **new** String("Runoob");

    System.out.print("返回值 :" );
    System.out.println(Str.replace('o', 'T'));

    System.out.print("返回值 :" );
    System.out.println(Str.replace('u', 'D'));
  }
}

以上程序执行结果为：

返回值 :RunTTb
返回值 :RDnoob

split()

split() 方法根据匹配给定的正则表达式来拆分字符串。

注意： . 、 $、 | 和 ***** 等转义字符，必须得加 \。

注意：多个分隔符，可以用 | 作为连字符。

语法

public String[] split(String regex, int limit)

参数

  • regex -- 正则表达式分隔符。
  • limit -- 分割的份数。

返回值

字符串数组。

实例

public class Test {   
public static void main(String args[]) {        String str = new String("Welcome-to-Runoob");         System.out.println("- 分隔符返回值 :" );     
for (String retval: str.split("-")){            System.out.println(retval);      
	}         
System.out.println("");      
System.out.println("- 分隔符设置分割份数返回值 :" );        for (String retval: str.split("-", 2)){            System.out.println(retval);  
	}         
System.out.println("");      
String str2 = new String("www.runoob.com");        System.out.println("转义字符返回值 :" );  
for (String retval: str2.split("\\.", 3)){            System.out.println(retval);      
	}         
System.out.println("");   
String str3 = new String("acount=? and uu =? or n=?");      
System.out.println("多个分隔符返回值 :" );   
for (String retval: str3.split("and|or")){            System.out.println(retval);       
		}   
	} 
}

以上程序执行结果为：

- 分隔符返回值 :
Welcome
to
Runoob

- 分隔符设置分割份数返回值 :
Welcome
to-Runoob

转义字符返回值 :
www
runoob
com

多个分隔符返回值 :
acount=? 
 uu =? 
 n=?

trim()

trim() 方法用于删除字符串的头尾空白符。

语法

public String trim()

参数

  • 无

返回值

删除头尾空白符的字符串。

实例

public class Test {
    public static void main(String args[]) {
        String Str = new String("    www.runoob.com    ");
        System.out.print("原始值 :" );
        System.out.println( Str );

        System.out.print("删除头尾空白 :" );
        System.out.println( Str.trim() );
    }
}

以上程序执行结果为：

原始值 :    www.runoob.com    
删除头尾空白 :www.runoob.com

concat()

在 Java 中，concat() 方法用于连接两个字符串。

该方法属于 String 类，使用它可以将一个字符串连接到另一个字符串的末尾。

需要注意的是，concat() 方法不会修改原字符串，而是返回一个新的字符串。

语法

public String concat(String s)

参数

  • s -- 要连接的字符串。

返回值

返回连接后的新字符串。

实例

**public** **class** Test {
    **public** **static** **void** main(String args[]) {
        String s = "菜鸟教程：";
        s = s.concat("www.runoob.com");
        System.out.println(s);
    }
}

以上程序执行结果为：

菜鸟教程：www.runoob.com

注意事项

  • 如果传递给 concat() 方法的参数为 null，则会抛出 NullPointerException。
  • 如果传递给 concat() 方法的参数为空字符串 ("")，则返回的字符串与调用 concat() 方法的字符串相同。

实例

**public** **class** ConcatExample {
  **public** **static** **void** main(String[] args) {
    String str1 = "Hello";
    
    *// 连接空字符串*
    String result = str1.concat("");
    
    *// 打印结果*
    System.out.println(result); *// 输出 "Hello"*
  }
}

总结起来，concat() 方法是一个简单而有效的字符串连接方法，但需要注意避免传递 null 以防止异常。

正则表达式

正则表达式定义了字符串的模式。

正则表达式可以用来搜索、编辑或处理文本。

正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

Java 提供了 java.util.regex 包，它包含了 Pattern 和 Matcher 类，用于处理正则表达式的匹配操作。

正则表达式实例

一个字符串其实就是一个简单的正则表达式，例如 Hello World 正则表达式匹配 "Hello World" 字符串。

.（点号）也是一个正则表达式，它匹配任何一个字符如："a" 或 "1"。

下表列出了一些正则表达式的实例及描述

正则表达式 描述
this is text 匹配字符串 "this is text"
this\s+is\s+text 注意字符串中的 \s+。匹配单词 "this" 后面的 \s+ 可以匹配多个空格，之后匹配 is 字符串，再之后 \s+ 匹配多个空格然后再跟上 text 字符串。可以匹配这个实例：this is text
^\d+(.\d+)? ^ 定义了以什么开始\d+ 匹配一个或多个数字? 设置括号内的选项是可选的. 匹配 "."可以匹配的实例："5", "1.5" 和 "2.2

字符通配符

image-20240805163110296

次数通配符

image-20240805163247301

其他通配符

image-20240805163425090

java.util.regex 包

java.util.regex 包是 Java 标准库中用于支持正则表达式操作的包。

java.util.regex 包主要包括以下三个类：

  • Pattern 类：

    pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

  • Matcher 类：

    Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

  • PatternSyntaxException：

    PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

以下实例中使用了正则表达式 .*runoob.* 用于查找字符串中是否包了 runoob 子串：

实例

import java.util.regex.*;  
class RegexExample1{  
public static void main(String[] args){   
String content = "I am noob " + "from runoob.com.";    String pattern = ".*runoob.*";   
boolean isMatch = Pattern.matches(pattern, content);  System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch); 
	} 
}

实例输出结果为：

字符串中是否包含了 'runoob' 子字符串? true

捕获组

捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

例如，正则表达式 (dog) 创建了单一分组，组里包含"d"，"o"，和"g"。

捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：

  • ((A)(B(C)))
  • (A)
  • (B(C))
  • (C)

可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。

还有一个特殊的组（group(0)），它总是代表整个表达式。该组不包括在 groupCount 的返回值中。

实例

下面的例子说明如何从一个给定的字符串中找到数字串：

import java.util.regex.Matcher; import java.util.regex.Pattern; 
public class RegexMatches {  
public static void main( String[] args ){    
// 按指定模式在字符串查找    
String line = "This order was placed for QT3000! OK?";     
String pattern = "(\\D*)(\\d+)(.*)";    
// 创建 Pattern 对象    
Pattern r = Pattern.compile(pattern);    
// 现在创建 matcher 对象   
Matcher m = r.matcher(line);    
if (m.find( )) {    
System.out.println("Found value: " + m.group(0) );    System.out.println("Found value: " + m.group(1) );    System.out.println("Found value: " + m.group(2) );    System.out.println("Found value: " + m.group(3) );    } else {       
System.out.println("NO MATCH");   
}   
}
}

以上实例编译运行结果如下：

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT
Found value: 3000
Found value: ! OK?

StringBuffer和StringBuilder

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

img

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

实例

public class RunoobTest{
    public static void main(String args[]){
        StringBuilder sb = new StringBuilder(10);
        sb.append("Runoob..");
        System.out.println(sb);  
        sb.append("!");
        System.out.println(sb); 
        sb.insert(8, "Java");
        System.out.println(sb); 
        sb.delete(5,8);
        System.out.println(sb);  
    }
}

以上实例编译运行结果如下：

Runoob..
Runoob..!
Runoob..Java!
RunooJava!

然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

public class Test{  
public static void main(String args[]){   
StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");    
sBuffer.append("www");   
sBuffer.append(".runoob");    
sBuffer.append(".com");  
System.out.println(sBuffer); 
	} 
}

以上实例编译运行结果如下：

菜鸟教程官网：www.runoob.com

StringBuffer 方法

以下是 StringBuffer 类支持的主要方法：

序号 方法描述
1 public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2 public StringBuffer reverse() 将此字符序列用其反转形式取代。
3 public delete(int start, int end) 移除此序列的子字符串中的字符。
4 public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。
5 insert(int offset, String str) 将 str 参数的字符串插入此序列中。
6 replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

以下列表列出了 StringBuffer 类的其他常用方法：

序号 方法描述
1 int capacity() 返回当前容量。
2 char charAt(int index) 返回此序列中指定索引处的 char 值。
3 void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
4 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。
5 int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
6 int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7 int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
8 int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。
9 int length() 返回长度（字符数）。
10 void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。
11 void setLength(int newLength) 设置字符序列的长度。
12 CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。
13 String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
14 String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。
15 String toString() 返回此序列中数据的字符串表示形式。

image-20240805164622554

日期和时间类

Java 提供了多种类来处理日期和时间。以下是一些常用的日期和时间类：

  1. Date: 这是 Java 最早的日期和时间类，它表示特定的瞬间，精确到毫秒。然而，由于它的线程不安全和一些设计上的缺陷，Java 8 引入了新的日期和时间 API。

  2. Calendar: 这个类是一个抽象类，它为各种具体日历系统提供了一个框架，允许用户完成日期和时间的转换、计算等操作。

  3. GregorianCalendar: 这是 Calendar 类的一个具体实现，代表公历。

  4. SimpleDateFormat: 用于格式化和解析日期对象为字符串表示形式。

  5. java.time 包（Java 8 引入）:

    • LocalDate: 表示没有时间的日期（年、月、日）。
    • LocalTime: 表示没有日期的时间（小时、分钟、秒、纳秒）。
    • LocalDateTime: 表示日期和时间的组合，但不包含时区信息。
    • ZonedDateTime: 表示带时区的日期和时间。
    • Instant: 表示时间线上的一个瞬时点，通常表示为自 Unix 纪元（1970-01-01T00:00:00Z）以来的秒和纳秒。
    • Duration: 表示两个 Instant 之间的时间长度。
    • Period: 表示日期之间的时间长度，如年、月、日。

  6. java.util.concurrent 包中的一些类，如 ScheduledExecutorService，用于安排任务在未来的某个时间点执行。

  7. java.time.format.DateTimeFormatter: 用于格式化和解析日期和时间。

  8. java.time.temporal 包提供了一组接口，用于操作日期和时间的字段，如 ChronoField、TemporalAdjuster 等。

使用这些类，你可以执行各种日期和时间的操作，包括创建、格式化、解析、比较、计算日期和时间等。

包装类

在Java中，包装类（Wrapper Class）是指用来包装基本数据类型的类。Java为每种基本数据类型提供了对应的包装类，使得基本类型可以拥有对象的特性，比如可以作为对象集合的元素，可以有方法调用等。

包装类的特点：

  1. 命名规则：包装类的名称通常是在其对应的基本类型名称前加上一个Byte、Short、Integer、Long、Float、Double、Boolean或Character。

  2. 静态字段：每个包装类都有一个静态的TYPE字段，它表示相应基本类型的Class对象。

  3. 缓存机制：对于Integer和Long，Java虚拟机（JVM）会对-128到127之间的值进行缓存，以提高性能。

  4. 方法：包装类提供了转换和比较等方法，例如intValue()、doubleValue()等，用于将包装类转换回基本类型。

    image-20240805165452222

基本数据类型与包装类：

  • 基本数据类型：如int、double等，它们是Java语言的内置类型，直接存储原始值。
  • 包装类：如Integer、Double等，是基本数据类型的类表示形式。

包装类的共同点：

  • 都是不可变（Immutable）的，一旦创建，其值不能更改。
  • 都实现了Comparable接口，可以比较值的大小。
  • 都重写了equals()和hashCode()方法，以便于在集合中使用。

自动装箱/拆箱：

  • 自动装箱（Autoboxing）：在需要一个对象的时候，自动将基本类型转换为对应的包装类对象。例如，Integer num = 5; 这里5是一个int类型，自动转换为Integer对象。
  • 自动拆箱（Unboxing）：在需要一个基本类型的时候，自动将包装类对象转换为对应的基本类型。例如，int num = numObj; 这里numObj是一个Integer对象，自动转换为int类型。

自动装箱和拆箱是Java 5引入的特性，它简化了代码，使得基本类型和包装类之间的转换更加方便。然而，过度使用自动装箱可能会导致性能问题，尤其是在循环中，因为每次循环都可能创建新的包装类实例。在这种情况下，最好手动进行装箱或拆箱，或者使用基本类型。

image-20240805165413844

数字类

Java 的 Math 类是 java.lang 包的一部分，它提供了一些用于执行基本数学运算的静态方法。以下是 Math 类的一些常见用法和特点：

  1. 常量：

    • Math.PI：圆周率的近似值。
    • Math.E：自然对数的底数（欧拉数）。

  2. 基础数学运算：

    • Math.abs(x)：返回参数的绝对值。
    • Math.sqrt(x)：返回正平方根。
    • Math.pow(x, y)：返回 x 的 y 次幂。
    • Math.round(x)：将浮点数四舍五入到最接近的整数。

  3. 三角函数：

    • Math.sin(x)：返回正弦值（x 以弧度为单位）。
    • Math.cos(x)：返回余弦值。
    • Math.tan(x)：返回正切值。

  4. 双曲函数：

    • Math.sinh(x)：返回双曲正弦值。
    • Math.cosh(x)：返回双曲余弦值。
    • Math.tanh(x)：返回双曲正切值。

  5. 对数和指数：

    • Math.log(x)：返回自然对数。
    • Math.exp(x)：返回 e 的 x 次幂。

  6. 最小值和最大值：

    • Math.min(x, y)：返回两个数中的较小值。
    • Math.max(x, y)：返回两个数中的最大值。

  7. 随机数：

    • Math.random()：返回一个 [0.0, 1.0) 范围内的随机浮点数。

  8. 角度和弧度的转换：

    • Math.toRadians(x)：将角度转换为弧度。
    • Math.toDegrees(x)：将弧度转换为角度。

  9. 浮点数舍入：

    • Math.ceil(x)：向上取整到最接近的整数。
    • Math.floor(x)：向下取整到最接近的整数。

image-20240805164806696

image-20240805164904750

Math 类的方法都是静态的，因此你可以直接通过类名调用它们，而不需要创建 Math 类的实例。这个类提供了广泛的数学运算支持，是Java编程中不可或缺的一部分。

请注意，Math 类中的所有方法都是静态的，并且大多数方法都接受 double 类型的参数，返回值也是 double 类型，除非特别指明。

标签：String,int,StringBuilder,System,StringBuffer,字符串,public,out
From： https://www.cnblogs.com/1762898523qq/p/18344568

相关文章

  • C语言day11（string函数族、递归函数、结构体、共用体、枚举）
    【1】string函数族1.strlen头文件：#include<string.h>格式：size_tstrlen(constchar*s);功能：计算字符串实际长度，不包括\0参数：s:目标字符串首地址返回值：字符串实际长度2.strcpy    头文件：#include<string.h>    格式：char*strcpy(char*dest,......
  • ARC181 - B - Annoying String Problem
    B-令人讨厌的字符串问题编辑：evima在大多数情况下，\(f(S,T,X)\)和\(f(S,T,Y)\)的长度相等，这揭示了\(T\)的长度。让我们来看看当已知\(S\)和\(T\)的长度时，在什么条件下\(S\)和\(T\)满足\(f(S,T,X)=f(S,T,Y)\)。例题例如，当\(|S|=6\)和\(|T|=4\)时，让我们考虑当\(S+......
  • String类常用方法
    常用方法字符串比较：equals(Objectanother):比较两个字符串的内容是否相等。equalsIgnoreCase(Stringanother):比较两个字符串的内容，忽略大小写。字符串长度：length():返回字符串的长度。字符串转换：toString():返回其自身的字符串表示形式。valueOf(类型x......
  • StringBuffer 和 StringBuilder
    StringBuffer和StringBuilder目录StringBuffer和StringBuilderStringBuffer：StringBuilder常用方法StringBuffer：StringBuffer是线程安全的。这意味着它的方法是同步的，可以在多线程环境中使用而不会出现问题。由于同步，StringBuffer的性能比StringBuilder稍低，特别是......
  • [LeetCode] 2053. Kth Distinct String in an Array
    Adistinctstringisastringthatispresentonlyonceinanarray.Givenanarrayofstringsarr,andanintegerk,returnthekthdistinctstringpresentinarr.Iftherearefewerthankdistinctstrings,returnanemptystring"".Notethat......
  • String类
    String类一.字符串常量池在Java（以及许多其他编程语言中），字符串常量值是指那些在程序中直接以字符串字面量形式给出的值。这些值被双引号（""）包围，并且一旦在代码中定义，就不能被改变（尽管你可以将字符串变量指向另一个字符串常量或字符串对象的引用）。字符串常量值在编译时会被存储在......
  • EFCore执行自定义SQL时格式化错误：Input string was not in a correct format.
      记录一下EFCore执行自定义SQL报System.FormatException异常的问题，这个异常可能是“Inputstringwasnotinacorrectformat.”，也可能是其它格式化异常，比如：System.ArgumentException:“Formatoftheinitializationstringdoesnotconformtospecificationstartingat......
  • C++ //练习 15.31 已知s1、s2、s3和s4都是string，判断下面的表达式分别创建了什么样的
    C++Primer（第5版）练习15.31练习15.31已知s1、s2、s3和s4都是string，判断下面的表达式分别创建了什么样的对象：(a)Query(s1)|Query(s2)&~Query(s3);(b)Query(s1)|(Query(s2)&~Query(s3));(c)(Query(s1)&(Query(s2))|(Query(s3)&Query(s4)));......
  • 嵌入式学习day9（string函数族）
    一丶strcpy和strncpy1.strcpy    #include<string.h>    char*strcpy(char*dest,constchar*src);    功能：实现字符串复制    参数：char*dest：目标字符串首地址    constchar*src：原字符串首地址    返回值：目标字符串首地......
  • QString成员函数一览表
    QString类是Qt框架中的一个核心类，用于处理Unicode字符串。它提供了大量的成员函数，用于字符串的创建、操作、查询和转换。以下是QString类的一些主要成员函数，按照功能分类：构造和赋值-QString():构造一个空字符串。-QString(constchar*):从ASCII字符串构造。-Q......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99