JAVA中Stringbuilder类的方法是啥？
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA中Stringbuilder类的方法是啥？相关的知识，希望对你有一定的参考价值。
参考技术A常用方法有以下几个:
1.追加内容到当前StringBuilder对象的结尾StringBulider append（参数）
2.将内容插入到StringBulider对象的指定位置StringBulider insert(位置，参数)
3.将StringBulider对象转换为String对象 String toString（）
4.获取字符串的长度
int length（）
StringBulider str = new StringBulider（"hello"）；str.append（"nihao"）；
str.append(520);
System.out.println("字符串长度"+str.length());
System.out.println("插入前"+str);
str.insert（11，"！"）；
String str2=str.toString(); //转换为String类型
System.out.println（"插入后"+str2）；
Java 常用API
目录
Java 常用API（二）
1. Object类
- Object类位于 java.lang.Object 包下。
- 类Object是类层次结构的根类（父类）。
- 每个类都使用Object类作为超类（父类）。
所有对象（包括数组）都实现了这个类的方法。
- public String toString()：返回该对象的字符串表示。
public boolean equals(Object obj)： 指示其他某个对象是否与此对象“相等”。
注意事项：
- 看一个类是否重写了 toString方法，直接打印这个类的对象即可。
- 如果没有重写 toString方法，那么打印的是对象的地址值。
- Random类没有重写 toString方法
- Scanner、ArrayList
<E>类重写了 toString方法。- Object类中的equals方法默认比较的是两个对象的地址值，而String类中的equals方法是将Object类中的equals方法覆盖重写 了，比较的是字符串的内容。
多态的缺点：不能向下使用子类的特有的内容（属性和方法）。
解决：使用向下转型。
- 示例：
// Person.java
public class Person
private String name;
private int age;
public Person()
public Person(String name, int age)
this.name = name;
this.age = age;
// 覆盖重写Object类中的toString方法
@Override
public String toString()
return "Person" + "name='" + name + "\'" + ", age=" + age + "";
// 覆盖重写Object类的equals方法
@Override
public boolean equals(Object obj)
// 判断是否等于自身
if (obj == this)
return true;
// 判断是否为空
if (obj == null)
return false;
// 判断是否为自定义的Person类
if (obj instanceof Person)
// 向下转型
Person person = (Person)obj;
return person.age == this.age && person.name.equals(this.name);
// 不是Person类直接返回false
return false;
/*
// 使用 alt + ins 添加的
@Override
public boolean equals(Object o)
if (this == o) return true;
// getClass()是使用反射技术判断 o 是否是Person类型 等效于 o instanceof Person
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
*/
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;
// Demo02Main.java
import java.util.ArrayList;
public class Demo02Main
public static void main(String[] args)
Person one = new Person("迪丽热巴", 20);
Person two = new Person("迪丽热巴", 20);
System.out.println(one); // 没有重写之前打印的是地址值
one.toString(); // Personname='迪丽热巴', age=20
// System.out.println(one.toString()); // 没有重写之前打印的也是地址值
System.out.println(one.equals(two)); // true
System.out.println(one == two); // false
关于Objects类的介绍
在JDK 7添加了一个Objects工具类，它提供了一些方法来操作对象，它有一些静态的实用方法组成，这些方法是null-save（空指针安全）或者null-tolernt（容忍空指针的），用于计算对象的hashcode，返回对象的字符串表示形式，比较两个对象。
在比较 两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题，防止空指针异常。
- Objects类中的equals方法
public static boolean equals(Object a, Object b)
return (a == b) || (a != null) && a.equals(b);
2. Date类
概述
- java.util.Date：表示日期和时间类。
- 类Date表示特定的瞬间，精确到毫秒。1 秒 = 1000 毫秒
- 毫秒值的作用：可以对日期和时间进行计算。
- 时间原点：1970 年 1 月 1 日 00:00:00（英国格林威治）
- 1 天 = 24 × 60 × 60 = 86400 秒 = 86400000毫秒
注意事项：
中国属于东八区，会把时间增加8个小时
1970 年 1 月 1 日 08:00:00
// 输出当前时间距离时间原点的毫秒数，这是一个long类型
// 1565579081183L
System.out.println(System.currentTimeMillis());构造方法和成员方法
Date类的空参构造
- Date()：获取当前系统的时间和日期。
import java.util.Date;
public class DemoDate
public static void main(String[] args)
Date date = new Date();
System.out.println(date); // Mon Aug 12 11:18:35 CST 2019
Date类的带参构造
- Date(long date)：传递毫秒值，把毫秒值装换为date日期。
Date dateOne = new Date(1565579081183L);
// Mon Aug 12 11:04:41 CST 2019
System.out.println(dateOne);
Date dateTwo = new Date(0L);
// Thu Jan 01 08:00:00 CST 1970
System.out.println(dateTwo);Date类的成员方法：
- long getTime()：返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
public static void method03()
Date date = new Date();
// 1565580373625
// 相当于System.currentTimeMillis()方法
System.out.println(date.getTime());
3. DateFormat类
概述
- java.text.DateFormat：是日期/时间格式化子类的抽象类
- 作用：格式化（日期 --> 文本），解析（文本 --> 日期）
成员方法：
- String format(Date date)：按照指定的模式，把Date日期，格式化为符合模式的字符串。
- Date parse(String source)：把符合模式的字符串，解析为Date日期。
DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat类的子类，SimpleDateFormat就是DateFormat的一个子类。
java.text.SimpleDateFormat extends DateFormat
SimpleDateFormat类
- SimpleDateFormat(String pattern)：用指定的模式和默认语言环境的日期和时间格式符号构造 SimpleDateFormat
- 参数：String pattern：传递指定的模式（区分大小写）。
- 常用的格式规则：
| 标识字母（区分大小写） | 含义 |
|---|---|
| y | 年 |
| M | 月 |
| d | 日 |
| H | 时 |
| m | 分 |
| s | 秒 |
注意事项：模式中的字母不能更改，连接模式的符号可以改变。
DateFormat类中的format方法的使用步骤：
- 创建一个SimpleDateFormat对象，构造方法中传递指定的模式。
- 调用SimpleDateFormat中的方法format，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本）。
使用parse方法时的注意事项：
- public Date parse(String source) throws ParseException
parse 方法声明了一个异常：ParseException- 如果字符串和构造方法的模式不一样，那么程序就会抛出此异常。
- 调用一个抛出异常的方法，就必须处理这个异常，要么throws继续抛出这个异常，要么 try catch 自己处理。
- 示例：
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DemoSimpleDateFormat
public static void main(String[] args) throws ParseException
// 首先将当前 Date格式化为 String
// pattern:yyyy-MM-dd HH-mm-ss
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 创建一个Date对象
Date date = new Date();
// 调用SimpleDateFormat类中的format方法
String format = sdf.format(date);
System.out.println(format); // 2019-08-12 12:24:57
// 将String解析为Date类
Date parse = sdf.parse(format);
System.out.println(parse); // Mon Aug 12 12:24:14 CST 2019
练习
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
/*
题目要求：
使用日期时间相关的API，计算一个人已经出生了多少天？
分析：
1.输入你的出生日期，使用Scanner类中的next方法获取
2.将出生日期装换为毫秒
3.获取当前时间并装换为毫秒
4.差值 = 当前时间 - 出生日期
5.打印结果: 差值 / 1000/60/60/24
*/
public class DemoSimpleDateFormatTest
public static void main(String[] args) throws ParseException
// 创建一个Scanner对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的出生日期，格式：yyyy-MM-dd.");
// 接受输入的出生日期
String birthdayStr = sc.next();
// 转换为 Date类
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date birthdayDate = sdf.parse(birthdayStr);
// 装换为毫秒
long birthdayTime = birthdayDate.getTime();
// 获取当前时间并装换为毫秒
long currentTime = new Date().getTime();
// 计算差值
long difference = currentTime - birthdayTime;
// 装换为天数
long liveDay = difference/1000/60/60/24;
// 打印结果
System.out.println(liveDay);
4. Calendar类
- java.util.Calendar类：日历类
- Calendar类是一个抽象类，里边提供了很多操控日历字段的静态方法（YEAR、MONTH、DAY_OF_MONTH、HOUR 等）。
- Calendar类无法直接创建对象使用，里面有一个静态方法getInstance()，该方法返回了Calendar类的子类对象。
- public static Calendar getInstance()：使用默认时区和语言环境获得一个日历。
常用方法
public int get(int field)：返回给定日历字段的值。
参数：传递给定的日历字段（YEAR、MONTH）
返回值：日历字段代表的具体值public void set(int field, int value)：将给的的日历字段设置为给定值。
int field：传递给定的日历字段。
int value：给指定的日历字段设置值。public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加 / 减去指定的时间量。
int field：传递指定的日历字段。
int amount：增加 / 减少指定的值。public Date getTime()：将Calendar对象装换为Date类对象。
5. System类
java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或者系统级操作。
常用方法
- public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
- public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。
System.currentTimeMillis()用来测试系统的运行时间
public class DemoSystem
public static void main(String[] args)
long start = System.currentTimeMillis();
int sum = 0;
for (int i = 0; i < 9999; i++)
System.out.println(i);
long end = System.currentTimeMillis();
long time = end - start;
System.out.println("程序耗时：" + time);
6. StringBuilder类
- java.lang.StringBuilder
String类的原理
- 字符串是常量：它们的值在创建之后不能改变。
- 字符串底层是一个被final修饰的字节数组，不能改变，是一个常量。
private final byte[] value; 进行字符串相加时，内存中就会有多个字符串，占用空间多，效率低下。
例如：对字符串"a" + "b" + "c"计算的结果是一共有五个字符串，分别是：”a"，"b"，"c"，"ab"，"abc"。
StringBuilder类的原理
- StringBuilder也叫字符串缓冲区，可以提高字符串的操作效率（看成一个长度可以变化的字符串），底层也是一个字符串，但是没有被final修饰，可以改变长度。byte[ ] value = new byte[16];
- 对字符串"a" + "b" + "c"来说，会得到四个字符串，分别是："a"， "b"， "c"，"abc"。
- StringBuilder在内存当中始终是一个数组，占用空间少，效率高。
- 如果超出StringBuilder的容量，会自动的扩容。
StringBuilder的构造方法
- public StringBuilder()：构造一个空的字符串生成器，其初始容量为 16 个字符。
- public StringBuilder(String str)：构造一个字符串生成器，并初始化为指定的字符串内容。
StringBuilder的常用方法
- public StringBuilder append(...)：添加任意类型数据的字符串表示形式，并返回当前对象自身。
public String toString()：将当前StringBuilder对象转换为String对象。
- StringBuilder和String可以相互转换
- String --> StringBuilder：使用StringBuilder的构造方法。
- StringBuilder --> String：使用StringBuilder的toString方法。
注意事项：
- append方法返回的是自身，也就是 this
- 使用 append方法无需接受返回值
7. 包装类
概述
基本数据类型使用起来非常方便，但是没有对应的方法来操作这些基本类型的数据，可以使用一个类，把基本类型的数据包装起来，在类中定义一些方法，这个类叫做包装类，我们可以使用类中的方法来操作这些基本类型的数据。
装箱与拆箱（以 int 类型为例）
基本类型与包装类对象之间，来回转换的过程称为”装箱“与”拆箱“。
- 装箱：基本类型装换为对应的包装类对象。
- 拆箱：从包装类对象装换为对应的基本类型。
一、装箱
装箱通过两种方式，一种构造方法，另一种静态方法，下列构造方法已过时。
- 构造方法：
- public Integer(int value)：构造一个新分配的Integer对象，它表示指定的的 int 值。
- public Integer(String s)：构造一个新分配的Integer对象，它表示 String 参数所指示的 int 值。传递的字符串对应的基本类型的字符串，否则会抛出异常：NumberFormatException，例如："100" 正确，"a" 错误。
- 静态方法：
- public static Integer valueOf(int i)：返回一个表示指定 int 值的 Integer 实例。
- public static Integer valueOf(String s)：返回保存指定的 String 的值的 Integer对象。
二、拆箱
成员方法：
- int intValue() ：以 int 类型返回 Intrger 的值。
自动装箱与自动拆箱
- 基本数据类型和包装类之间可以自动的相互转换。
- 从JDK 1.5+开始支持自动装箱与自动拆箱。
基本类型与字符串类型之间的相互转换
一、基本类型 --> 字符串类型
- 基本类型的值 + "" 最简单的方式（工作中常用）。
- 包装类的静态方法：toString(参数)，不是Object类的toString()，是重载public static String toString(int i)：返回一个表示指定整数的 String 对象。
- String类的静态方法：valueOf(int i)：返回 int 参数的字符串表示形式。
二、字符串类型 --> 基本类型
- 使用包装类的静态方法 parseXXX("数值类型的字符串");
Integer类：public static parseInt(String s)
Double类：public static parseDouble(String s)
// 基本类型 --> 字符串类型
int i1 = 100;
String s1 = i1 + "";
System.out.println(s1); // 100
int i2 = 100;
String s2 = Integer.toString(i2);
System.out.println(s2 + 200); // 100200
int i3 = 100;
String s3 = String.valueOf(i3);
System.out.println(s2 + 200); // 100200
// 字符串类型 --> 基本类型
String s4 = "100200";
int i4 = Integer.parseInt(s4);
System.out.println(i4); // 100200以上是关于JAVA中Stringbuilder类的方法是啥？的主要内容，如果未能解决你的问题，请参考以下文章
大数据必学Java基础（五十）：String类和StringBuilder类的讲解
JAVA中String和StringBuilder类的特点及使用