黑马程序员------String类

最新推荐文章于 2022-11-29 13:49:05 发布

xiaoya0o0o

最新推荐文章于 2022-11-29 13:49:05 发布

阅读量430

点赞数

分类专栏： java 文章标签： java 黑马程序员

本文链接：https://blog.csdn.net/xiaoya0o0o/article/details/48582309

版权

java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

------ <a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

1.String

1.1 string类

*java.lang.String类：String 类代表字符串。Java 程序中的所有字符串字面值（如"abc" ）都作为此类的实例实现。

* 1.此类被定义为final，不能被继承；

* 2.在Java中，"字符串"是用String类的对象表示的；

* 3.字符串是常量；它们的值在创建之后不能更改。

*4.String内部，就是使用"字符数组"处理；

*5.String对象实例化的方式比较特殊：

* 1).String s = "abc";//OK的

* 2).String s1 = newString("abc");//OK的

*6.String类的构造方法：

* public String()：构造一个零长度字符串；会产生对象空间，不是空指针；

publicString(byte[] bytes)：将一个byte[]数组(每个byte值作为一个ASCII码值，查找对应的字符)转换为一个String；

publicString(byte[] bytes,int offset,int length)：将一个byte[]数组的一部分转换为String。

publicString(char[] value):将一个char[]数组转换为一个String;

publicString(char[] value,int offset,int count):将一个char[]数组的一部分转换为String

publicString(String original):用一个String构造一个String

7.成员方法：

public int length():获取内部字符的长度；

public class Demo {
	public static void main(String[] args) {
		//1.public String()：构造一个零长度字符串；会产生对象空间，不是空指针；
		String s1 = new String();//零长度字符串
		System.out.println("是否是空指针：" + (s1 == null));//false
		System.out.println("内部字符的长度：" + (s1.length()));//0
		
		String s2 = "";//零长度字符串
		System.out.println("s1 == s2 : " + (s1 == s2));//false
		System.out.println("s1.equals(s2) : " + s1.equals(s2));//true
		
		//2.public String(byte[] bytes)：将一个byte[]数组，转换为一个String；
		byte[] byteArray = {97,98,99,100};
		String s3 = new String(byteArray);
		System.out.println("s3 = " + s3);
		
		//3.public String(byte[] bytes,int offset,int length)
		//取cd
		String s4 = new String(byteArray,2,2);
		System.out.println("s4 = " + s4);
		//取bc
		s4 = new String(byteArray,1,2);
		System.out.println("s4 = " + s4);
		
		//4.public String(char[] value)
		char[] charArray = {'a','b','你',':','好'};
		String s5 = new String(charArray);
		System.out.println("s5 = " + s5);
		
		//5.public String(char[] value,int offset,int count)
		//取ab
		String s6 = new String(charArray,0,2);
		System.out.println("s6 = " + s6);
		
		//6.public String(String original)
		String s7 = new String("我爱Java");
		String s8 = new String(s7);
		System.out.println("s7 = " + s7);
		System.out.println("s8 = " + s8);
		
		
	}
}

1.2 String类的特点

/*
 * String类的特点：
 * 字符串是常量；它们的值在创建之后不能更改。
 * 
 * String s1 = "你好"
 * s1 = "java";//改变的引用，原值"你好"的空间被丢弃，而且原空间的值没有被修改；
 */
public class Demo {
	public static void main(String[] args) {
		int n = 10;
		n = 20;
		System.out.println("n = " + 20);
		
		String s1 = "你好";
		s1 = "java";
		System.out.println("s1 = " + s1);
	}
}

1.3. String的例子==和equals

==和equals的区别

==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。

equals方法是用于比较两个独立对象的内容是否相同

public class Demo {
	public static void main(String[] args) {
		String s1 = "你好";//s1 = 0x2233
		String s2 = "你好";//s2 = 0x2233
		System.out.println("s1 == s2 : " + (s1 == s2));//true
		System.out.println("s1.equals(s2) : " + (s1.equals(s2)));//true
		
		String s3 = "你好";
		String s4 = new String("你好");
		System.out.println("s3 == s4 : " + (s3 == s4));//false
		System.out.println("s3.equals(s4) : " + (s3.equals(s4)));//true
		
		String s5 = new String ("你好");
		String s6 = new String("你好");
		System.out.println("s5 == s6 : " + (s5 == s6));//false
		System.out.println("s5.equals(s6) : " + (s5.equals(s6)));//true
		
		//---------------------------------------------------------------------//
		String s7 = "你好";
		String s8 = "java";
		String s9 = "你好java";
		String s10 = s7 + s8;
		String s11 = s7 + "java";
		String s12 = "你好" + s8;
		String s13 = "你好" + "java";//s13 = "你好java";
		
		System.out.println("s9 == s10 : " + (s9 == s10));//false
		System.out.println("s9 == s11 : " + (s9 == s11));//false
		System.out.println("s9 == s12 : " + (s9 == s12));//false
		System.out.println("s9 == s13 : " + (s9 == s13));//true
	}
}

1.4 String的判断功能

*String的判断功能：

*boolean equals(Object obj)：将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String对象时，结果才为 true。

*boolean equalsIgnoreCase(String str)：不区分大小写的判断

*boolean contains(String str)：当且仅当此字符串包含指定的参数字符串时，返回 true。区分大小写

*boolean startsWith(String str)：测试此字符串是否以指定的前缀开始。区分大小写

*boolean endsWith(String str)：测试此字符串是否以指定的后缀结束。区分大小写

*boolean isEmpty()：判断是否0长度字符串；

public class Demo {
	public static void main(String[] args) {
		String s1 = "java";
		String s2 = "java";
		String s3 = "Java";
		//1.boolean equals(Object obj):区分大小写
		System.out.println("s1.equals(s2) : " + (s1.equals(s2)));
		System.out.println("s1.equals(s3) : " + (s1.equals(s3)));
		//2.boolean equalsIgnoreCase(String str)：不区分大小写的判断
		System.out.println("s1.equalsIgnoreCase(s2) : " + s1.equalsIgnoreCase(s2));
		System.out.println("s1.equalsIgnoreCase(s3) : " + s1.equalsIgnoreCase(s3));
		
		//3.boolean contains(String str):区分大小写
		String s4 = "你好java";
		System.out.println("s4中是否包含\"你好\":" + s4.contains("你好"));
		System.out.println("s4中是否包含\"a\":" + s4.contains("a"));
		System.out.println("s4中是否包含\"z\":" + s4.contains("z"));
		System.out.println("s4中是否包含\",\":" + s4.contains(","));
		System.out.println("s4中是否包含\"av\":" + s4.contains("av"));
		System.out.println("s4中是否包含\"AV\":" + s4.contains("AV"));
		
		//4. boolean startsWith(String str)
		String s5 = "你好java";
		System.out.println(s5 + "中是否以\"你\"开头：" + s5.startsWith("你"));
		System.out.println(s5 + "中是否以\"你好\"开头：" + s5.startsWith("你好"));
		System.out.println(s5 + "中是否以\"你好java\"开头：" + s5.startsWith("你好java"));
		System.out.println(s5 + "中是否以\"java\"开头：" + s5.startsWith("java"));
		System.out.println(s5 + "中是否以\"你好ja\"开头：" + s5.startsWith("你好ja"));
		System.out.println(s5 + "中是否以\"你好JA\"开头：" + s5.startsWith("你好JA"));
		
		//5.boolean endsWith(String str)
		System.out.println(s5 + "中是否以\"java\"结尾：" + s5.endsWith("java"));
		System.out.println(s5 + "中是否以\"Java\"结尾：" + s5.endsWith("Java"));
		
		//6.boolean isEmpty()
		String s6 = "";//0x2233
		String s7 = new String("");//0x5566
		String s8 = null;//null
		System.out.println("s6.isEmpty() : " + s6.isEmpty());//true
		System.out.println("s7.isEmpty() : " + s7.isEmpty());//true
		System.out.println("s8.isEmpty() : " + s8.isEmpty());//运行时异常：NullPointerException
	}
}

1.5 String类的获取功能

*String类的获取功能：

* int length()：区分数组的length属性

charcharAt(int index):获取index位置上的字符

intindexOf(int ch):在此字符串中查找一个ch所代表的字符，如果存在则返回此字符的索引位置，否则返回-1;

intindexOf(String str)：在此字符串中查找str，如果存在则返回此字符的索引位置，否则返回-1;

intindexOf(int ch,int fromIndex):在此字符串中查找一个ch所代表的字符，从fromIndex开始找；

intindexOf(String str,int fromIndex):在此字符串中查找str，从fromIndex开始找；

Stringsubstring(int start):截取子字符串，从start开始，截取到末尾(返回新字符串，原字符串不变)

Stringsubstring(int start,int end)：截取子字符串，从start开始，到end - 1处；

publicint lastIndexOf(String str):从右侧开始查找字符串str，如果找到返回这个str在字符串中出现的位置(从左到右)

public class Demo {
	public static void main(String[] args) {
		String s1 = "你好java";
		System.out.println("s1.length() : " + s1.length());
		
		int[] intArray = {24,32,43,25234};
		System.out.println("intArray.length = " + intArray.length);
		
		//2.char charAt(int index)
		//获取j
		char c = s1.charAt(2);
		System.out.println("c = " + c);
		//遍历字符串
		for(int i = 0;i <s1.length() ; i++){
			char cr = s1.charAt(i);
			System.out.print(cr);
		}
		System.out.println();
		//3.int indexOf(int ch)
		System.out.println("indexOf = " + s1.indexOf(98));
		
		//4.int indexOf(String str)
		String s2 = "你好java";
		System.out.println("查找java : " + s2.indexOf("java"));
		
		//5.int indexOf(int ch,int fromIndex)
		System.out.println("查找v : " + s2.indexOf(118,2));
		//6.int indexOf(String str,int fromIndex)
		System.out.println("查找va : " + s2.indexOf("va",2));
		
		//7.String substring(int start)
		//截取java
		System.out.println("截取java:" + s2.substring(2));
		System.out.println("s2 = " + s2);
	
		//8.String substring(int start,int end)
		//截取:ja
		System.out.println("截取ja : " + s2.substring(2,4));
		//截取：java
		System.out.println("截取java : " + s2.substring(2,6));
		
		//9.public int lastIndexOf(String str)
		String s3 = "我爱java";
		System.out.println("s3.lastIndexOf(\"a\") : " + s3.lastIndexOf("a"));
	}
}

1.6 String的例子--遍历字符串和统计字母的数量

遍历字符串

public class Demo {
	public static void main(String[] args) {
		String str = "我爱java，我真的爱java，谢谢！";
		for(int i = 0;i < str.length() ; i++){
			char c = str.charAt(i);
			System.out.println(c);
		}
	}
}

统计字母的数量

public class Demo {
	public static void main(String[] args) {
		String str = "fjiERf432Gfdfds2435FDSsdD3";
		int num1 = 0;//大写  7
		int num2 = 0;//小写  11
		int num3 = 0;//数字  8
		
		for(int i = 0; i < str.length() ; i++){
			char c = str.charAt(i);
			if(c >= 'A' && c <= 'Z'){
				num1++;
			}
			if(c >= 'a' && c <= 'z'){
				num2++;
			}
			if(c >= '0' && c <= '9'){
				num3++;
			}
		}
		System.out.println("大写字母的数量：" + num1);
		System.out.println("小写字母的数量：" + num2);
		System.out.println("数字字符的数量：" + num3);
		
	}
}

1.7 String类的转换功能

*String类的转换功能：

* 注意：下面的所有方法，都不会对原字符串产生变化

* byte[] getBytes()：将一个String转换为一个byte[]数组

char[]toCharArray():将本字符串转换为char[]数组；

staticString valueOf(char[] chs):静态方法。将字符数组转换为String

staticString valueOf(int i):静态方法。将一个int值转换为一个String;

StringtoLowerCase():全部转换为小写

StringtoUpperCase()：全部转换为大写

Stringconcat(String str):将参数字符串追加到当前字符串的末尾。相当于+符号的字符串相连；

public class Demo {
         publicstatic void main(String[] args) {
                   Strings1 = "abc";
                   s1= "你好";
                   byte[]byteArray = s1.getBytes();//使用GBK
                   for(inti = 0;i < byteArray.length ; i++){
                            System.out.println(byteArray[i]);
                   }
                   System.out.println("------------------------------");
                   s1= "你好java";
                   char[]charArray = s1.toCharArray();
                   for(inti = 0 ;i < charArray.length ; i++){
                            System.out.println(charArray[i]);
                   }
                  
                   charArray= new char[]{'a','b','你','好'};
                   Strings2 = String.valueOf(charArray);
                   System.out.println("s2= " + s2);
                  
                   intn = 200;
                   Strings3 = String.valueOf(n);
                   Strings4 = "" + n;
                   System.out.println("s3= " + s3);
                   System.out.println("s4= " + s4);
                  
                   Strings5 = "Hello";
         //      s5 = "你好";
                   System.out.println("全部转换为大写：" + s5.toUpperCase());
                   System.out.println("全部转换为小写：" + s5.toLowerCase());
                   System.out.println("原字符串s5 = " + s5);
                  
                   Strings6 = "Hello";
                   Strings7 = "World";
                   System.out.println(s6.concat(s7));
         }
}

/*
 * 把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
 */
public class Demo {
	public static void main(String[] args) {
		String str = "hEllOwoRLD";//转换为：Helloworld
		//1.先全部转换为小写
	/*	str = str.toLowerCase();
		//2.将第一个字母取出
		String s1 = str.substring(0,1);
		String s2 = str.substring(1);
		//3.将s1转换为大写
		s1 = s1.toUpperCase();
		//4.将s1 和 s2链接
		str = s1.concat(s2);
		System.out.println("str = " + str);*/
		
		//写成一句话：
		str = str.substring(0,1).toUpperCase().concat(
				str.substring(1).toLowerCase());
		
		System.out.println("str = " + str);
	}
}

1.8 String类的其它功能

*String类的其它功能：

* 替换功能

Stringreplace(char old,char new)：将字符串中的所有old字符，替换为new字符

String replace(String old,String new)：将字符串中的所有的old字符串，替换为new字符串；

去除字符串两空格

Stringtrim()：

按字典顺序比较两个字符串

intcompareTo(String str)：区分大小写

intcompareToIgnoreCase(String str)：不区分大小写

public class Demo {
	public static void main(String[] args) {
		String str = "HelloWorld";
		//将字符串中所有o字符，替换为*字符
		String s1 = str.replace('o', '*');
		System.out.println("s1 = " + s1);
		System.out.println("str = " + str);
		
		//将所有的ll,替换为LL
		s1 = str.replace("ll", "L");
		System.out.println("s1 = " + s1);
		
		//trim()：去除字符串两端的空格
		str = "    你好   ";
		s1 = str.trim();
		System.out.println("去除两端空格后：" + s1);
		
		//compareTo():按字典顺序比较两个字符串
		String t1 = "a";
		String t2 = "b";
		String t3 = "c";
		System.out.println("a.compareTo(b) : " + t1.compareTo(t2));//-1
		System.out.println("a.compareTo(c) : " + t1.compareTo(t3));//-2
		
		System.out.println("c.compareTo(a) : " + t3.compareTo(t1));//2
		
		String t4 = "abc";
		String t5 = "aac";
		String t6 = "aa";
		String t7 = "abc";
		String t8 = "abcd";
		String t9 = "abcdef";
		String t10 = "ac";
		String t11 = "ab";
		System.out.println("abc.compareTo(aac) : " + t4.compareTo(t5));//1
		System.out.println("abc.compareTo(aa) : " + t4.compareTo(t6));//1
		System.out.println("abc.compareTo(abc) : " + t4.compareTo(t7));//0
		System.out.println("abc.compareTo(abcd) : " + t4.compareTo(t8));//-1
		System.out.println("abc.compareTo(abcdef) : " + t4.compareTo(t9));//-3（abc的长度 - abcdef的长度）
		System.out.println("abc.compareTo(ac) : " + t4.compareTo(t10));//-1
		System.out.println("abc.compareTo(ab) : " + t4.compareTo(t11));//1(abc的长度-ab长度)
		
		String t12 = "a";
		String t13 = "A";
		System.out.println("a.compareToIgnoreCase(A) : " + t12.compareToIgnoreCase(t13));//0
		
	}
}

1.9 例子--字符串反转

import java.util.Scanner;

/*
 * 字符串反转
 * 举例：键盘录入"abc"		输出结果："cba"
 * 		     abcd				dcba
 * 
 * 方式一：将字符串倒序遍历，封装为一个新字符串，然后输出
 * 方式二：转换为char数组，将数组的元素，第一和最后一个对调，将第二个和倒数第二个对调....
 */
public class Demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一句话：");
		String str = sc.next();
		//将str反转
		String result = "";
		for(int i = str.length() - 1 ; i >= 0 ; i--){
			result = result + str.charAt(i);//""+'c' //"c" + 'b' //"cb" + 'a' //"cba"
		}
		System.out.println("result = " + result);
		
		//方式二：转换为数组，对调元素
		char[] charArray = str.toCharArray();
		for(int i = 0;i < charArray.length / 2 ; i++){
			char c = charArray[i];//首
			charArray[i] = charArray[charArray.length - 1 - i];
			charArray[charArray.length - 1 - i] = c;
			
		}
		//将数组转换为String
		System.out.println("转换数组：" + new String(charArray));
	}
}

/*
 * 统计大串中小串出现的次数
 * 举例：在字符串”woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”中java出现了5次

 */
public class Demo {
	public static void main(String[] args) {
		String str = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
		int count = 0;//计数器
		int index = str.indexOf("java");
		while(index != -1){
			count++;
			index = str.indexOf("java",index + 1);
		}
		System.out.println("出现的次数：" + count);
	}
}

2.StringBuffer和StringBuilder

2.1StringBuffer描述

*java.lang.StringBuffer类：

* 1.之前我们学习使用了String类，String类的一个重要特点：其值是不可变的：

* 我们经常做一些字符串的拼接操作：例如：

* String str = "Hello";

* str = str + "World";

* System.out.println("str =" + str);//str = HelloWorld

* ----------------------------------------------------------------

* int[] array ={1,32,432,432,545};

* String str = "[";

* for(int i = 0;i <array.length ; i++){

* if(i + 1 ==array.length){

* str += array[i]+ "]";

* }else{

* str +=array[i] + ", ";

* }

* System.out.println(str);

*2.StringBuffer类：字符串缓冲区类。

* 1).一个类似于 String 的字符串缓冲区；

* 2).虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容(它的内部是可变的)。

*3.StringBuffer和String的区别：

* 1).StringBuffer内部的值是可变的；

* String的内部的值是不可变的；

* 4.注意：StringBuffer和String不同，不能使用"字符串字面量"直接赋值：

* 错误：StringBuffer buf = "abc"; //错误的

*5.StringBuffer的构造方法：

* public StringBuffer() :构造一个初始容量为16的StringBuffer。

* public StringBuffer(int capacity):使用一个容量来构造一个StringBuffer。

* public StringBuffer(String str):使用一个String构造一个StringBuffer。

* (将一个String转换为一个StringBuffer)。

* 说明两个概念：

* 1).容量：可以存储的字符的数量：capacity()

* 2).长度：已经存储的字符的数量：length()

public class Demo {
	public static void main(String[] args) {
		//1.public StringBuffer() 
		StringBuffer buf = new StringBuffer();
		System.out.println("容量：" + buf.capacity());//16
		System.out.println("长度：" + buf.length());//0
		//2.public StringBuffer(int capacity)
		StringBuffer buf2 = new StringBuffer(30);
		System.out.println("容量：" + buf2.capacity());//30
		System.out.println("长度：" + buf2.length());//0
		//3.public StringBuffer(String str)
		StringBuffer buf3 = new StringBuffer("Hello");
		System.out.println("容量：" + buf3.capacity());//16 + 5 
		System.out.println("长度：" + buf3.length());//5
		
		StringBuffer buf4 = new StringBuffer("aaaaaaaaaaaaaaaaa");//17个字符
		System.out.println("容量：" + buf4.capacity());//16 + 17 
		System.out.println("长度：" + buf4.length());//17
		
	}
}

2.2 StringBuffer的添加功能

/*
 * StringBuffer的添加功能：
 * 
 * public StringBuffer append(String str)：将str追加到当前字符序列的末尾；
 * public StringBuffer insert(int offset,String str):将指定 str 插入此序列的offset
 * 												     位置。原offset位置上的字符依次后移；0
 */
public class Demo {
	public static void main(String[] args) {
		StringBuffer buf = new StringBuffer();
		StringBuffer buf2 = buf.append("Hello");
		System.out.println("buf2 = " + buf2);
		System.out.println("buf = " + buf);
		System.out.println("buf2 == buf : " + (buf2 == buf));
		
		/*
		buf.append(12345);
		buf.append(true);
		buf.append('你');
		buf.append('a');
		buf.append('好');
		*/
		buf.append(12345).append(true).append('你').append('a').append('好');
		
		
		System.out.println("buf容量：" + buf.capacity());//原长度 * 2 + 2
		System.out.println("buf长度：" + buf.length());//17
		System.out.println("buf = " + buf);
		
		StringBuffer buf3 = new StringBuffer("HelloWorld");
		//要在World前，加入：Java
		buf3.insert(5, "Java");
		System.out.println("buf3 = " + buf3);
		
		
	}
}

2.3 StringBuffer删除功能

/*
 * 删除功能
 * public StringBuffer deleteCharAt(int index):删除index位置上的字符
 * public StringBuffer delete(int start,int end):删除从start开始 到 end - 1处的所有字符；
 * 
 * 
 */
public class Demo {
	public static void main(String[] args) {
		StringBuffer buf = new StringBuffer("HelloWorld");
		//删除W字符
	//	buf.deleteCharAt(5);
	//	System.out.println("buf = " + buf);//buf内部是可变的；
		
		//删除Hello
		buf.delete(0, 5);
		System.out.println("buf = " + buf);
		
		
		
	}
}

2.4 StringBuffer替换功能

/*
 * 替换功能
 * public StringBuffer replace(int start,int end,String str):替换从start到end - 1 处的所有字符，替换为str
 * 反转功能	 
 * public StringBuffer reverse():反转内部的所有字符；

 */
public class Demo {
	public static void main(String[] args) {
		StringBuffer buf = new StringBuffer();
		buf.append("HelloWorld");
		//将Hello替换为*****
		buf.replace(0, 5, "*****");
		System.out.println("替换后的结果：" + buf);
		
		StringBuffer buf2 = new StringBuffer();
		buf2.append("HelloWorld");
		buf2.reverse();
		System.out.println("buf2 = " + buf2);
	}
}

2.5 StringBuffer截取功能

/*
 * 截取功能:以下两个方法，返回String,原StringBuffer中的内容不变；
 * public String substring(int start):截取从start开始，到内部字符序列的末尾；
 * public String substring(int start,int end):截取从start，到end - 1处
 * 
 */
public class Demo {
	public static void main(String[] args) {
		StringBuffer buf = new StringBuffer();
		buf.append("HelloWorld");
		
		//截取Hello
		String str = buf.substring(0,5);
		System.out.println("str = " + str);//Hello
		System.out.println("buf = " + buf);//HelloWorld
		
		//截取World
		str = buf.substring(5);
		System.out.println("str = " + str);
	}
}

2.6 String和StringBuffer的相互转换

/*
 * String和StringBuffer的相互转换
 * 
 * String --> StringBuffer:
 * 		1.StringBuffer的构造方法：
 * 				StringBuffer buf = new StringBuffer("Hello");
 * 		2.StringBuffer的append()方法
 * 				StringBuffer buf = new StringBuffer();
 * 				buf.append("Hello");
 * StringBuffer --> String:
 * 		1.全部：StringBuffer的toString():
 * 		2.部分：StringBuffer的substring():
 */
public class Demo {
	public static void main(String[] args) {
		//1.String --> StringBuffer
		String str = "Hello";
		//--构造方法
		StringBuffer buf1 = new StringBuffer(str);
		//--append
		StringBuffer buf2 = new StringBuffer();
		buf2.append(str);
		
		//2.StringBuffer --> String
		//--全部：toString()
		String s1 = buf2.toString();
		//--部分：substring()
		String s2 = buf2.substring(2);//llo
		
	}
}

2.7字符串反转

/*
 * 字符串反转：
 * 
 * 1.将字符串转换为StringBuffer;
 * 2.调用StringBuffer的reverse():
 * 3.将StringBuffer转换为String;
 */
public class Demo {
	public static void main(String[] args) {
		String str = "HelloWorld";
		//转换为StringBuffer
		StringBuffer buf = new StringBuffer(str);
		//调用方法，进行反转
		buf.reverse();
		//将StringBuffer转换为String
		String result = buf.toString();
		
		System.out.println("result = " + buf);
		
		
	}
}

2.8 StringBuffer和StringBuilder的区别

*StringBuffer和StringBuilder的区别：

* 它们的功能"是完全一样的";

*1.StringBuffer:

* 1).从JDK1.0开始

* 2).线程同步(线程安全的)

* 3).效率低；

*2.StringBuild:

* 1).从JDK1.5开始

* 2).线程不同步的(线程不安全)

* 3).效率高；

public class Demo {
	public static void main(String[] args) {
		StringBuffer buf = new StringBuffer();
		long start = System.currentTimeMillis();//获取当前时间的毫秒值；此值从1970年1月1日开始到现在的毫秒值；
		for(int i = 0;i < 40000000 ; i++){
			buf.append(i);
		}
		long end = System.currentTimeMillis();
		System.out.println("Buffer:执行时间：" + ( end - start) + " 毫秒");//2403 毫秒
		
		StringBuilder bld = new StringBuilder();
		start = System.currentTimeMillis();
		for(int i = 0 ;i < 40000000 ; i++){
			bld.append(i);
		}
		end = System.currentTimeMillis();
		System.out.println("Builder:执行时间：" + ( end - start) + " 毫秒");//2006 毫秒
	}
}

2.9 String做为形参和StringBuffer作为形参

/*
 * 看程序写结果：
 * String作为参数传递:
 * StringBuffer作为参数传递:
 * 
 */
public class Demo {
	public static void main(String[] args) {
		String str = "Hello";//str = 0x2233
		fun1(str);//fun1(0x2233);
		System.out.println("str = " + str);//Hello
		
		StringBuffer buf = new StringBuffer("Hello");//0x7788
		fun2(buf);//fun2(0x7788)
		System.out.println("buf = " + buf);//HelloWorld
		
		for(int i = 0 ; i < str.length() / 2 ; i++){
			char c1 = str.charAt(i);
			char c2 =  str.charAt(str.length() - 1 - i);
			if(c1 != c2){
				System.out.println("不是对称串");
			}
		}
	}
	
	public static void fun1(String str){//str = 0x2233
		str = "World";//"World"被开辟新空间存储：str = 0x4455
	}
	public static void fun2(StringBuffer buf){//buf = 0x7788
		buf.append("World");//0x7788.append("World");
	}
}

2.10 例子

/*
 * 把数组拼接成一个字符串
 */
public class Demo {
	public static void main(String[] args) {
		int[] array = {123,54,35,6,5,321,35,46};
		StringBuffer buf = new StringBuffer("[");
		for(int i = 0;i < array.length ; i++){
			//判断是否最后一个元素
			buf.append(array[i]);
			if(i + 1 == array.length){
				buf.append("]");
			}else{
				buf.append(", ");
			}
		}
		//转换为字符串
		String result = buf.toString();
		System.out.println("result = " + result);
	}
}

/*
 * 判断一个字符串是否是对称字符串
 * 例如"abc"不是对称字符串，
 * "aba"、"abba"、"aaa"、"mnanm"是对称字符串
 * 
 * 方式一：将字符串反转，跟原串比较，如果相同，就是对称字符串；
 * 方式二：判断第一个字符和最后一个字符是否相同，然后判断第二个和倒数第二个....
 *      如果发现有一个不同的，就不是对称字符串；
 */
public class Demo {
	public static void main(String[] args) {
		String str = "aaa";
		StringBuffer buf = new StringBuffer(str);
		String result = buf.reverse().toString();
		
	//	System.out.println(buf.reverse().toString());
		if(result.equals(str)){
			System.out.println(str + " 是对称串！");
		}else{
			System.out.println(str + " 不是对称串！");
		}
		
	}
}

xiaoya0o0o

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员------String类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------1.String1.1 string类/* *java.lang.String类：String 类代表字符串。Java 程序中的所有字符串字面值（如"abc" ）都作为此类的实例实现。 * * 1.此类被定义为final，不能被继承； * 2.在Java中，"字符
复制链接

扫一扫

专栏目录