java_String类、StringBuilder类、Arrays类、Math类的使用

String类

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实例

构造方法

java.lang.String ：此类不需要导入。

代码如下:

public static void main(String[] args) {
	//1.String() 创建一个空的字符串对象
	String str1=new String();
	System.out.println("str1: "+str1);
	// 2.String(String original) 根据字符串来创建一个字符串对象
	String str2=new String("abc");
	System.out.println(str2);
	// 3.String(char[] value) 通过字符数组来创建字符串对象
	char[] chs={'A','B','C','D','E'};
	String str3 = new String(chs);
	System.out.println(str3);
	// 4.String(byte[] bytes) 通过字节数组来构造新的字符串对象
	byte[] bytes={97,98,99,100,101};
	String str4 = new String(bytes);
	System.out.println(str4);
	// 5.String(byte[] bytes, int offset, int length) 通过字节数组一部分来构造新的字符串对象
	String str5 = new String(bytes, 1, 2);
	System.out.println(str5);
}

String特点

1. 字符串不变：字符串的值在创建后不能被更改。

String s1="abc";
s1+="d";
System.out.println(s1); //"abcd"
//内存中有"abc","abcd"两个对象,s1从指向"abc",改变指向,指向了"abcd"

1. 因为String对象是不可变的，所以它们可以被共享。

String s1="abc";
String s2="abc";
//内存中只有一个"abc"对象被创建，同时被s1和s2共享。

常用方法

判断功能的方法

public static void main(String[] args) {
	//创建字符串对象
	String s1="abcd";
	String s2="abcd";
	String s3="ABCD";
	//boolean equals•(Object anObject) 将此字符串与指定对象进行比较。
	System.out.println(s1.equals(s2)); //true
	System.out.println(s1.equals(s3)); //false
	System.out.println("----------------");
	//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
	System.out.println(s1.equalsIgnoreCase(s2)); //true
	System.out.println(s1.equalsIgnoreCase(s3)); //true
	System.out.println("----------------");
}

获取功能的方法

public static void main(String[] args) {
	String str="HelloWorld";
	//public int length () ：返回此字符串的长度。
	System.out.println(str.length());
	System.out.println("---------------");
	//public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
	String str2 = str.concat("_Java");
	System.out.println(str2);
	System.out.println("---------------");
	//public char charAt (int index) ：返回指定索引处的 char值。
	char c1 = str2.charAt(0);
	char c2 = str2.charAt(1);
	System.out.println(c1);
	System.out.println(c2);
	System.out.println("---------------");
	//public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
	int a = str.indexOf("o");
	int b = str.indexOf("l");
	int c = str.indexOf("ll");
	System.out.println(a);
	System.out.println(b);
	System.out.println(c);
	System.out.println("---------------");
	/*
	public String substring (int beginIndex) ：返回一个子字符串，
	从beginIndex开始截取字符串到字符串结尾。
	*/
	String sub1 = str.substring(5);
	System.out.println(sub1);
	System.out.println("---------------");
	/*
	public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到
	endIndex截取字符串。含beginIndex，不含endIndex。
	*/
	String sub2 = str.substring(2, 4);
	System.out.println(sub2);
	System.out.println("---------------");
}

转换功能的方法

public static void main(String[] args) {
	String str="abcde";
	//public char[] toCharArray () ：将此字符串转换为新的字符数组。
	char[] chars = str.toCharArray();
	for(int i=0;i<chars.length;i++){
	System.out.print(chars[i]+",");
	}
	System.out.println("\n-------------");
	//public byte[] getBytes ()：使用平台的默认字符集将该 String编码转换为新的字节数组。
	byte[] bytes = str.getBytes();
	for(int i=0;i<bytes.length;i++){
	System.out.print(bytes[i]+",");
	}
	System.out.println("\n-------------");
	//public String toLowerCase() ：使用默认语言环境的规则将此 String所有字符转换为小写。
	String lowerCase = str.toLowerCase();
	System.out.println(lowerCase);
	System.out.println("-------------");
	//public String toUpperCase() ：将此 String所有字符转换为大写，使用默认语言环境的规则。
	String upperCase = str.toUpperCase();
	System.out.println(upperCase);
	System.out.println("-------------");
	//public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字
	符串使用replacement字符串替换。
	String str2="HelloWorld";
	String str3 = str2.replace("l", "L");
	System.out.println(str2); //注意，replace会返回一个新的字符串，新字符串才是被替换后的。这里输出
	HelloWorld
	System.out.println(str3); //HeLLoWorLd
}

分割功能的方法

public static void main(String[] args) {
String str="你好,我叫张三,我喜欢java";
String[] strs = str.split(","); //["你好","我叫张三","我喜欢java"]
for(int i=0;i<strs.length;i++){
System.out.println(strs[i]);
}
}

常量池
常量池也是JVM中的一块内存区域，在JDK1.6及以前，常量池是存储在方法区的，在JDK1.7之后，常量池被划分到了堆内存。常量池的东西只会保存一份

String s1="abc";
String s2="abc";
System.out.println(s1==s2); //返回true

因为常量池的东西只保存一份，因此 s1==s2 返回的是 true

StringBuilder类

java.lang.StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

构造方法

public StringBuilder() ：构造一个空的StringBuilder容器。

public StringBuilder(String str) ：构造一StringBuilder容器，并将字符串添加进去

public class Demo{
	public static void main(String[] args) {
		StringBuilder sb1 = new StringBuilder();
		System.out.println(sb1); // (空白)
		// 使用带参构造
		StringBuilder sb2 = new StringBuilder("abcd");
		System.out.println(sb2); //abcd
	}
}

常用方法

append方法
append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。

public class Demo{
	public static void main(String[] args) {
		//创建对象
		StringBuilder builder = new StringBuilder();
		//public StringBuilder append(任意类型)
		StringBuilder builder2 = builder.append("hello");
		//对比一下
		System.out.println("builder:"+builder);
		System.out.println("builder2:"+builder2);
		System.out.println(builder == builder2); //true
		// 可以添加 任何类型
		builder.append("hello");
		builder.append("world");
		builder.append(true);
		builder.append(100);
		// 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
		// 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
		//链式编程
		builder.append("hello").append("world").append(true).append(100);
		System.out.println("builder:"+builder);
	}
}

toString方法
通过toString方法，StringBuilder对象将会转换为不可变的String对象

public class Demo{
	public static void main(String[] args) {
		// 链式创建
		StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
		// 调用方法
		String str = sb.toString();
		System.out.println(str); // HelloWorldJava
	}
}

Arrays类

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法

操作数组的方法

将数组转换成字符串

public static void main(String[] args) {
	int[] arr={24,546,7,5678,58,76,83,45,435,34};
	System.out.println(arr); //[I@2460c14f
	//将数组转换成字符串
	String str = Arrays.toString(arr); //[24, 546, 7, 5678, 58, 76, 83, 45, 435, 34]
	System.out.println(str);
}

数组按数字升序进行排序

public static void main(String[] args) {
	int[] arr={24,546,7,5678,58,76,83,45,435,34};
	System.out.println("排序前： "+Arrays.toString(arr));
	//将数组升序排序
	Arrays.sort(arr);
	System.out.println("排序后： "+Arrays.toString(arr));
}

Math类

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数，其所有方法均为静态方法

基本运算的方法

返回 double 值的绝对值

double d1 = Math.abs(-5); //d1的值为5
double d2 = Math.abs(5); //d2的值为5

返回大于等于参数的最小的整数。（向上取整）

double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(-3.3); //d2的值为 -3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0

返回小于等于参数最大的整数。（向下取整）

double d1 = Math.floor(3.3); //d1的值为3.0
double d2 = Math.floor(-3.3); //d2的值为-4.0
double d3 = Math.floor(5.1); //d3的值为 5.0

返回最接近参数的 long。(相当于四舍五入方法)

long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0