API中的String、StringBuilder、System使用

常用API

字符串String类

字符串使用频率非常高，生活中的很多数据都需要使用字符串来表示
不同于，字符’a’ 包含一个字符，字符串"aa"字符串可以是任意个字符
字符串也是对象，产生字符串对象的类java.lang.String

java.lang.String

最终类，不能被继承，String类继承Object，实现了多个接口，String类就是字符串对象，任何"无论写的是什么内容"，都这这个类的对象
字符串是常量，一旦创建了，不能修改

字符串对象的创建

• 直接声明方式：String str=“abc”;
• 使用new关键字：String str=new String(“abc”);

字符串是常量

pub1ic static void main(String[] args) {
	//str引用变量， 指向对象abc
	string str ="abc";
	system. out. print1n(str);
	//str引用变量,指向新的对象bcd，原来对象abc没有变
	str = "bcd";
	system. out. print1n(str);
}

java中本身没有字符串这个类型，一切字符串都是采用单个字符组成，字符串的最终表示形态，char数组

private final char value[];//字符串，会存储在数组中，数组的名字 value

• 数组的修饰符final最终，锁定数组
  。数组的地址不会改变，因此他是字符串常量
  。JDK9的时候，节约内存 数组变成 private final byte value[]

关于字符串常见问题

public static void main(String[] args) {
	//定义上的问题
	string s1 = "abc";
	String s2 = "abc";
	System. out. print1n(s1 == s2); // true
	string s3 = "qq";
	String s4 = new String("qq");
	System. out. print1n(s3 == s4); // false
	string s5 = "helloworld";
	string s6 = "he11o"+"world";
	system. out. print1n(s5 == s6);// true
	string s7 = "he11o";
	System. out. print1n(s5 == s7+"wor1d");// false
}

构造方法

方法参数	方法的解释
byte[]数组	适用平台的默认字符集解码该字节数组
byte[]，String charset	使用指定的字符集解码该字节数组
byte[]数组,int off，int len	使用平台的默认字符集解码该字节数组,开始索引，解码的个数
byte[]数组,int off，int len，String charset	使用指定的字符集解码该字节数组,开始索引,解码的个数
char[] 数组	数组转成字符串
char[]数组,int off,int len	数组转成字符串，开始索引，转换的个数

pub1ic static void main(String[] args) throws UnsupportedEncodi ngException {
	//字节数组byte使用平台的默认字符集解码该字节数组
	//平台(操作系统)默认字符集，简体中文GBK
	//GBK编码表，汉字2个字节,负数
	byte[] bytes = {-97 ,-98,-99, -100};
	String s = new String(bytes);
	System. out. print1n(s);
	byte[] bytes1 = {-26,-104,-81};
	//byte[]数组，String charset(指定字符集)
	String s1 = new string(bytes1, "utf-8");
	System. out. print1n(s1);
}

public static void main(String[] args) {
	//构造方法的参数，字节数组,int off,int 1en
	byte[] bytes = {97 , 98，99, 100, 101,102};
	//参数，从几索引开始,转几个
	string S = new string(bytes,2,2);
	System. out. print1n(s);
	char[] chs = {'a','b','c','d','e','f'};
	//构造方法参数,是字符数组，和编码表无关,,int off,int len 
	String s1 = new string(chs,1,5);
	System. out. print1n(s1);

}

String类的判断方法

返回值	方法名字	解释
boolean	equals(Object obj)	字符串进行比较,完全一样返回true
boolean	equalslgnoreCase(String s)	字符串进行比较忽略大小写
boolean	startsWith(String s)	判断一个字符串是否以另一个字符串开头
boolean	endsWith(String s)	判断一个字符串是否以另一个字符串结尾
boolean	contains(CharSequence C)	判断是否包含一个字符串
boolean	isEmpty()	判断字符串的长度，长度=0,返回true

public static void main(String[] args) {
	//equals方法，判断字符串是否完全相等,继承object,方法重写
	//equals方法没有比较内存地址,比较的是字符串的值
	String s1 = "abc";
	String s2 = new String("abc");
	boolean
	bool = s1.equals(s2);
	System. out. println("s1和s2::" + bool); // true
	//equalsIgnoreCase方法,判断字符串,忽略大写小写
	String s3 = "hello";
	String s4 = "HeLLO" ;
	bool = s3. equalsIgnoreCase(s4);
	system. out. print1n("He11o. java是否以He11o开头::"+boo1); // true
	boo1 = "He11o. java" . endswi th("java"); 
	System. out. print1n("He11o. java是否以. java结尾::"+boo1);// true
	//contains ()判断字符串是否包含另一个，完全包含返回true
	boo1 = "how are you". contains ("you"); 
	System. out. print1n("how are you 是否包含you::"+ boo1);// true
	//isEmpty()字符串的长度是0，就是true
	System. out. print1n(" ". isEmptyO)); //false
}

String类的获取方法

返回值	方法名	方法解释
char	charAt(int index)	返回指定索引上的字符
int	indexOf(String str)	返回字符串第一次出现的索引
int	lastIndexOf(String str)	返回字符串第一次出现的索引,反向查找
String	substring(int start,int end)	返回字符串的一 部分,截取

public static void main(String[] args) {
	//字符 串的获取方法
	char c = "abcdef" . charAt(3);
	System. out . println("字符是::"+c);//d
	//字符串第一次出现的索引
	int index = "how are yoreu" . indexOf("re");
	System. out. println("第一次出现的索引::"+ index);//5
	//字符串第一次出现的索引,反向查找
	index = "how are yoreu".lastIndex0f("re");
	System. out . print1n("第一次出现的索引板向查找::"+ index);//10
	//截取字符串一部分substring(开始索引,结束索引)
	//包含开始索引,不包含结束索引
	String str = "welcome";
	//截取后,返回新的字符串
	String str1 = str. substring(1,4);
	System. out. println(str1);//elc 	
}

字符串的转换方法

返回值	方法名	解释
byte[]	getBytes()	通过平台默认字符集编码字符串
byte[]	getBytes(String charset)	通过指定编码表编码字符串
char[]	toCharArray()	字符串转成字符数组
String	toUpperCase()	字符串全部转成大写
String	toLowerCase()	字符串全部转成小写
String	static valueOf(任意传递)	任意类型转成字符串

public static void main(String[] args) throws UnsupportedEncodingException{
	//字符串转成字节数组,平台默认编码表GBK
	//方法: getBytes()
	byte[] bytes = "abc" . getBytes();
	System. out. print1n("=====忧郁的分割线======");
	//字符串转成字节数组,指定编码表UTF-8
	byte[] bytes1="abc" . getBytes("UTF-8");
	System. out. print1n("=====忧郁的分割线======");
	//字符串,转成字符数组toCharArray()
	char [ ]ch ="helloworld" . toCharArray();
	System. out. print1n("=====忧郁的分割线======");
	//字符串全部转成大写,或者小写
	//toUpperCase()大写，toLowerCase()
	String s = "HeLLoWoRld" ;
	String upper = s. toUpperCase();
	System. out . println(upper) ;
	String lower = s. toLowerCase() ;
	System. out . println(lower) ;
	System. out. print1n("=====忧郁的分割线======");
	//static String value0f(随意) 任意类型转字符串
	String str = String. value0f(1);
	System. out . println(str+1) ;//11			
}

字符串的其他方法

返回值	方法名	解释
String	trim()	去掉字符串两端的空格
String[]	split(String s)	对字符串进行切割
String	replace(String old,String newString)	替换字符串
int	compareTo(String s)	字符串自然顺序比较 abc 123
int	length()	返回字符串长度

public static void main(String[ ] args) {
	//trim()去掉字符串两端空格,返回新的字符
	String s1=" abc de fg  ";
	String s2 = s1. trim();
	System. out . println(s2) ;//abc de fg
	System. out. print1n("=====忧郁的分割线======");
	//split()字符串进行切割,返回值是String[]
	//字符串没有被切割，结果数组strs,只有一个长度
	String s3 ="ab-cde-f";
	String[] strs = s3.split("-"); //按照-切割字符串
	System. out. print1n("=====忧郁的分割线======");
	//replace(老串,新串)替换字符串,返回新的字符串
	String s4 ="how do you do" ;
	s4 = s4.replace("o"， "t");
	System. out . println(s4) ;//htw dt ytu dt
	System. out. println("=====忧郁的分割线======");
	/*
	*length() 返回字符串的长度, 字符串中包含字符的个数
	*数组的长度:数组.1ength属性
	*字符串的长度:字符串对象.length() 方法
	*/
	int i="abcdefg" .length( );
	System.out. println(i) ;//7
	System. out. println("=====忧郁的分割线======");
	/*字符串的自然顺序比较，字典顺序
	*String类,实现接口Comparable,重写了该接口的方法.
	*int compareTo(String s)比较的结果是int类型
	*结论:
	*调用者和参数比较:
	*调用者小于参数,返回负数if( < 0)
	*调用者大于参数,返回正数if( > 0)
	*调用者等于参数,返回0 if( ==0)
	*/
	int com ="abc" . compareTo( "abc");
	System. out . println (com) ;//=0
	int com="abc " . compareTo("adc") ;
	System. out . println( com);//<0
	int com="azc". compareTo( " bbc ");
	System. out . println( com) ;//<0
}

StringBuilder类

java.lang.StringBuilder类，称为字符串的缓冲区对象，目的是为了提高字符串的操作效率.
String对象效率低下分析：

• 字符串不变性造成
• 体现中字符串的拼接尤为严重

Sting s1="a";
Sting s2="b";
Sting s3="c";
运行程序，内存中出现3个数组
String s4=s1+s2+s3;
s4是个新数组，保存 abc
程序运行起来，内存中，出现4个char[]数组

• 解决String对象效率问题，开发了StringBuilder

StringBuilder类的高效原理

• String对象，采用数组来实现 char[]，数组被final修饰
• 一个可变的字符序列
  。字符序列：就是字符数组char[]
  。StringBuilder底层实现，依然是char[]数组，没有final
  。数组的弊端是定长特性，StringBulider里面数组可以"变长"
  。"可变"长度是利用数组的复制原理实现

StringBuilder类的方法

• append(任意类型),将任意类型的数据，添加到字符串缓冲区
  。方法返回值StringBuilder类型，返回对象依然是调用者
  。当一个方法返回值是一个对象的时候，使用方法调用链(链式编程)
  。builder.append(1).append(2).append(3)

public static void main(String[] args) {
	//创建对象，无参数构造方法
	stringBuilder builder = new stringBuilderO;
	//append方法，向缓冲区中追加数据，变成字符串
	builder . append(false) . append(1) . append(2.5). append("aa");
	System. out. print1n(builder);
}

• StringBuilder delete(int start,int end)删除缓冲区中的字符，开始索引，不好含接收索引

public static void main(String[] args) {
	StringBuilder builder = new StringBuilder();
	builder . append(123) . append( "abc");
	System. out . println(builder);
	builder .delete(1, 3);
	System. out . print1n(builder) ;//1bc
	}

• int length()返回字符串缓冲区中字符的个数
• StringBuilder insert(int 索引，任意数据)在指定的索引上，插入任何数据
• StringBuilder reverse()翻转缓冲区中的字符

String对象和StringBuilder对象的互转

• String对象转成StringBuilder
  。利用StringBuilder的构造方法 StringBuilder(String str)
  。StringBuilder追加方法append()

//String对象转成StringBuilder
public static void stringTostringbuilderO {
	//创建对象，构造方法
	stringBuilder builder = new stringBuilder("abcd");
	//append方法追加
	builder. append("he11o");
	system. out. print1n(builder);
}

• StringBuilder对象转为String对象
  。利用String类的构造方法String(StringBuilder builder)
  。利用StringBuilder类的方法toString(）

//StringBuilder对象转为String对象
public static void stringBuilderToString() {
	StringBuilder builder = new StringBuilder("abcd"); 
	//String类的构造方法
	String s = new String(builder);
	System. out . println(s) ;
	//StringBuilder对象的方法toString( )
	String str=builder.toString();
	System. out . println(str) ;
}

String和StringBuilder作为方法的参数

public static void main(String[] args) {
	//字符不变性
	String s = "abcde";
	System.out . println(s); //abcde
	change(s);
	System. out. println(s); // abcde.
	System. out . print1n("=======");
	StringBuilder builder = new StringBuilder();
	builder. append("a");
	System. out . println(builder);// a
	change (builder);
	System. out . println(builder);// ab
}
	/*
	*方法的参数是StringBuilder
	*/
	pub1ic static void change(StringBuilder builder) {
		builder . append("b");
	}
	//方法的参数是字符串String
	pub1ic static void change(String s) {
		s = "Hello";
	}

StringBuffer类

StringBuffer类是字符串的缓冲区对象，目的是为了提高字符串的效率
StringBuffer和StringBuilder方法一模一样,不需要学习

• StringBuffer出现JDK1.0版本,特点线程安全,运行速度慢,几乎少用
• StringBuilder 出现JDK1.5版本,特点线程不安全,运行速度块,常用

System类

java.lang.System类，系统类
包含有用的方法和字段(成员变量),最终类不能被继承，不能被实例化(不能new对象)
这个类的构造方法被私有修饰 private System(){}
类的成员都是静态的，类名直接调用

• static void exit(int s) 结束JVM 参数传递int ，非0表示异常终止
• static void gc() 运行垃圾回收器(JVM堆内存收取垃圾,不要调用！！！！) STW(Stop The World)
• static void arraycopy(Object src,int srcPost,Object desc,int desPos,int len)复制数组元素
  。src：要复制的原始数组
  。srcPost：原始数组的开始索引
  。desc：复制后的目标数组
  。desPos：复制后的目标数组的开始索引
  。len：复制几个元素

public static void main(String[] args) {
	// 数组的复制
	int[] src = {1,2,3,4,5};
	int[] dest = {6,7,8,9,0,11,22,33};
	System. arraycopy(src, 1, dest, 2, 3);
	for(int i = 0 ; i < dest.length; i++) {
	System. out. println(dest[i]);
	}//6,7,2,3,4,11,22,33
}

• static long currentTimeMillisO) 返回自1970年1月1日午夜0点0分0秒,到程序运行的时刻，经过的亳秒值.1000毫秒=1秒
• 1ong time = system. currentTimeMillis();