Java字符串&异常处理
14.字符串
String StringBuffer类 StringBuilder类
【练习】
1.下面这条语句一共创建了多少个对象：String s=“welcome”+“to”+“huayu”;
答：1个
答案解析：
在Java中，String对象是不可变的，所以对String类对象进行+操作，相当于是创建了一个新的String对象，而字符串常量也是一个String对象，所以这条语句中应该是创建了四个对象："welcome "、"to "、"huayu"和"welcome to huayu"这四个字符串，但是这个问题的正确答案却是1个
2. String s = new String(“xyz”);创建了几个字符串对象？()
正确答案： 两个或一个都有可能
3.String类、StringBuffer、StringBuilder的区别？
正确答案：
- String是Java中基础且重要的类，并且String也是Immutable类的典型实现，被声明为final class，除了hash这个属性其它属性都声明为final,因为它的不可变性，所以例如拼接字符串时候会产生很多无用的中间对象，如果频繁的进行这样的操作对性能有所影响。
- StringBuffer就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类，提供append和add方法，可以将字符串添加到已有序列的末尾或指定位置，它的本质是一个线程安全的可修改的字符序列，把所有修改数据的方法都加上synchronized。但是保证了线程安全是需要性能的代价的。
- StringBuilder是JDK1.5发布的，它和StringBuffer本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。
4.String有哪些方法？请写出10个常用的方法，并说出功能
正确答案：
- int length():获取字符串的长度（字符数）
- char charAt(int index):获取指定下标位置的字符
- String[] split(String regex):根据表达式来拆分字符串
- boolean startWith(String prefix):是否以某个字符串开头
- boolean endtWith(String suffix):是否以某个字符串结尾
- String subString(beginIndex,endIndex):获取子串，包含beginIndex，不包含endIndex
- String subString(beginIndex):获取子串，从beginIndex一直到结束；
- String replace(oldString,newString):将字符串中所有的oldString替换成newString;返回一个新的字符串；
- String replaceAll():
- String replaceFirst();
- int compareTo(String another):与另外一个字符串进行比较大小，如果相等，返回0，如果小于another，返回负数，否则返回一个正数
- int compareToIgnoreCase(String another):忽略大小写进行比较
- boolean contains(CharSequence s):当前串中是否包含了s,如包含，返回true,否则返回false
- int lastIndexOf(String):查找某个字符串最后一次出现的索引，如不存在，返回-1
- int indexOf(String):查找某个字符串第一次出现的索引，如不存在，返回-1
- String toLowerCase():返回一个新串，将原串的所有字符转成小写
- String toUpperCase():返回一个新串，将原串的所有字符转成大写
- String trim():返回去掉前后的空格后的新串
- static String valueOf(Object):将其它类型转成String
- boolean equals(Object):与某个对象进行比较，如果内容相同，返回true,否则返回false
- boolean equalsIgnoreCase(Object):忽略大小写，比较内容是否相同；
【编程题】
5.定义一个方法，求出字符串中有多少种字符，以及每个字符的个数
static void printCharInfo(String str)
例如有字符串 str="apple is a apple.";
结果应该是 a:3 p:4 l:2 e:2 :3 i:1 s:1 .:1（换行了的）
public class Test6 {
static void printCharInfo(String str) {
char[] a = new char[100];
int[] b = new int[100];
char[] ch = str.toCharArray();
int index = 0;
for(int i = 0;i6.字符串右移n位,例如 “hello world” 右移两位后"ldhello wor"
要求写一个方法实现此功能,方法的格式是
String moveToRight(String str,int position)
str:需要移动的字符串
p:右移的位数
public class Test9 {
//字符串右移n位,例如 “hello world” 右移两位后"ldhello wor"
public static String moveToRight(String str,int position) {
String left = str.substring(0,str.length()-position);
String right = str.substring(str.length()-position);
return right+left;
}
public static void main(String[] args) {
String str="hello world";
System.out.println(moveToRight(str,2));
}
}
7.【编程题】若可以从一个源字符串中， 找到一个相符的字符串(忽略大小写)， 则返回第一个字符的索引位置，否则返回-1。
int stringAt(String str,String subStr)
public class Test10 {
public static int stringAt(String str,String subStr){
if(str.toLowerCase().contains(subStr.toLowerCase())){
return str.toLowerCase().indexOf(subStr.toLowerCase());
}else{
return -1;
}
}
public static void main(String[] args) {
String str = "asdgafHellosldfld";
String subStr = "hello";
System.out.println(stringAt(str,subStr));
String subStr2 = "fklashf";
System.out.println(stringAt(str,subStr2));
}
}8.【编程题】编写一个方法，判断一个字符串是否是回文
str.equals(new StringBuffer(str).reverse().toString())
9.如下字符串,01#张三#20-02#李四#30-03#王五#40。。。。。。,解析每个人分数多少。样式如下：
01 张三 20
02 李四 30
03 王五 40。并且计算总分。public class Test12{
public static void grade(String str){
String string[] = str.split("-");
for (int i=0;i10.【编程题】已知字符串：“this is a test of java”.
按要求执行以下操作：
(1) 统计该字符串中字母s出现的次数
(2) 取出子字符串"test"
(3) 用多种方式将本字符串复制到一个字符数组Char[] str中.
(4) 将字符串中每个单词的第一个字母变成大写， 输出到控制台。
(5) 用两种方式实现该字符串的倒叙输出。(用StringBuffer和for循环方式分别实现)
(6) 将本字符串转换成一个字符串数组，要求每个数组元素都是一个有意义的额英文单词,并输出到控制台
public class Test13 {
public static void main(String[] args) {
String str = "this is a test of java";
//----------------4----------------------
/*String s = "";
//是否要改大写
boolean b = true;
for(int i = 0;i='a'&&c<='z'||c>='A'&&c<='Z') {
if(b) {
c = (char)(c-32);
s+=c;
b = false;
}else {
s+=c;
}
}else {
b = true;
s+=c;
}
}
System.out.println(s);*/
//----------------6--------------
String[] strs = new String[str.length()];
String s = "";
//是否要将s存储到数组中
boolean b = true;
int index = 0;
for(int i = 0;i='a'&&c<='z'||c>='A'&&c<='Z') {
s+=c;
}else {
if(!"".equals(s))
strs[index++]=s;
s = "";
}
if(i==str.length()-1&&!"".equals(s)){
strs[index++]=s;
}
}
for(int i = 0;i 11.【编程题】获取一个字符串在另一个字符串中出现的次数
例如,获取"kk"在"abkkcdkkefkkskk"中出现的次数
public class Test14 {
public static void main(String[] args) {
String str = "abkkcdkkefkkskk";
System.out.println((str.length()-str.replace("kk", "").length())/2);
}
}12.【编程题】拟一个trim方法，去除字符串两端的空格
思路：
1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止,结尾处判断空格也是如此。
2，当开始和结尾都判断到不是空格时，就是要获取的字符串。
public class Test15 {
public static void main(String[] args) {
String str = " a a a ";
for(int i = 0;i=0;i--) {
if(str.charAt(i)!=' ') {
str = str.substring(0,i+1);
break;
}
}
System.out.println(str);
}
} 13.【编程题】将一个字符串进行反转
将字符串中指定部分进行反转，“abcdefgeee”;
replace(str,start,end)
思路：
1，曾经学习过对数组的元素进行反转。
2，将字符串变成数组，对数组反转。
3，将反转后的数组变成字符串。
4，只要将或反转的部分的开始和结束位置作为参数传递即可。
public class Test16 {
public static void main(String[] args) {
String str = "abcdefgeee";
System.out.println(replace(str,1,3));
}
public static String replace(String str,int start,int end) {
if(str!=null&&str.length()>0) {
String s1 = str.substring(0,start);
String s2 = str.substring(start,end+1);
String s3 = str.substring(end+1);
return s1+new StringBuffer(s2).reverse()+s3;
}
return str;
}
}14.【编程题】获取两个字符串中最大相同子串
例如找到字符串"abcwerthelloyuiodef"和"cvhellobnm"中的最大相同字串
此题，应该从子串的长度考虑。
思路：
1，将短的那个子串按照长度递减的方式获取到。
2，将每获取到的子串去长串中判断是否包含，如果包含，已经找到！。
public class Test18 {
public static void main(String[] args) {
String s1 = "abcwerthelloyuiodef";
String s2 = "cvhellobnm";
String max = "";
String sub = "";
for(int i = 0;imax.length())
max = sub;
}else {
break;
}
}
}
System.out.println(max);
}
} 15.【编程题】给你一组字符串如：iu7i8hy4jnb2，让你编程输出里面的数字：
public class Test17 {
public static void main(String[] args) {
String s = "iu7i8hy4jnb2";
for(int i = 0;i='0' && s.charAt(i)<='9') {
System.out.println(s.charAt(i));
}
}
}
} 16.【编程题】假设字符串类似这样的aba和aab就相等，现在随便给你二组字符串，请编程比较他们看是否相等
public class Test19 {
public static void main(String[] args) {
String s1 = "aba";
String s2 = "aab";
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
Arrays.sort(c1);
Arrays.sort(c2);
System.out.println(Arrays.equals(c1, c2));
}
}String类
字符串是内容不可改变的字符序列，在字符串类中封装了一个char[] ；在JDK10后字符串中封装的是byte[]了字符序列：String类实现了CharSequence接口
内容不可改变：在使用 String 类的一些 API 方法时，如果这个方法是改变字符串内容的方法，这个方法一定会返回一个新的字符串，例如截取字符串、替换字符串等方法
对字符串的操作其实就是对 byte[] 数组内容的操作。
字符串类的常用方法：
1. charAt(int index) 方法 : 返回一个 char 值，获得指定位置的 char 值
public static void main(String[] args) {
String str = "abcdef";
/*char c = str.charAt(2);
System.out.println(c);*/
String str2 = "";
for(int i = str.length()-1;i>=0;i--){
char c = str.charAt(i);
str2 = str2 + c;
}
System.out.println(str2);
} 2. indexOf(String str) 方法：返回第一次出现的指定字符串在字符串中的位置。
String str = "abcdefbcdbcdef";
int index = str.indexOf("bcd"); //1
index = str.indexOf("db"); //8
System.out.println(index); lastIndexOf(String str) 方法：返回最后一次出现的指定字符串在字符串中的位置。
public static void main(String[] args) {
String str = "abcdefbcdbcdef";
int index = str.lastIndexOf("bcd"); //9
System.out.println(index);
index = str.lastIndexOf("db"); //8
System.out.println(index);
} 3. substring(int start) 方法 : 从指定位置到最后，获得字符串的子串
String str = "abcdefbcdbcdef";
String str2 = str.substring(8);
System.out.println(str2); substring(int start,int end) 方法 ：从指定索引范围，获得子串，包含 start 不包含 end
String str = "abcdefbcdbcdef";
String str2 = str.substring(8,10); //db
System.out.println(str2); 4. split(String str) 方法： 根据指定的字符串，对字符串进行拆分，结果是字符串数组。
String str = "abcdefbcdbcdef";
String[] strs = str.split("c");
for(int i = 0;i5. compareTo(String str)方法：按字典顺序比较两个字符串。compareToIgnoreCase(String str)方法：忽略大小写比较。
String str = "abc";
System.out.println(str.compareTo("abd")) 6. concat(String str) 方法：将指定的字符串连接到字符串的末尾。当连接空字符串 ( 长度为 0 的字符串 ) 时，返回 当前的字符串，并不创建新的字符串。
String str = "abc";
//连接def字符串
//String str2 = str+"";
//System.out.println(str==str2); //false
String str2 = str.concat("");
System.out.println(str==str2); //true 7. contains(String str) 方法：指定字符串是否是字符串的子串
String[] strs = {"张天师","李晓旭","张天昊","张旭","李天使","张李李"};
//查询出含有天字的姓名
for(int i = 0;i 8. getBytes() : 根据平台默认的字符集将字符串编码成 byte[] , getBytes(String charset) ：指定字符集将字符串 编码为 byte[]
public static void main(String[] args) {
//将字符串 通过网络传给其他的程序，将字符串编码为二进制(byte[])
String str1 = "你好啊";
byte[] bytes = str1.getBytes(); //编码 encoding
//其他的程序 获得字符串输出
String str2 = new String(bytes); //解码 decoding
System.out.println(str2);
}
public static void main(String[] args) throws UnsupportedEncodingException {
//将字符串 通过网络传给其他的程序，将字符串编码为二进制(byte[])
String str1 = "你好啊";
byte[] bytes = str1.getBytes("GBK"); //编码 encoding
System.out.println(bytes.length);
//其他的程序 获得字符串输出
String str2 = new String(bytes,"GBK"); //解码 decoding
System.out.println(str2);
} 9. String.join(CharSequence delimiter, CharSequence ... elements) 方法： 其中的 CharSequence ...
elements 代表可以传入多个 CharSequence 的实参
String message = String.join("-", "Java", "is", "cool");
// message returned is: "Java-is-cool" 10. replace(String old,String new) 方法 : 将子串串全部替换另一个字符串
public static void main(String[] args) throws UnsupportedEncodingException {
String str1 = "ab1cde1sddf1sddf1aa1";
String str2 = str1.replace("1","0");
System.out.println(str2);
} 11. trim() 方法：去掉字符串的前后空格。
12. String.valueOf( 各种类型 ) 方法： 将各种类型的对象 / 数据 ，转为字符串
public static void main(String[] args) {
//将一个对象 转为字符串形式
Object obj = new Person();
//1. 调用对象的toString方法
System.out.println(obj.toString());
//2. 强制转型 ，只有obj对象是字符串时，可以强制转型
//System.out.println((String)obj);
//3. 使用+和 空字符串连接，默认调用对象的toString方法
System.out.println(obj+"");
//4. 调用String.valueOf(obj)
System.out.println(String.valueOf(obj));
//最安全的 是 方式3和方式4
} 字符串池（ String pool)
是用来存储字符串常量对象的，例如 "abc" 。字符串池中的字符串对象是共享的
public static void main(String[] args) {
String s1 = "abc"; //在字符串池中 创建了"abc"字符串常量对象
String s2 = "abc"; //字符串池中有"abc"字符串常量对象，交给s2引用
System.out.println(s1==s2); // true
String s3 = new String("abc"); //创建在堆内存中
String s4 = new String("abc"); //创建在堆内存中
System.out.println(s3==s4); //false
}
public static void main(String[] args) {
String s1 = "abc";
String s2 = s1+""; //在运行期 只要连接了字符串，一定会创建新的字符串
System.out.println(s1==s2); //false
String s3 = "abc";
String s4 = "abc"+""; //在编译期，编译器可以进行一些基本的运算功能
//也就是在编译期生成的指令是 s4 = "abc";
System.out.println(s3==s4); //true
} String 对象在连接大量字符串时，效率极低
StringBuffffer和StringBuilder
StringBuffffer 是一个带缓冲的、 内容可变的字符序列 ，当要大量改变字符串内容时，效率高。
所谓内容可改变：在改变 StringBuffffer 中的字符内容时，不会创建新的 StringBuffffer 对象
所谓字符序列： StringBuffffer 实现了 CharSequence 接口
public static void main(String[] args) {/*String s1 = "abc";
long start = System.currentTimeMillis();
//1w 31ms
//10w 700ms
//100w 40000ms
for(int i = 0;i<10000;i++){
s1 += "a";
}
long end = System.currentTimeMillis();
System.out.println("连接字符串用时："+(end-start));*/
//1w 1ms
//10w 7ms
//100w 15ms
//1000w 48ms
StringBuffer sb = new StringBuffer();
sb.append("abc");
long start = System.currentTimeMillis();
for(int i = 0;i<10000000;i++){
sb.append("a");
}
long end = System.currentTimeMillis();
System.out.println("StringBuffer连接字符串用时："+(end-start));
} 常用的方法：
1. append(String str) 方法 ： 向 StringBuffffer 的内容中从末尾追加内容。返回当前的 StringBuffffer 对象
public static void main(String[] args) {
//整个过程中 只有一个StringBuffer对象
StringBuffer sb = new StringBuffer("abc");
sb.append("a");
sb.append("e").append("f").append("g");
System.out.println(sb);
} 2. delete(int start,int end) 方法：删除 StringBuffffer 指定范围的内容 .
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("abcdefg");
sb.delete(2,5);
System.out.println(sb);
}
3. insert(int index,String str) 方法：在指定位置插入字符串
4. reverse() 方法：反转内容
5. toString() 方法：获得 StringBuffffer 内容的字符串
StringBuilder
StringBuilder 是内容可改变的字符序列， StringBuilder 的 API 方法和 StringBuffffer 相同。但 StringBuilder 是线程不
安全的，效率高， StringBuffffer 是线程安全的，效率低。
下一篇：15.异常处理