Java知识点整理(API) StringBuilder 正则表达式 Object

是阿柒

已于 2022-11-30 23:54:46 修改

阅读量192

点赞数

CC 4.0 BY-SA版权

分类专栏： JAVA 文章标签： java 开发语言

于 2022-11-22 21:36:00 首次发布

本文链接：https://blog.youkuaiyun.com/SlimShadyback/article/details/127989240

JAVA 专栏收录该内容

33 篇文章

订阅专栏

本文介绍Java中StringBuilder类的使用方法及其优势，并详细解释了正则表达式的常见用法，包括matches(), replaceAll(), 和 split()等方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.StringBuilder:

由于String是不变对象,每次修改内容都会创建新的对象,因此String不适合频繁修改操作,为了解决这个问题,java提供了StringBuilder类

StringBuilder是专门用于修改字符串的一个类,内部维护一个可变的char数组,所做操作都是在这个数组的基础上进行,修改速度,性能优秀,并且提供了修改字符串的常见方式:增,删,改,插

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

        StringBuilder s = new StringBuilder("a");
        for (int i = 0; i < 10000000; i++) {
            s.append(i);//做添加,不新建对象

        }
        System.out.println("执行完毕");


//        //String不适合频繁修改内容(效率低)(一直在新建对象)
//        String s = "a";
//        for (int i = 0; i < 100000000; i++) {
//            s +=i;
//
        }

2.StringBuilder常用方法:

append():追加内容-----增

delete():删除部分内容-----删

replace():替换部分内容----改

insert():插入内容-------插

public class StringBuilderDemo {

    public static void main(String[] args) {
        String str = "好好学习java";
        //复制str的内容到builder中----------好好学习java
        StringBuilder builder = new StringBuilder(str);

        //append():追加内容----在末尾追加
        builder.append(",为了找个好工作");
        System.out.println(builder);//好好学习java,为了找个好工作

        //replace():替换部分内容(含头不含尾)
        //将下标为9-15的内容替换为---就是为了改变世界
        builder.replace(9, 16, "就是为了改变世界");
        System.out.println(builder);//好好学习java,就是为了改变世界

        //delete():删除内容
        builder.delete(0,9);
        System.out.println(builder);


        //insert():插入内容
        builder.insert(0,"活着");
        System.out.println(builder);

//StringBuilder的创建方式:
    StringBuilder builder1 = new StringBuilder();//空字符串
    StringBuilder builder2 = new StringBuilder("123");//123串

    //基于String来创建StringBuilder
    String str = "abc";
    StringBuilder builder3 = new StringBuilder(str);//abc串
    //将stringbuilder转换为String
    String str2 = builder2.toString();

3.正则表达式:

用于描述字符串的内容格式,使用他荣昌用于匹配一个字符串是否符合格式要求

正则表达式的语法:----------------了解即可

1.[]:表示一个字符,该字符可以是[]中指定的内容
  例如:
  [abc]:这个字符可以是a或b或c
  [a-z]:表示任意一个小写字母
  [a-zA-Z]:表示任意一个字母
  [a-zA-Z0-9]:表示任意一个字母数字
  [a-zA-Z0-9_]:表示任意一个数字字母下划线
  [^abc]:该字符只要不是a或b或c
2.预定义字符:
  .:表示任意一个字符,没有范围限制
  \d:表示任意一个数字,等同于[0-9]
  \w:表示任意一个单词字符,等同于[a-zA-Z0-9_]----单词字符指字母、数字和_
  \s:表示任意一个空白字符
  \D:不是数字
  \W:不是单词字符
  \S:不是空白字符
3.量词:
  ?:表示前面的内容出现0-1次
    例如: [abc]? 可以匹配:a 或 b 或 c 或什么也不写
          但是不能匹配：m或aaa
  +:表示前面的内容最少出现1次       
    例如: [abc]+ 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcba....
          但是不能匹配:什么都不写 或 abcfdfsbbaqbb34bbwer...
  *:表示前面的内容出现任意次(0-多次)---匹配内容与+一致，只是可以一次都不写
    例如: [abc]* 可以匹配:b或aaaaaaaaaa...或abcabcba....或什么都不写
          但是不能匹配:abcfdfsbbaqbb34bbwer...
  {n}:表示前面的内容出现n次
      例如: [abc]{3} 可以匹配:aaa 或 bbb 或 aab 或abc 或bbc
           但是不能匹配: aaaa 或 aad
  {n,m}:表示前面的内容出现最少n次最多m次
        例如: [abc]{3,5} 可以匹配:aaa 或  abcab 或者 abcc
        但是不能匹配:aaaaaa 或 aabbd
  {n,}:表示前面的内容出现n次以上(含n次)
       例如: [abc]{3,} 可以匹配:aaa 或 aaaaa.... 或 abcbabbcbabcba....
            但是不能匹配:aa 或 abbdaw...             
4.()用于分组,是将小括号里面的内容看做是一个整体
  例如: (abc){3} 表示abc整体出现3次. 可以匹配abcabcabc
        但是不能匹配aaa 或abc 或abcabccba
        (abc|def){3}表示abc或def整体出现3次.
        可以匹配: abcabcabc 或 defdefdef 或 abcdefabc
        但是不能匹配abcdef 或abcdfbdef

4.String支持的正则表达式的方法

matches():使用给定的正则表达式验证当前字符串的格式是否符合要求,若符合则返回true,否则返回false

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

        /*
        邮箱正则表达式:
        [a-zA-Z0-9_]+@[a-zA-Z0-9]+(\.[a-zA-Z]+)+
         */

        String email= "12345689@qq.com";
        String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
        //使用regex匹配email是否符合格式要求
        boolean match = email.matches(regex);
        if (match){
            System.out.println("是正确的邮箱格式");
        }else {
            System.out.println("是错误的邮箱格式");
        }
    }
}

replaceAll():将当前字符串中满足正则表达式的部分给替换为指定字符串

public class ReplaceAllDEmo {
    public static void main(String[] args) {
        //String replaceAll(String regex,String s):替换
        //将当前字符串中满足正则表达式(regex)的部分替换为指定字符串(s)
        String line = "cas231efc12a561";
        //将line中的数组部分替换为****
        line = line.replaceAll("[0-9]+","***");
        System.out.println(line);

split():将当前字符串中按照满足正则表达式的部分进行才分,将拆分出的以String[]的形式返回

public class SplitDemo {
    public static void main(String[] args) {
        String line = "sc15dsac514sac";
        String[] data = line.split("[0-9]+");//按数字拆分(数字拆没了)
        System.out.println(Arrays.toString(data));//将data数组转换为字符串

        line = "132.132.132";
        data = line.split("\\.");//按.拆(.就拆没了)
        System.out.println(Arrays.toString(data));


        //最开始可就是可拆分项(.),那么数组第一个元素为空字符串--------""
        //如果连续两个(两个以上)可拆分项,那么中欧间也会拆出一个空字符串---""
        //如果末尾连续多个可拆分项,那么拆出的空字符串被忽略
        line = ".132.132..156.....";
        data = line.split("\\.");//按.拆(.就拆没了)
        System.out.println(Arrays.toString(data));
        System.out.println(data.length);

5.object:

是所有类的鼻祖,所有类都直接或者间接继承了object,万物皆对象,为了多态

Object中有两个经常被派生类重写的方法:toSting()和equals()

调用object类的toString()时默认返回:类的全称@hashcode值,没有参考意义,所有常常重写toString()来返回具体的属性值

注意:String,StringBuilder等都重写了toString()返回字符串内容了

import java.util.Objects;
/**
 * 点
 */
public class Point {
    private int x;
    private int y;

    @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;
    }

    @Override
    public String toString() {
        return x+","+y;
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}
public class ObjectDemo {
    public static void main(String[] args) {
        /*
          输出引用类型变量时会默认调用Object类的toString()方法
          该方法返回的字符串格式为: 类的全称@地址(hashcode值)
          但通常这个返回结果对我们的开发是没有意义的
          我们真正想输出的应该是对象的属性值
          我们认为Object类的toString()并不能满足需求
          因此常常需要重写toString()来返回具体的属性值
         */
        
        Point p = new Point(100,200);
        System.out.println(p);
        System.out.println(p.toString());
    }
}

调用object类的equals()时默认比较的还是==(比较地址),没有参考意义,所以常常重写equals()来比较具体的值

注意:

string类已经重写了equals()来比较字符串内容了,但是StringBuilder并没有

重写equals()的基本原则:

原则上要比较两个对象的属性值是否相同

两个对象必须是同一个类型,若类型不同则返回false

public class Point {
    private int x;
    private int y;

    @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;
    }

    @Override
    public int hashCode() { //-----------后期讲散列表时它是有意义的
        return Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return x+","+y;
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

public class ObjectDemo {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        //String类重写了equals()来比较字符串内容是否相同
        System.out.println(s1.equals(s2)); //true

        StringBuilder builder1 = new StringBuilder("hello");
        StringBuilder builder2 = new StringBuilder("hello");
        //StringBuilder类没有重写equals()，因此调用的还是Object类的equals(),比较的还是地址
        System.out.println(builder1.equals(builder2)); //false

        //s1与builder1的类型不同，所以equals()一定是false
        System.out.println(s1.equals(builder1)); //false

        /*
          调用Object类的equals()，内部还是在使用==比较地址，没有参考意义
          若想比较对象的属性值是否相同，我们认为Object类的equals()并不能满足需求
          因此常常重写equals()
         */
        /*
        Point p1 = new Point(100,200);
        Point p2 = new Point(100,200);
        System.out.println(p1==p2); //false，==比较的是地址
        //因为Point类重写了equals()方法
        //所以此处调用的是重写之后的equals()，比较的是属性的值是否相同
        System.out.println(p1.equals(p2)); //true
        */

    }
}

6.补充:

getter/setter:

 public class Point {
    /*
      数据private，设计getter/setter的原因:
      1)很多框架都是基于getter/setter来配置获取数据的，可以理解为它是一种行业的标准
      2)getter/setter时可以对数据进行控制，而public权限时无法控制数据的
      3)getter/setter并非一定同时出现，可以只getter或只setter，可根据需求自行设置
     */
    private int x;
    private int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

public class GetterSetterDemo {
    public static void main(String[] args) {
        Point p = new Point(1,2);
        p.setX(100);
        p.setY(200);
        System.out.println(p.getX()+","+p.getY());
    }
}