java基础—3.String类与正则表达式

一、概述及理解

	java.lang.String是处理字符串的类。字符串是java编程中经常处理的对象。

二、常见功能

	常见功能有CRUD，即：

|--1.获取

1.1  获取字符串的长度
	 int length()
1.2   返回指定索引处的 char 值
	char  charAt(int index) 
1.3    根据字符获取字符在字符串中的位置
	int  indexOf(int ch)     返回指定字符在此字符串中第一次出现处的索引
	int  indexOf(int ch, int fromIndex)   返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
	int  indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引
	int  indexOf(String str, int fromIndex)  返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
1.4  获取字符串中的一部分
	String subString(begin , end)  包含头，但是不包含尾

|--2.判断

2.1 字符串中是否包含某一个子串
	boolean contains(str)
	str.indexOf("aa")!=-1
2.2 字符中是否有内容
	boolean isEmpty();
2.3 字符串是否是以指定内容开头
	boolean startsWith(str)
2.4 字符串是否是经指定内容结尾
	boolean endsWith(str)

|--3.转换

3.1 将数组转成字符串
	构造函数 ：String ( char[] )
		String ( char[],offset ,count)
		String( byte[])
		String( byte[] , offset ,count )
	静态方法：
		static String copyValueOf( char [] ch);
		static String copyValueOf( char[] data ,int offset , int count )
		static String valueOf( char[] )
3.2 将字符串转成数组
	char[] toCharArray()
	byte[] getByte()
3.3 将基本数据类型转成字符串
	static String valueOf( int )
	static String valueOf(double)
	3+""  等效于 String.ValueOf( 3 )
3.4 将字符串转成大写或小写
	String  toUpperCase()
	String  toLowerCase()	

|--4.切割
	String[] split(String regex)  
|--5.替换
	String replace(oldChar , newChar )
	String replace(CharSequence target, CharSequence replacement) 
	String trim()   去除字符串两端的空格
|--6.比较
	int comparaTo( String )

三、StringBuffer/StringBuilder

	StringBuffer/StringBuilder都是一个容器，相较于数组，1.可以操作多个数据类型，2.这两个容器的长度都是可变的，所以对内存更加友好，程序运行的效率更高。3.最终会通过toString()方法转成字符串，
	StringBuffer是线程同步的，StringBuilder线程不同步，StringBuilder效率高些。作为一个容器，类比数据库常见功能有CRUD，即：
		Create—创建 Read—读取 Update—修改  Delete—删除

|--1. 存储
	StringBuffer append(数据)   数据可以是基本的常用类型 
	StringBuffer inser(插入的位置 , 数据)     
|--2. 删除
	StringBuffer delete( start ,  end ) 包含头，不包含尾
	StringBuffer deleteCharAt( index ) 删除指定位置的字符
|--3. 获取
	char charAt( index )
	int  indexOf( String str )
	int  lastIndexOf(String str)
	int  length()
	String subString( start ,end )
	void getChars(int srcBegin, int srcEnd,   char[] dst, int dstBegin)取一char数组
	StringBuffer reverse();  反转
|--4. 修改
	StringBuffer replace(start , end , string )  指定开关及结尾替换成指定字符
	void setCharAt(index , char ch)  指定位置替换成指定字符

四、正则表达式

	正则表达式是符合一定规则的表达式，是用于专门操作字符串的。用一些特定的符号来表示代码操作。正则表达式可以简化对字符串的操作。正则表达式有一个缺点是阅读性差。
	操作步骤：
		1.将正则表达式封装成对象；
			Pattern p = Pattern.compile(reg);
		2.让正则对象和要操作的字符串相关联；
			Matcher m =p.matcher(str);
		3.关联后，获取正则匹配引擎；
		4.通过引擎对符合规则的子串进行操作:

while(m.find()){
	System.out.print(m.group()+"\t");
	System.out.println(m.start()+"…………"+m.end());
}
	其实String类中使用正则表达式的方法，底层调用的都是正则表达式中的Pattern类和Matcher类

|--1.匹配：String类中matchs()方法：boolean  mathchs()
			String qq = "123455";
			String regex = "[1-9]\\d{4,14}";
			boolean flag = qq.mathchs(regex);  
|--2.切割：String类中的String[] split(String regex)  
			String str = "ab bdd     sdfsd    yeyt"
			String regex ="\\b[a-z]+\\b"
			String[]  st = str.split(regex);
|--3.替换：String类中的String replaceAll(String regex , String replacement)
			String str = "abdfsddfsdfdfsdffaaa";
			String regex = "([a-z])\\1+";
			String st = str.replaceAll(regex);
|--4.获取：将字符串中的符合规则的子串取出

package stringTest;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * 1.针对"ming tian jiu yao fang jia le,haha."，找出连续仅包含4个字符的字符串
 * 2.打印符合条件字符串的位置
 * */

public class RegexTest {

	public static void main(String[] args) {
		String str = "ming tian jiu yao fang jia le,haha.";
		String reg = "\\b[a-z]{4}\\b";
		//将规则封装成对象
		Pattern p = Pattern.compile(reg);
		//让正则对象和要作用的字符串相关联，获取匹配器对象Matcher
		Matcher m =p.matcher(str);

		//打印处理前的字符串
		System.out.println(str);
		while(m.find()){
			//打印符合规则的字符串
			System.out.print(m.group()+"\t");
			//打印符合规则字符串的开关和结尾
			System.out.println(m.start()+"…………"+m.end());
		}
	}

}

结果如下：

五、正则表达式的练习

package stringTest;
/**
 *题目：
 *1.模拟一个trim方法，去除字符串两端的空格
 *2.将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg","abfedcg";
 *3.获取一个字符串在另一个字符串中出现的次数
 *4.获取两个字符串中最大相同子串。
 *		abcwerthelloyuiodef
 *		cvhelloobnm
 */

public class StringFunDemo {

	public static void main(String[] args) {
		System.out.println(myTrim("   abc bc    "));
		System.out.println(reverseString("abcd yeyt abcd   ",5,8));
		System.out.println(stringCount("I miss you,just you miss me","ss"));
		System.out.println(getMaxSubString("fyeyt","kjk yeyt j"));
	}
	//练习一，去除字符串两端的空格
	public static String myTrim(String str){
		if(str==null)
			return null;
		int start=0,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[] ch = str.toCharArray();
		char c;//中间变量
		//对要求反转的部分反转
		for(;start<end;start++,end--){
			c = ch[start];
			ch[start]=ch[end];
			ch[end]=c;
		}
		//排好序的数组构造新字符串，返回结果
		return new String(ch);
	}
	//练习三：获取一个字符串在另一个字符串中出现的次数
	public static int stringCount(String str,String key){
		int count=0,index =0;
		//每次查找后，都把查找点增加
		while((index = str.indexOf(key, index))!=-1){
			index = index + key.length();
			count++;
		}
		
		return count;
	}
	//练习四：获取两个字符串中最大相同子串
	public static String getMaxSubString(String s1,String s2){
		String min,max;
		String maxStr;
		if(s1.length()>=s2.length()){
			min=s2;
			max=s1;
		}
		else{
			min = s1;
			max = s2;
		}
		//遍历较短的字符串，所有组合从长到短与s1比较，如果包含则返回
		for(int x=0;x<min.length();x++){
			for(int y=0;y<=x;y++){
				maxStr =min.substring(y, min.length()-x+y);
				if(max.contains(maxStr)){
					 return maxStr ;

				}
			}
		}
		
		return null;
	}
}

运算结果：