Java String用法，Java String类怎么用？

String常见用法

1、获取

1.1、字符串中包含的字符数，也就是字符串的长度：int length()。注意：数组中的是length属性，String类中是length();

public class StringMethodDemo {
	public static void main(String[] args) {
		StringMethodDemo();
	}
	
	public static void StringMethodDemo(){
		String s = new String("abcde");
		System.out.println("len="+s.length());//通过String类的length()方法来获取字符串的长度，这里我们需要和数组中的length属性区分开
	}

}

1.2、根据位置获取对应位置上的字符。char charAt(int index).当访问到字符串中不存在的角标时会发生StringIndexOfBoundsException

public class StringMethodDemo {
	public static void main(String[] args) {
		StringMethodDemo();
	}
	
	public static void StringMethodDemo(){
		String s = new String("abcde");
		System.out.println("char="+s.charAt(2));//通过charAt()方法打印指定位置的字符，如果指定位置不存在，则会报字符串角标越界异常
	}

}

1.3、根据字符获取该字符在字符串中的位置。int indexOf(int ch)，返回的是ch在字符串中第一次出现的位置，;为什么接收的是int呢？因为接收的是ASCII码。

indexOf(int ch,int fromIndex)：从fromIndex指定位置开始，获取ch在字符串中出现的位置

int indexOf(String str)，返回的是str在字符串中第一次出现的位置

indexOf(String str,int fromIndex)：从fromIndex指定位置开始，获取str在字符串中出现的位置

int lastIndexOf(String str):反向索引一个字符出现的位置。

public class StringMethodDemo {
	public static void main(String[] args) {
		StringMethodDemo();
	}
	
	public static void StringMethodDemo(){
		String s = new String("abcdae");
		System.out.println("index="+s.indexOf('a'));//指定字符第一次出现的位置
		System.out.println("index="+s.indexOf('k'));//如果指定字符在字符串中不存在则返回-1
		System.out.println("lastIndex="+s.lastIndexOf('a'));//指定字符最后一次出现的位置
	}

}

截取字符串中的一部分:

String substring(int beginIndex,int endIndex);从指定位置开始，到指定位置结束

String substring(int beginIndex)从指定位置开始到末尾

2、判断

2.1、字符串中是否包含某一个子串。

boolean contains(CharSequence s);

特殊之处：IndexOf(str)：可以索引str第一次出现位置，如果返回-1，表示该str不在字符串中存在。所以也可以用于对指定判断的包含。而且该方法既可以判断，又可以获取出现的位置。

2.2、字符串中是否有内容。

boolean isEmpty(str); JDK1.6才出现，原理就是判断长度是否为0

2.3、字符串是否以指定内容开头。

boolean startsWith(str);

2.4、字符串是否以指定内容结尾。

boolean endsWith(str);

2.5、判断字符串内容是否相同。

boolean equals(str)。复写了Object的equals方法。

2.6、判断内容是否相同，并忽略大小写。

boolean equalsIgnoreCase(str)。

3、转换

3.1、将字符数组转成字符串。

构造函数：String(char [ ] )

String(char [ ],offset,count):将字符数组中的一部分转成字符串。

静态方法：

static String copyValueOf(char [ ]);

static String copyValueOf(char [ ],offeset,count);

static String valueOf(char [ ]);

3.2、将字符串转成字符数组。

char [ ] toCharArray();

3.3、将字节数组转成字符串。

String(byte [ ] )

String(byte[ ],offset,count):将字节数组中的一部分转成字符串。

3.4、将字符串转成字节数组。

byte[ ] getBytes();

3.5、将基本数据类型转成字符串。

static String valueOf(int);

static String vlaueOf(double);

3+"";//String.valueOf(3);

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4、替换

String replace(oldchar,newchar);如果要替换的字符串不存在，返回的还是原字符串。

String replaceAll(String regex,String replacement)：按照指定的规则进行替换。

5、切割

String [] split(regex);

public class StringMethodDemo {
	public static void main(String[] args) {
		StringMethodDemo();
	}
	
	public static void StringMethodDemo(){
		String s = "张三,李四,王武";
		String[] arr = s.split(",");//调用split()方法按照指定的规则进行切割
		
		for(int x = 0;x<arr.length;x++){
			System.out.println(arr[x]);
		}
	}

}

6、子串。获取字符串中的一部分

String subString(begin); 从指定位置开始到末尾位置，如果角标不存在，会出现角标越界异常。

String subString(begin,end);从指定位置开始，到指定位置结束。注意：包含头，不包含尾。

7、转换、取出空格、比较。

7.1、将字符串转成大写或者小写

String toUpperCase();

String toLowerCase();

7.2、将字符串两端的多个空格去除。

String trim();

7.3、对两个字符串进行自然顺序的比较。

int compareTo(str);如果参数字符串等于此字符串，则返回值0；如果此字符串按字典顺序小于字符串参数，则返回一个小于0的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于0的值。

关于String的练习：

public class StringTest {
	public static void main(String[] args) {
		// String str = "      abc sd     ";
		String str = "abckkadskksdaskksd";
		// sop(myTrim(str));
		// sop(reverseString(str, 6, 14));
		// sop(getSubCount_2(str, "kk")+"");
		String str1 = "asaasfadffgdfhd";
		String str2 = "sfgdasdaa";
		sop(getMaxSubString(str1, str2));
	}

	public static void sop(Object obj) {
		System.out.println(obj);
	}

	// 练习四：两个字符串中最大相同的子串  

/* 
 思路：
①既然取的是最大子串，先看短的那个字符串是否在长的那个字符串中。如果存在，短的那个字符串
就是最大子串。
②如果不是，那么就将短的那个子串进行长度递减的方式去子串，去子串中判断是否存在。如果存在
就已找到，就不用再找了。*/
	public static String getMaxSubString(String str1, String str2) {
		String max = "", min = "";
		max = (str1.length() > str2.length()) ? str1 : str2;//三元运算，当str1长度大于str2时，将str1赋给max
		min = (max == str1) ? str2 : str1;

		for (int x = 0; x < min.length(); x++) {
			for (int y = 0, z = min.length() - x; z != min.length() + 1; y++, z++) {
				String temp = min.substring(y, z);
				// sop(temp);
				if (max.contains(temp))
					return temp;
			}
		}
		return null;
	}

	// 练习三：方式二：一个子串在整串中出现的次数

/*
思路：
①要找的子串是否存在，如果存在获取其出现的位置，这个可以使用indexOf完成。
②如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，而剩余字符串的起始位
是出现位置+子串的长度。
③以此类推，通过循环完成查找，如果找不到就是-1，并且每次找到用计数器记录。*/
	public static int getSubCount_2(String str, String key) {
		int count = 0;
		int index = 0;
		while ((index = str.indexOf(key, index)) != -1) {
			index = index + key.length();
			count++;
		}
		return count;
	}

	// 练习三：

	public static int getSubCount(String str, String key) {
		int count = 0;
		int index = 0;
		while ((index = str.indexOf(key)) != -1) {
			str = str.substring(index + key.length());
			count++;
		}
		return count;
	}

	// 练习一：模拟一个trim功能方法，去除字符串两端的空白。

/*
思路：
①定义两个变量。
一个变量作为从头开始判断字符串空格的角标，不断++。
一个变量作为从尾开始判断字符串空格的角标，不断--。
②判断到不是空格为止，取头部之间的字符串即可<*/

	public static String myTrim(String str) {
		int start = 0;
		int end = str.length() - 1;
		while (start <= end && str.charAt(start) == ' ') {
			start++;
		}
		while (start <= end && str.charAt(end) == ' ') {
			end--;
		}

		return str.substring(start, end + 1);
	}

	// 练习二：将字符串进行反转
	public static String reverseString(String str, int start, int end) {
		// 字符串变成数组
		char[] arr = str.toCharArray();
		// 反转数组
		reverse(arr, start, end);
		// 数组变成字符串
		return new String(arr);

	}

	public static String reverseString(String str) {

		return reverseString(str, 0, str.length());

	}

	private static void reverse(char[] arr, int x, int y) {
		// TODO Auto-generated method stub
		for (int start = x, end = y - 1; start <= end; start++, end--) {
			swap(arr, start, end);
		}
	}

	private static void swap(char[] arr, int start, int end) {
		// TODO Auto-generated method stub
		char temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;

	}
}

StringBuffer：是一个字符串缓冲区，他是一个容器。而且长度是可变化的，数组也是容器，但是长度是固定的。StringBuffer可以操作多种数据类型，但数组只能操作一种数据类型，最终可以通过toString方法变成字符串。

1、存储

StringBuffer append()：将指定数据作为参数添加到已有数据结尾处。

StringBuffer insert(int offset,数据)：可以将数据插入到指定offset位置

2、删除

StringBuffer delete(start,end)：删除缓冲区中的数据，包含start，不包含end。清空缓冲区：sb.delete(0,str.length());

StringBuffer deleteCharAt(index)：删除指定位置的字符。

3、获取

char charAt(index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start,int end)

4、修改

StringBuffer replace(int start,int end,String str)

void setCharAt(int index,char ch)

5、反转

reverse();

6、void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)：将缓冲区中指定数据存储到指定字符数组中。

在JDK1.5出现了StringBuilder，StringBuilder是StringBuffer一个简易的替换，但StringBuilder是线程不同步的，是线程不安全的。StringBuffer是线程安全的。如果在单线程的情况下，我们建议使用StringBuilder，效率会比StringBuffer高，多线程使用StringBuffer，但我们也可以在多线程的时候使用StringBuilder，因为我们可以自己添加锁。

JDK升级的三个要素：1、简化书写。2、提高安全性。3、提高效率

基本数据类型包装类：

byte Byte

short Short

int Integer

long Long

boolean Boolean

float Float

double Double

char Character

基本数据类型对象包装类的最常见作用，

就是用于基本数据类型和字符串类型之间做转换。

基本数据类型转成字符串。

基本数据类型+""

基本数据类型.toString(基本数据类型值);如：Integer.toString(34);//将34变成"34"

字符串转成基本数据类型。

xxx a = Xxx.pareseXxx(String);

int a = Integer.pareseInt("123");//必须传入数字格式的字符串

Integer i = new Integer("123");

int num = i.intValue();

十进制转成其他进制

toBinaryString()

toHexString()

toOctalString()

其他进制转成十进制

pareseInt(String,radix);

Integer x = new Integer("123");

Integer y = new Integer(123);

x==y x.equals(y)我们通过验证发现==时为false，因为两者是分别new的一个对象，equals时为true，因为Integer里面重写了equals方法，两个值相同。

JDK1.5版本以后出现的新特性：

Integer x = new Integer(4);

Integer x = 4;//自动装箱。//new Integer(4);

x = x/*自动拆箱：x.intValue()*/+2;//x+2：x进行了自动拆箱。变成了int类型，和2进行加法运算，再将和进行装箱赋给x

Integer 默认值是null。

Integer m = 128；

Integer n= 128；

m==n？结果为false

Integer x= 127；

Integer y = 127；

x==y? 结果为true，因为x和y指向了同一个对象。因为当数值在byte范围内时，对于新特性，不会再开辟新的空间，如果该数值已经存在，则不会开辟新的空间。