【黑马】程序员————String类，正则表达式，基本数据类型封装类。

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！-----

[b]一、String类[/b]

常用方法

String s = new String(char[]); //带参数的构造方法，把字符数组转换为字符串

char[] toCharArray() //

Byte[] getBytes()

String s = new String(Byte[],offset,count) ;//字节数组转换为字符串。

String valueOf(int)； //基本数据类型转换为字符串

String valueOf(double)；

equals();　　//按字典顺序各字符比较大小 enqualsIgnoreCase() //忽略大小写比较

int indexOf(); //获取索引，参数类型可以是：(int char)(int char,int fromIndex)(String str)(String,int fromIndex)

int lastIndexOf(); //反向索引。

char charAt(int index)// 获取索引位置的字符

String subString(int fromIndex,int lastIndex) //获取子串

boolean contains(String str) //是否包含某个子串

boolean startsWith(str)/endsWith(str);//某字符串是否以某个字符串结尾/开头

void trim(); //去除两端空格

String[] spit(regex) //切割

String replace(oldChar,newChar) //替换字符，形成新的字符串

练习举例

1.获取一个字符串中某子串出现的次数

/*获取一个字符串中某子串的出现次数
*
*
*/
public class Test6 {

public static void main(String[] args) {

String s = "abaacdebaafaabbagaah";

System.out.println(stringCount(s,"bb"));

}

public static int stringCount(String s1,String s2) {  //封装方法

int count = 0;       //计数器，用来标记字符串出现的次数
while(s1.contains(s2)){

//如果s1包含s2,则把s1截取为除去s2的短串儿，循环，count自增

s1 = s1.substring(s1.indexOf(s2)+s2.length());
System.out.println(s1);
count ++;

}

return count;  //返回count,如果没有该子串，返回0

}

}

2.反转某个字符串

public class Test6 {

public static void main(String[] args) {

String s = "abaacdebaafaabbagaah";

System.out.println(s = reverseString(s));
}

public static String reverseString(String s1) {  //封装方法

char[] ch = s1.toCharArray();  //先转换为字符数组

char temp;

//定义角标，循环互换，自加自减
for(int start = 0,end = ch.length-1;start < end;start++,end--) {

temp = ch[start];
ch[start] = ch[end];
ch[end] = temp;

}

return  new String(ch);  //返回新字符串
}

}

3.字符串排序

package com.fan.testmain;

/*冒泡法字符串排序
*
*/
public class Test6 {
public static void main(String[] args) {

String s1 = "lfkajlfopeiowq";
System.out.println(BubbleStr(s1));

}

public static String BubbleStr(String s1) {

char ch[] = s1.toCharArray();   //将字符串转换为数组
char temp;

for(int i = 0 ; i<ch.length - 1;i++) {   //二层循环冒泡排序
for(int j = 0;j< ch.length - 1 -i;j++) {

if(ch[j] > ch[j+1]) {
temp = ch[j];
ch[j] = ch[j+1];
ch[j+1] = temp;
}

}

}

return new String(ch);   //返回字符串
}
}

4.获取两个字符串的最大相同子串

package com.fan.testmain;

/*冒泡法字符串排序
* 思路：比较两个字符串长度，用max和min表示
*        算法思路是截取min的所有子串，从大到小截取，判断max中是否含有该子串
*/
public class Test6 {
public static void main(String[] args) {

String s1 = "lfkaajlffffffobbbbbbbbbpeiowq";
String s2 = "c";

System.out.println(getSubStr(s1,s2));

}

public static String getSubStr(String s1,String s2) {

String max = (s1.length()>s2.length())?s1:s2;  //获取较长的字符串
String min = (s1 == max)? s2:s1;    // 获取较短的字符串

String s = null;

a:for(int i = 0;i<min.length() - 1;i++) {   //二层循环 截取从大到小的子串
for(int j = 0,k = min.length()-i;k<min.length()+1;j++,k++) {

String s3 = min.substring(j, k);

if(max.contains(s3)) {  //判定条件：如果该串儿被max包含
s = s3;
break a;   //跳出大循环
}

}
}

return s;
}
}

StringBuffer和StringBuilder

StringBuffer和StringBuilder均为容器，用于对字符串进行操作。StringBuffer同步，StringBuilder不同步。

常用方法：

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

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

StringBuffere delete(start,end)：删除缓冲区中的数据，包含start，不包含end。

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

delete(0,对象.length()); 包含头不包含尾

char charAt(int index)； 获取字符

int indexOf(String str)；获取索引

int lastIndexOf(String str)；从尾部获取索引

int length()； 获取长度

String substring(int start,int end)； 获取子串

StringBuffer replace(int start,int end,String str)； 替换

void setCharAt(int index,char ch)； 设置字符

StringBuffer reverse()；

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

[b]二、基本数据类型包装类[/b]

基本数据类型包装类就是把基本数据类型封装成了对象，以便于操作。

数据类型包装类

byte　　Byte

short　Short

int Integer

long Long

float Float

double Double

char Character

boolean　　Boolean

基本数据类型和字符串转换

基本数据类型转换为字符串

1 . 基本数据类型+“”

2. 基本数据类型封装类toString //Interger.toString(9999);

字符串转为基本数据类型 xxx a=Xxx.parseXxx(string)

String s = Integer.toString(666);

int i = Integer.parseInt(s);
Integer i = new Integer("s");

boolean b = Boolean.parseBoolean("ture");

十进制和其他进制转化

public class Test6 {
public static void main(String[] args) {

int i = 10;
System.out.print(Integer.toOctalString(i));  //转换为8进制

int a = Integer.parseInt("12", 8);  //8进制转换为10进制
System.out.print(a);

}

}

自动拆箱装箱1.5新特性

Integer i = new Integer(20) //旧写法，创建了对象

1.5新特性自动拆装箱子：

Integer i = 20; //简化书写

i += 20; //先拆箱，进行数据运算，之后装箱返回i.

Integer a =127;

Integer b = 127;

a==b为true.

这是因为当数据小于一个字节时候，数据共享，当大于一个字节后，会开辟另一个空间，地址值不同，所以值为false.

三、正则表达式

正则表达式是符合一定规则的表达式，专门用于操作字符串，可以简化对字符串的复杂操作。但是

当正则表达式过长时，影响阅读性

正则表达式规则

1、字符

x 字符 x

\\ 反斜线字符

\t 制表符 ('\u0009')

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

\r 回车符 ('\u000D')

\f 换页符 ('\u000C')

\a 报警 (bell) 符 ('\u0007')

2、字符类

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

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

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

[a-d[m-p]] a到 d或 m 到 p：[a-dm-p]（并集）

[a-z&&[def]] d、e或 f（交集）

[a-z&&[^bc]] a到 z，除了 b和 c：[ad-z]（减去）

[a-z&&[^m-p]] a到 z，而非 m到 p：[a-lq-z]（减去）

3、预定义字符类

. 任何字符（与行结束符可能匹配也可能不匹配）

\d 数字：[0-9]

\D 非数字： [^0-9]

\s 空白字符：[ \t\n\x0B\f\r]

\S 非空白字符：[^\s]

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

\W 非单词字符：[^\w]

4、边界匹配器

^ 行的开头

$ 行的结尾

\b 单词边界

\B 非单词边界

\A 输入的开头

\G 上一个匹配的结尾

\Z 输入的结尾，仅用于最后的结束符（如果有的话）

\z 输入的结尾

5、Greedy数量词

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

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n次

X{n,} X，至少 n次

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

6、组和捕获

捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C)))中，存在四个这样的组：

1 ((A)(B(C)))

2 \A

3 (B(C))

4 (C)

组零始终代表整个表达式。在替换中常用$匹配组的内容。

正则表达式程序举例

匹配 QQ号校验：长度5-15，0不能开头

　　 手机号校验 13* 15* 18*

/*正则匹配示例
*/
public class Test6 {
public static void main(String[] args) {

System.out.println(qqCheck("03203021"));
System.out.println(phoneNumberCheck("13934242321"));

}

public static boolean qqCheck(String s) {

String regex = "[1-9]\\d{4,14}";    //0不开头，5-15位

return s.matches(regex);

}

public static boolean phoneNumberCheck(String s) {

String regex = "1[358]\\d{9}";   //13，15，18开头，长度11位

return s.matches(regex);

}

}

切割

String regex1="\\.";//按 .切
String regex2=" +";//按空格切，可能有一个空格或者多个空格
String regex3="(.)\\1+";//按照出现两次或者以上的叠词切  ()是组的概念，后面的1是指第一个组+

替换

String regex1="\\d{5,}";//把5个以上的数字替换

String s1="erej569831217woshi2659810wosxs12356f";
System.out.println(s1.replaceAll(regex1, "*"));

获取　　

1）将正则表达式封装成对象。

2）让正则对象和要操作的字符串相关联。

3）关联后，获取正则匹配引擎。

4）通过引擎对符合规则的子串进行操作，比如取出。

public class Test6 {
public static void main(String[] args) {

String regex="\\b[a-z]{1,4}\\b";     //将所有单词打印
String s1 = "jin tian xing qi wu shang shan da lao hu";
getStr(s1,regex);
}

public static void getStr(String s,String regex) {

Pattern p = Pattern.compile(regex);  //将regex封装成对象
Matcher m = p.matcher(s);   //匹配字符串

while(m.find()) {   //应用字符串
System.out.println( m.group()); //输出结果
}

}

}