Java学习之常用类（一.String类，正则表达式）

一.String类：

 

String的常用方法:
1. public char charAt(int index)
　　返回字符串中的index个字符
2. public int length()
　　返回字符串长度
3. public int indexOf(String str)
　　返回字符串中出现str的第一个位置，如果没有找到,则返回-1
4. public boolean equalsIgnoreCase(String another)
　　比较字符串与another是否相同（忽略大小写）
5. public String replace(char oldChar, char newChar)
　　在字符串中用newChar替换oldChar
6. public boolean startsWith(String prefix)
　　判断字符串是否以prefix开头
7. public boolean endsWith(String suffix)
　　判断字符串是否以suffix结束
8. public String toUpperCase()
　　返回该字符串的大写形式
9. public String toLowerCase()
　　返回该字符串的小写形式
10. public String substring(int beginIndex)
　　返回该字符串从beginIndex开始到结尾的子串
11. public String substring(int beginIndex,int endIndex)
　　返回该字符串从beginIndex开始到endIndex结尾的子串
13. public String trim()

去除字符串头尾的空格

 

package dg;
 
 
/**
 *
 * @author DUGANG
 */
public class StringMethod {
    public static void main(String[] args){
        String str = "Hello World!!!";
        System.out.println("示例字符串为：" + str);
        //public char charAt(int index)方法
        System.out.println(str + "中第四个字符为：" + str.charAt(4));
        //public int length()方法
        System.out.println(str + "的字符长度为：" + str.length());
        //public int indexOf(String str)方法
        System.out.println(str + "中第一个“l”出现在字符串的第" + str.indexOf("l") + "位");
        //public boolean equalsIgnoreCase(String another)方法
        System.out.println(str + "与hello world!!!相同:" + str.equalsIgnoreCase("hello world!!!"));
        //public String replace(char oldChar, char newChar)方法
        System.out.println(str + "用‘L’替换‘l’后为：" + str.replace("l", "L"));
        //public boolean startsWith(String prefix)方法
        System.out.println(str + "以字母‘H’开头：" + str.startsWith("H"));
        //public boolean endsWith(String suffix)方法
        System.out.println(str + "以‘！’结尾:" + str.endsWith("!"));
        //public String toUpperCase()方法
        System.out.println(str + "转换为大写：" + str.toUpperCase());
        //public String toLowerCase()fangfa
        System.out.println("JAVA转换为小写：" + "JAVA".toLowerCase());
        //public String substring(int beginIndex)
        System.out.println(str + "从第六个字符开始截取子串为：" + str.substring(6));
        //public String trim()方法
        System.out.println("       hello      " + "去掉开头和结尾的空格为:" + "       hello      ".trim());
    }
 
}

 

结果：

示例字符串为：Hello World!!!
Hello World!!!中第四个字符为：o
Hello World!!!的字符长度为：14
Hello World!!!中第一个“l”出现在字符串的第2位
Hello World!!!与hello world!!!相同:true
Hello World!!!用‘L’替换‘l’后为：HeLLo WorLd!!!
Hello World!!!以字母‘H’开头：true
Hello World!!!以‘！’结尾:true
Hello World!!!转换为大写：HELLO WORLD!!!
JAVA转换为小写：java
Hello World!!!从第六个字符开始截取子串为：World!!!
hello 去掉开头和结尾的空格为:hello

 

1.String 方法:length(),charAt() ,getBytes()和 getChars()

方法 length()

–返回 String 的长度,是按照 char 返回的长度

–与数组不同之处: String 类不含有 length 成员域(属性)

方法 charAt(int index)

–获得字符串指定位置的字符

方法 getBytes()

–使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中

方法 getChars(int srcBegin, int srcEnd,char[ ] dst, int dstBegin)

–拷贝字符串的部分字符序列到指定的字符数组的指定位置

注意:对于字符串中的汉字,是按照 char 来计算的,一个中文汉字占两个字节,也就是说,通过 length()得到的是字符串 char 的长度,而不是字节数,利用这个特点,就可以进行中文判断了。

 

2.字符串比较

–字符类型的数据也是数值类型数据

–比较字符串大小,实际上就是依次比较其所包含的字符的数值大小

–小写字母与大小字母是不相同的,Java 是区分大小写

方法 compareTo(String s):

比较两个字符串的大小。返回 0 表示相等,返回大于 0 的数表示前面的字符串大于后面的字符串,返回小于 0 表示前面的字符串小于后面的字符串,区分大小写的。

 方法 compareToIgnoreCase(String s):忽略大小写,比较两个字符串的大小。返回 0 表示相等,返回大于 0 的数表示前面的字符串大于后面的字符串,返回小于 0 表示前面的字

 

 

3.查找字符串中的字符或子串

方法 lastIndexOf

–public int lastIndexOf(int ch, int fromIndex)

–从指定位置往回查找,返回找到的最大的字符下标位置

–即返回满足下面条件的最大值:

(this.charAt(k) == ch) && (k <= fromIndex)

–返回-1: 如果当前字符串不含该字符

方法 indexOf

四种重载方法 indexOf() 返回第一次找到时的下标

如果没有找到,则返回-1。实例:

String name = "CoolTools";

System.out.println (name.indexOf("oo"));

方法 startsWith(Stirng prefix):测试此字符串是否以指定的前缀开始,如下:

public class Test{
    public static void main(String[] args) {
    String str = "这里是 Java 笔记";
    String str2 = "Java";
    System.out.println(str.startsWith(str2));
    }
}

 

运行结果:false

方法 startsWith(String prefix,int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

 

public class Test{
    public static void main(String[] args) {
    String str = "这里是 Java 笔记";
    String str2 = "Java";
    System.out.println(str.startsWith(str2,3));
    }
}

 

运行结果:true

方法 endsWith(String suffix):测试此字符串是否以指定的后缀结束

 

4:从当前字符串中抽取子字符串

方法 substring

–substring(int beginIndex)

返回新的字符串: 当前字符串的子串

该子串从指定的位置开始,并一直到当前字符串结束为止

–substring(int beginIndex, int endIndex)

返回新的字符串: 当前字符串的子串

该子串从指定的位置(beginIndex )开始, 到指定的位置(endIndex - 1)

结束

例如:

“unhappy”.substring(2) 返回 "happy"

“Harbison“.substring(3)返回 "bison"

“emptiness”.substring(9)返回 "" (空串)

“emptiness“.substring(10)返回 StringIndexOutOfBoundsException

“hamburger“.substring(4, 8)返回 "urge"

“smiles“.substring(1, 5)返回 "mile"

 

 

5:字符串拼接

方法 concat

–拼接两个字符串,并返回一个新字符串

–源字符串不会被修改

–s1.concat( s2 )

返回字符串 s1 和 s2 拼接的结果

实例:

String s1 = "ABC";

String s2 = "XYZ";

s1 = s1.concat(s2); // 等同于 s1 = s1 + s2;

 

 

6:类 String 的成员方法 valueOf

静态(static)成员方法 valueOf

–将参数的值转化成相应的字符串

–valueOf(char[ ] data)

返回 new String(data);

–valueOf(char[ ] data, int offset, int count)

返回 new String(data, offset, count);

–其它 valueOf 方法的参数的类型: boolean、char、int、long、float、double

和 Object

对象还可以通过方法 toString 转化成字符串

 

 

7:字符串分解

方法 split(String regex)

根据给定正则表达式的匹配拆分此字符串,得到拆分好的字符串数组,示例如下:

public classTest{
    public static void main(String[] args) {
    String str = "这里,是 Java,笔记";
    String tempS[] = str.split(",");//按照“,”对字符串进行拆分
        for(inti=0;i<tempS.length;i++){
    System.out.println("tempS["+i+"]==="+tempS[i]);
        }
    }
}    

 

运行结果:

tempS[0]===

这里

tempS[1]===

是Java

tempS[2]===

笔记

注意:

(1)如果用“.”作为分隔的话,必须是如下写法:String.split("\\."),这样才能正确的分隔开,不能用 String.split(".");

(2)如果用“|”作为分隔的话,必须是如下写法:String.split("\\|"),这样才能正确的分隔开,不能用 String.split("|");

因为“.”和“|”都是转义字符,必须得加"\\";

StringTokenizer 类

与 String 的 split 方法功能类似,也是用来分解字符串,StringTokenizer 是出于兼容性的原因而被保留的遗留类(在新代码中并不鼓励使用它)。建议所有寻求此功能的人使用 String 的split 方法或 java.util.regex 包。所以这里就不多说了。

 

 

8:其它 String 方法

方法 replace( char1, char2 )

–返回一个新的字符串,它是将 s1 中的所有 char1 替换成的结果 char2

–源字符串没有发生变化

–如果 s1 不含 char1, 则返回源字符串的引用,即 s1

实例:

– “mesquite in your cellar”.replace(‘e’, ‘o’) 结 果 返 回

"mosquito in your collar"

–“JonL”.replace(‘q’, ‘x’)结果返回“JonL” (没有发生变化)

方法 toUpperCase

–返回对应的新字符串,所有小写字母都变为大写的,其它的不变

–如果没有字符被修改,则返回源字符串的引用

–类似方法 s1.toLowerCase (所有大写字母都变为小写字母)

方法 trim( )

–返回新字符串,截去了源字符串最前面和最后面的的空白符

–如果字符串没有被改变,则返回源字符串的引用

方法 toString( )

–由于 s1 本身就是字符串了,所以返回 s1 本身

–其它引用类型也可以通过方法 toString,生成相应的字符串

方法 toCharArray( )

–将字符串转换成字符数组

 

方法 intern

–返回具有相同内容的字符串的引用

–如果字符串池含有该内容的字符串,则返回字符串池中具有该内容的字符串的引用

–如果字符串池没有字符串的内容与其相同,则在字符串池中创建具有该内容的字符串,再返回新创建的字符串的引用

字符串池

–组成: 字符串直接量 以及 由方法 intern 产生的字符串

–字符串池中的字符串 s 与 t : s 与 t 具有相同内容(s.equals(t))当且仅当指向 s 与 t 的同一个字符串(s.intern() == t.intern())

–可以采用这个机制加速字符串是否相等的判定

 

 

 

 

 

 

完整的正则表达式语法是比较复杂的,这里只是简单地入个门,更多的正则表达式请参考相应的书籍或者文章。不过没有什么大的必要,常见的正则表达式基本都是写好了的,拿过来用就可以了。

正则表达式是什么

在编写处理字符串的程序时,经常会有查找符合某些复杂规则的字符串的需要,正则表达式就是用于描述这些规则的工具。换句话说,正则表达式就是记录文本规则的代码。

回忆一下在 Windows 下进行文件查找,查找的通配符也就是*和?。如果你想查找某个目录下的所有的 Word 文档的话,你会搜索*.doc。在这里,*会被解释成任意的字符串。和通配符类似,正则表达式也是用来进行文本匹配的工具,只不过比起通配符,它能更精确地描述你的需求——当然,代价就是更复杂——比如你可以编写一个正则表达式,用来查找所有以 0 开头,后面跟着 2-3 个数字,然后是一个连字号“-”,最后是 7 或 8 位数字的字符串(像010-12345678 或 0123-1234567)。

简言之正则表达式是用于进行文本匹配的工具,也是一个匹配的表达式。

正则表达式基础入门

学习正则表达式的最好方法是从例子开始,理解例子之后再自己对例子进行修改,实验 。

下面给出了不少简单的例子,并对它们作了详细的说明。

假设你在一篇英文小说里查找 hi,你可以使用正则表达式 hi。

这是最简单的正则表达式了,它可以精确匹配这样的字符串:由两个字符组成,前一个字符是 h,后一个是 i。通常,处理正则表达式的工具会提供一个忽略大小写的选项,如果选中了这个选项,它可以匹配 hi,HI,Hi,hI 这四种情况中的任意一种。

不幸的是,很多单词里包含 hi 这两个连续的字符,比如 him,history,high 等等。用hi 来查找的话,这里边的 hi 也会被找出来。如果要精确地查找 hi 这个单词的话,我们应该使用bhi\b。

\b 是正则表达式规定的一个特殊代码(某些人叫它元字符,meta character),代表着单词的开头或结尾,也就是单词的分界处。虽然通常英文的单词是由空格或标点符号或换行来分隔的,但是\b 并不匹配这些单词分隔符中的任何一个,它只匹配一个位置。

 

 

假如你要找的是 hi 后面不远处跟着一个 Lucy,你应该用\bhi\b.*\bLucy\b。

.是另一个元字符,匹配除了换行符以外的任意字符。*同样是元字符,不过它代表的不是字符,也不是位置,而是数量——它指定*前边的内容可以连续重复出现任意次以使整个表达式得到匹配。因此,.*连在一起就意味着任意数量的不包含换行符 。 现 在

\bhi\b.*\bLucy\b 的意思就很明显了:先是一个单词 hi,然后是任意个任意字符(但不能是换行符),最后是 Lucy 这个单词。

如果同时使用其它的一些元字符,我们就能构造出功能更强大的正则表达式。比如下面这个例子:

0\d\d-\d\d\d\d\d\d\d\d 匹配这样的字符串:以 0 开头,然后是两个数字,然后是一个连字号“-”,最后是 8 个数字(也就是中国的电话号码。当然,这个例子只能匹配区号为3 位的情形)。

这里的\d 是一个新的元字符,匹配任意的数字(0,或 1,或 2,或……)。-不是元字符,只匹配它本身——连字号。

为了避免那么多烦人的重复,我们也可以这样写这个表达式:0\d{2}-\d{8}。 这里\d后面的{2}和{8}的意思是前面\d 必须连续重复匹配 2 次和 8 次。

在 Java 中运行正则表达式

在 Java 中的 String 类中有好几个方法都跟正则表达式有关,最典型的就是

方法matches(String regex)

告知此字符串是否匹配给定的正则表达式

使用这个方法来测试和运行上面学到的正则表达式,示例如下:

public class Test{
    public static void main(String[] args) {
    String str = "010-86835215";
    System.out.println("str 是一个正确的电话号码？答案是 :
    "+str.matches("0\\d{2}-\\d{8}"));
    }
}

 

运行结果:str是一个正确的电话号码？答案是:true

注意:由于在 Java 里面“\”需要转义,应该变成“\\”。

在 Java 中,有专门进行正则表达式的类,在 java.util.regex 包里面。

1:java.util.regex.Pattern 类

Pattern 类是正则表达式的编译表示形式。

指定为字符串的正则表达式必须首先被编译为此类的实例。然后,可将得到的模式用于创建 Matcher 对象,依照正则表达式,该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中,所以多个匹配器可以共享同一模式

 

常见方法如下:

static Pattern compile(String expression)

static Pattern compile(String expression, int flags):编译正则表达式字符串到 pattern 对象用以匹配的快速处理

参数:

expression 正则表达式

flags 下 列 标 志 中 的 一 个 或 多 个 : CASE_INSENSITIVE, UNICODE_CASE,

MULTILINE, UNIX_LINES, DOTALL, and CANON_EQ

Matcher matcher(CharSequence input):返回一个 matcher 对象,它可以用来在一个输入中定位模式匹配

String[] split(CharSequence input)

String[] split(CharSequence input, int limit):将输入字符串分离成记号,并由pattern 来指定分隔符的形式。返回记号数组。分隔符并不是记号的一部分。

参数:

input 分离成记号的字符串

limit 生成的最大字符串数。

2:java.util.regex.Matcher 类

Mathcer 类通过解释 Pattern 对字符序列执行匹配操作的引擎。

常见方法如下:

boolean matches():返回输入是否与模式匹配

boolean lookingAt():如果输入的起始匹配模式则返回 True

boolean find()

boolean find(int start):尝试查找下一个匹配,并在找到匹配时返回 True

参数:

start 开始搜索的索引

int start():返回当前匹配的起始位置位置

int end():返回当前匹配的结尾后位置

String group():返回当前匹配

int groupCount():返回输入模式中的分组数

int start(int groupIndex)

int end(int groupIndex)

返回一个给定分组当前匹配中的起始位置和结尾后位置

参数:

groupIndex 分组索引(从 1 开始),0 表示整个匹配

String group(int groupIndex):返回匹配一个给定分组的字符串

参数:

groupIndex 分组索引(从 1 开始),0 表示整个匹配

String replaceAll(String replacement)

String replaceFirst(String replacement)

 

返回从 matcher 输入得到的字符串,但已经用替换表达式替换所有或第一个匹配

参数:

replacement 替换字符串

Matcher reset()

Matcher reset(CharSequence input)

复位 mather 状态。

3:Java 中操作正则表达式示例

public class Test{

public static void main(String[] args) {

String str = "010-86835215";

Pattern p = Pattern.compile("0\\d{2}-\\d{8}");

Matcher m = p.matcher(str);

boolean flag = m.matches();

System.out.println("

str是一个

正确的电话号码？答案是:"+flag);

}

}

运行结果:str是一个正确的电话号码？答案是:true

元字符

现在你已经知道几个很有用的元字符了,如\b、.、*,还有\d.当然还有更多的元字符

可用,比如\s 匹配任意的空白符,包括空格,制表符(Tab),换行符,中文全角空格等。\w

匹配字母或数字或下划线或汉字等。

常用的元字符

代码 说明

. 匹配除换行符以外的任意字符

\w 匹配字母或数字或下划线或汉字

\s 匹配任意的空白符

\d 匹配数字

\b 匹配单词的开始或结束

^ 匹配字符串的开始

$ 匹配字符串的结束

下面来试试更多的例子:

例 1:\ba\w*\b

匹配以字母 a 开头的单词——先是某个单词开始处(\b),然后是字母 a,然后是任意数量的字母或数字(\w*),最后是单词结束处(\b)(好吧,现在我们说说正则表达式里的单词是什么意思吧:就是几个连续的\w。不错,这与学习英文时要背的成千上万个同名的东西的确关系不大)。

 

 

例 2:\d+

匹配 1 个或更多连续的数字。这里的+是和*类似的元字符,不同的是*匹配重复任意次(可能是 0 次),而+则匹配重复 1 次或更多次。

例 3:\b\w{6}\b

匹配刚好 6 个字母/数字的单词。

例 4:^\d{5,12}$

匹配必须为 5 位到 12 位数字的字符串

元字符^(和数字 6 在同一个键位上的符号)以及$和\b 有点类似,都匹配一个位置。^匹配你要用来查找的字符串的开头,$匹配结尾。这两个代 码在验证输入的内容时非常有用,比如一个网站如果要求你填写的 QQ 号时,可以使用。

这里的{5,12}和前面介绍过的{2}是类似的,只不过{2}匹配只能不多不少重复 2 次,{5,12}则是重复的次数不能少于 5 次,不能多于 12 次,否则都不匹配。

因为使用了^和$,所以输入的整个字符串都要用来和\d{5,12}来匹配,也就是说整个输入必须是 5 到 12 个数字,因此如果输入的 QQ 号能匹配这个正则表达式的话,那就符合要求

了。

重复

已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下 面是正则表达式中所有的限定符(指定数量的代码,例如*,{5,12}等):

常用的限定符

代码/语法 说明

* 重复零次或更多次

+ 重复一次或更多次

? 重复零次或一次

{n} 重复 n 次

{n,} 重复 n 次或更多次

{n,m} 重复 n 到 m 次

下面是一些使用重复的例子:

Windows\d+ : 匹配 Windows 后面跟 1 个或更多数字

13\d{9} : 匹配 13 后面跟 9 个数字(中国的手机号)

字符类

要想查找数字,字母或数字,空白是很简单的,因为已经有了对应这些字符集合的元字符,但是如果你想匹配没有预定义元字符的字符集合(比如元音字母 a,e,i,o,u),应该怎么办？

很简单,你只需要在中括号里列出它们就行了,像[aeiou]就匹配任何一个英文元音字母,[.?!]匹配标点符号(.或?或!)(英文语句通常只以这三个标点结束)。

我们也可以轻松地指定一个字符范围,像[0-9]代表的含意与\d 就是完全一致的:一位数字,同理[a-z0-9A-Z_]也完全等同于\w(如果只考虑英文的话)。

常见正则表达式

(1):检测是否 Email 地址

^([\\w-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([\\w-]+\\.)

+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$

(2):判断输入的字符串只包含汉字

^[\u4e00-\u9fa5]+$

(3):匹配 3 位或 4 位区号的电话号码,其中区号可以用小括号括起来,也可以不用,区号

与本地号间可以用连字号或空格间隔,也可以没有间隔

^\\(0\\d{2}\\)[- ]?\\d{8}$|^0\\d{2}[- ]?\\d{8}$|^\\(0\\d{3}\\)[- ]?\\d{7}$|

^0\\d{3}[- ]?\\d{7}$

(4):判断输入的字符串是否是一个合法的手机号,这个不完全,只是 13 开头的

^13\\d{9}$

(5):判断输入的字符串只包含数字,可以匹配整数和浮点数

^-?\\d+$|^(-?\\d+)(\\.\\d+)?$

(6):匹配非负整数

^\\d+$

(7):判断输入的字符串只包含英文字母

^[A-Za-z]+$

(8):判断输入的字符串是否只包含数字和英文字母

^[A-Za-z0-9]+$

好了,学到这里对基本的正则表达式就有了基本的认识,下面来看看 String 里面跟正则表达式有关的几个方法的使用。

相关 String 类的方法

方法 matches(String regex)

告知此字符串是否匹配给定的正则表达式

方法 replaceAll(String regex, String replacement)

使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串

示例如下:

public class Test{
    public static void main(String[] args) {
    String str = "
    这里是Java笔记,到Java笔记学习Java";
    String regStr = "Java";
    str = str.replaceAll(regStr, "ABC");
    System.out.println("str="+str);
    }
}

 

运行结果:

str=

这里是

ABC

笔记,到

ABC

笔记学习

ABC

方法 replaceFirst(String regex, String replacement)

使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串

方法 split(String regex)

根据给定正则表达式的匹配拆分此字符串,它是全部拆分

方法 split(String regex, int limit)

根据匹配给定的正则表达式来拆分此字符串,limit 是限制拆分的次数,实际分解

的次数是 limit-1 次,limit 就是分解后数组的 length。

示例如下:

public class Test{
    public static void main(String[] args) {
    String str = "这里,是Java,笔记";
    String tempS[] = str.split(",",2);
        for(int i=0;i<tempS.length;i++){
    System.out.println("tempS["+i+"]=="+tempS[i]);
        }
    }
}    

 

运行结果:

tempS[0]==

这里

tempS[1]==

是

Java,

笔记

 

 

部分内容转自优才网。呵呵。