字符串使用

字符串

1.字符串的不可变性

string:字符串，使用一对””引起来表示。

1.String声明为final的，不可被继承。
2.String实现了serializable接口:表示字符串是支持序列化的。
   String实现了Comparable接口:表示String可以比较大小
3.String内部定义了final char[ ] value用于存储字符串数据
4.String:代表不可变的字符序列。简称:不可变性。
     体现 : 1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值.
           2．当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能原有的value进行赋值.
           3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能原有的value进行赋值.
5.迪过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中。
6.字符串常量池中是不会存储相同内容的字符串的。

• 定义String的类型数据时子要他们的只是一样，常量池就会将第二次定义的数据地址指向第一出现这个值的位置，所以s1和s2相等的。常量池中的数据是不可变的如果有不一样的数据只会重新创建新的数据，地址指向新的数据地址

2.String对象使用

String的2种实例化方式：

//1.在常量池中创建  
string str = "hello";
//2.在堆中创建  本质上this.value = new char[e];
/string s1 = new String();

String对象的构造方法：

//this.value = original.value;
String s2 = new String(String original);
//this.value = Arrays.copyof(value, value.length);
String s3 = new String(char[] a);

String s4 = new String(char[]a,int startIndex,int count);

3.字符串中常用的方法

1、charAt（）根据索引获取某个指定位置的字符

2、substring（）截取某个范围的值

3、indexOf（） 获取某个字符在字符串中第一次出现的索引

4、lastIndexOf() 获取某个字符在字符串中最后一次出现的索引

5、getBytes() 字符串转换成字节类型

案例：

        String str="java 编程,我喜欢JAVA编程";

      /***********************索引操作************************/
        //截取字符串中指定的某个字符，字符串中空格不会被过滤
        System.out.println(str.charAt(0));//j
        //截取字符串指定字符后的所有字符
        System.out.println(str.substring(5)); //编程
        //截取字符串指定字符范围的字符
        System.out.println(str.substring(4,7)); // 编程

        //获取某个字符在字符中第一次出现的位置
        System.out.println(str.indexOf('a')); // 1
        System.out.println(str.indexOf("编程")); // 5
        //获取某个字符在字符中最后一次出现的位置
        //区分大小写
        System.out.println(str.lastIndexOf('a')); // 3
        System.out.println(str.lastIndexOf("编程")); // 15

        //指定起始位置进行查询,指定其实位置6开始查找
        System.out.println(str.indexOf("编程",6)); //15

       /***********************字符串和char数组的转换************************/
         //字符数组和string的转换
        char[] chars = s1.toCharArray();
        String string = new String(chars);
        //字符串和整数的转换
        String s = String.valueOf(1);
       int a = Integer.valueOf(s);


      /***********************字符串和字节的转换************************/
        //字符串转换成字节类型  中文占3个字节
        byte[] bytes = str.getBytes();//默认工程的格式是：UTF-8
        byte[] gbks = str.getBytes("GBK"); //转换的格式
        //将字节类型转换成字符串类型

       System.out.println(Arrays.toString(bytes));//遍历获取数组的数据
        String s = new String(bytes); //转换成字符串
        //由于上方转换的gbks是GBK格式，所以转换时格式也得是GBK
        String s2 = new String(gbks,"GBK");

        System.out.println("s="+s);
        System.out.println("s2="+s2);

4.StringBuffer和StringBuilders

String、StringBuffer和StringBuilders 三者异同？

string:不可变的字符序列;底层使用char[]存储

StringBuffer:可变的字符序列;线程安全的，效率低;底层使用char[]存储

StringBuilder:可变的字符序列; jdk5.0新增的，线程不安全的，效率高;底层使用char[]存储

StringBuffer底层原理

//StringBuffers初始化创建时默认创建长度为16的字符数组
StringBuffer sb2 = new StringBuffer();//new char[16]
StringBuffer sb2 = new StringBuffer( "abc"); //char[] value = new char[ "abc".lengt+16]
//问题1.System.out.println(sb2.Length());//3
//问题2．扩容问题:
//如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
//默认情况下，扩容为原来容量的2倍＋2，同时将原有数组中的元素复制到新的数组中。
    
    指导意义:开发中建议大家使用:StringBuffer(int capacity)

StringBuffer的常用方法:

stringBuffer append(xxx);//提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end);//删除指定位置的内容
stringBuffer replace(int start， int end，string str);//把[ start,end)位置替换为str
stringBuffer insert(int offset， xxx);//在指定位置插入xxx
StringBuffer reverse();//把当前字符序列逆转
public int indexof(String str)
public string substring(int start,int end)
public int length()
public char charAt(int n )
public void setcharAt(int n ,char ch)

使用：

/**
 * 总结:
 * 增:append(xxx)
 * 时: delete(int start,int end)
 * 改: setCharAt(int n ,char ch) / replace(int start, int end，String str)
 * 查: charAt(int n )
 * 插:insert(int offset，xxx)
 * 长度:Length();
 * 遍历:for( +charAt() / toString)
 */

StringBuffer stringBuffer = new StringBuffer("abc");
System.out.println(stringBuffer.length());
stringBuffer.delete(0,1);//删除a  输出:bc
stringBuffer.replace(0,1,"hello");//把b替换程hello 输出:helloc
stringBuffer.insert(1,false);  //在后面插入hello  输出:hfalseelloc
stringBuffer.reverse(); //将当前字符串逆转 输出：colleeslafh
int llo = stringBuffer.indexOf("ll"); //获取当前字符串的索引位置。 输出：2
String substring = stringBuffer.substring(0, 3);  //截取指定范围字符 输出：col
char c = stringBuffer.charAt(1); //获取指定索引的位置
stringBuffer.setCharAt(10,'l'); //将第10字符改成l

对比String、StringBuffer、 StringBuiLder三者的效率:

从高到低排列:StringBuilder > StringBuffer > String

5.面试题

1. new 方式创建string对象，在内存中创建了几个对象?

两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据:"abc“

2.字符串面试题

public class StringTest {
    String str=new String("good");
    char[] ch={'t','e','s','t'};

    public void change(String str,char ch[]){
        str="test ok";
        ch[0]='b';
    }

    public static void main(String[] args) {
        StringTest stringTest = new StringTest();
        stringTest.change(stringTest.str,stringTest.ch);
        System.out.println(stringTest.str);//输出：good
        System.out.println(stringTest.ch);//best
    }
}

3.字符串比较面试题

String s1="javaEEhadoop";
String s2="javaEE";
String s3= s2+"javaEE";
System.out.println(s1==s3);// false

final String s4="javaEE"; //常量
String s5=s4+"hadoop";
System.out.println(s1==s5);//true

4.String常见面试算法题

（1）模拟一个trim方法，去除字符串两端的空格。

String s=" 012345   54321 0 ";
//去除字符串首尾空格
String trim = s.trim();
System.out.println("{"+trim+"}");
//去除字符串中所有空格
String s2=s.replaceAll("\\s", "");
System.out.println("{"+s2+"}");

(2)将一个字符串进行反转。将字符串中指定部分进行反转。比如"abcdefg”反转为”abfedcg”

String a="abcdefg";
String substring = a.substring(2,6);
String s = new StringBuffer(substring).reverse().toString();
String replace = a.replace(substring, s);
System.out.println(replace);

(3)获取一个字符串在另一个字符串中出现的次数。比如:获取“ab”在“abkkcadkabkebfkabkskab”中出现的次数

String str="abkkcadkabkebfkabkskab";
int count = 0;
int index = 0;
//返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
while((index=str.indexOf("ab",index))!=-1){
    System.out.println(index);
    //将索引下标移动到出现ab后的索引
    index = index+"ab".length();
    count++;
}
System.out.println(count);

**(4).获取两个字符串中最大相同子串。**比如:

str1 = “abcwerthelloyuiodef”;str2 = “cvhellobnm”

提示:将短的那个串进行长度依次递减的子串与较长的串比较。

public static String getMaxSameString(String str1, String str2){
    if(str1!=null&&str2!=null){

    String maxStr=str1.length()>=str2.length()?str1:str2;
    String minStr=str1.length()<str2.length()?str1:str2;

    //取小的长度
    int length = minStr.length();
    //遍历最小的长度
    for (int i=0;i<length;i++){
        for (int x=0,y=length-i;y<=length;x++,y++){
             //规律：
            // 第一次循环x=0,y=10
            // 第二次：x=0,y=9；  x=1,y=10,
            // 第三次x=0,y=8；    x=1,y=9；   x=2,y=10,
            // 第四次x=0,y=7    x=1,y=8；   x=2,y=9,   x=3,y=10
            String subStr=minStr.substring(x,y);
            if (maxStr.contains(subStr)){
                return subStr;
            }

        }
    }
    }
    return null;
}
public static void main(String[] args) {

    String str1="abcwerthelloyuiodef";
    String str2="cvhellobnm";
    String maxSameString = getMaxSameString(str1, str2);
    System.out.println(maxSameString);

}

(5)对字符串中字符进行自然顺序排序。提示:

1）字符串变成字符数组。

2）对数组排序，选择，冒泡，Arrays.sort();

3）将排序后的数组变成字符串。

方式一：

   String str="cshvgead";
   char[] chars = str.toCharArray();
   char c;
   for (int i = 0; i <chars.length; i++) {
       for (int j = i; j <chars.length ; j++) {
           if(chars[i]>chars[j]){
               c=chars[i];
               chars[i]=chars[j];
               chars[j]=c;
           }
       }
   }
   System.out.println(String.valueOf(chars));

方式二：

//方式二：
String str="cshvgead";
char[] chars = str.toCharArray();
Arrays.sort(chars);
System.out.println(String.valueOf(chars));

（6)StringBuffer转字符串null问题

String str=null;
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(str);
System.out.println(stringBuffer);//"null"
System.out.println(stringBuffer.length());//4

StringBuffer stringBuffer1 = new StringBuffer(str); //出现空指针异常