Java入门——(6)Java常见类的使用2

---

前言

今天继续总结一下常用类。😁

---

一、StringBuffer类和StringBuilder类

前面我们又学到过String类型的字符串，但是String的值是不可变的，只要改变一次就会创建一个新的String对象，很消耗空间，那么如果一个字符串需要经常进行改变呢？
这里就可以用到我们今天要学的StringBuffer类和StringBuilder类了。
这两个类差别其实并不大，但为什么区分为两个呢？这里就要提到我们还没说到的多线程问题了。

StringBuffer类的方法时多线程安全的，StringBuilder类是不安全的，但是StringBuilder类速度上会快一点。
String
字符串(String)对象一旦创建，其内容不能再被修改 (read-only)
StringBuffer 对象的内容是可以被修改的，除了字符的长度之外，还有容量的概念，加速字符的管理。

常用方法：

1、append(str)：在字符串的末尾追加给定的字符串，并返回追加后的字符串。

StringBuffer stringBuffer = new StringBuffer("Hello");
stringBuffer.append(" World");
System.out.println(stringBuffer.toString()); // 输出: Hello World

2、insert(index, str)：在指定的位置插入给定的字符串，并返回插入后的字符串。

StringBuilder stringBuilder = new StringBuilder("Hello World");
stringBuilder.insert(5, ", ");
System.out.println(stringBuilder.toString()); // 输出: Hello, World

3、delete(start, end)：删除指定索引范围内的字符，并返回删除后的字符串。

StringBuffer stringBuffer = new StringBuffer("Hello World");
stringBuffer.delete(5, 11);
System.out.println(stringBuffer.toString()); // 输出: Hello

4、reverse()：颠倒字符串中字符的顺序，并返回结果。

StringBuffer stringBuffer= new StringBuffer("Hello");
StringBuffer.reverse();
System.out.println(stringBuffer.toString()); // 输出: olleH

5、length()：返回StringBuffer对象的长度。

StringBuffer buf=new StringBuffer();
buf.append("0123456789");
System.out.println("长度："+buf.length());//输出 长度:10

6、capacity()：返回StringBuffer的容量。
capacity在没有规定容量时，会默认为16，如果字符串容量超过16，那么计算容量的公式是：16 * 2 + 2 = 34。也就是当前容量的二倍加二。

StringBuffer buf=new StringBuffer();
buf.append("0123456789");
System.out.println("容量："+buf.capacity());//输出 长度:16

如果一开始就定义了容量大小，那么它就会是当前定义的容量大小。如果超过了当前定义容量，那么就是按长度对容量进行扩容。

StringBuffer buffer = new StringBuffer(10);
buffer.append("1234568785653213245678965");//10 25
System.out.println(buffer.capacity());

7、charAt()：返回StringBuffer对象中指定位置的字符

StringBuffer buf=new StringBuffer();
buf.append("0123456789");
char c=buf.charAt(4);
System.out.println(c);//输出 4

8、delect()：允许删除StringBuffer对象中指定区间的字符

StringBuffer buf=new StringBuffer();
buf.append("0123456789");
buf.delete(3,7);
System.out.println(buf);//输出 012789

9、replace()：将此顺序的子字符串中的字符替换为指定的String字符

StringBuffer buf=new StringBuffer();
buf.append("0123456789");
buf.replace(3,7,"abc");
System.out.println(buf);//输出 012abc789

10、setLength()：增加或减小StringBuffer的长度

StringBuffer buf=new StringBuffer();
buf.append("0123456789");
buf.setLength(5);
System.out.println(buf);//输出 01234

两者功能基本类似，在此就不做赘述了。

---

二、自动装箱拆箱

包装类

前面我们有学到八种基本数据类型，但它们并不具备java的面向对象的特性，没有属性，不能调用，比起引用数据类型来说，并不是很方便。
那么此时就要提到了包装类这个概念，就相当于对基本数据类型进行装配，升级装备。
每个包装类的对象都可以封装对应的基本类型的数据，并提供更多的功能，但是包装类的对象，一经创建，其内容不可改变。

基本数据类型的包装类型如下：

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

创建包装类

自动装箱和拆箱是编译器提供的特性，用于自动地将基本类型转换为对应的包装类型（装箱）或将包装类型转换为基本类型（拆箱）。

1、通过构造函数创建包装类实例。

Integer intValue = new Integer(10);
Double doubleValue = new Double(3.14);
Character charValue = new Character('A');

2、通过静态方法创建包装类实例。

Integer intValue = Integer.valueOf(10);
Double doubleValue = Double.valueOf(3.14);
Character charValue = Character.valueOf('A');

3、使用自动装箱进行创建。

Integer intValue = 10;
Double doubleValue = 3.14;
Character charValue = 'A';

4、创建各种类型的实例：

// 创建整数类型的包装类实例
Integer intValue = new Integer(10);
Integer intValue2 = Integer.valueOf(20);
Integer intValue3 = 30; // 自动装箱
// 创建浮点数类型的包装类实例
Double doubleValue = new Double(3.14);
Double doubleValue2 = Double.valueOf(1.618);
Double doubleValue3 = 2.718; // 自动装箱
// 创建字符类型的包装类实例
Character charValue = new Character('A');
Character charValue2 = Character.valueOf('B');
Character charValue3 = 'C'; // 自动装箱
// 创建布尔类型的包装类实例
Boolean boolValue = new Boolean(true);
Boolean boolValue2 = Boolean.valueOf(false);
Boolean boolValue3 = true; // 自动装箱

字符串转换成Integer

1、public static int parseInt(String s)

将字符串参数解析为带符号的十进制整数。 。

2、public static Integer valueOf(String s)

根据指定的String参数，返回一个Integer对象。

3、public static Integer decode(String s)

将 String解码成 Integer对象：

String s="1208";
Integer x=Integer.valueOf(s);
Integer y=Integer.parseInt(s); 
Integer z=Integer.decode(s);
System.out.println(x); //输出1208 
System.out.println(y); //输出1208 
System.out.println(z); //输出1208        

转换成其他类型

Integer i=100;
//转换成字符串
String s=i.toString();
//转换成double
double d=i.doubleValue(); 
//转换成short
short sh=i.shortValue();   

转换成其他进制

//转换成二进制字符串
String s2=Integer.toBinaryString(100);
System.out.println(s2);//输出：1100100
//转换成八进制字符串
String s8=Integer.toOctalString(100);
System.out.println(s8);//输出：144
//转换成十六进制字符串
String s16=Integer.toHexString(100);
System.out.println(s16);//输出：64

比较和计算

Integer x=10;
Integer y=15;
//比较大小，输出：-5
System.out.println( x.compareTo(y) );
//返回两个整数中较大的一个
Integer max=Integer.max(10,15);
System.out.println(max);//输出：15
//返回两个整数中较小的一个
Integer min=Integer.min(10,15);
System.out.println(min);//输出：10
//返回两个整数的和
Integer sum=Integer.sum(10,15);
System.out.println(sum);//输出：25

1.一个方法：字符串类型转换成 基本数据类型valueOf。
2.包装类和基本数据类型，可以自动转换，也就是自动装箱和自动拆箱操作。
3.包装类比基本数据类型，多一个值：null，也就是包装类可以为空。

---

三、日期类

Data类

java.util包里面的Date类，是Java里面进行日期操作常用类。
Data类用来表示特定的瞬间，可以精确到毫秒，他得基准标准时间是1970年1月1日00：00：00，毫秒的时间从这一时间开始计算。

public class Test {
    public static void main(String args[]) {
        long d1 = new Date().getTime();// 得到当前的时间
        int sum = 0;
        for (int i = 1; i <= 1000000; i++) {// 一百万次
        	sum += i;
        }
        System.out.println("从 1 加到 1000000 的和=" + sum);
        long d2 = new Date().getTime();// 得到此时的时间
        System.out.println("从 1 加到 1000000 所耗费的时间是=" + (d2 - d1) + "毫秒");
    }
}

SimpleDateFormat

但是在我们日常生活中一般还是不会精确到毫秒的，而且传入的数据也不一定是Data类型的数据，这里就要用到格式转化了。

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd  hh:mm:ss");  //括号内就是转化的形式

字母	日期或时间元素	表示	示例
G	Era 标志符	Text	AD
y	年	Year	1996; 96
M	年中的月份	Month	July; Jul; 07
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
d	月份中的天数	Number	10
F	月份中的星期	Number	2
E	星期中的天数	Text	Tuesday; Tue
a	Am/pm 标记	Text	PM
H	一天中的小时数（0-23）	Number	0
k	一天中的小时数（1-24）	Number	24
K	am/pm 中的小时数（0-11）	Number	0
h	am/pm 中的小时数（1-12）	Number	12
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
S	毫秒数	Number	978
z	时区	General time zone	PST; GMT-08:00
Z	时区	RFC 822 time zone	-0800

// 获取当前日期
LocalDate currentDate = LocalDate.now();
System.out.println(currentDate); // 输出当前日期，例如: 2023-08-05
// 根据年月日构造日期
LocalDate date = LocalDate.of(2022, 12, 25);
System.out.println(date); // 输出: 2022-12-25
// 日期格式化为指定字符串格式
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
String formattedDate = date.format(formatter);
System.out.println(formattedDate); // 输出: 25/12/2022

时区问题

Data的测量也是和时区有关系的，也就是说中国测试基准值就不是1970年1月1日的0点整，而是八点整，我们可以对此进行处理：

public class Test {
    public static void main(String args[]) {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        df.setTimeZone(TimeZone.getTimeZone("GMT+0:00"));//设置时区为0
        Date d = new Date(0L);
        String str = df.format(d);
        System.out.println("基准时间是：" + str);
    }
}

其中，日期Date型通过getTime方法获得毫秒数，计算机内就可以通过毫秒数进行时间上的计算，然后Date型也可以通过格式转换SimpleDateFormat，转换为我们所需要的字符串格式。然后字符串格式的时间也可以通过格式转换的方法转换为Date日期

---

四、BigInteger类和BigDecimal类

BigInteger和BigDecimal类分表表示大整数类和大浮点数类，理论可以表示足够大的数，提供了大数值和高精度计算的能力。

BigInteger

BigInteger对象是不可变的任意精度的整数。

// 创建BigInteger对象
BigInteger number1 = new BigInteger("1234567890");
BigInteger number2 = BigInteger.valueOf(987654321);
// 加法
BigInteger sum = number1.add(number2);
System.out.println(sum); // 输出: 2222222211
// 乘法
BigInteger product = number1.multiply(number2);
System.out.println(product); // 输出: 1219326311126352690

BigDecimal

我们在利用double进行计算的时候，二进制和十进制进行转换时，会发生精度损失的问题，那么BigDecimal可以解决精度损失的问题。

// 创建BigDecimal对象
BigDecimal decimal1 = new BigDecimal("3.1415");
BigDecimal decimal2 = BigDecimal.valueOf(2.7182);
// 加法
BigDecimal sum = decimal1.add(decimal2);
System.out.println(sum); // 输出: 5.8597
// 除法
BigDecimal quotient = decimal1.divide(decimal2, 4, RoundingMode.HALF_UP);
System.out.println(quotient); // 输出: 1.1549

---

总结

今天关于java常用类的总结就到这儿了。