Java中String字符串的API及数据类型转换
- 字符串的基本操作
- 1、substring(start,end)——含前不含后
- 2、charAt(index)——返回字符串index位置的字符
- 3、Integer.valueOf()
- 4、trim()
- 5、split()
- 6、startsWith和endsWith
- 7、toUpperCase()和toLowerCase()
- 8、valueOf()静态方法
- 9、字符串与字符串数组之间的转换
- 9、字符串与整型数组之间的转换
- 10、将字符串与指定的对象比较
- 11、按字典顺序比较两个字符串
- 12、String concat(String str)将str字符串连接到字符串的末尾
- 13、copyValueOf返回指定数组中表示该字符序列的String
- 14、indexOf返回指定字符(字符串)索引
- 15、valueOf
- 16、replace()—替换字符串
- int与字符串数据类型转换
字符串的基本操作
目前对字符串的操作还不是很熟悉,因此做以下整理,一方面加深记忆,一方面方便复习!
1、substring(start,end)——含前不含后
用于截取字符串的一个子字符串,从start开始,end-1为止。
String s="123456789";
String sub=s.substring(1,5);
System.out.println(sub);//2345
2、charAt(index)——返回字符串index位置的字符
String s="123456789";
char c=s.charAt(5);
System.out.println(c);//6
3、Integer.valueOf()
字符串不能强行转为int,需要通过Integer.valueOf()转换
String s="123456789";
int n=Integer.valueOf(s);
System.out.println(n);//123456789
4、trim()
去掉字符串开头和结尾的空字符串(空格,tab等),并且得到的字符串时一个新的字符串,因为字符串相当于是常量,不会改变值
String ss=" 12345678 ";
System.out.println(ss);// 12345678
System.out.println(ss.trim());//12345678
5、split()
就是将字符串按照分割符(空格等)分为多个字符串
String ssp="I am a Student";
String[] ssp1=ssp.split(" ");
//ssp1[0]=I,ssp1[1]=am,ssp1[2]=a,ssp1[3]=Student
6、startsWith和endsWith
booelan startsWith(str):判断字符串是否是以参数str指定的内容开始
boolean endsWith(str); 常用于判断文件后缀
String ssp="I am a Student";
System.out.println(ssp.startsWith("I"));//true
System.out.println(ssp.startsWith("Stu", 7));//true
System.out.println(ssp.endsWith("ent"));//true
7、toUpperCase()和toLowerCase()
统一转换为大写或小写
String ssp="I am a Student";
System.out.println(ssp.toUpperCase());//I AM A STUDENT
System.out.println(ssp.toLowerCase());//i am a student
8、valueOf()静态方法
将其他类型转换为字符串类型
System.out.println(String.valueOf(1234));//1234
System.out.println("0000"+String.valueOf(1234));//00001234
9、字符串与字符串数组之间的转换
字符串转为字符数组:public char[] toCharArray()
字符数组转为字符串 : public String(char[] value)
public String(char[] value,int offset,int count)
String str="123456789";
char[] c=str.toCharArray();
for(int i=0;i<c.length;i++) {
System.out.printl(c[i]+",");
}//1,2,...,9
String str1=new String(c);
System.out.println(str1);//123456789
String str2=new String(c,2,6);
System.out.println(str2);//345678
字符串与字节数组之间的转换:
字符串转字节数组:public byte[] getBytes()
字符数组转字符串:public String(byte[] bytes)
public String(byte[] bytes,int offset,int length)
String str1 = "hello" ; // 定义字符串
byte b[] = str1.getBytes() ; // 将字符串变为byte数组
System.out.println(new String(b)) ; // 将全部的byte数组变为字符串
System.out.println(new String(b,1,3)) ;// 将部分的byte数组变为字符串
9、字符串与整型数组之间的转换
String s1="123456789";
int n1[]=new int[s1.length()];
for(int i=0;i<n1.length;i++)
n1[i]=Integer. parseInt(String.valueOf(s1.charAt(i)));
//整型数组转为字符串:
int n2[]={1,2,3};
String s2="";
for(int i=0;i<n2.length;i++)
s2+=Integer.toString(n2[i]);
System.out.println(s2);
10、将字符串与指定的对象比较
boolean equals(Object anObject) 考虑大小写
boolean equalsIgnoreCase(String anotherString) 不考虑大小写
String s3="hello";
System.out.println(s3.equals("heLLo"));//false
System.out.println(s3.equalsIgnoreCase("heLLO"));//true
11、按字典顺序比较两个字符串
int compareTo(String anotherString) //区分大小写
int compareToIgnoreCase(String str) //不区分大小写
String s1="abc";
String s2="aBc";
//A的Unicode码为65,a的Unicode码为97,所以A<a
if(s1.compareTo(s2)>0)
System.out.println("s1>s2");
if(s1.compareTo(s2)==0)
System.out.println("s1==s2");
if(s1.compareTo(s2)<0)
System.out.println("s1<s2");
//s1>s2
12、String concat(String str)将str字符串连接到字符串的末尾
String s3="hello";
System.out.println(s3.concat("1234"));//hello1234
13、copyValueOf返回指定数组中表示该字符序列的String
String copyValueOf(char[] data)
data - 字符数组; 返回:一个 String,它包含字符数组的字符。
String copyValueOf(char[] data, int offset, int count)
data - 字符数组。offset - 子数组的初始偏移量。count - 子数组的长度;返回:一个 String,它包含字符数组的指定子数组的字符。
char[] c=new char[]{'a','b','c','d'};
System.out.println(String.copyValueOf(c));
/*返回有c中所有元素构成的字符串,
相当于String s=new String(c);
结果就是产生一个 "abcd "字符串*/
System.out.println(String.copyValueOf(c,2,2));
/*返回由c中从下标2的元素(就是 'c ')开始,长度为2的元素构成的字符串,
相当于String s=new String(c,2,2);
结果就是产生一个 "cd "字符串。*/
14、indexOf返回指定字符(字符串)索引
int indexOf(char ch||String str) 返回指定字符(字符串)在此字符串中第一次出现处的索引
int indexOf(char ch||String str, int fromIndex) 返回在此字符串中第一次出现指定字符(字符串)处的索引,从指定的索引开始搜
int lastIndexOf(char ch||String str) 返回指定字符(字符串)在此字符串中最后一次出现处的索引
int lastIndexOf(char ch||String str,int fromIndex) 返回指定字符(字符串)在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索
String s = "abcbade";
int n1=s.indexOf('a');//n1=0
int n2=s.lastIndexOf('a'); //n2=4
int n3=s.indexOf('b',2); //n3=3
int n4=s.lastIndexOf('b',3);//n3=3
int m1=s.indexOf("bc"); //m1=1
int m2=s.lastIndexOf("ab"); //m2=0
15、valueOf
接口 | 含义 |
---|---|
valueOf(boolean b) | 返回 boolean 参数的字符串表示形式。 |
valueOf(char c) | 返回 char 参数的字符串表示形式。 |
valueOf(char[] data) | 返回 char 数组参数的字符串表示形式。 |
valueOf(char[] data, int offset, int count) | 返回 char 数组参数的特定子数组的字符串表示形式。 |
valueOf(double d) | 返回 double 参数的字符串表示形式。 |
valueOf(float f) | 返回 float 参数的字符串表示形式。。 |
valueOf(int i) | 返回 int 参数的字符串表示形式。 |
valueOf(long l) | 返回 long 参数的字符串表示形式。 |
valueOf(Object obj) | 返回 Object 参数的字符串表示形式。 |
char c[]={'a','b','c','d','e','f'};
int n=2020;
String s1=String.valueOf(c);//字符或字符数组均可转换
String s2=String.valueOf(c,2,4);
String s3=String.valueOf(n);//只有单个整型可转换,整型数组不行
System.out.println(s1);//abcdef
System.out.println(s2);//cdef
System.out.println(s3); //2020
16、replace()—替换字符串
String replace(char oldChar,char newChar) 返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar得到的
String replace(char oldStr,char newStr) 返回一个新的字符串,它是通过用 newStr 替换此字符串中出现的所有 oldStr 得到的
String str3="java";
System.out.println(str3.replace('a','A')); //返回“jAvA”
System.out.println(str3.replace("ja","JA")); //返回“JAva”
int与字符串数据类型转换
int -> String
int i=12345;
String s="";
第一种方法:s=i+"";
第二种方法:s=String.valueOf(i);
这两种方法有什么区别呢?作用是不是一样的呢?是不是在任何下都能互换呢?
String -> int
s="12345";
int i;
第一种方法:i=Integer.parseInt(s);
第二种方法:i=Integer.valueOf(s).intValue();
这两种方法有什么区别呢?作用是不是一样的呢?是不是在任何下都能互换呢?
以下是答案:
第一种方法:s=i+""; //会产生两个String对象
第二种方法:s=String.valueOf(i); //直接使用String类的静态方法,只产生一个对象
第一种方法:i=Integer.parseInt(s);//直接使用静态方法,不会产生多余的对象,但会抛出异常
第二种方法:i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s)),也会抛异常,但会多产生一个对象