String类、Math类、System类、BigInteger类、BigDecimal类常用方法

String

 

indexOf(String str)    indexOf(String str,int i)

根据字符串来返回索引,参数可以是字符串，ascii码，第二个参数表示从下标为i的开始查找

String str = "abcde";
int index = str.indexOf("d");
System.out.println(index);//结果为3

String str2 = "abcdeabcde";
index = str2.indexOf("d",4);
System.out.println(index);//结果为8

charAt(int index)

根据指定下标找字符

String str1 = "abcde";
System.out.println(str1.charAt(3));//结果为d

substring(int index)   substring(int index,int i)

截取下标为index和index之后的子字符串，第二个参数表示截取的字符串的下标是index~i-1

String str1 = "abcdefghij";
System.out.println(str1.substring(3));//结果为defghij
System.out.println(str1.substring(5, 8));//结果为fgh

isEmpty()   

判断字符串是否为空

String str1 = "";
System.out.println(str1.isEmpty());//结果为true

equals()

判断两个字符串的值是否相等，区分大小写

String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equals(str2));//结果为false

equalsIgnoreCase()

比较两个字符串是否相同，忽略大小写

String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equalsIgnoreCase(str2));//结果为true

compareTo()

比较两个字符串的字典（ASCII码表），大于则返回正数，小于则返回负数，等于则返回0

String str1 = "abcde";
String str2 = "abcfaaaaaaaa";
String str3 = "zzzzzzzz";
String str4 = "abcde";
System.out.println(str1.compareTo(str2));//结果为负数
System.out.println(str3.compareTo(str1));//结果为正数
System.out.println(str4.compareTo(str1));//结果为0

concat()

将字符串连接到指定字符串的末尾

String str1 = "abcde";
String str2 = "fghij";
System.out.println(str1.concat(str2));//结果为abcdefghij

contains(String str)

判断字符串是否包含str

String str1 = "abcde";
System.out.println(str1.contains("a"));//结果为true
System.out.println(str1.contains("z"));//结果为false

lastIndexOf(String str)

从后往前搜索下标

String str1 = "hello.java.txt";
System.out.println(str1.lastIndexOf("."));//结果为10

replaceAll(String regex,String str)

regex:正则表达式

str:需要替换的字符串

String str1 = "a1b2c3d4e5";
System.out.println(str1.replaceAll("\\d", ""));//结果为abcde

split(String regex)

把正则表达式regex用做分隔符,并转换成字符串数组

String str1 = "hello,java,txt";
String str2 = "hello.java.txt";
System.out.println(Arrays.toString(str1.split(",")));	//结果为[hello, java, txt]
System.out.println(Arrays.toString(str2.split("\\.")));	//结果为[hello, java, txt]

startsWith(String str)

判断字符串是否以某个指定的字符串开头

String s1 = "abcde";
String s2 = "a";
String s3 = "b";
System.out.println(s1.startsWith(s2));		//true
System.out.println(s1.startsWith(s3));		//false

endsWith(String str)

判断字符串是否以某个指定的字符串结尾

String s1 = "abcde";
String s2 = "e";
String s3 = "d";
System.out.println(s1.endsWith(s2));		//true
System.out.println(s1.endsWith(s3));		//false

getBytes()

把字符串转换成字节数组

String str = "abcde";
byte[] bytes = str.getBytes();

toCharArray()

把字符串转换成字符数组

String str = "abcde";
char[] chs = str.toCharArray();

String.valueOf(Object obj)

把其他形式的对象类型转换为字符串

char[] ch = {'a','b','c'};
System.out.println(String.valueOf(ch));//结果为String类型的字符串abc

trim()

去除字符串前后的空格

String str1 = " a b c ";
System.out.println(str1.trim());//结果为a b c

toLowerCase()

把字符串转换成小写

toUpperCase()

把字符串转换成大写

String str = "ABCDE";
System.out.println(str.toLowerCase());		//转换成小写abcde
System.out.println(str.toUpperCase());		//转换成大写ABCDE

 

Math

Math.PI

System.out.println(Math.PI); // PI的值3.141592653589793

Math.abs(a)

取绝对值

System.out.println(Math.abs(-10)); // 10,取绝对值

Math.ceil(a)

向上取整,结果是double类型

System.out.println(Math.ceil(10.1)); // 11.0,向上取整,结果是double类型
System.out.println(Math.ceil(10.9)); // 11.0

Math.floor(a)

向下取整,结果是double类型

System.out.println(Math.floor(10.1)); // 10.0,向下取整,结果是double类型
System.out.println(Math.floor(10.9)); // 10.0

Math.max(a,b)

比最大

Math.min(a,b)

比最小

System.out.println(Math.max(5, 10)); // 10,比最大
System.out.println(Math.min(5, 10)); // 5,比最小

Math.round()

四舍五入数字，double类型的数字四舍五入之后是long类型，float类型的数字四舍五入之后是int类型

double d1 = 3.4;
double d2 = 3.6;
long round1 = Math.round(d1);	//double类型的数字四舍五入之后是long类型
long round2 = Math.round(d2);
float f1 = 3.4f;
float f2 = 3.6f;
int round3 = Math.round(f1);	//float类型的数字四舍五入之后是int类型
int round4 = Math.round(f2);
System.out.println(round1);//结果为3
System.out.println(round2);//结果为4
System.out.println(round3);//结果为3
System.out.println(round4);//结果为4

Math.random()

生成随机数，结果在0~1之间，含0不含1

double random = Math.random();
System.out.println(random);//随机数，结果为 [0~1)

Math.pow(int a,int b)

幂运算，a的b次方

double pow = Math.pow(4, 2);
System.out.println(pow);//结果为16

Math.sqrt(int a)

开根号，根号a

double sqrt = Math.sqrt(9);
System.out.println(sqrt);//结果为3

可变长参数

public class Demo7 {

	public static int sum(int... a) {	//可变长参数
		//可变长使用数组来接受参数
		//可变长参数放在参数列表的最后一个位置
		int sum = 0;
		for (int i = 0; i < a.length; i++) {
			sum += a[i];
		}
		return sum;
	}
	public static void main(String[] args) {
		
		int sum = sum(1,2,3,4,5);//可以放入多个参数
		System.out.println(sum);
		
	}

}

 

System

System类被Final修饰 ，不可被继承，构造方法被private修饰，不可被实例化，里面所有的方法都被static修饰，所有可以通过类名取调用

public static void gc()

public static void exit(int status) 终止正在运行的jvm

System.exit(0);		//非0状态码表示异常终止
System.out.println("111");        //程序并不会继续运行下去

public static void currentTimeMillis()  返回从格林威治时间到当前时间的毫秒数

long start = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
	System.out.println("*");
}
long end = System.currentTimeMillis();
System.out.println(end - start);		//时间不固定，我显示的是16

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

拷贝数组

src：源数组。 
srcPos：源数组中的起始位置。 
dest：目标数组。 
destPos：在目标数组中的起始位置。 
length：要拷贝的数组长度。 

int[] src = { 1, 2, 3, 4, 5 };
int[] dest = new int[10];
// 拷贝前
System.out.println(Arrays.toString(dest)); // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
System.arraycopy(src, 0, dest, 0, src.length);
// 拷贝后
System.out.println(Arrays.toString(dest)); // [2, 3, 4, 5, 0, 0, 0, 0, 0, 0]

 

BigInteger

 

构造方法
public BigDecimal(String val)
成员方法
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)

		BigInteger bi1 = new BigInteger("100");
		BigInteger bi2 = new BigInteger("2");

		System.out.println(bi1.add(bi2)); // +,102
		System.out.println(bi1.subtract(bi2)); // -,98
		System.out.println(bi1.multiply(bi2)); // *,200
		System.out.println(bi1.divide(bi2)); // (除)/,50

		BigInteger[] div = bi1.divideAndRemainder(bi2);// 返回bi1/bi2和bi1%bi2的数组
		for (BigInteger bigInteger : div) {
			System.out.println(bigInteger);// 50,0

 

BigDecimal

		System.out.println(2.0 - 1.1); // 结果:0.8999999999999999,传统double类型计算不精确
		
                BigDecimal bd1 = new BigDecimal(2.0); // 当传入的值是double类型(一般开发中不推荐)
		BigDecimal bd2 = new BigDecimal(1.1);
		System.out.println(bd1.subtract(bd2)); // 结果0.899999999999999911182158029987476766109466552734375,比传统double计算更精确

		BigDecimal bd3 = new BigDecimal("2.0"); // 当传入的值是String类型时(开发中常用这中方法)
		BigDecimal bd4 = new BigDecimal("1.1");
		System.out.println(bd3.subtract(bd4)); // 结果0.9

		BigDecimal bd5 = BigDecimal.valueOf(2.0);// 或者使用这种方式
		BigDecimal bd6 = BigDecimal.valueOf(1.1);
		System.out.println(bd5.subtract(bd6)); // 结果0.9