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会将它放入常量池缓存。在一般情况下，常量池中字符串对象不会被垃圾回收，当程序再次需要使用该字符串时，直接让引用变量指定常量池的字符串。
示例：

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

	}
}

1，str1,str2两个字符串变量的值都是直接量，他们都指向常量池的“hello java”字符串，所以身str1和str2相等。

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”; 
StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”); 

你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个 
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 会规规矩矩的按照原来的方式去做。