Java常用类库（Object类、String类、StringBuffer类、包装类、Math类、System类）详解

常用类库

java.lang

java.lang包下放置了Java开发中常用的类和接口，所以为简化该包下类的使用，java.lang包下的类在使用时不需要导入这些类

java.lang包下常用类有：

• Object
• String
• StringBuffer和StringBuilder
• 八种基本数据类型的包装类
• Thread等等

一、Object类

java.lang.Object类是类层次结构中最顶层父类。所有的类(包括数组)直接或者间接的继承自Object类，同时也继承了该类中的方法

Object的构造方法:

• Object类只有一个无参的构造方法
• Object()

Object中常用的方法:

• boolean equals(Object o) 比较两个对象是否相同
• int hashCode() 返回一个对象的哈希码
• String toString() 将一个对象转换为字符串

1.getClass()

获取该对象的类的完整路径结构！

//getClass():  //获取该对象的类的完整结构
Student stu= new Student("张三",18);
Class clazz = stu.getClass();
System.out.println(clazz);


Class clazz_1 = Student.class;
String name = clazz_1.getName();//获取完整路径
System.out.println(name);

String simpleName = clazz_1.getSimpleName();
System.out.println(simpleName);//获取当前类名
           

运行结果：

class com.changyongleiku.Objece_1.Student
com.changyongleiku.Objece_1.Student
Student
           

2.hashcode()*

获取对象在内存中的地址！

@Override
public int hashCode() {
    return Objects.hash(name, age);
}
           

//hashcode() //获取对象在内存中的地址
int i = stu.hashCode();
System.out.println(i);
           

运行结果：

460141958

注意：

相同的对象应该具有相同的哈希码值，所以重写equals()的方法也要重写hashcode()方法。

3.toString()*

对象的字符串形式！

@Override
public String toString() {
    return super.toString();
}
           

重写toString()方法：

@Override
public String toString() {
return this.name+"  "+this.age;
}
//toString()对象的字符串形式
System.out.println(stu);
           

运行结果：

张三 18

4.equals()*

判断字符串是否相等：

equals(Object obj);判断传入的对象和当前对象是否相等

boolean equals(Object o):

• Object类的equals方法用于判断两个对象是否相等
• Object类的equals方法的返回值为boolean的true和false
• Object类的equals方法只有一种情况返回true：两个非空的引用变量o1和o2指向的是同一个对象时

//判断传入的对象和当前对象是否相等
public boolean xd(Object obj){
    if(obj == null){
        return false;
    }if(!(obj instanceof Student)){
        return false;
    }
    Student stu = (Student)obj;
    if(stu.getAge() == this.age && stu.getName() == this.name){
        return true;
    }
    return false;
}

//自己写的    
           

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age &&
            Objects.equals(name, student.name);
}

//自带的

           

equals方法和==的区别:

• ==可以用于比较基本数据类型的值
• ==可以用于比较两个对象是否相等
• equals只能比较两个对象是否相等

== 比较地址（基本数据类型）

equals比较值（引用数据类型）

注意：

当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码.

5.Clone()

克隆： 要实现接口Cloneable

public class Student implements Cloneable{


@Override
protected Object clone() throws CloneNotSupportedException {
    return super.clone();
	}
 }
           

克隆后判断相等。

Student stu_3 = (Student)stu.clone();
System.out.println(stu.equals(stu_3));
           

6.finalize()

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

7.创建一个类重写方法

package com.changyongleiku.Objece_1;

import java.util.Objects;

public class PErson {
    private String name;
    private int age;
    private String gender;
    private String email;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
    
    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

/*    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        PErson pErson = (PErson) o;

        if (age != pErson.age) return false;
        if (name != null ? !name.equals(pErson.name) : pErson.name != null) return false;
        if (gender != null ? !gender.equals(pErson.gender) : pErson.gender != null) return false;
        return email != null ? email.equals(pErson.email) : pErson.email == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        result = 31 * result + (gender != null ? gender.hashCode() : 0);
        result = 31 * result + (email != null ? email.hashCode() : 0);
        return result;
    }*/

    //判断字符串是否相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PErson pErson = (PErson) o;
        return age == pErson.age &&
                Objects.equals(name, pErson.name) &&
                Objects.equals(gender, pErson.gender) &&
                Objects.equals(email, pErson.email);
    }

    //哈希编码
    @Override
    public int hashCode() {
        return Objects.hash(name, age, gender, email);
    }

    //显示属性
    @Override
    public String toString() {
        return "PErson{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", email='" + email + '\'' +
                '}';
    }

    //构造方法
    public PErson() {
    }

    public PErson(String name, int age, String gender, String email) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.email = email;
    }
}
           

二、String类

• String类代表字符串，提供了开发中常用的字符串处理的方法，如：求字符串的长度、截取字符串、替换字符串等方法

• 字符串是常量，它的值创建之后就不可以再修改了。

  String类常用构造方法

  • String() 无参构造方法
  • String(String str) 有一个字符串参数的构造方法
  • String(char[]ch) 有一个char类型数组参数的构造方法
  • String(byte[] b) 有一个byte数组参数的构造方法

声明和创建字符串对象的方式

String类常用方法：

• int length() 求字符串值的字符个数
• boolean equals(Object o) 比较两个字符串是否相同
• String replace(char old,char n) 字符串替换
• char charAt(int index) 返回指定字符串指定位置的字符
• int **compareTo(String s)**按字典顺序比较字符串大小
• boolean endsWith(String s) 比较字符串是否以指定的参数结尾
• boolean **startsWith(String s)**比较字符串是否以指定的参数开头
• String **valueOf(int i)**将基本数据类型转换为字符串
• boolean isEmpty() 判别一个字符串值的长度是不是为0
• int indexOf(int ch) 返回指定字符ch在字符串中的索引
• int **lastIndexOf(int ch)**返回指定字符ch在字符串中最后出现的索引
• String **substring(int begin)**从指定索引位置截取字符串
• split 根据给定分隔符拆分此字符串
• toCharArray 将此字符串转换为一个新的字符数组。
• toLowerCase 转小写
• toUpperCase 转大写
• trim 去掉前后空格/忽略前导空白和尾部空白
• concat 字符串拼接

String类中的构造方法和常用方法：

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws UnsupportedEncodingException {

        //常用构造方法

        //String 类被final修饰，
        //字符串一旦声明好，长度不能改变。对他的运算就是产生新的字符串。
        String str = "hello";//基本数据类型
        String s = new String("hello");//引用数据类型
        System.out.println(s.equals(str));//true
        System.out.println(s==str);//false

        //将ASCII转换成字符
        s = new String (new byte[]{97, 98, 99});
        System.out.println(s);//abc

        s = new String(new byte[]{97,98,99},"utf8");
        System.out.println(s);//abc

        //编码   解码
        s = "好";
        byte[] utf8s = s.getBytes("utf8");
        for (int i = 0; i < utf8s.length; i++) {
            System.out.println(utf8s[i]);
        }
        /*  -27
            -91
            -67*/

        s = new String(utf8s,"utf8");
        System.out.println(s);//好



        //常用方法

        //charAt()  返回指定索引处 的Char值
        s = "sadqwdzxc";
        char c = s.charAt(3);
        System.out.println(c);//q


        //compareTo    按字典顺序比较两个字符串
        int qwe = s.compareTo("qwe");
        System.out.println(qwe);//2

        int aFc = s.compareToIgnoreCase("AFc");//忽略大小写，按字典顺序比较两个字符串
        System.out.println(aFc);//18

        //concat 字符串拼接
        s = "sadqwdzxc";
        String concat = s.concat(" word");
        System.out.println(concat);//sadqwdzxc word


        //contains    是否包含此字符
        s = "sadqwdzxc";
        boolean a = s.contains("a");
        System.out.println(a);//true


        //endsWith     判断是否以该字符结尾的
        s = "sadqwdzxc";
        boolean wewe = s.endsWith("wewe");
        System.out.println(wewe);//false

        //startsWith     判断是否以该字符开头的
        s = "sadqwdzxc";
        boolean wewe1 = s.startsWith("wewe");
        System.out.println(wewe);//false

        //indexOf   返回指定字符在此字符串中第一次出现处的索引
        s = "sadqwdzxc";
        int d = s.indexOf("d");
        System.out.println(d);//2


        //isEmpty     当且仅当 length() 为 0 时返回 true
        boolean empty = s.isEmpty();
        System.out.println(empty);//false

        //replace   返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
        s = "sadqwdzxc";
        String replace = s.replace("d", "*");
        System.out.println(replace);//sa*qw*zxc


        //split    根据给定分隔符拆分此字符串
        s = "aaa,bbb,ccc,ddd";
        String[] split = s.split(",");
        System.out.println(Arrays.toString(split));//[aaa, bbb, ccc, ddd]

        //substring    从指定位置 截取返回一个新的字符串，它是此字符串的一个子字符串。
        s = "hello world";
        String substring = s.substring(6);
        System.out.println(substring);//world

        //substring   截取指定索引到指定索引的元素  [左闭右开）
        String substring1 = ss.substring(2,4);
        System.out.println(substring1);//ll
        
        //toCharArray     将此字符串转换为一个新的字符数组。
        char[] chars = s.toCharArray();
        System.out.println(chars);//hello world

        //toLowerCase  转小写
        String s1 = s.toLowerCase();//转小写
        System.out.println(s1);//hello world

        //toUpperCase   转大写
        String s2 = s.toUpperCase();
        System.out.println(s2);//HELLO WORLD


        //trim   去掉前后空格/忽略前导空白和尾部空白
        s= " sd sd dasd  ";
        String trim = s.trim();
        System.out.println(trim);//sd sd dasd


        //转成字符串
        int i = 1;
        s = i + "";
        String s4 = String.valueOf(10);
        System.out.println(s);//1
        System.out.println(s4);//10


        // valueOf   返回 char 数组参数的特定子数组的字符串表示形式
        String s3 = String.valueOf(new char[]{'a', 's', 's', 'a', 's'}, 2, 3);
        System.out.println(s3);//sas
    }
}
           

String类、StringBuffer和StringBuilder之间的区别：

String字符串是常量，一旦创建无法修改

StringBuffer和StringBuilder是可变字符串，创建之后仍可以修改

StringBuffer是线程安全的、StringBuilder线程不安全

三、StringBuffer类和StringBuilder

StringBuffer和StringBuilder都是带有缓冲区的可变字符串

为什么要使用StringBuffer或者StringBuilder？

一个String对象的长度是固定的，不能改变它的内容，也不能附加新的字符至String对象中。可以使用加号“+”运算符来连接字符串以达到附加新字符或字符串的目的，但使用加号“+”运算符会产生一个新的String实例，即需要另外分配空间。如果既想节省开销，又能改变字符串的内容，则可以使用StringBuilder类。

StringBuffer类的构造方法

• StringBuffer()
• StringBuffer(String s)

StringBuffer的常用方法

• StringBuffer **append(int i)**在可变字符串末尾追加I
• StringBuffer **insert(int offset,String s)**在可变字符串指定位置插入另外一个字符串s
• int length() 返回可变字符串中字符的个数
• String toString() 将可变字符串转化为字符串对象

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

        String a = "as";
        //构造方法

        //构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符
        StringBuffer s = new StringBuffer();

        //构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
        String str = "hello word   ";
        StringBuffer ss = new StringBuffer(str);
        System.out.println(ss);


        //常用方法

        //append     追加
        ss.append("  hello");
        System.out.println(ss);//hello word     hello

        //delete   删除
        ss.delete(15,20);//开始下标，结束下标
        System.out.println(ss);//hello word


        //insert    插入
        ss.insert(5,"hello");//插入位置，插入字符
        System.out.println(ss);//hellohello word

        //replace  替换
        ss.replace(0,5,"*****");//开始下标，结束下标，替换字符
        System.out.println(ss);//*****hello word

        //reverse()  倒转
        ss.reverse();
        System.out.println(ss);//     drow olleh*****

        //toString  转回字符串
        String s1 = ss.toString();
        System.out.println(s1);


    }
}
           

四、包装类

java.lang包下为8种基本数据类型提供对应的包装类

8中基本数据类型以及对应的包装类

包装类提供了字符串、基本数据类型和包装类相互转化的方法

数字基本数据类型的包装类都继承了Number类，它们的使用方式相似，下面以常用的基本数据类型int对应的包装类Integer为例说明数字类型包装类的使用。

基本数据类型 int值转化为Integer类型对象:

• int i = 20;
• Integer integer1 = new Integer(i);//方法一
• Integer integer2 = Integer.valueOf(i);//方法二
• Integer对象转化为基本数据类型int值:
  • Integer integer = new Integer(20);
  • int i1 = integer**.intValue**();
• String类型的数字转化为Integer对象:
  • String s = “120”;
  • Integer integer1 = new Integer(s);//方法一
  • Integer integer2 = Integer.valueOf(s);//方法二
• Integer类型转化为String类型:
  • Integer integer = new Integer(20);
  • String s1 = integer.toString();

String类型的数字转化为基本数据类型的int值:

• String s = “120”;
• int i1 = Integer.parseInt(s);//方 法一
• Integer integer = new Integer(s);
• int i2 = integer.intValue();//方法二

基本数据类型int转化为字符串:

• int i1 = 20;
• String str = String.valueOf(i1);//方法一
• str = Integer.toString(i2);//方法二

Integer的equals方法:

• Integer的equals方法继承自Object，并且进行了重写
• Integer的equals方法只有一种情况返回true：两个Integer类型的对象 i1 和 i2包含的值相等时；其他情况返回false

如:

• Integer i1 = new Integer(20);
  • Integer i2 = new Integer(30);
  • Integer i3 = new Integer(20);
  • boolean b = i1.equals(i2);//false
  • b = i1.equals(i3);//true

根据基本数据类型int和对应包装类Integer的知识，总结如下内容

• byte/short/long/float/double类型和包装类之间转换的方法
• byte/short/long/float/double的包装类和字符串之间的转换方法
• byte/short/long/float/double类型和字符串之间的转换方法

boolean类型的包装类Boolean

• Boolean用于将一个基本数据类型boolean值包装为对象

将boolean值转换为Boolean对象

• Boolean b1 = new Boolean(true);//方法一
• Boolean b2 = Boolean.valueOf(true);//方法二

将Boolean对象转换为boolean值

• Boolean b = new Boolean(true);
• boolean b1 = b.booleanValue();//方法一

String类型对象转换为Boolean对象

• String s=“true”;
• Boolean b1 = new Boolean(s);//方法一
• Boolean b2 = Boolean.valueOf(s);//方法二

将Boolean对象转换为String类型

• Boolean b = new Boolean(true);
• String s1 = b.toString();//方法一
• String s2 = Boolean**.toString**(b);//方法二
• String s3 = String.valueOf(b);//方法三

boolean值转换为String对象

• boolean b = true;
• String s1 = String.valueOf(b);

String对象转换为boolean值

• String s = “true”;
• boolean b1 = Boolean.parseBoolean(s);//方法一
• Boolean b = new Boolean(s);
• boolean b2 = b.booleanValue();//方法二

字符包装类Character用于将char类型值包装为对象

将char值转换为Character对象

• Character c1= new Character(‘A’);//方法一
• Character c2 = Character.valueOf(‘A’);//方法二

将Character对象转换为char值

• Character c1= new Character(‘A’);
• char ch1 = c1.toString();//方法一
• char ch2 = Character.toString(c1);//方法二

Character包装类除了提供以上char和Character相互转换的方法外也提供了以下有用的方法

包装类是将基本数据类型的值包装为Java中的对象，Java语言为8种基本数据类型分别提供了包装类.

包装类提供了基本数据类型、包装类、字符串之间的相互转换的方法，这些转换的的方法在今后的开发中十分有用。

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


 //包装类
 //把基本数据类型包装一下，


        //Integer   构造方法的使用
        //int--> Integer
        Integer i = new Integer(90);
        Integer.valueOf(i);
        System.out.println(i);//90


        //Integer--> int
        int i1 = i.intValue();
        System.out.println(i1);//100

        //String-->Integer
        i = new Integer("100");//只能转  "数字"
        Integer.valueOf(i);

        System.out.println(i);//100

        //Integer--> String
        String s = i.toString();
        System.out.println(s);//100

        //int-->String
        String str = 10 +"";
        String s1 = String.valueOf(str);
        System.out.println(s1);

        //String --> int
        i = Integer.parseInt(str);
        System.out.println(i);

        //其他常用方法
        Integer x = new Integer(3);
        Integer y = new Integer(5);

        //compareTo  比较两个对象大小
        int i2 = x.compareTo(y);
        System.out.println(i2);//-1  //x<y



 //boolean  类型的包装类

        //boolean --> Boolean
        Boolean boo = new Boolean(true);
        System.out.println(boo);

        //String --> boolean
        boo = new Boolean("true");
        System.out.println(boo);//ture

        boo = new Boolean("sdadadad");
        System.out.println(boo);//false

        //Boolean --> boolean
        boolean b = boo.booleanValue();
        System.out.println(b);

        //String-->boolean
        boolean asdad = Boolean.parseBoolean("asdad");
        System.out.println(asdad);//false

        //Boolean -- > String
        boo.toString();
        System.out.println(boo);//false


 //Character  包装类

        //char --> Character
        Character charq = new Character('a');

        //Character-->char
        charq.charValue();

        //Character-->String
        charq.toString();

        //char-->String
        String.valueOf('a');

        //String --> char
        "a".charAt(0);



 //Character的其他方法

        Character cc = new Character('a');

        //  isDigit 确定指定字符是否为数字。
        boolean a = Character.isDigit('5');
        System.out.println(a);//true

        //isLetter  确定指定字符是否为字母。
        boolean a_1 = Character.isLetter('K');
        System.out.println(a_1);//true

        //isLetterOrDigit  确定指定字符（Unicode 代码点）是否为字母或数字。
        boolean a_2 = Character.isLetterOrDigit('K');
        System.out.println(a_2);//true


        // isLowerCase  确定指定字符是否为小写字母。
        boolean a_3 = Character.isLowerCase('K');
        System.out.println(a_3);//fasle

        // isUpperCase  确定指定字符是否为大写字母。
        boolean a_4 = Character.isUpperCase('K');
        System.out.println(a_4);//true


        // 确定指定字符是否为空白字符。isWhitespace
        boolean spaceChar = Character.isSpaceChar(' ');
        System.out.println(spaceChar);//true
        boolean whitespace = Character.isWhitespace('\n');///\\一般用这个
        System.out.println(whitespace);//true

        //转小写toLowerCase     |、转大写：toUpperCase
        Character.toLowerCase('H');


    }
}

           

自动拆装箱：

public class main {

    public static void main(String[] args) {

        //自动拆装箱

        //自动装箱
        Integer i = 10;
        Boolean o = true;

        Integer q = 10;
        Integer w = 10;
        System.out.println(q==w);//true

        Integer q_1 = 200;
        Integer w_1 = 200;
        System.out.println(q_1==w_1);//false
        /* 范围  -128 ~  127  一个字节内相等*/
        
        //自动拆箱
        int j = new Integer(10);
        boolean ji = new Boolean(true);
        
        //自动装箱
        tt(5);
    }
    public static void tt(Object o){
        System.out.println(o);
    }
}
           

五、Math类

在java.lang.Math类中提供了在数学应用中常见的常量(如：PI值)以及方法(如：三角函数)

Math的构造方法是私有的，所有无法创建Math对象

Math中只有static修饰的常量和类方法

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

//Math类    静态方法
        Math.max(10,14);//最大
        double pi = Math.PI;  //静态常量  pi
        Math.ceil();//向上取整
        Math.floor();//向下取整
        Math.round();//四舍五入
        Math.sqrt();//平方根
        Math.random();//获取一个随机数
        
        
//Random类    随机数
        //Random r = new Random();
        //r.nextInt(101);//1-100之间的随机数
        
        
//Sanner类  扫描器
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();//输入一个整数
        String next = sc.next();//获取输入的字符串,以空格结束，空格后面的获取不到
        String s = sc.nextLine();//获取输入的一整行
    }
}
           

六、System

• System类代表运行时系统，提供了一些获取设置和获取当前系统运行环境的方法
• System有三个成员变量
  • in 标准输入流
  • out 标准输出流
  • err 错误输出流

System中的方法

• System.arrayCope()//快速复制数组的方法
• System.exit(0);//退出Java虚拟机的方法

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

//System类
        System.out.println("hello word");
        PrintStream out = System.out;//输出流
        InputStream in = System.in;//输入流

        //从1970年到现在的秒数
        long l = System.currentTimeMillis();
        System.out.println(l);//1626939039073
        long l_1 = System.currentTimeMillis();
        System.out.println(l_1-l);//0

        System.exit(0);//退出虚拟机   后面的东西不会运行

    }
}
           

七、练习

练习一：

1.创建一个Student类，该有String类型的学号stuNo,String类型的姓名，要求将该类所有的成员变量进行封装，并且提供公共的getter和setter方法，重写equals方法，只要学生的学号相同即返回true，重写toString()方法，toString方法返回值类似”姓名:张三 学号:201301 ”

String 类 String str = “abcd”; 求字符串的字符个数

将str字符串截取为”cd”

import java.util.Objects;

public class Student {
    private String stuNo;
    private String name;

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }



    //只要学生的学号相同即返回true
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(stuNo, student.stuNo);
    }

    @Override
    public int hashCode() {
        return Objects.hash(stuNo);
    }

    @Override
    public String toString() {
        return "学号：'" + stuNo + '\'' +
                ", 姓名='" + name + '\'' ;
    }

    //字符个数
    public int count(String str){
        return str.length();
    }

    //截取字符
    public String jie(String str){
        return str.substring(2);
    }

    public Student() {
    }

    public Student(String stuNo, String name) {
        this.stuNo = stuNo;
        this.name = name;
    }
}
           

public class main {
    public static void main(String[] args) {
        Student stu = new Student("1026", "张三");
        Student stu_1 = new Student("1026", "李四");

        boolean equals = stu.equals(stu_1);
        System.out.println("两个学生是否相等："+equals);

        String str = "abcd";

        //打印学生信息
        System.out.println(stu.toString());
        System.out.println(stu_1.toString());

        //获取字符串个数
        int count = stu.count(str);
        System.out.println("字符串个数为："+count);

        //截取字符串
        String jie = stu.jie(str);
        System.out.println("截取后的字符串为："+jie);
    }

}
           

练习二：

编写敏感词过滤程序

在网络程序中，如聊天室、聊天软件等，经常需要对一些用户所提交的聊天内容中的敏感性词语进行过滤。如“性”、“色情”、“爆炸”、“恐怖”、“枪”等，这些都不可以在网上进行传播，需要过滤掉或者用其他词语替换掉。

思路：将用户的聊天内容保存到一个字符串对象或一个StringBuilder对象中，然后与敏感词语进行比对。如果属于敏感词语，就过滤掉或替换掉。

正则解法：

public class Genghuan {
    public static String gh(String str){
        return str.replaceAll("(?:性|色情|爆炸|恐怖|枪)","*");

​    }
}
           

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

        String str = "你性福吗，色情这个东西，恐怖分子拿着枪，闯进了银行！";
        String gh = Genghuan.gh(str);
        System.out.println(gh);

    }
}
           

StringBuffer 解法：

package com.changyongleiku.hw.hw_2;

public class mmIN {
    public static void main(String[] args) {
        String[] a = {"性","爆炸","在这里","怎样"};
        String aa = "asdad性sdjafj爆炸sdsad性是否奈法在这里啊，你要怎么样怎样啊";
        StringBuffer ss = new StringBuffer(aa);

        for (int i = 0; i < a.length; i++) {
            StringBuffer aaaa = new StringBuffer();
            for (int j = 0; j < a[i].length(); j++) {
                aaaa.append("*");
            }

            for(;;) {
                ss.replace(ss.indexOf(a[i]), ss.indexOf(a[i]) + a[i].length(), String.valueOf(aaaa));
                if(ss.indexOf(a[i])<0){
                    break;
                }
            }
        }
        ss.toString();
        System.out.println(ss);
    }
}
           

练习三：

在注册时通常要验证用户名和密码是否合法，运用学习过的知识完成如下操作：

用户名长度大于等于6位，必须包含数字和英文字母

密码长度大于等于8位，必须包含特殊符合_或者$，英文字母以及数字

以上两个条件同时成立注册才能成功。

正则解法：

public class ZhuCe {
    private String usename;
    private String password;

    public void check(String username, String password) {

        if ((username.length() < 6 || password.length() < 8) && (username != "^(\\d+[A-Za-z]+[A-Za-z0-9]*)|([A-Za-z]+\\d+[A-Za-z0-9]*)$"
                || password != "^[[0-9]+[a-zA-Z]+[$|_]+]+$")) {

            System.out.println("注册失败");
        } else {
            System.out.println("注册成功");

        }
    }
    public String getUsename() {
        return usename;
    }

    public void setUsename(String usename) {
        this.usename = usename;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

    public ZhuCe() {
    }

    public ZhuCe(String usename, String password) {
        this.usename = usename;
        this.password = password;
    }
           

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

        ZhuCe z = new ZhuCe();
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入要注册的账号：");
        String zhanghao = scan.next();
        System.out.println("请输入要注册的密码：");
        String mima = scan.next();
        z.setUsename(zhanghao);
        z.setPassword(mima);
        z.check(z.getUsename(), z.getPassword());
    }
}
           

Character解题：

package com.changyongleiku.hw.hw_3;

public class User1 {
    
    //注册账号功能
    public boolean verifyUserName(String username){
        if(username.length()>=6&&containsDigit(username)&&containsLetter(username)&&!containsSpecialChar(username)&&!containsOtherSpecialChar(username)){
            return true;
        }
        return false;
    }

    //注册密码
    public boolean verifyPassword(String password){
        if(password.length()>=8&&containsDigit(password)&&containsLetter(password)&&containsSpecialChar(password)&&!containsOtherSpecialChar(password)){
            return true;
        }
        return false;
    }


    // 是否包含数字
    public boolean containsDigit(String str){
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if(Character.isDigit(chars[i])){
                return true;
            }
        }
        return false;
    }

    // 是否包含字母
    public boolean containsLetter(String str){
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if(Character.isLetter(chars[i])){
                return true;
            }
        }
        return false;
    }


    // 是否包含_或者$
    public boolean containsSpecialChar(String str){
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if(chars[i]=='_'||chars[i]=='$'){
                return true;
            }
        }
        return false;
    }

    // 是否包含其他字符
    public boolean containsOtherSpecialChar(String str){
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if(chars[i]!='_'&&chars[i]!='$'&&!Character.isDigit(chars[i])&&!Character.isLetter(chars[i])){
                return true;
            }
        }
        return false;
    }
}
           

package com.changyongleiku.hw.hw_3;

public class mmmmAin {
    public static void main(String[] args) {
        User1 us = new User1();
        boolean a1 = us.verifyUserName("asdawweqf123");
        boolean a2 = us.verifyPassword("asdaszc12151_");
        if(a1 && a2){
            System.out.println("注册成功！");
        }else{
            System.out.println("注册失败！");
        }
    }
}