java基础_String
String类
基本方法：
1. 获取：
1.1 获取字符串中字符的个数(长度).
int length();
1.2 根据位置获取字符。
char charAt(int index);
1.3 根据字符获取在字符串中的第一次出现的位置.
int indexOf(int ch)
int indexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
int indexOf(String str);
int indexOf(String str,intfromIndex);
返回指定子字符串在此字符串中最右边出现处的索引。
int lastIndexOf(int ch)
int lastIndexOf(int ch,intfromIndex):从指定位置进行ch的查找字符串在此字符串中最右边出现处的索引。
int lastIndexOf(String str);
int lastIndexOf(String str,intfromIndex);
1.4 获取字符串中一部分字符串。也叫子串.
String substring(int beginIndex, intendIndex)//包含begin 不包含end 。
String substring(int beginIndex);
2. 转换：
2.1 将字符串变成字符串数组(字符串的切割)
String[] split(String regex)://涉及到正则表达式.
2.2 将字符串变成字符数组。
char[] toCharArray();
2.3 将字符串变成字节数组。
byte[] getBytes();
2.4 将字符串中的字母转成大小写。
String toUpperCase():大写
String toLowerCase():小写
2.5 将字符串中的内容进行替换
String replace(char oldch,char newch);
String replace(Strings1,String s2);
replace方法是在原字符串的基础上，返回一个新的字符串，原字符串不变。
public static void method_replace() { String s = "hello java"; //String s1 = s.replace('a','n'); String s1 = s.replace("java","world"); //return hello world sop("s="+s);//还是 hello java sop("s1="+s1);//hello world }
2.6 将字符串两端的空格去除。
String trim();
3. 判断
3.1 两个字符串内容是否相同啊？
boolean equals(Object obj);
boolean equalsIgnoreCase(string str);//忽略大写比较字符串内容。
3.2 字符串中是否包含指定字符串？
boolean contains(string str);
3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。
boolean startsWith(string);
boolean endsWith(string);
4. 比较。
4.1 比较大小
int compareTo(String anotherString)
StringBuffer类
StirngBuffer就是字符串缓冲区，用于存储数据的容器，增删改查 C (craet) U (updata) R (read) D (delete)1，特点
1.1而且长度是可变化的。
1.2可以直接操作多个数据类型。
1.3最终会通过toString方法变成字符串。1.4可以对字符串进行修改
2. 功能
增删改查 C(create)U(update)R(read)D(delete)
2.1添加：
StringBuffer append(data);
StringBuffer insert(index,data);
2.2删除：
StringBuffer delete(start,end):包含头，不包含尾。
StringBuffer deleteCharAt(int index):删除指定位置的元素
2.3查找：
char charAt(index);
int indexOf(string);
int lastIndexOf(string);
2.4修改：
StringBuffer replace(start,end,string);
void setCharAt(index,char);
StringBuilder类
JDK1.5 版本之后出现了StringBuilder.
StringBuffer是线程同步。如果是单线程，StringBuffer效率比较低
StringBuilder是线程不同步。
JVM对字符串的处理
String java = new String("java");,
1，String对象实例化
常见的问题是：上面语句创建了几个字符串对象？上面语句实际上创建了2个字符串对象，一个是“java”这个直接量对应的字符串对象，一个是由new String()构造器返回的字符串对象。
对于java成程序中的字符直接量，JVM会使用一个常量池（是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。）来保存它们，当第一次使用
字符串直接量时（在编译时期能直接确定），JVM会将它放入常量池缓存。在一般情况下，常量池中字符串对象不会被垃圾回收，当程序再次需要使用该字符串时，直接让引用变量指定常量池的字符串。
示例：
1，str1,str2两个字符串变量的值都是直接量，他们都指向常量池的“hello java”字符串，所以身str1和str2相等。
class StringTest { public static void main(String[] args) { String str0 = "java"; //str1的值是字符串直接量 String str1 = "hello java"; //str2的值也指向常量池的“hello java”字符串 String str2 = "hello java"; System.out.println(str1 == str2);//true //str3的值可以在编译时确定，所以str3也会直接引用常量池的“hello java”字符串 String str3 = "hello "+"java"; System.out.println(srt1 == str3);//true //因为str4的值包含了变量，因此不能在编译时确定 String str4 = "hello "+str0; System.out.println(str1 == str4);//false } }
2，str3的值是一个字符串连接表达式，但由于这个字符串连接表达式的值可以在编译时期确定，所以JVM在编译时计算str3的值，
并让str3指向常量池的“hello java”字符串。所以身str1和str3相等。
3，str4也是字符串连接表达式，但是由于这个字符串连接表达式中包含了一个变量，因此str4不会指向常量池的“hello java”字符串。因此石str1 == str4 为false。
（如果程序使用了变量，调用了方法，那就只能等运行时才可确定该字符串连接表达式的值，因此无法利用JVM的常量池）。
2，创建了几个对象
String str = "hello"+"java"+"100";
问题：上面语句创建了几个对象，
其实这段代码只创建了一个字符串对象，因为str的值可以在编译时确定下来，JVM会在编译时就计算出str的值。
3，关于equals()和==:
这个equals()对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。4，不可变的字符串
String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能再修改此对象中存储的字符串内容。
class StringTest { public static void main(String[] args) { String str = "hello "; System.out.pritnln(str);//hello <span style="white-space:pre"> </span>str = str+"java"; System.out.pritnln(str);//hello java } }1，可以看到上面两次输出str不一样。看起来好像str对应的字符串该变了，但是要记住，str只是一个引用类型变量，它并不是真正的String对象，它只是指向String对象而已，也就是说，发生改变的不是String对象，而是str变量本身，它指向了一个新的String对象。
2，当str指向新的String对象后，原来的String对象没有变量指向它，也许以后永远都不会再被利用，但是这个字符串不会被垃圾回收，因为它一直存在于常量池中——这就是java内存泄露的原因之一。
5. String和StringBuffer的区别
某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，如在以下的字符串对象生成中，String 效率是远要比 StringBuffer 快的：
String S1 = “This is only a” + “ simple” + “ test”;你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
String S1 = “This is only a” + “ simple” + “test”; 其实就是： String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。
但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了。
譬如： String S2 = “This is only a”; String S3 = “ simple”; String S4 = “ test”; String S1 = S2 +S3 + S4; 这时候 JVM 会规规矩矩的按照原来的方式去做。
