Java类库StrringBuffer类、Math、SimpleDateFormat、Random随机数、大数字处理类和UUID 无重复数据（附带面试题）

Alphamilk

已于 2023-08-06 07:57:41 修改

阅读量128

点赞数

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

于 2023-07-26 21:48:03 首次发布

本文链接：https://blog.youkuaiyun.com/dogxixi/article/details/131944899

版权

Java 专栏收录该内容

36 篇文章

订阅专栏

本文介绍了Java中处理字符串的StringBuffer和CharSequence接口，强调了它们与String的区别，特别是在多线程环境下的性能和线程安全。另外，文章讲解了Math类的常用数学计算方法，以及Date和SimpleDateFormat在日期处理中的应用。此外，还提到了Random类生成随机数的功能，以及处理大数字的BigInteger和BigDecimal类。最后，文章讨论了UUID在生成唯一标识时的作用。

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

1.StrringBuffer类 CharConsequnse接口

2.Math数学计算

3.Date日期处理类与SimpleDateFormat

4.Random随机数

5.大数字处理类

6.UUID 无重复数据

1.StrringBuffer类 CharConsequnse接口

虽然一般对String的操作都是通过String类内部的方法，但是当一个String类进行频繁的修改则最好还是用StringBuffer类，以下是StringBuffer类的常用方法：

方法	描述
`append()`	将指定的字符串、字符、布尔值、整数等追加到当前`StringBuffer`对象的末尾
`insert()`	在指定位置插入指定的字符串、字符、布尔值、整数等
`delete()`	删除指定范围内的字符
`deleteCharAt()`	删除指定位置的字符
`replace()`	用指定字符串替换指定范围内的字符
`reverse()`	反转当前字符串
`substring()`	返回指定范围内的子字符串
`length()`	返回字符串的长度
`capacity()`	返回`StringBuffer`对象的容量
`charAt()`	返回指定索引位置的字符
`setCharAt()`	将指定索引位置的字符设置为指定字符
`indexOf()`	返回指定字符或字符串第一次出现的索引
`lastIndexOf()`	返回指定字符或字符串最后一次出现的索引
`toString()`	将`StringBuffer`对象转换为字符串

StringBuffer与String的不同

可变性：String 是不可变的，一旦创建就无法修改，任何对 String 的操作都会返回一个新的 String 对象。而 StringBuffer 是可变的，可以在已有对象上进行修改，避免频繁创建新对象。

线程安全性：StringBuffer 是线程安全的，多个线程可以同时访问和修改同一个 StringBuffer 对象，保证线程安全。而 String 是不可变的，因此天生具有线程安全性。

性能：由于 String 是不可变的，每次对 String 进行修改操作（如连接、替换等），都需要创建一个新的 String 对象，导致内存消耗和性能开销较大。而 StringBuffer 可以在原有对象上进行修改，避免了频繁的对象创建和销毁，提高了性能。

API 功能：String 类提供了丰富的字符串操作方法，例如字符串分割、查找、替换等操作。而 StringBuffer 除了提供了 String 的大部分方法外，还提供了插入、删除、反转等针对可变字符串的操作。

常用方法案例代码1：

package Example1501;

public class javaDemo {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer();
//        字符串连接
        str.append("大家好啊").append("我是电棍");
        System.out.println(str);
//        字符串反转
        str.reverse();
        System.out.println(str);

        StringBuffer str1 = new StringBuffer();
        str1.append("塔菲喵");
//        字符串插入
        str1.insert(0,"关注");
        System.out.println(str1);

        StringBuffer str3 = new StringBuffer();
        str3.append("不要断章取义");
//        字符串删除
        str3.delete(0,1);
        System.out.println(str3);
    }
}

CharConsequense 接口：

该接口有三个子类：StringBuffer String 与StringBuilder

接口提供的方法：

方法	描述
`charAt(int index)`	返回指定索引位置的字符
`length()`	返回字符序列的长度
`subSequence(int start, int end)`	返回特定开始索引（包括）到结束索引（不包括）之间的子序列

package Example1502;

public class javaDemo {
    public static void main(String[] args) {
        CharSequence str = "千万不能断章取义啊";
//        截取字符串
        CharSequence sub = str.subSequence(3,9);
        System.out.println(sub);
    }
}

*面试题java 中操作字符串都有哪些类？它们之间有什么区别？

（1）String

String是不可变对象，每次对String类型的改变时都会生成一个新的对象。

（2）StringBuilder

线程不安全，效率高，多用于单线程。

（3）StringBuffer

线程安全，由于加锁的原因，效率不如StringBuilder，多用于多线程。

不频繁的字符串操作使用String，操作频繁的情况不建议使用String。

StringBuilder > StringBuffer > String。

2.Math数学计算

由于经常会遇到数据计算，所以学好Math非常重要，以下是开发中Math常用的方法：

方法	描述
`abs(x)`	获取参数的绝对值
`ceil(x)`	向上取整，返回不小于参数的最小整数
`floor(x)`	向下取整，返回不大于参数的最大整数
`round(x)`	四舍五入，将参数舍入为最接近的整数
`max(x, y)`	返回两个参数中的较大值
`min(x, y)`	返回两个参数中的较小值
`sqrt(x)`	计算参数的平方根
`pow(x, y)`	计算 x 的 y 次幂
`exp(x)`	计算 e 的 x 次幂
`log(x)`	计算参数的自然对数（以 e 为底）

案例代码：

package Example1503;

public class javaDemo {
    public static void main(String[] args) {
         int i = -114514;
//        取绝对值
        System.out.println(Math.abs(i));
//        取最大值
        System.out.println(Math.max(1,112));
//        开根号
        System.out.println(Math.sqrt(4));
//        乘方
        System.out.println(Math.pow(2,2));
    }
}

*面试题 java 中的 Math.round(-1.5) 等于多少？

-2

Math提供了三个与取整有关的方法：ceil、floor、round

（1）ceil：向上取整；

Math.ceil(11.3) = 12;

Math.ceil(-11.3) = 11;

（2）floor：向下取整；

Math.floor(11.3) = 11;

Math.floor(-11.3) = -12;

（3）round：四舍五入；

加0.5然后向下取整。

Math.round(11.3) = 11;

Math.round(11.8) = 12;

Math.round(-11.3) = -11;

Math.round(-11.8) = -12;

*面试题： 如何将字符串反转？

添加到StringBuilder中，然后调用reverse()。

3.Date日期处理类与SimpleDateFormat

日期处理类一般是获取当前的时间。以下是日期处理类的常用的方法：

方法	描述
`Date()`	使用当前日期和时间创建一个 `Date` 对象
`Date(long time)`	使用指定的时间值（以毫秒为单位）创建一个 `Date` 对象
`getTime()`	返回 `Date` 对象表示的时间值（以毫秒为单位）

案例代码：

package Example1504;

import java.util.Date;

public class javaDemo {
    public static void main(String[] args) {
//        获取当前时间
        Date date = new Date();
        System.out.println("有效期起始时间:"+date);
        long time  =  date.getTime();
//        时间加上10天后的毫秒数
        time+=846000*1000;
        System.out.println("有效期结束:"+new Date(time));
    }
}

虽然通过Date可以获取当前的日期，但是并不能输出我们想要的格式所以引入Simple日期格式化

SimpleDataFormat日期格式化

要了解日期格式化首先要了解日期格式化模板标记

`G`	Era 标记，例如 AD
`y`	年份，例如 2023
`M`	月份，如 7
`d`	月中的天数，如 26
`h`	小时（1-12小时制），如 10
`H`	小时（0-23小时制），如 22
`m`	分钟，如 56
`s`	秒钟，如 30
`S`	毫秒，如 123
`E`	星期几的缩写，如 Mon
`EEEE`	星期几的完整拼写，如 Monday
`z`	时区，如 GMT+08:00
`Z`	时区偏移量，如 +0800
`a`	上午/下午标记，如 AM/PM

SimpleDatefomat常用的方法：

方法	描述
`format(Date date)`	将指定的`Date`对象格式化为字符串，使用`SimpleDateFormat`对象的模式。
`parse(String source)`	将给定的字符串解析为`Date`对象，根据`SimpleDateFormat`对象的模式进行解析。
`SimpleDateFormat(String pattern)`	使用给定的模式创建一个`SimpleDateFormat`对象。

案例代码：

package Example1505;

import java.text.SimpleDateFormat;
import java.util.Date;

public class javaDemo {
    public static void main(String[] args)throws Exception {
//        将date对象通过format函数转为str字符串
       Date date = new Date();
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd");
       String str = sdf.format(date);
       System.out.println(str);
       
//       将字符串转为date对象
       String birthday = "2023-7-26";
       SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-mm-dd");
       Date date1 = sdf2.parse(birthday);
        System.out.println(date1);
    }
}

4.Random随机数

生产中需要用到随机的事件非常多，比如抽奖，或者随机选择一个幸运儿的号码。而随机数也分两种一种是可以重复的随机数，一种是不可重复的随机数以下是Random的常用方法以及实现这两种情况的方法

Random的常用方法

方法	描述
`nextInt(int bound)`	生成一个介于0（含）和指定边界值（不含）之间的随机整数。
`nextDouble()`	生成一个介于0.0（含）和1.0（不含）之间的随机双精度浮点数。
`nextLong()`	生成一个随机的长整型数。
`nextBoolean()`	随机生成一个布尔值，true或false。
`nextFloat()`	生成一个介于0.0（含）和1.0（不含）之间的随机单精度浮点数。
`nextGaussian()`	生成一个符合高斯分布的随机双精度浮点数。
`setSeed(long seed)`	使用指定的种子设置随机数生成器的种子值。
`nextInt()`	生成一个随机整数。
`nextBytes(byte[] bytes)`	生成随机字节数组，并将其存储到指定的字节数组中。

1.可重复情况

package Example1506;

import java.util.Random;

public class javaDemo {
    public static void main(String[] args) {
        Random random = new Random();
//        一个班级有62号人数那么将在62号人中抽取一个人回答问题
        System.out.println("恭喜"+random.nextInt(62)+"号，同学被抽中回答问题");
//可重复抽取的情况
         for (int  i =0;i<3;i++){
             System.out.println(random.nextInt(3));
        }

    }
}

2.不可重复情况

36个人中需要抽取7个去搬运书籍：

package Example1507;


import java.util.Random;

public class javaDemo {
    public static void main(String[] args) {
        int array[] =  new int[7];
        Random random =new Random();
        int randomNumber = random.nextInt(36);

        for (int i=0;i<7;i++){
            while (isUse(randomNumber,array)){
                randomNumber = random.nextInt(36);
            }
            array[i] = randomNumber;
        }
        printArray(array);
    }
    public static boolean isUse(int data,int array[]){
        for (int i = 0;i<7;i++){
            if (array[i]==data){
                return true;
            }
        }
        return false;
    }
    public static void printArray(int array[]){
        for (int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
}

5.大数字处理类

由于有些数字太过于巨大以至于int这种数据类型无法进行接收，比如游戏中可能出现战力膨胀可能数字需要几百几千亿的攻击力而生命值也有几千万亿，那么这两个数字没办法接收也就没办法去计算了，所以这时候就需要用到大数字处理类

在 Java 中，int 是一个有符号的 32 位整数类型。它的取值范围为 -2,147,483,648（-2^31）到 2,147,483,647（2^31-1）之间，即 -2 的 31 次方到 2 的 31 次方减一。超出这个范围的整数值将导致溢出。

大数字有两类BigInteger类与BigDecimal类，顾名思义一个是整数类，一个是小数类

以下是BigInteger类常用的方法：

`add(BigInteger val)`	将当前BigInteger与指定的BigInteger相加。
`subtract(BigInteger val)`	从当前BigInteger中减去指定的BigInteger。
`multiply(BigInteger val)`	将当前BigInteger与指定的BigInteger相乘。
`divide(BigInteger val)`	将当前BigInteger除以指定的BigInteger。
`mod(BigInteger val)`	返回当前BigInteger除以指定BigInteger的余数。
`pow(int exponent)`	返回当前BigInteger的指定幂次方。
`compareTo(BigInteger val)`	比较当前BigInteger与指定的BigInteger的大小关系。
`equals(Object obj)`	判断当前BigInteger是否与指定对象相等。
`toString()`	将当前BigInteger转换为字符串表示形式。
`valueOf(long val)`	返回具有指定值的BigInteger实例。
`isProbablePrime(int certainty)`	测试当前BigInteger是否可能为素数。

以下是BigDecimal类常用的方法：

方法	描述
`add(BigDecimal augend)`	将当前BigDecimal与指定的BigDecimal相加。
`subtract(BigDecimal subtrahend)`	从当前BigDecimal中减去指定的BigDecimal。
`multiply(BigDecimal multiplicand)`	将当前BigDecimal与指定的BigDecimal相乘。
`divide(BigDecimal divisor)`	将当前BigDecimal除以指定的BigDecimal。
`remainder(BigDecimal divisor)`	返回当前BigDecimal除以指定BigDecimal的余数。
`pow(int exponent)`	返回当前BigDecimal的指定幂次方。
`setScale(int newScale, RoundingMode roundingMode)`	设置当前BigDecimal的小数位数和舍入模式。
`compareTo(BigDecimal val)`	比较当前BigDecimal与指定的BigDecimal的大小关系。
`equals(Object obj)`	判断当前BigDecimal是否与指定对象相等。
`toString()`	将当前BigDecimal转换为字符串表示形式。
`valueOf(long val)`	返回具有指定值的BigDecimal实例。
`stripTrailingZeros()`	返回一个去除尾部零的BigDecimal。

使用的案例代码：

package Example1508;

import java.math.BigInteger;

public class javaDemo {
    public static void main(String[] args) {
        BigInteger dead = new BigInteger("0");
//        boss血量
        BigInteger bossLife = new BigInteger("10000000000");
//        攻击力
        BigInteger attackValue = new BigInteger("5000000000");

        System.out.println("打Boss啦");
        while (bossLife.compareTo(dead)==1){
            System.out.println("勇者发动了攻击造成50000000伤害");
            bossLife = bossLife.subtract(attackValue);
            System.out.println("boss受伤了还剩余"+bossLife+"的血量");
        }
        System.out.println("大boss死了啦");
    }
}

6.UUID 无重复数据

由于卖的笔记本电脑，手机等等这些贵重的物品需要每一个都要有各自的编号并且不能重复，如果用排序的方法可能哪一天电脑抽抽了就不知道该从第几个序号开始才能确保唯一性，那么该如何保证id能够唯一呢？java中提供了UUID（universally unique id）

方法：randomUUID();

具体使用：

package Example1509;

import java.util.UUID;

public class javaDemo {
    public static void main(String[] args) {
        UUID id =  UUID.randomUUID();
        System.out.println(id);

    }
}