黑马程序员-String类和正则表达式

第一讲Stirng类

1.      String类概述

就是由多个字符组成的一串数据。也可以看成是一个字符数组。

 

2.      String类的构造方法

public String():空构造

public String(byte[] bytes):把字节数组转成字符串

public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串

public String(char[] value):把字符数组转成字符串

public String(char[] value,int index,int count):把字符数组的一部分转成字符串

public String(String original):把字符串常量值转成字符串

 

3.      String类的判断功能

boolean equals(Object obj):比较字符串的内容是否相同,区分大小写

boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

boolean contains(String str):判断大字符串中是否包含小字符串

boolean startsWith(String str):判断字符串是否以某个指定的字符串开头

boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾

boolean isEmpty():判断字符串是否为空。

 

4.      String类的获取功能

int length():获取字符串的长度。

char charAt(int index):获取指定索引位置的字符

int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。

为什么这里是int类型，而不是char类型?

原因是：'a'和97其实都可以代表'a'

int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。

int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。

int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

String substring(int start):从指定位置开始截取字符串,默认到末尾。

String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。

 

5.      String类的转换功能

byte[] getBytes():把字符串转换为字节数组。

char[] toCharArray():把字符串转换为字符数组。

static String valueOf(char[] chs):把字符数组转成字符串。

static String valueOf(int i):把int类型的数据转成字符串。

           注意：String类的valueOf方法可以把任意类型的数据转成字符串。

String toLowerCase():把字符串转成小写。

String toUpperCase():把字符串转成大写。

String concat(String str):把字符串拼接。

 

6.      String类的其他功能

替换功能：

String replace(char old,char new)

String replace(String old,String new)

去除字符串两空格

String trim()

按字典顺序比较两个字符串 

int compareTo(String str)

int compareToIgnoreCase(String str)

7.      String类注意点

7.1字符串的特点：一旦被赋值（直接赋值的方式），就不能改变。

如以下代码

String s= "hello";

           s += "world";

           System.out.println("s:"+ s);

S打印出来的是“helloworld”。

7.2  Strings = new String(“hello”)和String s = “hello”的区别

前者会创建2个对象，后者创建1个对象。

示例：

/*
 * ==:比较引用类型比较的是地址值是否相同
 * equals:比较引用类型默认也是比较地址值是否相同，而String类重写了equals()方法，比较的是内容是否相同。
 */
publicclass StringDemo2 {
   public static void main(String[] args) {
            String s1 = newString("hello");
            String s2 = "hello";
 
            System.out.println(s1 == s2);// false
            System.out.println(s1.equals(s2));//true
   }
}

在这里，s1和s2的地址值是不相等的

8. String类的代码示例‘

8.1 字符串反转

举例：键盘录入”abc”  输出结果：”cba”

分析：

A:键盘录入一个字符串
B:定义一个新字符串
C:倒着遍历字符串，得到每一个字符
a:length()和charAt()结合
b:把字符串转成字符数组
D:用新字符串把每一个字符拼接起来
E:输出新串

public class StringTest3 {
	public static void main(String[] args) {
		// 键盘录入一个字符串
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String line = sc.nextLine();

		String s = myReverse(line);
		System.out.println("实现功能后的结果是：" + s);
	}

	/*
	 * 两个明确： 返回值类型：String 参数列表：String
	 */
	public static String myReverse(String s) {
		// 定义一个新字符串
		String result = "";

		// 把字符串转成字符数组
		char[] chs = s.toCharArray();

		// 倒着遍历字符串，得到每一个字符
		for (int x = chs.length - 1; x >= 0; x--) {
			// 用新字符串把每一个字符拼接起来
			result += chs[x];
		}
		return result;
	}
}

 8.2 统计大串中小串出现的次数

 举例：
在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
 结果：
java出现了5次

分析：
前提：是已经知道了大串和小串。
 
A:定义一个统计变量，初始化值是0
B:先在大串中查找一次小串第一次出现的位置
a:索引是-1，说明不存在了，就返回统计变量
b:索引不是-1，说明存在，统计变量++
C:把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
D:回到B

public class StringTest5 {
	public static void main(String[] args) {
		// 定义大串
		String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
		// 定义小串
		String minString = "java";

		// 写功能实现
		int count = getCount(maxString, minString);
		System.out.println("Java在大串中出现了：" + count + "次");
	}

	/*
	 * 两个明确： 返回值类型：int 参数列表：两个字符串
	 */
	public static int getCount(String maxString, String minString) {
		// 定义一个统计变量，初始化值是0
		int count = 0;

		
		// 先在大串中查找一次小串第一次出现的位置
		int index = maxString.indexOf(minString);
		// 索引不是-1，说明存在，统计变量++
		while (index != -1) {
			count++;
			// 把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
			// int startIndex = index + minString.length();
			// maxString = maxString.substring(startIndex);
			maxString = maxString.substring(index + minString.length());
			// 继续查
			index = maxString.indexOf(minString);
		}
		
		return count;
	}
}

第二讲 StringBuffer和StringBuilder类

1.      StringBuffer类

StringBuffer是线程安全的可变字符串

2.      StringBuffer和String的区别

前者长度和内容可变，后者不可变。

如果使用前者做字符串的拼接，不会浪费太多的资源。

3.      String Buffer的构造方法

publicStringBuffer():无参构造方法

publicStringBuffer(String str):指定字符串内容的字符串缓冲区对象

4.      StringBuffer的添加功能

public StringBufferappend(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

public StringBufferinsert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

5.      StringBuffer的删除功能

public StringBufferdeleteCharAt(int index):删除指定位置的字符，并返回本身

public StringBufferdelete(int start,int end):删除从指定位置开始指定位置结束的内容并返回本身

6.      StringBuffer的替换功能

public StringBufferreplace(int start,int end,String str):从start开始到end用str替换

7.      StringBuffer的反转功能

public StringBufferreverse()

8.      StringBuffer的截取功能

注意返回值类型不再是StringBuffer本身了

public Stringsubstring(int start)

public Stringsubstring(int start,int end)

9.      StringBuilder和StringBuffer类

StringBuilder和StringBuffer类的用法差不多，但是有区别

StringBuffer是线程安全的，而StringBuilder是线程不安全的。

10. 代码示例

10.1 把数组拼接成一个字符串，如int[] a = {12,13,143}变为a = [12,13,14]

/*
 * 把数组拼接成一个字符串
 */
public class StringBufferTest2 {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 44, 33, 55, 11, 22 };

		// 定义功能
		// 方式1：用String做拼接的方式
		String s1 = arrayToString(arr);
		System.out.println("s1:" + s1);

		// 方式2:用StringBuffer做拼接的方式
		String s2 = arrayToString2(arr);
		System.out.println("s2:" + s2);
	}

	// 用StringBuffer做拼接的方式
	public static String arrayToString2(int[] arr) {
		StringBuffer sb = new StringBuffer();

		sb.append("[");
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				sb.append(arr[x]);
			} else {
				sb.append(arr[x]).append(", ");
			}
		}
		sb.append("]");

		return sb.toString();
	}

	// 用String做拼接的方式
	public static String arrayToString(int[] arr) {
		String s = "";

		s += "[";
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				s += arr[x];
			} else {
				s += arr[x];
				s += ", ";
			}
		}
		s += "]";

		return s;
	}
}

第三讲 正则表达式

1.      正则表达式概述

是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。

2.      正则表达式常见的定义规则

A:字符

x 字符 x。举例：'a'表示字符a

\\ 反斜线字符。

\n 新行（换行）符 ('\u000A')

\r 回车符 ('\u000D')

   

B:字符类

[abc] a、b 或 c（简单类）

[^abc] 任何字符，除了 a、b 或 c（否定）

[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）

[0-9] 0到9的字符都包括

   

C:预定义字符类

. 任何字符。我的就是.字符本身，怎么表示呢? \.

\d 数字：[0-9]

\w 单词字符：[a-zA-Z_0-9]

在正则表达式里面组成单词的东西必须有这些东西组成

 

D:边界匹配器

^ 行的开头

$ 行的结尾

\b 单词边界

就是不是单词字符的地方。

举例：hello world?haha;xixi

   

E:Greedy 数量词

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超过 m 次

3.      正则表达式的方法

3.1  判断功能

public boolean matches(String regex)

3.2  分割功能

public String[] split(String regex)

3.3  替换功能

public String replaceAll(String regex,String replacement)

3.4  获取功能

Pattern和Matcher类的使用

示例：模式和匹配器的典型调用顺序

// 把正则表达式编译成模式对象

Pattern p= Pattern.compile("a*b");

// 通过模式对象得到匹配器对象，这个时候需要的是被匹配的字符串

Matcher m= p.matcher("aaaaab");

// 调用匹配器对象的功能

boolean b= m.matches();

System.out.println(b);

 

//这个是判断功能，但是如果做判断，这样做就有点麻烦了，我们直接用字符串的方法做

String s= "aaaaab";

Stringregex = "a*b";

booleanbb = s.matches(regex);

System.out.println(bb);

4.代码示例

4.1 验证邮箱 

  分析：
   A:键盘录入邮箱
   B:定义邮箱的规则
   1517806580@qq.com
   liuyi@163.com
   linqingxia@126.com
   fengqingyang@sina.com.cn
   fqy@itcast.cn
   C:调用功能，判断即可
   D:输出结果 * 校验邮箱

public class RegexTest {
	public static void main(String[] args) {
		//键盘录入邮箱
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入邮箱：");
		String email = sc.nextLine();
		
		//定义邮箱的规则
		//String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z_0-9]{2,3})+";
		String regex = "\\w+@\\w{2,6}(\\.\\w{2,3})+";
		
		//调用功能，判断即可
		boolean flag = email.matches(regex);
		
		//输出结果
		System.out.println("flag:"+flag);
	}
}

4.2 字符串分割功能的练习

public class RegexDemo2 {
	public static void main(String[] args) {
		// 定义一个字符串
		String s1 = "aa,bb,cc";
		// 直接分割
		String[] str1Array = s1.split(",");
		for (int x = 0; x < str1Array.length; x++) {
			System.out.println(str1Array[x]);
		}
		System.out.println("---------------------");

		String s2 = "aa.bb.cc";
		String[] str2Array = s2.split("\\.");
		for (int x = 0; x < str2Array.length; x++) {
			System.out.println(str2Array[x]);
		}
		System.out.println("---------------------");

		String s3 = "aa    bb                cc";
		String[] str3Array = s3.split(" +");
		for (int x = 0; x < str3Array.length; x++) {
			System.out.println(str3Array[x]);
		}
		System.out.println("---------------------");
		
		//硬盘上的路径，我们应该用\\替代\
		String s4 = "E:\\JavaSE\\day14\\avi";
		String[] str4Array = s4.split("\\\\");
		for (int x = 0; x < str4Array.length; x++) {
			System.out.println(str4Array[x]);
		}
		System.out.println("---------------------");
	}
}