一、String类。
所谓String类就是对字符串这一类事物的描述，该类定义了专用于操作字符串的方法。
class StringDemo{
public static void main(String[] args){
String s1 = new String("abc");
}
}
以上是该String类最传统的定义方法，其中s1是一个String类的引用，“abc”是一个对象，字符串最大的特点是：一被初始化后该对象就不能够再被改变。
package com.itheima;
class StringDemo{
public static void main(String[] args){
String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
}
}
由上面这段程序可以看出，我们构造String类对象可以有两种方法。但是从程序运行的结构来说，s1与s2是不相等的。为什么呢？这是因为s1里面存储的是一个String类对象的引用与s2里面存储的引用不是同一个，s1存在两个对象(s1本身new一个对象，“abc"也是一个对象)，而s2只有一个对象("abc")。而调用equals()方法打印出来的是true，说明s1和s2指向对象封装的内容是相等的。
说明：在String类中的equals()方法是复写了Object类中的equals()方法。它的功能是对两个String类对象内部的字符串进行相同性的比较。
再来一段程序：
package com.itheima;
class StringDemo{
public static void main(String[] args){
String s1 = new String("abc");
String s2 = "abc";
String s3 = "abc";
System.out.println(s1==s2);
System.out.println(s2==s3);
System.out.println(s1.equals(s2));
}
}
为什么s2和s3是想等的呢？这是因为s1和s3内部存放的都是对象"abc"的引用！(s3没有new一个对象，在堆内存中就没有重新分配一个空间产生新地址)
我们学习String类对象-字符串主要是为了学习其内部封装的字符串的处理方法。因为在后期的开发中，对字符串的处理是最基础中的基础工作，所以这个类是十分重要的类。下面我们来一一看一下String类里到底封装了哪些对字符串的操作。
1、获取
char charAt(int index);//获取某一角标代表的字符串。
int length();//获取该字符串长度
int indexOf(int char);//正序地获取字符char(int类型)在字符串里的位置，若该字符串没有char则返回-1
int indexOf(int char a,int fromindex);//正序地从字符串的角标fromindex位置之后获取字符char(int类型)的位置，若该字符串没有'a'则返回-1
int indexOf(String str);//正序地获取字符串str在字符串中的位置，若该字符串没有str则返回-1
int indexOf(String str,int fromindex);//正序地从fromindex位置之后获取str在字符串中的位置，若没找到则返回-1
int lastIndexOf(int char)//倒序地获取字符char(int类型)在字符串里的位置，若该字符串没有char则返回-1，之后还有3个如上函数倒推可得
package com.itheima;
public class StringMethodDemo {
public static void main(String[] args){
huoquMethod("haha.java");
}public static void huoquMethod(String s1){
System.out.println(s1.length());
System.out.println(s1.charAt(10));
System.out.println(s1.indexOf(66));
System.out.println(s1.indexOf(66,3));
System.out.println(s1.indexOf("wwwww"));
System.out.println(s1.indexOf("wwwww",3));
System.out.println(s1.lastIndexOf(66));
}
}
2、判断
boolean contains(String str);//字符串是否包含str字串
boolean isEmpty();//字符串是否为空
boolean endWith(String str);//字符串是否以str字符串结尾
boolean startWith(String str);//字符串是否以str字符串开头
boolean equals(Object obj);//复写了Object类的equals()方法，两个字符串是否相等
boolean equalsIgnoreCase();//比较并且忽略大小写
package com.itheima;
public class StringMethodDemo {
public static void main(String[] args){
panduanMethod("haha.java");
}
public static void panduanMethod(String s1){
System.out.println(s1.isEmpty());
System.out.println(s1.contains("sadada"));
System.out.println(s1.endsWith("java"));
System.out.println(s1.startsWith("haha"));
System.out.println(s1.equals("suidhau"));
}
}
3、转换
将字符数组转成字符：
构造函数形式：String(char[] arr);
String(char[] arr,int setoff,int count);
//将字符数组setoff角标之后的字符转成字符串
静态方法形式：static String copyValueOf(char[] arr);
static String copyValueOf(char[] arr,int setoff,int count);
//将字符数组setoff角标之后的字符转成字符串
将字符串转化成字符数组：char[] toCharArray(String str)
将字符串转化成字节数组：byte[] getBytes()
将字节数组转化成字符串：String(byte[] arr)
将基本数据类型转化成字符串静态方法：static String valueOf(int)...
package com.itheima;
public class StringMethodDemo {
public static void main(String[] args){
zuanhuaMethod("haha.java");
}
public static void zuanhuaMethod(String s1){
char[] arr={'a','b','c'};
byte[] arr1="saujhdade".getBytes();
System.out.println(String.copyValueOf(arr));
System.out.println(String.copyValueOf(arr, 1, 2));
System.out.println(new String(arr));
System.out.println(new String(arr,1,2));
System.out.println(s1.getBytes());
System.out.println(new String(arr1));
System.out.println(s1.toCharArray());
System.out.println(String.valueOf(true));
}
}
4、替换
String replace(char oldchar,char newchar);//将字符串中某一老字符换成新字符
package com.itheima;
public class StringMethodDemo {
public static void main(String[] args){
tihuanMethod("haha.java");
}
public static void tihuanMethod(String s1){
System.out.println(s1.replace("haha", "hehe"));
}
5、切割
String[] split(regex);//将字符串按照正则表达式切割。
package com.itheima;
public class StringMethodDemo {
public static void main(String[] args){
qiegeMethod("haha.java");
}
public static void qiegeMethod(String s1){
String[] arr=s1.split("\\.");
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
6、字串
String subString(int begin);从begin位置到字符串末尾获得字串
String subString(int begin,int end); //从begin位置到end-1角标位置获得字串，包含头不包含尾
package com.itheima;
public class StringMethodDemo {
public static void main(String[] args){
zichuanMethod("haha.java");
}
public static void zichuanMethod(String s1){
System.out.println(s1.substring(1,3));
}
7、转换大小写，去空格，比较
String toUpperCase();//转换成大写
String toLowerCase();//转换成小写
String trim();//去空格
boolean compareTo(String s);//将当前字符串和s进行自然顺序的比较
package com.itheima;
public class StringMethodDemo {
public static void main(String[] args){
OtherMethod("haha.java");
}
public static void OtherMethod(String s1){
System.out.println(s1.toUpperCase());
System.out.println(s1.toLowerCase());
System.out.println(s1.trim());
System.out.println(s1.compareTo("heihei.java"));
}
二、StringBuffer类
所谓StringBuffer类，其实就是一个字符串缓冲区，它就是一个容器。它有三个特点：
1、长度是可变化的
2、可以字节形式操作多个数据类型
3、最终会通过toString()方法变成字符串
StringBuffer类主要也在于对其内部封装的方法的使用上，这些方法是：
1、存储
StringBuffer append(数据);//在该容器中增加一个元素
StringBuffer insert(int index,数据);//在该容器指定位置插入一个元素
package com.itheima;
public class StringBufferDemo {
public static void main(String[] args){
StringBuffer sb = new StringBuffer();
sb.append("wode").append("java").append("xuexi").append("biji");
sb.insert(2, "daxing");
}
2、删除
StringBuffer delete(begin,end);//删除角标为begin到end-1之间的元素
<span style="font-size:18px;">package com.itheima;
public class StringBufferDemo {
public static void main(String[] args){
StringBuffer sb = new StringBuffer();
sb.append("wode").append("java").append("xuexi").append("biji");
sb.insert(2, "daxing");
deleteMethod(sb);
}
public static void deleteMethod(StringBuffer sb){
sb.delete(1, 2);
System.out.println(sb);}
}
3、获取
char charAt(int index);
int indexOf(String str) ;同String类
int lastIndexOf(String str) ;同String类
int length() ;同String类
String substring(int start, int end) ;同String类
太过雷同，不在举例子了！
4、修改
StringBuffer replace(start,end,数据);//将StringBuffer里面的第start号元素到第end-1号元素全部替换成数据
package com.itheima;
public class StringBufferDemo {
public static void main(String[] args){
StringBuffer sb = new StringBuffer();
sb.append("wode").append("java").append("xuexi").append("biji");
sb.insert(2, "daxing");
xiugaiMethod(sb);
}
public static void xiugaiMethod(StringBuffer sb){
sb.replace(1, 5, "javajava");
System.out.println(sb);
}
}
5、反转
StringBuffer reverse();//将当前容器的元素反转
package com.itheima;
public class StringBufferDemo {
public static void main(String[] args){
StringBuffer sb = new StringBuffer();
sb.append("wode").append("java").append("xuexi").append("biji");
sb.insert(2, "daxing");
reverseMethod(sb);
}
public static void reverseMethod(StringBuffer sb){
sb.reverse();
System.out.println(sb);
}
}
在JDK1.5版本以后出现了StringBuilder类，它与StringBuffer类的功能几乎是一模一样，但是他们的区别在于：StringBuffer是线程同步的而StringBuilder是线程不同步的。大部分情况下，为了减少操作步骤，我们一般都使用StringBuilder容器，当出现多线程同步时，可以再代码上自主添加锁，也不用StringBuffer了！
三、正则表达式
所谓正则表达式，就是符合一定规则的表达式，
正则表达式专门作用于字符串，它的特点是：用一些特定的符号来表示一些代码的操作，这样就简化了书写，所以学习正则表达式就是学习一些特殊符号的使用。
它的好处是：可以简化对字符串的复杂操作
弊端：符号定义多阅读性极其差。
正则表达式也是一个字符串，它用于对字符串的操作，一般主要的正则符号有以下几种(注意使用下面带有\的功能时，需要在字符串内表示为\\)：
| 字符类 |
|---|
| [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]（减去） |
| |
|
|---|
| 预定义字符类 |
|---|
| \d | 数字：[0-9] |
| \D | 非数字： [^0-9] |
| \s | 空白字符：[ \t\n\x0B\f\r] |
| \S | 非空白字符：[^\s] |
| \w | 单词字符：[a-zA-Z_0-9] |
| \W | 非单词字符：[^\w] |
| 边界匹配器 |
|---|
| ^ | 行的开头 |
| $ | 行的结尾 |
| \b | 单词边界 |
| \B | 非单词边界 |
| \A | 输入的开头 |
| \G | 上一个匹配的结尾 |
| \Z | 输入的结尾，仅用于最后的结束符（如果有的话） |
| \z | 输入的结尾 |
| |
|
|---|
| Greedy 数量词 |
|---|
| X? | X，一次或一次也没有 |
| X* | X，零次或多次 |
| X+ | X，一次或多次 |
| X{n} | X，恰好 n 次 |
| X{n,} | X，至少 n 次 |
| X{n,m} | X，至少 n 次，但是不超过 m 次 |
正则表达式的应用主要在四个方面：
1、匹配：
使用了String类中的matches()方法,具体用法如下：
package com.itheima;
public class RegexDemo {
public static void main(String[] args){
matchesMethod();
}
public static void matchesMethod(){
String qq = "196788342";
String regex="[1-9]\\d{4,14}";
System.out.println("qq数字是"+qq.matches(regex));
}
}
2、切割
使用了String类中的split()方法。注意：在定义切割标标记时，若标记已经在正则表达式中具有特殊含义，需要在该标记之前加上\\以示区别。
package com.itheima;
public class RegexDemo {
public static void main(String[] args){
splitMethod();
}
public static void splitMethod(){
String files = "wozueiaidejavachengxu.txt.bmp.java";
String regex = "java";
String regex1= "\\.";
String[] arr = files.split(regex);
for(String s:arr){
System.out.println(s);
}
String[] arr1 = files.split(regex1);
for(String s:arr1){
System.out.println(s);
}
}
3、替换
使用了String类中的replace()方法。
package com.itheima;
public class RegexDemo {
public static void main(String[] args){
replaceMethod();
}
public static void replaceMethod(){
String s1 = "wow4874687aiudufh45789451fhuibuh54785dhuasd";
String regex = "\\w+";
System.out.println(s1.replaceAll(regex, "@"));
}
4、获取。注意，该方法需要import java.util.regex.*;
步骤：1、将规则封装成对象 Pattern p = pattern.compile(regex);
2、将规则对象和需要作用的字符串联系起来 matcher m = p.matcher(string);
3、关联后获取正则匹配引擎
4、通过引擎对符合规则的字串进行操作
package com.itheima;
import java.util.regex.*;
public class RegexDemo {
public static void main(String[] args){
getMethod();
}
public static void getMethod(){
String str = "wo zuei ai de bian cheng yu yan shi java";
String regex = "\\d[a-z]{3}\\d";
Pattern p =Pattern.compile(regex);
Matcher m = p.matcher(str);
while(m.find()){
System.out.println(m.group());
System.out.println(m.start()+"。。。。。"+m.end());
}
}
注意，网页爬虫也就是通过网络获得的字符串信息中进行以上获取操作来获得合法的邮箱地址，其规则一般是”\\w+@\\w+(\\.\\w+)\\1+“
四、基本数据类型包装类。
基本数据类型包装类主要有：
int------------integer
byte---------Byte
short--------Short
long---------Long
char---------Character
boolean----Boolean
float---------Float
double------Double
基本数据类型包装类最常见的作用就是用于基本数据类型和字符串之间的转换。
基本数据类型转换成字符串方法：基本数据类型值+”“;
基本数据类型包装类.toString(基本数据类型值)
String.valueOf(基本数据类型值)
public class IntegerDemo {
public static void main(String[] args){
changeToStringMethod();
}
public static void changeToStringMethod(){
Integer x = 321;
if((x+"" instanceof String))
System.out.println("转换成功啦！");
else
System.out.println("转换失败啦！");
if((Integer.toString(x) instanceof String))
System.out.println("转换成功啦！");
else
System.out.println("转换失败啦！");
if((String.valueOf(x) instanceof String))
System.out.println("转换成功啦！");
else
System.out.println("转换失败啦！");
}
}
字符串转换成基本数据类型，以Integer类为列子：Integer.parseint("必须是整型数字字符串")
package com.itheima;
public class IntegerDemo {
public static void main(String[] args){
changeToInteger();
}
public static void changeToInteger(){
if((Integer.parseInt("123")+4)==127)
System.out.println("转换成功啦！");
else
System.out.println("转换失败啦！");
}
此外，基本数据类型包装类还有其他应用，以Integer为列子：
数制转换：
Integer toBinaryString();//将十进制数变成二进制，然后在变成字符串
Integer toHexString();//将十进制变成十六进制
Integer toOctalString();//将十进制变成八进制
小知识：
Integer x=3这种初始化Integer对象的方法叫做自动装箱，可以如此初始化。也可以System.out.println(x//相当于x.value()，叫做自动拆箱)
当自动装箱的值小于127的时候，此时：
Integer x=127；
Integer y=127；
System.out.println(x==y)
此时打印的结果是true，这是因为自动装箱的数值小于byte类型可以表示的最大值时，装箱相同的数值是不会重新产生一个对象的。x和y都是同一个对象的引用。
评论