常用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();