String
类代表字符串,每个双引号里面的字符串都是一个String类的对象,例如"abc"是一个字符串对象。
字符串最大的特点:
一旦被初始化就不可以被改变
String类适用于描述字符串事物
那么它提供了许多个方法对字符串进行操作
常见的操作有哪些?
1.获取
1)字符串中包含的字符数,也就是字符串的长度
int length(); 获取长度
2)根据位置获取位置上某个字符
char charAt(int index);
3)根据字符获取该字符在字符串中位置
int indexOf(int ch);返回的是ch在字符串中第一次出现的位置,ch是ASCII值
int indexOf(int ch, int fromIndex);从fromIndex指定位置开始,获取ch在字符串中出现的位置
int indexOf(String str);返回的是str在字符串中第一次出现的位置
int indexOf(String str, int fromIndex);从fromIndex指定位置开始,获取str在字符串中出现的位置
int lastIndexOf(int ch); 反向索引字符出现的位置,正向索引和反向索引得到的角标值一样
示例代码:
JDK 1.5 版本之后出现了StringBuilder
StringBuffer是线程同步的
StringBuilder是线程不同步的
以后开发,建议使用StringBuilder
升级的三个因素:
1.提高效率
2.简化书写
3.提高安全性
基本数据类型对象包装类
byte Byte
short Short
int Integer
long Long
char Character
float Float
double Double
boolean Boolean
基本数据类型对象包装类的最常见作用,
就是用于基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
1.基本数据类型+""
2.基本数据类型.toString(基本数据类型值);
3.String.valueOf(基本数据类型);
如: Integer.toString(45); //将34整数变成"45"
字符串转成基本数据类型
方法一:转换成基本数据类型
xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("34"); //必须是数字格式的字符串
boolean b = Boolean.parseBoolean("true");
注意:Character类没有这个方法
Integer a = new Integer("43");
int num = a.intValue();
方法二:转换成基本数据类型的包装类对象
Xxx a = Xxx.valueOf(String);
Integer a = Integer.valueOf("78"); //必须是数字格式的字符串
Boolean b = Boolean.valueOf("true");
注意:Character类没有 Xxx.valueOf(String)这个方法
Xxx Xxx.valueOf(xxx);主要用来将基本数据类型封装成包装类对象
十进制转成其他进制
Xxx.toBinaryString();
Xxx.toHexString();
Xxx .toOctalString();
注意: Xxx只能是Integer和Long,
但是有 Float.toHexString(float);和 Double.toHexString(double);
其他进制转成十进制
方法一:parseInt(String, radix);
方法二:valueOf(String, radix);
JDK1.5版本以后出现的新特性
自动装箱
Integer a = 4;
自动拆箱
int num = a + 69; 等同于 int num = a.intValue() + 69;
注意:Integer 比 int 多一个值 null,自动拆箱时应注意判断
一个小例子
Integer m = 128;
Integer n = 128;
System.out.println("m==n:"+(m==n)); //结果为false
Integer a = 127;
Integer b = 127;
System.out.println("a==b:"+(a==b)); //结果为true,因为a和b指向同一个Integer对象
//因为当数值在byte范围内容,对于新特性,如果该值已存在,则不会开辟新的空间
2.判断
1)字符串中是否包含某一个字符
boolean contains(charSequence s);String是charSequence的实现类
特殊之处:int indexOf(String str);可以索引str第一次出现的位置,如果返回-1,表示str不在字符串中存在。
所以,也可以用户于对指定字符串判断是否包含。
所以,也可以用户于对指定字符串判断是否包含。
if(str.indexOf("aa") != -1)
该方法既可以判断,又可以获取出现的位置
2)字符串中是否有内容
boolean isEmpty();原理就是判断长度是否为0.
3)字符串是否是以指定内容开头
boolean startsWith(String str);
4)字符串是否是以指定内容结尾
boolean endsWith(String str);
5) 判断字符串内容是否相同,覆写了Object类中的equals方法
boolean equals(Object anObject);
6) 判断内容是否相同,并忽略大小写
boolean equalsIgnoreCase(String anotherString);
字符串练习示例代码
StringBuffer是字符串缓冲区
是一个容器
特点:
1.长度是可变化的
2.可以字节操作多个数据类型
3.最终会通过toString方法变成字符串
C create
U update
R read
D delete
1.存储
StringBuffer append(基本数据类型,字符数组,String,StringBuffer, Object);将指定数据作为参数添加到已有数据结尾
StringBuffer insert(index, 数据);可以将数据出插入到指定index位置
2.删除
StringBuffer delete(int start, int end);删除缓冲区中的数据,包含start,不包含end
StringBuffer deleteCharAt(int index);删除指定位置的数据
3.获取
char charAt(int index);
int length();
int indexOf(String str);
int lastIndexOf(String str);
String substring(int start, int end); 返回值为String
4.修改
StringBuffer replace(start, end, string);
void setCharAt(int index, char ch); 注意:返回值为空
5.反转
StringBuffer reverse();
6.将缓冲区中指定数据存储早指定字符数组中
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin);
3.转换
1)将字符数组转成字符串
构造函数:
String(char[] value);
String(char[] value, int offset, int count);将字符数组中一部分封装成字符串
静态方法:
static String copyValueOf(char[] data);
static String copyValueOf(char[] data, int offset, int count);
static String valueOf(char[] data);
2)将字符串转成字符数组
char[] toCharArray();
3)将字节数组转成字符串
String(byte[] value);
String(byte[] value, int offset, int count);将字节数组中一
部分封装成字符串
4)将字符串转成字节数组
byte[] getBytes();
5)将基本数据类型转换成字符串
static String valueOf(int data);
static String valueOf(double data);
6+""; 等同于 String.valueOf(6);
特殊:字符串和字节数组在转化过程中,是可以指定编码表的。
示例:
4.替换
String replace(char oldChar, char newChar);
String replace(CharSequence target, CharSequence replacement);
5.切割
String[] split(String regex);
6.子串,获取字串中的一部分
String substring(int beginIndex);
String substring(int beginIndex, int endIndex);
7.转换,去除空格,比较。
1)将字符串转成大写或者小写
String toUpperCase();
String toLowerCase();
2)将字符串两端的多个空格去除
String trim();
3)对两个字符串进行自然顺序的比较
int compareTo(String str);
public static void method_7(){
String s = " Hello World ";
sop(s.toUpperCase()); //转换成大写
sop(s.toLowerCase()); //转换成小写
sop(s.trim()); //去空格
String s1 = "abc";
String s2 = "aaa";
sop(s1.compareTo(s2)); //比较
}
public static void method_sub(){ //截取子串
String s ="abcdef";
sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在,会出现字符串角标越界
sop(s.substring(2, 4));//包含开头,不包含结尾。s.substring(0, s.length());
}
public static void method_split(){ //切割
String s = "zhangsanmmlisimmwangwu";
String[] arr = s.split("mm");
for(int i=0; i<arr.length; i++){
sop(arr[i]);
}
}
public static void method_replace(){ //替换
String s = "hello java";
String s1 = s.replace('a', 'n');//如果要替换的字符不存在,返回的是原串
String s2 = s.replace("java", "txt");
sop("s="+s);
sop("s1="+s1);
sop("s2="+s2);
}
public static void method_trans(){//转换
char[] arr = {'a', 'b', 'c', 'd', 'e', 'f'};
String str = new String(arr);
sop("str="+str);
String str2 = new String(arr, 2, 2);
sop("str2="+str2);
char[] chs = str.toCharArray();
for(int i=0; i<chs.length; i++){
sop(chs[i]+"");
}
}
public static void method_get(){ //获取
String str = "abcdeaef";
//长度
sop(str.length());
//根据索引获取字符
sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException
//根据字符获取索引
sop(str.indexOf('a',3));//如果没有找到,返回-1
//反向索引一个字符出现位置
sop(str.lastIndexOf('a'));
}
public static void method_is(){ //判断
String str = "ArrayDemo.java";
//判断文件名称是否是Array单词开头
sop(str.startsWith("Array"));
//判断文件名称是否是.java的文件
sop(str.endsWith(".java"));
//判断文件中收费包含Demo
sop(str.contains("Demo"));
}
public static void sop(Object obj){
System.out.println(obj);
}
字符串练习示例代码
public class StringTest {
public static void main(String[] args) {
System.out.println(getMaxSameSubString("skfkdhellodkie", "iejikehellohd"));
System.out.println(getCountString("heleokkhdidkkddkkdsse", "kk"));
System.out.println(reverseString("hello"));
String str = " kjkidd ";
System.out.println("<"+str+">");
System.out.println("<"+myTrim(str)+">");
}
//获取两个字符串中最大相同子串
public static String getMaxSameSubString(String str1, String str2){
String max = "", min = "";
max = (str1.length() > str2.length())?str1:str2;
min = (max == str1)?str2:str1;
for(int i=0; i<min.length();i++){
for(int start=0, end=min.length()-i; end!=min.length()+1; start++, end++){
if(max.contains(min.substring(start, end)))
return min.substring(start, end);
}
}
return null;
}
//获取一个字符串在另一个字符串中出现的次数
public static int getCountString(String str, String key){
int index = 0, count = 0;
while((index = str.indexOf(key, index)) != -1){
System.out.println("index="+index);
count++;
index = index + key.length();
}
return count;
}
//反转字符串
public static String reverseString(String str, int start , int end){
char[] arr = str.toCharArray();
reverseCharArray(arr, start, end);
return new String(arr);
}
//反转字符串的重载
public static String reverseString(String str){
return reverseString(str, 0, str.length());
}
//反转字符数组
private static void reverseCharArray(char[] arr, int start, int end){
for(int s=start, z=end-1; s<z; s++, z--){
swap(arr, s, z);
}
}
//交换字符数组中的两个字符
private static void swap(char[] arr, int a, int b){
char temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
//去除字符串两端的空格
public static String myTrim(String str){
char[] arr = str.toCharArray();
int start=0, end=arr.length-1;
while(start<=end && arr[start++]==' ');
while(start<end && arr[end--]==' ');
return str.substring(start, end+1);
}
}
StringBuffer是字符串缓冲区
是一个容器
特点:
1.长度是可变化的
2.可以字节操作多个数据类型
3.最终会通过toString方法变成字符串
C create
U update
R read
D delete
1.存储
StringBuffer append(基本数据类型,字符数组,String,StringBuffer, Object);将指定数据作为参数添加到已有数据结尾
StringBuffer insert(index, 数据);可以将数据出插入到指定index位置
2.删除
StringBuffer delete(int start, int end);删除缓冲区中的数据,包含start,不包含end
StringBuffer deleteCharAt(int index);删除指定位置的数据
3.获取
char charAt(int index);
int length();
int indexOf(String str);
int lastIndexOf(String str);
String substring(int start, int end); 返回值为String
4.修改
StringBuffer replace(start, end, string);
void setCharAt(int index, char ch); 注意:返回值为空
5.反转
StringBuffer reverse();
6.将缓冲区中指定数据存储早指定字符数组中
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin);
public class StringBufferDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append(new int[]{1,2,3,4}); //将数组添加到StringBuffer中
System.out.println(sb);
//将缓冲区中指定数据存储早指定字符数组中
sb.replace(0,sb.length(), "abcdef");
char[] dst = new char[8];
sb.getChars(1, 4, dst, 1);
for(int i=0; i<dst.length; i++){
sop("dst["+i+"]="+dst[i]);
}
}
public static void method_update(){
StringBuffer sb = new StringBuffer("abcdef");
sb.replace(1, 3, "QQ");
sb.setCharAt(5, 'H'); //替换一个字符,返回值为空
sop(sb);
}
//删除
public static void method_delete(){
StringBuffer sb = new StringBuffer("haha");
sb.delete(1, 3);
//清空缓冲区
sb.delete(0, sb.length());
sb.delete(1, 2);//删除下标为1的字符
sb.deleteCharAt(1);//删除下标为1的字符
sop(sb);
}
//存储
public static void method_add(){
StringBuffer sb = new StringBuffer();
sb.append("abc").append(467).append(false);//添加
sb.insert(3, "qq"); //插入
}
public static void sop(Object obj){
System.out.println(obj);
}
}
JDK 1.5 版本之后出现了StringBuilder
StringBuffer是线程同步的
StringBuilder是线程不同步的
以后开发,建议使用StringBuilder
升级的三个因素:
1.提高效率
2.简化书写
3.提高安全性
基本数据类型对象包装类
byte Byte
short Short
int Integer
long Long
char Character
float Float
double Double
boolean Boolean
基本数据类型对象包装类的最常见作用,
就是用于基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
1.基本数据类型+""
2.基本数据类型.toString(基本数据类型值);
3.String.valueOf(基本数据类型);
如: Integer.toString(45); //将34整数变成"45"
字符串转成基本数据类型
方法一:转换成基本数据类型
xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("34"); //必须是数字格式的字符串
boolean b = Boolean.parseBoolean("true");
注意:Character类没有这个方法
Integer a = new Integer("43");
int num = a.intValue();
方法二:转换成基本数据类型的包装类对象
Xxx a = Xxx.valueOf(String);
Integer a = Integer.valueOf("78"); //必须是数字格式的字符串
Boolean b = Boolean.valueOf("true");
注意:Character类没有 Xxx.valueOf(String)这个方法
Xxx Xxx.valueOf(xxx);主要用来将基本数据类型封装成包装类对象
十进制转成其他进制
Xxx.toBinaryString();
Xxx.toHexString();
Xxx .toOctalString();
注意: Xxx只能是Integer和Long,
但是有 Float.toHexString(float);和 Double.toHexString(double);
其他进制转成十进制
方法一:parseInt(String, radix);
方法二:valueOf(String, radix);
JDK1.5版本以后出现的新特性
自动装箱
Integer a = 4;
自动拆箱
int num = a + 69; 等同于 int num = a.intValue() + 69;
注意:Integer 比 int 多一个值 null,自动拆箱时应注意判断
一个小例子
Integer m = 128;
Integer n = 128;
System.out.println("m==n:"+(m==n)); //结果为false
Integer a = 127;
Integer b = 127;
System.out.println("a==b:"+(a==b)); //结果为true,因为a和b指向同一个Integer对象
//因为当数值在byte范围内容,对于新特性,如果该值已存在,则不会开辟新的空间