字符串相关的类（String,StringBuffer,StringBuilder）
1.String类
String代表不可变字符序列，，下面是Java8中声明String的源码，从源码中我们可以看到，String是一个final类，说明创建了一个String变量后不能更改。底层用final char value[]来存储字符串。字符串实现了Serializable接口，可支持序列化；实现了comparable接口，可支持比较大小。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
A.创建字符串的两种方式的对比和区别
创建String对象的方式有两种，第一种是通过String X方式来创建，此时的字符串值声明在字符串常量池中，常量池中不可以有重复的字符串，所以相同的字符串肯定有相同的地址值。当改变str内容时，必须在方法区新建一个地址保存该内容并将该地址返回给str保存。
//通过String X字面量的方式来创建字符串
@Test
public void Test1(){
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); //true，因为字符串存储在常量池中，内容相同的字符串地址肯定相同
s2 = "hello";
System.out.println(s1 == s2);//false,因为s2内容变了，所以s2存储的指向常量池的地址肯定也相应改变
System.out.println(s1);//abc
System.out.println(s2);//hello
}
第二种是通过new String( )方式来创建String对象，通过此方式创建是在堆区新建一个value属性，保存常量池相应内容的地址，然后堆区value的地址给str，相当于new一个字符串创建了两个对象。
//通过new String X的方式来创建字符串
@Test
public void Test2(){
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2); //false，在堆区新建了两个对象，来存储指向常量池的地址值，地址值可以相同，但是他们在堆区的地址不同
str1 = "world";
System.out.println(str1 == str2);//false
System.out.println(str1);//world
System.out.println(str2);//abc
}
B.字符串的拼接操作
注意：常量与常量的拼接结果在常量池中，但是只要有一个是变量，或者两个都是变量，结果就在堆中，那不论内容是否相同，地址都不一样。
@Test
public void Test3(){
String s0 = "helloworld";
String s1 = "hello";
String s2 = "world";
String s3 = "hello" + "world";
String s4 = s1 + "world";
String s5 = "hello" + s2;
String s6 = s1 + s2;
System.out.println(s3 == s0);//true
System.out.println(s3 == s4);//false
System.out.println(s3 == s5);//false
System.out.println(s3 == s6);//false
}
C.String的常用方法
@Test
public void Test4(){
String s1 = "HelloWorld";
System.out.println(s1.length());//10
System.out.println(s1.charAt(4));//o
System.out.println(s1.isEmpty());//false
System.out.println(s1.toLowerCase());//helloworld
System.out.println(s1.toUpperCase());//HELLOWORLD
String s2 = " HelloWorld ";
System.out.println(s2); // HelloWorld
System.out.println(s2.trim()); //HelloWorld
System.out.println(s1.equals(s2));//false
System.out.println(s1.concat(",Good Day"));//HelloWorld,Good Day
String s3 = "Study";
System.out.println(s1.compareTo(s3));//-11,ASCll码相减
System.out.println(s1.substring(2,5));//llo
System.out.println(s1.endsWith("d"));//true
System.out.println(s1.startsWith("H"));//true
System.out.println(s1.indexOf("d"));//9
}
D.String与基本数据类型包装类的转换
@Test
public void test5(){
//字符串转为基本数据类型/包装类——parseInt(String s)
String str1 = "123";
int num = Integer.parseInt(str1);
//基本数据类型/包装类转为字符串——valueOf(int n)
String str = String.valueOf(num);
//字符串转为char[]
char[] chars = str1.toCharArray();
//char[]转为字符串
char[] arr = new char[]{'h','e'};
String str2 = new String(arr);
//字符串转为byte[]
byte[] bytes = str1.getBytes();
//byte转为字符串
String str3 = new String(bytes);
}
E.String的几个算法题
1.模拟一个trim方法，去除字符串两端的空格
public class TrimMethod {
//模拟一个trim方法，去除字符串两端的空格
public static String getString(String str){
int start = 0;
int end = str.length();
while((start < end) && str.charAt(start) == ' '){
start++;
}
while((start < end) && str.charAt(end-1) == ' '){
end--;
}
return str.substring(start,end);
}
@Test
public void trimTest(){
String str = new String(" abc f ");
System.out.println(str);
System.out.println(getString(str));
}
}
2.将一个字符串指定进行反转，比如“abcdefg”反转为“abfedcg”
public class StringTest2 {
@Test
public void StringTest(){
String str = "abcdefg";
System.out.println(str);
System.out.println(reverse3(str,2,5));
}
//方法一：将字符串转换为数组，然后在数组里进行对调操作
public String reverse(String str,int startIndex, int endIndex){
if(str != null && str.length() != 0){
char[] arr = str.toCharArray();
for (int x = startIndex,y = endIndex; x < y; x++,y--) {
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
return new String(arr);
}
return null;
}
//方法二：使用String的拼接
public String reverse2(String str,int startIndex, int endIndex) {
if (str != null && str.length() != 0) {
String reverseStr = str.substring(0, startIndex);
for (int i = endIndex; i >= startIndex; i--) {
reverseStr += str.charAt(i);
}
reverseStr += str.substring(endIndex + 1);
return reverseStr;
}
return null;
}
//方法三：使用StringBuffer或者StringBuilder，调用它们的方法，最后返回String类型
public String reverse3(String str,int startIndex, int endIndex) {
if (str != null && str.length() != 0) {
StringBuilder builder = new StringBuilder(str.length());
builder.append(str.substring(0,startIndex));
for (int i = endIndex; i >= startIndex; i--) {
builder.append(str.charAt(i));
}
builder.append(str.substring(endIndex + 1));
return builder.toString();
}
return null;
}
}
3.获取一个字符串在另一个字符串中出现的次数，比如获取“ab”在"abkkcadkabkebfkabkskab"
public class StringTest3 {
@Test
public static void test(){
String mainstr = "abkkcadkabkebfkabkskab";
String substr = "ab";
System.out.println(getCount(mainstr,substr));
}
public static int getCount(String mainStr,String subStr){
int mainlength = mainStr.length();
int sublength = subStr.length();
int index = 0;
int count = 0;
if(mainlength >= sublength) {
while ((index = mainStr.indexOf(subStr, index) )!= -1) {
index += sublength;
count++;
}
return count;
}else{
return 0;
}
}
}
4.获取两个字符串中最大相同子串
package String;
import org.testng.annotations.Test;
//获取两个字符串的最大相同子串，多个的情况下
public class StringTest4 {
@Test
public void test(){
String str1 = "abcwerthelloyuiodeflobnm";
String str2 = "cvhellobnm";
System.out.println(getSameSubStr(str1,str2));
}
public String getSameSubStr(String str1,String str2) {
if (str1 != null && str2 != null) {
StringBuilder sBuffer = new StringBuilder();
String maxstr = str1.length() >= str2.length() ? str1 : str2;
String minstr = str1.length() < str2.length() ? str1 : str2;
int len = minstr.length();
for (int i = 0; i < len; i++) {
for (int x = 0, y = len - i; y <=len; x++, y++) {
String substr = minstr.substring(x, y);
if (maxstr.contains(substr)) {
sBuffer.append(substr + " ");
}
}
if(sBuffer.length() != 0){
break;
}
}
return sBuffer.toString();
}
return null;
}
}
2.StringBuffer类和tringBuilder类
A.String,StringBuffer,StrignBuilder的区别，源码分析
String是不可变的字符序列。StringBuffer是可变的字符序列，线程安全，效率低；StringBuilder也是可变的字符序列，线程不安全，效率高。
三者都是底层使用char[]存储，那为什么后两者是可变的字符序列？下面分析它们的源码。
1.String源码
private final char value[];
String源码中通过一个final类型的char数组来存储字符串，例如new String() 代表har[] value = new char[0]。new String(“abc”) 代表char[] value = new char[]{‘a’,‘b’,‘c’}。在字符串声明时char数组的大小就确定了，不能更改。
2.StringBuffer源码
1. public StringBuffer() {
super(16);
}
2. AbstractStringBuilder(int capacity) {
value = new char[capacity];
}
3. char[] value;
4. public StringBuffer(String str) {
super(str.length() + 16);
append(str);
new StringBuffer（）首先就在底层新建一个长度是16的char数组，使用append()函数可以添加数据。new StringBuffer（str）首先在底层新建一个长度是str.length()+16的char数组，使用append()函数可以添加数据。
扩容问题：当StringBuffer底层的char[]数组容量不够时，扩容为原来的2倍+2，并将原数据复制到新数组中。
private int newCapacity(int minCapacity) {
// overflow-conscious code
int newCapacity = (value.length << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
? hugeCapacity(minCapacity)
: newCapacity;
}
3.StringBuilder源码
1. public StringBuilder() {
super(16);
}
2. AbstractStringBuilder(int capacity) {
value = new char[capacity];
}
3. char[] value;
4. public StringBuilder(String str) {
super(str.length() + 16);
append(str);
StringBuilder的扩容与StringBuffer一样，都是扩大为原来的2倍+2
扫一扫
350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
