[2017.10.28-29]String类&StringBuffer
来源：互联网 发布：淘宝茶叶属于什么类目 编辑：程序博客网 时间：2024/06/07 23:10
String类
1.String类:
代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现;字符串一旦被赋值,其值不能再改变
2.String类常用的构造方法:
String():表示一个空字符序列。
public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
public String(char[] value):将字符数组构造成一个字符串
public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
public String(String original):通过字符串常量构造一个字符串对象
public int length():获取字符串的长度功能:
3.面试题:
数组中有没有length(),字符串(字符串缓冲区:StringBuffer)中没有length(),集合中有没有length()(集合后面讲)?
数组没有length(),length属性
字符串中有length()
集合中没有length(),获取集合中元素数量:size()
4.编码和解码:一定要保证编码格式一致
编码:
把能看懂的东西转换成一个看不懂的东西:String—–>byte[]:public byte[] getBytes(String charsetName)
解码:
把当前的byte[]转成能看懂的东西(String):byte[]—–>String :pu blic String(byte[] bytes,CharsetName ch)
5.举例:
今天老地方见
编码:”今”—–>字节数组:byte[]—->字节类型:形成一种二进制数据
解码:二进制数据—->十进制进制数据—–>String:”今”
6.演示:
public class StringDemo { public static void main(String[] args) throws UnsupportedEncodingException { //创建一个String对象 String s1 = new String() ; System.out.println("s1.length():"+s1.length()); System.out.println("s1:"+s1); System.out.println("----------------------"); //public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数 //创建一个字节数组 byte[] bys = {97, 98, 99, 100, 101} ; String s2 = new String(bys) ;//字节的值要找它对应的ASCII码表中的字符 System.out.println("s2:"+s2); //abcde System.out.println("s2.length():"+s2.length());//5 System.out.println("----------------------"); /** * 编码和解码 */ //定义一个字符串: String s = "你好" ; //[-60, -29, -70, -61] :GBK //[-28, -67, -96, -27, -91, -67]:utf-8// byte[] bys2 = s.getBytes("utf-8") ;//编码:以:GBK格式编码 utf-8:一个中文:对应三个字节 byte[] bys2 = s.getBytes() ;// System.out.println(bys2); //Arrays:数组工具类:toString(byte[] bys) System.out.println(Arrays.toString(bys2)); System.out.println("-------");// String str = new String(bys2, "utf-8") ; String str = new String(bys2) ; System.out.println("str:"+str); System.out.println("------------------"); //public String(char[] value):将字符数组构造成一个字符串 //定义一个字符数组 char[] chs = {'我','爱','高','圆','圆'} ; String s3 = new String(chs) ; System.out.println("s3.length():"+s3.length()); System.out.println("s3:"+s3); System.out.println("--------------------"); String s4 = new String(chs, 1, 4) ; System.out.println("s4:"+s4); System.out.println("s4.length():"+s4.length()); System.out.println("--------------------"); //public String(String original):通过字符串常量构造一个字符串对象 String s5 = new String("hello") ; System.out.println("s5:"+s5); System.out.println("s5.length():"+s5.length()); String s6 = "hello" ; System.out.println("s6:"+s6); System.out.println("s6.length():"+s6.length()); }}7.字符串的一个特点:
一旦被赋值,其值不能被改变(不可变的字符序列)
8.面试题:
String s = “hello”
和String s = new String(“hello”) 两个有什么区别?分别创建了几个对象?
第一个创建了一个对象;第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))
9.演示:
public class StringDemo { public static void main(String[] args) { String s = "hello" ; // String s = "abc" ; /*s += "world" ; System.out.println("s:"+s);*/ change(s) ; //输出字符串变量 System.out.println("s:"+s); } public static void change(String s) {//String类型作为形式参数和基本数据类型的效果一样 s += "javaweb" ; }}看程序写结果:
public class StringDemo2 { public static void main(String[] args) { //创建字符串对象 String s1 = new String("hello") ; String s2 = new String("hello") ; System.out.println(s1==s2);//false String s3 = "hello" ; String s4 = "hello" ; System.out.println(s3==s4); System.out.println(s3.equals(s4)); String s5 = new String("world") ; String s6 = "world" ; System.out.println(s5==s6); System.out.println(s5.equals(s6)); }}import java.util.Scanner;//提供猜数字游戏的类public class GuessNumberGame { //构造私有,通过静态功能 private GuessNumberGame(){ } //静态功能 public static void start(){ //生成一个随机数:Math.random() ; int number = (int) (Math.random()*100 +1) ; //定义一个统计变量 int count = 0 ; //由于多次录入 while(true){ //创建键盘录入对象 Scanner sc = new Scanner(System.in); System.out.println("请您输入一个数据:"); int guessNumber = sc.nextInt() ; //统计变量++ count ++ ; //判断 if(guessNumber > number){ System.out.println("您猜的数据"+guessNumber+"大了"); }else if(guessNumber < number){ System.out.println("您猜的数据"+guessNumber+"小了"); }else { System.out.println("恭喜您"+count+"次猜中了..."); break ; } } }}10.String类的中常用的判断功能:
boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
boolean contains(String str):判断str这个字符串是否包含在当前字符串中
boolean startsWith(String str):是否以str子字符串开头
boolean endsWith(String str):判断是否以str子字符串结尾
boolean isEmpty():判断字符串是否为空
String s = “” ;空字符
String s = ” ” ;字符串”空格”
String s = null ;当前字符串对象为空
11.演示:
public class StringDemo { public static void main(String[] args) { //定义一个字符串 String s1 = "helloworld" ; String s2 = "HelloWorld" ;// boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同 System.out.println("equals:"+s1.equals(s2)); //boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写 System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2)); //boolean contains(String str):判断str这个字符串是否包含在当前字符串中 System.out.println("contains:"+s1.contains("owo")); System.out.println("contains:"+s1.contains("ak47")); //boolean startsWith(String str):是否以str子字符串开头 System.out.println("starsWith:"+s1.startsWith("hel")); //boolean endsWith(String str):判断是否以str子字符串结尾 自己测试 //boolean isEmpty():判断字符串是否为空 System.out.println("isEmpty:"+s1.isEmpty()); }}看程序,写结果
/** * 字符串变量相加,先开辟空间,在相加 * 字符串常量相加:首先在字符串常量池找,有没有当前这个常量值,有,就直接返回,没有,需要创建! */public class StringDemo2 { public static void main(String[] args) { String s1 = "hello"; String s2 = "world"; String s3 = "helloworld"; System.out.println(s3 == s1 + s2);// false //System.out.println(s3 == (new StringBuilder(String.valueOf(s1))).append(s2).toString());// s1+s2 ====>new String("helloworld") System.out.println(s3.equals((s1 + s2)));//true , System.out.println(s3 == "hello" + "world");//true System.out.println(s3.equals("hello" + "world"));//true /** * 通过反编译工具查看第三个输出语句: * System.out.println(s3 == "helloworld"); System.out.println(s3.equals("helloworld")); * */ }}import java.util.Scanner;/** * 需求:模拟用户登陆,给3次机会,并给提示 * * 分析: * 假设:定义一个用户和密码 * String name = "admin" ; * String password = "admin" ; * 2)创建键盘录入对象,录入用户名和密码 * 3)给3次机会,使用for循环进行操作for(int x = 0 ; x <3 ; x ++){} * * 录入:录入的用户和密码来和已经存在的用户名和密码进行比较, * 判断:如果一致: * 登陆成功 * 不一致: * 有一个不符合,就登陆不成功 * if((2-x)==0){ * }else{ * //输出还有(2-x)次机会 * } * */public class StringTest { public static void main(String[] args) { //定义用户名和密码 String name = "admin" ; String password = "admin" ; //给3次机会 for(int x = 0 ; x <3 ; x ++){ //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; System.out.println("请输入用户名: "); String newUserName = sc.nextLine() ; System.out.println("请输入密码:"); String newPassword = sc.nextLine() ; //判断 if(name.equals(newUserName) && password.equals(newPassword)){ //一致了 System.out.println("登陆成功,开始玩游戏...."); //加入猜数字游戏 GuessNumberGame.start() ; break ; }else{ //登陆不成功 //2,1,0 //如果是0次机会了,换一种提示 if((2-x)==0){ System.out.println("速与管理员联系..."); }else{ //不是0次 System.out.println("你还有:"+(2-x)+"次机会"); } } } }}12.String类的获取功能:
int length() :获取字符串长度功能
char charAt(int index):返回的是索引处对应的字符
int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
为什么这里的字符用int来定义: 97 ‘a’
int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索
String substring(int start):从指定位置开始截取字符串,默认截取到末尾
String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
13.演示:
public class StringDemo { public static void main(String[] args) { //定义一个字符串: String str = "helloworld" ; //int length() :获取字符串长度功能 System.out.println("length:"+str.length()); //char charAt(int index):返回的是索引处对应的字符 System.out.println("charAt:"+str.charAt(1)); System.out.println("charAt:"+str.charAt(8)); System.out.println("-------------------------------"); //int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引 System.out.println("indexof:"+str.indexOf('l')); System.out.println("indexof:"+str.indexOf('k'));//-1 //int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引 System.out.println("indexOf:"+str.indexOf("owo")); System.out.println("-------------------------------"); //int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 System.out.println("indexOf:"+str.indexOf('l', 4)); //int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索 (自己测试) //String substring(int start):从指定位置开始截取字符串,默认截取到末尾(返回一个新的字符串,不再是字符串本身!) System.out.println("substring:"+str.substring(5)); //String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引) System.out.println("substring:"+str.substring(4, 8));//owor }}14.字符串的遍历
String str = “helloworld” ;
15.演示:
public class StringTest { public static void main(String[] args) { //定义字符串 String s = "helloworld" ; //最原始的做法 /* System.out.println(s.charAt(0)); System.out.println(s.charAt(1)); System.out.println(s.charAt(2)); System.out.println(s.charAt(3)); System.out.println(s.charAt(4)); System.out.println(s.charAt(5)); System.out.println(s.charAt(6)); System.out.println(s.charAt(7)); System.out.println(s.charAt(8)); System.out.println(s.charAt(9));*/ /** * 由于代码的重复度高,所以使用for循环 * 使用String类的length()和charAt()相结合 */ for(int x = 0 ; x < s.length() ; x ++){ System.out.print(s.charAt(x)+" "); } }}/** * 把数组中的数据按照指定个格式拼接成一个字符串举例： * int[] arr = {1,2,3}; 输出结果：[1, 2, 3] * * 分析: * 1)定义数组:int[] arr = {1, 2, 3} * 2)定义空字符串:String s = "" ; * 3)用空串拼接一个"[" * 4)遍历int类型的数组,获取到每一个数组中的元素 * 判断当前某一个索引是否是最大索引 * 如果是:用空串+= arr[x] ; * 用空串 +="]"; * 不是: * 用空串+= arr[x] * 用空串+= ", " * */public class StringTest2 { public static void main(String[] args) { //1)定义一个数组,静态初始化 int[] arr = {1, 2, 3} ; //将这个数组转换成字符串最终来封装成功能 String result = arrayToString(arr); //直接输出 System.out.println("result:"+result); } /** * 两个明确 * 明确返回值类型:String类型 * 明确参数类型:int int[] arr * */ public static String arrayToString(int[] arr){ //定义一个空字符串 String result = "" ; //拼接左中括号 result += "[" ; //遍历数组 for(int x = 0 ; x < arr.length ; x ++){ //判断 if(x==arr.length-1){ result += arr[x] ; result += "]" ; }else{ result += arr[x] ; result += ", " ; } } return result ; }}import java.util.Scanner;/** * 需求：使用键盘录入一个字符串:统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符) * * 举例: * "Hello123World" * * 大写字母字符:2个 * 小写字母字符:8个 * 数字字符:3个 * * 分析: * 1)定义三个统计变量 * int bigCount = 0 ; * int smallCount = 0 ; * int numberCount = 0 ; * 2)创建键盘录入对象,录入一个字符串 * 3)使用for循环遍历字符串 * 4) * ASCII码表中 * 'a' 97 * 'A' 65 * '0' 48 * 遍历的时候获取到字符 * ch>='a' && ch<='z' * 属于小写字母字符 * smallCount++; * ch>='A' && ch<='Z' * 属于大写字母字符 * bigCount++ * ch>='0' && ch<='9' * 属于数字字符 * numberCount++ * * 5)输出 * * */public class StringTest3 { public static void main(String[] args) { //创建三个统计遍历 int bigCount = 0 ; int smallCount = 0 ; int numberCount = 0 ; //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //录入并接收 System.out.println("请输入一个字符串:"); String line = sc.nextLine() ; //遍历字符串 for(int x = 0 ; x <line.length() ; x++){ //获取每一个字符 char ch = line.charAt(x) ; //对当前的这个字符进行判断 if(ch>='a' && ch<='z'){ //小写字母字符 smallCount ++ ; }else if(ch>='A' && ch <='Z'){ //大写字母字符 bigCount++ ; }else if(ch>='0' && ch <='9'){ //数字字符 numberCount ++ ; } } //输出结果 System.out.println("当前字符串中大写字母字符共有:"+bigCount+"个"); System.out.println("当前字符串中小写字母字符共有:"+smallCount+"个"); System.out.println("当前字符串中数字字母字符共有:"+numberCount+"个"); }}16.String类的转换功能(重点)
byte[] getBytes():将字符串转换字节数组
char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
static String valueOf(char[] chs):将字符数组转换成字符串
static String valueOf(int i):将一个int类型的数据转换成字符串
注意:
String类中的valueOf()可以将任何数据类型转换成字符串
String toLowerCase():将字符串全部转成小写
String toUpperCase():将字符串全部转换成大写
String concat(String str):字符串拼接方法
17.演示:
public class StringDemo { //构造方法: //构造方法不能使用递归 /*public StringDemo(){ StringDemo(); }*/ public static void main(String[] args) { //定义一个字符串 String s = "JavaSE" ; //byte[] getBytes():将字符串转换字节数组 byte[] bys = s.getBytes() ; //遍历字节数组 for(int x = 0 ; x < bys.length ; x++){ System.out.println(bys[x]); } System.out.println("---------------------"); //char[] toCharArray():将字符串转换成 字符数组 char[] chs = s.toCharArray() ; for (int x = 0; x < chs.length; x++) { System.out.println(chs[x]); } System.out.println("---------------------"); //static String valueOf(char[] chs):将字符数组转换成字符串 String s2 = String.valueOf(chs) ; System.out.println("s2:"+s2); //static String valueOf(int i):将一个int类型的数据转换成字符串 String s3 = String.valueOf(100) ; System.out.println("s3:"+s3); //String toLowerCase():将字符串全部转成小写 System.out.println("toLowerCase:"+s.toLowerCase()); //String toUpperCase():将字符串全部转换成大写 System.out.println("toUpperCase:"+s.toUpperCase()); //String concat(String str):字符串拼接方法 String s4 = "hello" ; String s5 = "world" ; System.out.println("contact:"+s4.concat(s5)); String s6 = "java" ; s6 += "web" ; System.out.println("s6:"+s6); /** *方法嵌套 * Math.max(Math.max(a,b),c); * *方法递归:方法调用本身的一种现象 * * 三个条件: * 1)需要定义个方法 * 2)方法必须有出口条件 * 3)必须有某一种规律 * public void show(int n){ * * if(n<0){ * System.exit(0) ; //让jvm退出,程序结束 * } * * System.out.println(n) ; * show(--n) ; * } * */ System.out.println("--------------------"); //需求:求5的阶乘 //5! = 5 * 4 * 3 * 2 * 1 ; //5! = 5 * 4! ; int jc = 1 ; //循环思想 for(int x = 2 ; x <=5 ; x ++){ jc *= x; } System.out.println("5的阶乘是:"+jc); System.out.println("-------------------------"); //使用递归的思想: //需要定义个方法 System.out.println("5的阶乘是:"+jieCheng(5)); } /** * 明确返回值类型: * int类型 * 参数类型:int类型的值 * * 2)出口条件: * if(n==1){ * return 1 ; * } * * 3)要有规律 * if(n!=1){ * return n* 方法名(n-1); * } * */ public static int jieCheng(int n){ if(n==1){ return 1 ; }else{ return n* jieCheng(n-1) ; //5 * 4 * 3 * 1 *１ } }}18.String类中的其他功能:
1)替换功能:
public String replace(char oldChar,char newChar):将字符串中某一 个字符用新的字符替换
public String replace(String oldStr,String newStr):将字符串中某一 个子字符串用新 的字符串去替代
2)去除字符串两端空格:
public String trim()
3)两个字符串进行比较:
public int compareTo(String anotherString) 是Comparable接口 中的方法(该接口可以实现一个自然排序)
4)Comparator接口可以比较器排序
19.演示:
public class StringDemo { public static void main(String[] args) { //定义字符串 String s1 = "helloworld" ; //替换功能// public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换// String s2 = s1.replace('l', 'k') ;// System.out.println("s:"+s2); //public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代 String s3 = s1.replaceAll("owo", "ak47") ; System.out.println("s3:"+s3); System.out.println("------------------"); String s4 = " hello world " ; System.out.println("s4:"+"----"+s4+"----"); //public String trim() String s5 = s4.trim() ; System.out.println("s5:"+"----"+s5+"----"); //public int compareTo(String anotherString) String s6 = "hello" ; String s7 = "hello" ; String s8 = "abc" ; System.out.println("compareTo():"+s6.compareTo(s7)); System.out.println("compareTo():"+s6.compareTo(s8)); }}import java.util.Scanner;/** * 需求:键盘录入一个字符串,将该字符串的第一个字母转换成小写,其余的字母字符转换成大写(不考虑其他的字母字符) * * 举例: "Helloworld" * * H--->h * elloworld--->ELLOWORLD * * 分析: * A:创建键盘录入对象,录入一个字符串 * B:截取:substring(int begin,int end) * C:将上面获取的字符串转换小写 * D:在截取刚才录入的这个字符串,substring(int begin):从指定位置截取到末尾,返回一个新的字符串 * E:将的得到新的字符串---->转换大写 * F:将C和E,使用concat()拼接:字符串拼接方法 * */public class StringTest { public static void main(String[] args) { //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //录入并接收数据 System.out.println("请您输入一个字符串:"); String line = sc.nextLine() ; //将接收到的字符串截取 String s1 = line.substring(0, 1) ; //将得到s1字符串转换成小写 String s2 = s1.toLowerCase() ; //在将line字符串的其余字母字符截取出来 String s3 = line.substring(1) ; //转换成大写 String s4 = s3.toUpperCase() ; //s2和s4作品接 String result = s2.concat(s4) ; System.out.println("result:"+result); System.out.println("------------------------------"); //链式编程 String result2 = line.substring(0, 1).toLowerCase().concat(line.substring(1).toUpperCase()) ; System.out.println("result2:"+result); }}20.遇到:看源码:comparTo()的源码
public class StringTest2 { public static void main(String[] args) { //定义两个字符串 String s1 = "hello" ; String s2 = "hel" ; System.out.println("compareTo():"+s1.compareTo(s2)); }}//在底层代码中,一个字符串会自动会转换成字符数组
private final char value[];
//s1= “helloworld” ;
//s2= “hel” ;
//将s1和s2的字符串自动转换成了字符数组
//s1:’h’,’e’,’l’,’l’,’0’
//s2:’h’,’e’,’l’
public int compareTo(String anotherString) {anotherString==>s2=”hel”
int len1 = value.length; //s1.length= 5 int len2 = anotherString.value.length;// s2.length: = 3 int lim = Math.min(len1, len2);// Math.min(5,3) ;=====>int lim = 3 ; char v1[] = value;//'h','e','l','l','0' char v2[] = anotherString.value;//"hel" int k = 0; while (k < lim) {k< lim=3 char c1 = v1[k];// char c1 = 'h','e','l','l','0' = v1[k] = 'h' char c2 = v2[k];//char c2 = 'h','e','l' = v2[k] = 'h' if (c1 != c2) { return c1 - c2; } k++; } return len1 - len2; // len1 - len2 = s1.length() - s2.lenth() = 5 -3 = 2 }21.演示:
import java.util.Scanner;/** * 需求:键盘录入一个字符串,将字符串进行反转 * * 举例: * "abc"--->"cba" * * 分析: * 1)创建键盘录入对象,录入并接收一个字符串 * 2)定义空字符串 * 3)可以将字符串转换成字符数组:toCharArray(); * 4)遍历字符数组,倒着遍历 * 5)遍历之后获取到字符串中的每一个字符,然后使用空串进行拼接 * 6)输出即可! * @author Apple */public class StringTest3 { public static void main(String[] args) { //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //录入数据并接收数据 System.out.println("请您输入一个字符串:"); String line = sc.nextLine() ; /* //定义一个空字符串 String result = "" ; //将字符串转换成字符数组 char[] chs = line.toCharArray() ; //遍历字符数组,倒着遍历 for(int x = chs.length-1; x >=0 ; x --){ //获取到每一个字符 result+= chs[x] ; }*/ String result = myReverse(line) ; //输出 System.out.println("result:"+result); } //写一个功能实现 public static String myReverse(String s){ //定义空字符串 String result = "" ; //将字符串字符数组 char[] chs = s.toCharArray() ; //遍历字符数组 for(int x = chs.length -1 ; x >=0; x --){ //拼接每一个字符 result+= chs[x]; } return result ; }}StringBuffer
1.线程
1)线程安全—->同步—->执行效率低!
举例:
银行的网站,医院的平台
2)线程不安全—>不同步—>执行效率高
举例:
一些论坛网站,相亲网站..
3)在实际开发中,线程不安全可能会造成死锁的现象!
线程安全和执行效率是相对的,并且也是困扰开发者的因素!
4)StringBuffer:线程安全的可变字符序列
面试题:
StringBuffer和String 的区别?
StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代
StringBuffer:线程不安全,单线程单纯为了提供执行效率!)
String:普通的一个字符串,从内存角度考虑,耗费空间!StringBuffer的构造方法:
public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
public StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。
4.常用的功能:
public int length():获取字符串长度数
public int capacity():获取当前字符串缓冲区的容量
5.演示:
public class StringBufferDemo { public static void main(String[] args) {// StringBuffer sb = "hello" ;// String s = "hello" ;// StringBuffer sb = s ;// public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符 //创建一个字符串缓冲区对象 StringBuffer sb = new StringBuffer() ; System.out.println("sb.length:"+sb.length()); System.out.println("sb.capacity:"+sb.capacity());//16 System.out.println("----------------------------"); // public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区 StringBuffer sb2 = new StringBuffer(50) ; System.out.println("sb2.length:"+sb2.length()); System.out.println("sb2.capacity:"+sb2.capacity());//50 System.out.println("----------------------------"); StringBuffer sb3 = new StringBuffer("hello") ; System.out.println("sb3.length:"+sb3.length()); System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度 }}6.StringBuffer中的和添加有关的方法
1)public StringBuffer append(int/String/char/boolean/double/float….):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
2)public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
7.演示:
public class StringBufferDemo2 { public static void main(String[] args) { //创建一个字符串缓冲区对象 StringBuffer sb = new StringBuffer() ; //追加数据 /* sb.append("hello") ; sb.append(true) ; sb.append(13.45) ; sb.append('A') ; sb.append(12.56F);*/ //链式编程 sb.append("hello").append(true).append(13.45).append('A').append(12.56F); //public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身 sb.insert(5, "world") ; //输出 System.out.println("sb:"+sb); }}8.StringBuffer的删除功能:
public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!
9.演示:
public class StringBufferDemo3 { public static void main(String[] args) { //创建字符串缓冲区对象 StringBuffer sb = new StringBuffer() ; //给缓冲区追加数据 sb.append("hello") ; sb.append("world") ; sb.append("java") ; ////public StringBuffer deleteCharAt(int index) //需求:要删除当前缓冲区中'e'这个字符// sb.deleteCharAt(1) ; //需求:要删除当前缓冲区中第一个'l'这个字符// sb.deleteCharAt(1) ;// public StringBuffer delete(int start,int end)// sb.delete(5, 9) ; //从0索引开始,当前缓冲的字符串全部删除掉 sb.delete(0, sb.length()) ; //输出 System.out.println("sb:"+sb); }}10.StringBuffer的反转功能:
public StringBuffer reverse():将此字符串中的字符序列直接反转
11.演示:
import java.util.Scanner;public class StringBufferDemo4 { public static void main(String[] args) { //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //录入并接收数据 System.out.println("请您输入一个字符串:"); String line = sc.nextLine() ; //可以创建字符串缓冲区对象 StringBuffer sb = new StringBuffer(line) ; //public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String //反转功能 String result = sb.reverse().toString() ; System.out.println("result:"+result); }}12.StringBuffer的替换功能:
public StringBuffer replace(int start, int end,String str)
从指定位置开始到指定位置结束的字符用str子字符串去替代
13.演示:
public static void main(String[] args) { //创建字符串缓冲区对象 StringBuffer sb = new StringBuffer() ; //给缓冲添加数据 sb.append("hello") ; sb.append("world") ; sb.append("java") ; //public StringBuffer replace(int start, int end,String str) sb.replace(5, 10, "节日快乐") ; System.out.println("sb:"+sb); }}14.StringBuffer的截取功能:
public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串
15.演示:
public class StringBufferDemo6 { public static void main(String[] args) { //创建字符串缓冲区对象 StringBuffer sb = new StringBuffer() ; //添加 sb.append("hello") ; sb.append("world") ; sb.append("java") ; //public String substring(int start)// String s1 = sb.substring(5) ;// System.out.println("s1:"+s1); //public String substring(int start,int end) String s2 = sb.substring(5,10) ; System.out.println("s2:"+s2); System.out.println("sb:"+sb); }}16.面试题:
String,StringBuffer,StringBuilder的区别?
String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
从线程角度考虑:
StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快
String和StringBuffer作为形式参数:
String类型作为形式参数和基本数据类型作为形式参数的效果一样
17.演示:
public static void main(String[] args) { //定义两个字符串 String s1 = "hello" ; String s2 = "world" ; System.out.println(s1+"---"+s2); change(s1,s2) ; System.out.println(s1+"---"+s2); //定义两个字符串缓冲区对象 StringBuffer sb1 = new StringBuffer("hello") ; StringBuffer sb2 = new StringBuffer("world") ; System.out.println(sb1+"---"+sb2);//hello---world change(sb1,sb2); System.out.println(sb1+"---"+sb2);//hello---worldworld //缓冲区是不变 } public static void change(StringBuffer sb1 ,StringBuffer sb2){ sb1 = sb2 ; //缓冲区不变"world" sb2.append(sb1) ;//worldworld } public static void change(String s1,String s2){ s1 = s2 ; s2 = s1 + s2 ; }}18.类与类之间的转换
A类型—>B类型
这里面可能最终使用B类型里面的功能
B类型—>A类型
有时候需要的不是B类型,所以又要将B类型–>A类型
StringBuffer—>String之间的相互转换
19.面试题:
StringBuffer和数组的区别?
两个共同特点:都属于容器类型的变量
数组:只能存储同一种数据类型的元素,数组的长度是固定的
int[] arr = {10,20,40,50,”hello”} 错误的
StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串
20.演示:
public class StringBufferTest { public static void main(String[] args) { //String--->StringBuffer //定义一个字符串 String s = "hello" ; /*StringBuffer sb = "hello" ; StringBuffer sb = s ;*/ //方式1)使用StringBuffer的构造方式:StringBuffer(String str) //创建一个字符串缓冲区并指向这个字符串 StringBuffer sb = new StringBuffer(s) ; System.out.println("sb:"+sb); //方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append() StringBuffer sb2 = new StringBuffer() ; sb2.append(s) ; System.out.println("sb2:"+sb2); System.out.println("--------------------"); //StringBuffer--->String //有一个字符串缓冲区对象 StringBuffer buffer = new StringBuffer("world") ; //1)方式1String的另一种构造方法:String(StringBuffer buffer) String s2 = new String(buffer) ; System.out.println("s2:"+s2); //2)方式2:/public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String String s3 = buffer.toString() ; System.out.println("s3:"+s3); }}/** * 将数组拼接成一个字符串,分别使用String和StringBuffer实现(定义功能方法) * * int[] arr = {11,55,33 ,44 ,22} ; * 形成这样一个字符串:[11, 55, 33, 44, 22] * 分析: * 1)存在一个数组,静态初始化 * 2)分别使用String和StringBuffer类型去完成 * * @author Apple */public class StringBufferTest2 { public static void main(String[] args) { //定义一个数组,静态初始化! int[] arr = {11,55,33,44,22} ; //方式1)使用String类型实现 String result = arrayToString(arr) ; System.out.println("result:"+result); System.out.println("------------------------"); //方式2:使用StringBuffer的append功能 String result2 = arrayToString2(arr) ; System.out.println("result2: " + result2); } public static String arrayToString2(int[] arr){ //1)创建字符串缓冲区对象 StringBuffer sb = new StringBuffer() ; //sb对象追加左中括号 sb.append("[") ; //遍历数组 for(int x = 0 ; x < arr.length ; x ++){ //判断是否是最大索引 if(x==arr.length-1){ //append追加 sb.append(arr[x]); }else{ sb.append(arr[x]).append(", ") ; } } sb.append("]") ; return sb.toString() ; //将StringBuffer--->String } /** * 明确返回值类型:String * 明确参数类型:int[] arr */ public static String arrayToString(int[] arr){ //定义一个空字符串 String result = "" ; //拼接左中括号 result +="[" ; //遍历int数组 for(int x = 0 ; x < arr.length ; x ++){ //判断是否最大索引 if(x==arr.length-1){ //拼接元素以及"]" result += arr[x] ; result += "]" ; }else{ result += arr[x] ; result += ", " ; } } return result ; }}import java.util.Scanner;/** * 分别使用String和StringBuffer实现字符串的反转 * @author Apple */public class StringBufferTest3 { public static void main(String[] args) { //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //录入并接收 System.out.println("请您输入一个字符串:"); String str = sc.nextLine() ; //方式1:使用String类型进行拼接 String result = myReverse(str) ; System.out.println("result:"+result); //方式2:使用StringBuffer的reverse()功能 String result2 = myReverse2(str) ; System.out.println("result2:"+result2); } //StringBuffer的rever()方法实现 public static String myReverse2(String s){ //创建字符串缓冲区对象h /*StringBuffer sb = new StringBuffer(s) ; //开始调用反转功能 sb.reverse() ; //返回 return sb.toString() ;*/ //一步完成: return new StringBuffer(s).reverse().toString() ; } //String类型的方式进行反转 public static String myReverse(String s){ //定义空串 String result = "" ; //可以字符组其转成字符数组 char[] chs = s.toCharArray() ; //倒着遍历 for(int x = chs.length-1 ; x >=0 ; x --){ //空串进行拼接 result += chs[x] ; } return result ; }}import java.util.Scanner;/** * 1判断一个字符串是否是对称字符串 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串 使用(String和StringBuffer实现这个功能) 分析: 用第一个字符和倒数第一个字符相比较 用二个字符和倒数第二个字符进行比较 ... * @author Apple */public class StringBufferTest4 { public static void main(String[] args) { //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //录入并接收数据 System.out.println("请您输入一个字符串:"); String line = sc.nextLine() ; //方式1:String类型的转换功能 boolean flag = isSame(line) ; System.out.println("flag:"+flag); //方式2:间接的使用StringBuffer的reverse()功能 boolean flag2 = isSame2(line) ; System.out.println("flag2:"+flag2); } public static boolean isSame2(String s){ //直接一步 //new StringBuffer(s).reverse().toString()--->StirngBuffer--->String return new StringBuffer(s).reverse().toString().equals(s) ; } /** * 两个明确: * 返回值类型:boolean * 参数类型:String s */ /*public static boolean isSame(String s){ //将字符串转换成字符数组 char[] chs = s.toCharArray() ; for(int start = 0,end = chs.length -1 ; start<=end;start++,end--){ //判断 if(chs[start] != chs[end]){ return false ; } } return true ; }*/ public static boolean isSame(String s){ //定义一个标记:假设返回值是true boolean flag = true ; //需要字符串转换成字符数组 char[] chs = s.toCharArray(); //遍历字符数组,获取前面索引对应的字符和后面索引的字符 for(int start = 0 ,end = chs.length -1 ; start<=end ; start++,end--){ //判断 if(chs[start]!= chs[end]){ //修改标记 flag = false ; break ; } } return flag ; }}阅读全文
0 0
- [2017.10.28-29]String类&StringBuffer
- String类、StringBuffer类
- String 与 StringBuffer类
- String StringBuffer类
- String和StringBuffer类
- String类和StringBuffer
- String和StringBuffer类
- StringBuffer，String类
- String&stringBuffer&包装类
- StringBuffer类和String
- StringBuffer类和String
- String、StringBuffer类
- String和StringBuffer类
- String&StringBuffer类转换
- string类 stringBuffer stringBuilder
- String StringBuffer StringBuilder类
- String、StringBuffer、StringBuffer类的区别
- String类和StringBuffer类
- 配置osg开发环境-win7+vs2015+osg
- 输入一个实数，并输出该数的绝对值
- The JAVA_HOME environment variable does not point to a working JDK or JRE.
- Hibernate 基本类型
- 标签控制器的简单使用
- [2017.10.28-29]String类&StringBuffer
- luoguP1758 管道取珠（bzoj1566）（dp+x^2的转化）
- SSH配置文件
- photoView查看大图,单击退出
- hdu 5120 Intersection (圆面积交)
- GitHub -- Git的导入
- 统计学习方法
- android 自定义view的简单实例
- vmware安装centos7时无法联网问题
