Object类（toString()方法、equals()方法）、date（getTime()方法）、SimpleDateFormat类（farmat()方法）、Calendar类、System类

最新推荐文章于 2021-09-19 16:33:02 发布

㈤㈥㈦

最新推荐文章于 2021-09-19 16:33:02 发布

阅读量387

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/weixin_45291606/article/details/103937615

版权

JavaSE 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

文章目录

一、Object类
二、date类
- date类的成员方法
三、Calendar类
四、System类
- 字符串和字符串缓冲区之间的相互转换

一、Object类

toString 方法：默认打印该对象的地址值，重写后返回该对象的字符串表示。

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方法
    打印对象的属性（name,age）
     */
/*
    @Override
    public String toString() {
//        return "abc";
        return "Person{name = "+name+", age = "+age+" }";
    }
*/

    //自动重写
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

/*
    java.lang.Object类
    类Object是类层次结构的根（最顶层）类。每个类都使用Object类作为超类。
    所有队列（包括数组）都实现了这个类的方法。
 */
public class Demo01ToString {
    public static void main(String[] args) {
        /*
           Person类默认继承了Object类，所以可以使用Object类中的toString方法
           String toString() 返回该对象的字符串表示。
         */
        Person p = new Person("张三", 18);
        String s = p.toString();
        System.out.println(s);//com.itheima.demo01.Person@1540e19d / abc / Person{name 张三, age = 18 }
        System.out.println("============================");

        //直接打印对象的名字，其实就是调用对象的toString方法, p = p.toString
        System.out.println(p);//com.itheima.demo01.Person@1540e19d / abc / Person{name 张三, age = 18 }
        System.out.println("============================");

        /*看一个类是否重写了toString方法，直接打印这个类对应对象的名字即可
            如果没有重写toString方法，那么就按照重写的方式打印。
        */
        Random r = new Random();
        System.out.println(r);//java.util.Random@677327b6
        System.out.println("============================");

        Scanner sc = new Scanner(System.in);//Scanner类重写了toString方法
        System.out.println(sc);//java.util.Scanner[delimiters=\p{javaWhitespace}+]
        System.out.println("============================");

        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        System.out.println(list);// [1, 2] 重写了toString方法
    }
}

equals方法：比较两对象的地址值是否相等，相等则返回true

public class Demo02Equals {
    public static void main(String[] args) {
        /*
        Person类默认继承了Object类，所以可以使用Object类的equals方法
        boolean equals(Object obj)指示其他某个对象是否与此对象的地址值 "相等”
         */
        Person p1 = new Person("迪丽热巴",18);
        Person p2 = new Person("古力娜扎",18);

        p1 = p2;

        System.out.println("p1的地址是：" + p1);
        System.out.println("p2的地址是：" + p2);
        System.out.println("======================");
        boolean b = p1.equals(p2);
        System.out.println(b); //true
    }
}

//打印结果：
/*
p1的地址是：com.itheima.demo01.Person@1540e19d
p2的地址是：com.itheima.demo01.Person@1540e19d
======================
true
*/

Object类的equals方法默认比较的是两个对象的地址值，这样的比较没有太大的意义，所以也需要对equals方法进行重写，比较两个对象的属性值（name，age）

import java.util.Objects;

public class Person {//定义一个标准的类
    private String name;
    private  int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /*
    重写equals方法：
    Object类的equals方法默认比较的是两个对象的地址值，这样的比较没有太大的意义，
    所以i也需要对equals方法进行重写，比较两个对象的属性值（name，age
        对象的属性值一样，则返回true，否则返回false
    问题:
        隐含着一个多态。
        Object obj = p2 = new Person("古力娜扎", 18);
        //多态的弊端：无法使用子类特有的内容（属性，方法）
        //  解决办法：可以使用向下转型（强转），把Object类型转换为Person、
     */
    //下面重写equals方法
/*    @Override
    public boolean equals(Object obj) {
        //增加一个判断，传递的参数obj如果是this本身，直接返回true，提高程序效率
        if(obj == this){
            return false;
        }

        //增加一个判断，传递的参数obj是null，直接返回false，提高程序的效率
        if(obj == null){
            return false;
        }

        *//*
            增加一个判断，是Person类型再转换，防止类型转换异常ClassCastException
         *//*
        if (obj instanceof Person){
            //首先使用向下转型，把Object类型转换为Person类型
            Person p = (Person)obj;
            //然后比较两个对象的属性：一个是调用方法的 this(p1) ,另一个就是转型过来的 p(obj=p2)
            boolean b = this.equals(p.name) && this.age==p.age;
            return b;
        }

        //不是Person类型直接返回false
        return false;
    }*/

    /*//下面是自动重写，版本 1， Intellij Default
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        //getClass() != o.getClass(); 使用反射机制，判断o是否为Person类型 等效于 obj instanceof Person
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }*/

    //下面是自动重写，版本2， （Java 7+）推荐
    @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);
    }

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

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

package com.itheima.demo01;

import java.util.ArrayList;
import java.util.Random;

public class Demo02Equals {
    public static void main(String[] args) {
        /*
            Person类默认继承了Object类,所以可以使用Object类的equals方法
            boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
            equals方法源码:
                public boolean equals(Object obj) {
                    return (this == obj);
                }
                参数:
                    Object obj:可以传递任意的对象
                    == 比较运算符,返回的是一个布尔值 true false
                    基本数据类型:比较的是值
                    引用数据类型:比较的是两个对象的地址值
               this是谁?那个对象调用的方法,方法中的this就是那个对象;p1调用的equals方法所以this就是p1
               obj是谁?传递过来的参数p2
               this==obj -->p1==p2
         */
        Person p1 = new Person("迪丽热巴",18);
        //Person p2 = new Person("古力娜扎",19);
        Person p2 = new Person("迪丽热巴",18);
        System.out.println("p1:"+p1);//p1:com.itheima.demo01.Object.Person@58ceff1
        System.out.println("p2:"+p2);//p2:com.itheima.demo01.Object.Person@7c30a50

        Random r = new Random();

        boolean b = p1.equals(p1);
        System.out.println(b); //false
    }
}

Objects.equals() 方法

package com.itheima.demo01;

import java.util.Objects;

public class Demo03OBject {
    public static void main(String[] args) {
        //String s1 = "abc";
        String s1 = null;
        String s2 = "aaa";

        //boolean b = s1.equals(s2);//NullPointerException空指针异常，原因：null是不能调用方法的，会抛出空指针异常
        //System.out.println(b); //NullPointerException

        /*
            Object类的equals方法：对两个对象进行比较，防止空指针异常
            public static boolean equals(Object a, Object b){
                return(a == b) || (a != null && a.equals(b));
         */

        boolean b2 = Objects.equals(s1, s2);
        System.out.println(b2); //false
    }
}

Objects类总结

package com.itheima.demo01;

public class Test01{
    public static void main(String[] args){
        String str = "abc";
        System.out.println(str);	//输出：变量地址值，相当于调用 toString方法
        System.out.println(str.toString());	//输出：abc
        System.out.println("===============");

        Student s = new Student("张三", 23);
        //System.out.println(s);  //com.itheima.demo01.Student@1540e19d
        //需要在Students类中对toString进行重写
        System.out.println(s);   //输出： 张三  23
        
    }
}

package com.itheima.demo01;

public class Student /*extends Object*/{
    private String name;
    private int age;

    public Student() {
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.itheima.demo01;

public class Test02 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";

        System.out.println(s1.equals(s2));  //  true


        Student stu1 = new Student("张三",23);
        Student stu2 = new Student("张三",23);
//        System.out.println(stu1.equals(stu2));  // 重写方法之前，返回false，因为重写之前比较的是地址值。

        //认为同姓名和同年龄的就是同一个人
        System.out.println(stu1.equals(stu2));//重写方法后，返回true
        /*
        Java Bean中equals方法重写如下：
        
		Student student = (Student) o; //此处o=传递过来的stu2
        return age == student.age &&
        Objects.equals(name, student.name);
   	
		*/

    }
}

package com.itheima.demo01;

import java.util.Objects;

public class Student /*extends Object*/{
    private String name;
    private int age;

    public Student() {
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true; //如果两个对象内存地址值一样，则直接返回true
        if (o == null || getClass() != o.getClass()) return false;//如果有一个对象为空，或者他们的类不是同一个，直接返回false
        Student student = (Student) o; //否则，向下转型
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}

package com.itheima.demo01;

import java.util.Objects;

public class Test03 {
    public static void main(String[] args) {
//        String s1 = "abc";
        String s1 = null;   //用第一种方法会出现安全问题
        String s2 = "abc";
//        System.out.println(s1.equals(s2)); // 空指针异常

        //解决方案，利用Objects类中的 equals方法
        boolean result = Objects.equals(s1, s2);
        System.out.println(result);     //不会出现安全问题，返回false
    }
}

二、date类

package com.itheima.demo02;

/*
    java.util.Data:表示日期和时间的类
    类 Date 表示特定的瞬间，精确到毫秒。
    毫秒：千分之一秒  1000毫秒 = 1秒
    特定的瞬间：一个时间点，一刹那时间

    毫秒值的作用：可以对时间和日期进行计算
    例如：
    2099-01-03 到 2088-01-01 中间一共有多少天
    可以日期转换为毫秒进行计算，计算完毕，再把毫秒转换为日期

    把日期转换为毫秒：
        当前日期：2088-01-01
        时间原点(0毫秒)：1970 年 1 月 1 日 00：00： 00 （英国格林威治）
        就是计算当前日期到时间原点之间一共经历了多少毫秒（1578744891223L）

    注意：
        中国属于东八区，会把时间增加8个小时
        1970 年 1 月 1 日 08：00： 00
    把毫秒转换为日期：
        1 天 = 24 * 60 * 60 = 86400 秒 = 86400 * 1000 = 86400000 毫秒


 */
public class Date {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());//获取当前系统一共到1970年1月1日经历了多少毫秒
    }
}

date类的成员方法

Date类的成员方法:
   long getTime(); 把日期转换为毫秒(相当于System.currentTimeMillis())
   返回自 1970 年 1 月 1 日 00：00：00  GMT以此来Date对象表示毫秒数

package com.itheima.demo02;

import java.util.Date;

public class Demo02Date {
    public static void main(String[] args){
        demo03();
    }

    private static void demo03(){
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time); //1587344271701
    }

    private static void demo02(){
        Date d1 = new Date(0L);
        System.out.println(d1); //Thu Jan 01 08:00:00 CST 1970

        Date d2 = new Date(1587344271701L);
        System.out.println(d2); //Mon Apr 20 08:57:51 CST 2020
    }

    /*
        Date类的空参数构造方法：
            Demo01Date() 获取的就是当前系统的日期和时间
     */
    private static void demo01() {
        Date date = new Date();
        System.out.println(date); //Mon Apr 20 09:01:41 CST 2020
    }
}

* 使用DateFormat类中的方法parse，把文本解析为日期。
* 使用步骤：
   1. 创建SimpleDateFormat对象，构造方法中传递指定的模式
   2. 调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串，解析为Date日期。

* 注意：
   public Date parse(String source) throws ParseException
   parse方法声明了一个异常叫做ParseException 解析异常
   如果字符串和构造方法中的模式不一样，n那么程序就会抛出此异常
   调用一个抛出了异常的方法，就必须的处理这个异常，要么throws继续声明抛出这一个异常，要么try...catch自己处理这个异常

package com.itheima.demo03;

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

public class Demo01DateFormat {
    public static void main(String[] args) throws ParseException {
        demo02();
    }

    private static void demo02() throws ParseException {
        //1. 创建SimpleDateFormat对象，构造方法中传递指定的模式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
		//2. 调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串，解析为Date日期
        Date date = simpleDateFormat.parse("2020-30-11 21:30:48");
        System.out.println(date);
    }

    /*
    使用SimpleDateFormat类中的方法farmat，把日期格式化为文本
    String format(Date date) 按照指定的模式，把 Date日期，格式化为符合某显示格式的字符串
    使用步骤：
        1. 创建SimpleDateFormat的对象，构造方法中传递指定的模式
        2. 调用SimpleDateFormat的对象中的方法format，按照构造方法中指定的模式把Date日期格式化为符合模式的字符串
     */

    private static void demo01(){
        //创建SimpleDateFormat对象，构造方法中传递指定的模式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        //调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式把Date日期格式化为符合模式的字符串
        Date date = new Date();
        String text = simpleDateFormat.format(date);
        System.out.println(date);   //Sat Jan 11 21:30:48 CST 2020
        System.out.println(text);   //2020-30-11 21:30:48

    }
}

三、Calendar类

    java.util.Calendar类：日历类
    Calender类是一个抽象类，里面提供了很多操作日历字段的方法（YEAR、MONTH、DAY_OF_MONTH、HOUR）
    Calendar类无法直接创建对象使用，里面有一个静态方法叫getInstance()，该方法返回了Calendar类的子类对象。
    static Calendar getInstance() 使用默认时区和语言环境获得一个日历。

package com.itheima.demo04;

import java.util.Calendar;

public class Demo01Calender {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();//多态
        System.out.println(c); 
		//打印结果：    
    	//java.util.GregorianCalendar[time=1587345889793,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=3,WEEK_OF_YEAR=17,WEEK_OF_MONTH=4,DAY_OF_MONTH=20,DAY_OF_YEAR=111,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=3,AM_PM=0,HOUR=9,HOUR_OF_DAY=9,MINUTE=24,SECOND=49,MILLISECOND=793,ZONE_OFFSET=28800000,DST_OFFSET=0]

    }
}

* Calendar类的成员方法：
    - public int get(int field):返回给定日历字段的值。
    - public void set(int field, int value):将给定的日历字段设置为给定值。
    - public abstract void add(int field, int amount):根据日历的规则，为给定的日历字段添加或减去指定的时间量。
    - public Date getTime():返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对相关。
* 成员方法的参数：
    int field:日历类的字段，可以使用Calendar类的静态成员变量获取。
    public static final int YEAR = 1;

package com.itheima.demo04;

import java.util.Calendar;
import java.util.Date;

public class Demo02Calendar {
    public static void main(String[] args) {
        demo04();
    }

    /*
    public Date getTime():返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对相关。
    把日历对象转换为日期对象
     */

    private static void demo04(){
        //使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        Date date = c.getTime();
        System.out.println(date); //Mon Apr 20 09:37:43 CST 2020

    }

    /*
    public abstract void add(int field, int amount):根据日历的规则，为给定的日历字段添加或减去指定的时间
        int field：传递指定的字段（YEAR，MONTH...）
        int amount：增加或减少的值，正数：增加； 负数：减少
     */
    private static void demo03() {
        //使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        //把年增加2年
        c.add(Calendar.YEAR,2);
        //把月减少3个月
        c.add(Calendar.MONTH,-3);

        int year = c.get(Calendar.YEAR);
        System.out.println(year); //2022

        int month = c.get(Calendar.MONTH);
        System.out.println(month);//西方的月份 0-11 东方 1-12:0


        int date = c.get(Calendar.DATE);
        System.out.println(date); //20

    }

    /*
    public void set(int field, int value):将给定的日历字段设置为给定值
    参数：
        int field：传递指定的字段（YEAR，MONTH...）
        int value：为传递的字段设置具体的值
     */
    private static void demo02() {
        //使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        //设置年为9999
        c.set(Calendar.YEAR, 9999);
        //设置月为9
        c.set(Calendar.MONTH, 9);
        //设置日为9
        c.set(Calendar.DATE, 9);

        //同时设置年月日，可以使用set重载方法
        c.set(8888, 8, 8);
        int year = c.get(Calendar.YEAR);
        System.out.println(year);//8888

        int month = c.get(Calendar.MONTH);
        System.out.println(month);//西方的月份 0-11 东方 1-12：8

        int date = c.get(Calendar.DATE);
        System.out.println(date); //8

    }

    /*
     public int get(int field):返回给定日历字段的值。
     参数：传递指定的字段（YEAR，MONTH...）
     */
    private static void demo01() {
        //使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        System.out.println(year); //2020

        int month = c.get(Calendar.MONTH);
        System.out.println(month);//西方的月份 0-11 东方 1-12：3

        int date = c.get(Calendar.DATE);
        System.out.println(date); //20
    }
}

四、System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
  - public static long currentTimeMillis()：返回毫秒为单位的当前时间。
  - public static void arraycopy(Object src, int srcPos, int destPos, int length):
    将数组中指定的数据拷贝到另一数组中。

package com.itheima.demo05;

import java.util.Arrays;

public class Demo01System {
    public static void main(String[] args) {
        demo02();
    }

    /*
     public static void arraycopy(Object src, int srcPos, int destPos, int length):
    将数组中指定的数据拷贝到另一数组中。
      参数：
            src - 源数组。
            srcPos - 源数组中的起始位置。
            dest - 目标数组。
            destPos - 目标数据中的起始位置。
            length - 要复制的数组元素的数量。
      练习：
        将src数组中前3个元素，赋值到dest数组的前3个位置上
        复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]
        复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]
     */
    private static void demo02() {
        //定义源数组
        int[] src = {1,2,3,4,5};
        //定义目标数组
        int[] dest = {6,7,8,9,10};
        System.out.println("复制前：" + Arrays.toString(dest));
        //使用System类的方法arraycopy将src数组中前3个元素，复制到dest数组的前3个位置上
        System.arraycopy(src,0,dest,0,3);
        System.out.println("复制后：" + Arrays.toString(dest));

    }
    
    /*
        public static void arraycopy(Object src, int srcPos, int destPos, int length):

     */

    /*
     public static long currentTimeMillis()：返回毫秒为单位的当前时间。
    用来测试程序的效率
    练习：
        验证for循环打印数字1-9999所需使用的时间（毫秒）
     */
    private static void demo01() {
        //程序执行前，获取一次毫秒值
        long s = System.currentTimeMillis();
        //执行for循环
        for (int i = 1; i <= 9999; i++) {
            System.out.println(i);
        }
        //程序执行后，再获取一次毫秒值
        long e = System.currentTimeMillis();
        System.out.println("程序共耗时：" + (e - s) + "毫秒");
    }
}

在这里插入图片描述

package com.itheima.demo06;

import com.sun.org.apache.xpath.internal.SourceTree;

/*
    StringBuilder类的成员方法：
        public StringBuilder append(...)添加任意类型数据库字符串格式，并返回当前对象自身。
        参数：
            可以是任意的数据类型
 */
public class Demo02StringBuilder {
    public static void main(String[] args) {
        //创建StringBuilder对象
        StringBuilder bu1= new StringBuilder();
        //使用append方法往StringBuilder中添加数据
//        //append方法返回的是this，调用方法的对象bu1
//        StringBuilder bu2 = bu1.append("abc");
//        System.out.println(bu1);//abc，没打印地址值，说明重写了toString方法
//        System.out.println(bu2);//abc
//        System.out.println(bu1 == bu2);//true,说明两个对象是同一个对象

        //使用append方法无需接收返回值
        /*bu1.append("abc");
        bu1.append(1);
        bu1.append(true);
        bu1.append(8.8);
        bu1.append('中');
        System.out.println(bu1);*/

        /*
        链式编程： 方法的返回值是一个对象，可以根据对象继续调用方法
         */
        System.out.println("abc".toUpperCase().toUpperCase().toUpperCase()); //ABC
        bu1.append("abc").append(true).append(8.8).append('中');
        System.out.println(bu1); //abc8.8中

    }
}

字符串和字符串缓冲区之间的相互转换

 StringBuilder和String可以相互转换：
  String -> StringBuilder: 可以使用StringBuilder的构造方法
         StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
  StringBuilder -> String：可以使用StringBuilder中的toString方法
         public String toString():将当前StringBuilder对象转换为String对象。

package com.itheima.demo06;

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

        //  String -> StringBuilder
        String str = "hello";
        System.out.println("str:" + str); //hello
        StringBuilder bu = new StringBuilder(str);
        //往StringBuilder中添加数据
        bu.append("world");
        System.out.println("bu:" + bu); //helloworld

        //StringBuilder -> String
        String s = bu.toString();
        System.out.println("s:" + s); //helloworld
    }
}