Day13——StringBuilder，正则表达式，Object，包装类

Day13

StringBuilder

常见构造器

• StringBuilder()：无参，构造一个空char[]

  StringBuilder s = new StringBuilder();
  

• StringBuilder(String str)：有参

  StringBuilder s = new StringBuilder(String str);
  

常见操作

1. 增

   s.append(String str)//将指定字符串添加到字符串末尾
   

2. 删，删除指定范围的字符串

   s.delete(int start, int end);//含左不含右
   

3. 改

   s.replace(int start, int end, String str);//含左不含右
   

4. 插

   s.insert(int index, String str);//在指定索引位置插入字符串
   

5. 反转

   s.reverse();//将字符串反转
   

StringBuffer与StringBuilder

1. 两个类的功能一致

2. StringBuffer在jdk1.0时便出现，StringBuilder在jdk1.5时才出现

3. StringBuffer是线程安全的，可并发处理，性能稍慢

   StringBuilder是非线程安全的，不可并发处理，性能稍快

正则表达式

常见表达式

预定义表达式

数量词

分组()

分组中可以使用|表示或关系

[0-9a-zA-Z_]+@[0-9a-zA-Z]+(\.[a-zA-Z]+)+  //邮箱正则表达式

[\w]+@[\w&&[^_]]+(\.[a-zA-Z]+)+

字符串拆分

将字符串按照特定的分隔符拆分成字符串数组

String[] split(String reget); //以正则表达式为参数，以正则表达式所表示的字符串为分隔符对源字符串进行拆分

String str = "abc123sdf5645sdf35s";
String[] words = str.split("[0-9]+");
System.out.println(Arrays.toString(words)); //[abc, sdf, sdf, s]

• 若字符串中出现了连续的可拆分项，则它们之间会拆分出一个空字符串

String line = "123==456=128=5";
String[] strings = line.split("=");
System.out.println(Arrays.toString(strings)); //[123, , 456, 128, 5]

• 若字符串最开始就是可拆分项，则拆分出的第一项就是空字符串，若连续则拆分出连续空字符串

String line2 = "====123==456=128=5====";
String[] strings2 = line2.split("=");
System.out.println(Arrays.toString(strings2));//[, , , , 123, , 456, 128, 5]

• 若字符串末尾连续出现可拆分项，则不会拆分空字符串，会直接省略

String line1 = "123==456=128=5==========";
String[] strings1 = line1.split("=");
System.out.println(Arrays.toString(strings1));//[123, , 456, 128, 5]

拆分重载方法

split(String regex, int limit)

• regex任然表示拆分标识
• limit表示一共拆分成几项

如下示例中，只拆分两项，索引碰到第一个=拆分后，剩余部分则不再进行操作

String line3 = "123==456=128=5==========";
String[] strings3 = line3.split("=", 2);
System.out.println(Arrays.toString(strings3));//[123, =456=128=5==========]

当limit大于最大可拆分项数时，最后的拆分结果只保留最大拆分项数（末尾若有连续拆分标识，也不再进行省略，会全部拆分为空字符串）

String line4 = "123==456=128=5=====";
String[] strings4 = line4.split("=", 22);
System.out.println(Arrays.toString(strings4));//[123, , 456, 128, 5, , , , , ]

limit为0时，最后拆分结果和不加limit参数效果一样

String line5 = "123==456=128=5=====";
String[] strings5 = line5.split("=", 0);
System.out.println(Arrays.toString(strings5));//[123, , 456, 128, 5]

limit为负数时，最后拆分结果和limit大于最大拆分数的结果相同

String line6 = "123==456=128=5=====";
String[] strings6 = line6.split("=", -2);
System.out.println(Arrays.toString(strings6));//[123, , 456, 128, 5, , , , , ]

替换字符串

replaceAll()方法用于将原字符串中满足指定条件的位置的字符串全部替换为指定字符串

方法格式

1. 第一个参数表示匹配标识，匹配到该标识的字符将用第二参数的字符串进行替换
2. 第二个参数表示要替换成的字符串

str.replaceAll(String regex, String replacement);

示例：将字符串中所有数字换成*

String str = "abc123def456jhi";
String string = str.replaceAll("\\d", "*");
System.out.println(string);//abc***def***jhi

示例：使用正则表达式，将信息中的敏感词汇和谐掉

//和谐用语
String regex = "(wqnblgb|dsb|cnm|mdzz|nmsl|djb)";
String message = "你个wqnblgb! 你真是个dsb，cnm！真是mdzz，nmsl，djb";
String cleanMessage = message.replaceAll(regex, "***");
System.out.println(cleanMessage);//你个***! 你真是个***，***！真是***，***，***

Object类

Java中所有类的父类，即Object是所有类的共性

toString()方法是Object中的重要方法，用于返回对象值的字符串表示，建议子类自己重写该方法

public class point {
    private int x;
    private int y;
    ...//省略构造方法、getter/setter方法
        
 	//重写toString()方法
    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

equals()方法在object中默认为==，对对象的地址进行比较，若要实现其对内容的比较需要对其进行重写

// 重写equals方法，根据x和y的值来判断两个Point对象是否相等
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Point point = (Point) o;
    return x == point.x && y == point.y;
}
// 重写hashCode方法，根据x和y的值来计算对象的哈希值
@Override
public int hashCode() { //hashCode()必须和equals方法一起重写
    return Objects.hash(x, y);
}

包装类

• 在进行类型转换的范畴内，有一种特殊的转换，需要将int这样的基本数据类型转换为对象
• 所有基本类型都有一个与之对应的类，即包装类

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

包装类的创建（Integer为例）

注：valueOf方法创建的方式只适用于-128~127范围内的数据的装箱

This method will always cache values in the range -128 to 127

int a = 123;
Integer i1 = new Integer(a);
Integer i2 = new Integer(a);
System.out.println(i1 == i2); //false,为不同对象

Integer i1 = Integer.valueOf(a);
Integer i2 = Integer.valueOf(a);
System.out.println(i1 == i2); //true,为同一对象

包装类转换为基本类型

小转大直接转，大转小可能会丢精度或者溢出

溢出示例：

Integer i = Integer.valueOf("128");
byte b = i.byteValue();
System.out.println(b);//-128

int b = i1.intValue();
long l = i1.longValue();
...

所有数字类型包装类，都支持两个常量MAX_VALUE和MIN_VALUE

System.out.println(Integer.MAX_VALUE);//2147483647
System.out.println(Integer.MIN_VALUE);//-2147483648

包装类可以将字符串转换为对应的基本类型

条件：该字符串必须正确描述了基本类型可以保存的值，否则会直接抛出异常NumberFormatException

例如：str = “123.123”，转换为int类型，不会丢失精度转化，而是直接报错

String str = "123.123";
int num = Integer.parseInt(str);//error：NumberFormatException
double parseDouble = Double.parseDouble(str);
System.out.println(parseDouble); //123.123