Object类、常用API

全栈程序员站长

发布于 2022-06-29 15:03:16

1.9K0

发布于 2022-06-29 15:03:16

Object类的toString方法

package com.itheima.demo01;

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@75412c2f|Person(name=张三,age=18)

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

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

        Scanner sc = new Scanner(System.in);
        System.out.println(sc);//重写了toString方法

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

    }
}

package com.itheima.demo01;

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

Object类的equals方法 默认比较的是两个对象的地址值

package com.itheima.demo01;

public class Demo02Equals {
   
    public static void main(String[] args) {
   
        /* Person类默认继承了Object类，所以可以使用Object类的equals方法 boolean equals（Object obj) 指示其他某个对象是否与此对象“相等”。 Object类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("古力娜扎",18);

       // p1=p2;

        System.out.println("p1:"+p1);//p1:com.itheima.demo01.Person@7c30a502
        System.out.println("p2:"+p2);//p2:com.itheima.demo01.Person@49e4cb85

        boolean b = p1.equals(p2);
        System.out.println(b);

    }

}

重写Object类的equals方法

package com.itheima.demo01;

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;
    }
    /* 直接打印对象的地址值没有意义，需要重写Object类的toString方法 打印对象的属性（name,age) */

// @Override
// public String toString() {
   
// return "Person(name="+name+",age="+age+")";
// }


// @Override
// public String toString() {
   
// return "Person{" +
// "name='" + name + '\'' +
// ", age=" + age +
// '}';
// }
    /* Object类的equals方法默认比较的是两个对象的地址值，没有意义 所以我们需要重写equals方法，比较两个对象的属性值（name,age) 对象的属性值一样，返回true；否则返回false 问题： 隐含着一个多态 Object obj = p2 = new Person("古力娜扎",18); 多态弊端：无法使用子类特有的内容（属性，方法） 解决：可以使用向下转型（强转）把Object类型转换为Person */
// @Override
// public boolean equals(Object obj){
   
// //增加一个判断，传递的参数obj是this本身，直接返回true，提高程序效率
// if(obj==this){
   
// return true;
// }
//
// //增加一个判断，传递的参数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.name.equals(p.name)&&this.age==p.age;
// return b;
// }
// return false;
// }

//
// @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;
// }
//
// @Override
// public int hashCode() {
   
// int result = name != null ? name.hashCode() : 0;
// result = 31 * result + age;
// return result;
// }


    @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() {
   

        return Objects.hash(name, 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;
    }
}

Objects类的equals方法

package com.itheima.demo01;

import java.util.Objects;

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

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

        /* Objects类的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);
    }
}

Object类&Objects类总结

一、Object类 1.Object类介绍 Object类是所有类的父类，一个类都会直接或者间接的继承自该类该类中提供了一些非常常用的方法！ 2.toString()方法 A 作用打印对象的信息 B 重写前：打印的是包名类名@地址值 C 重写后：打印的是对象中的属性值 3.equals()方法 A 作用：比较两个对象的 B 重写前：比较的是对象的地址值 C 重写后：比较的是对象中的属性值
二、Objects类 1.equals()方法比较两个对象是否相同，但是加了一些健壮性的判断！

Date类的构造方法和成员方法

package com.itheima.demo02.Date;

import java.util.Date;

public class Demo02Date {
   
    public static void main(String[] args) {
   
        demo01();
        System.out.println("===========");
        demo02();
        System.out.println("===========");
        demo03();
    }

    /* Date类的成员方法： long getTime()把日期转换为毫秒（相当于System.currentTimeMillis()) 返回自1970年1月1日00：00：00 GMT以来此Date对象表示的毫秒数。 */
    private static void demo03(){
   
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);//1581934167662
    }
    /* Date类的带参数构造方法： Date(long Date):传递毫秒值，把毫秒转换为Date日期 */
    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(1273777777777L);//Fri May 14 03:09:37 CST 2010
        System.out.println(d2);
    }
    /* Date类的空参数构造方法： Date()获取的就是当前系统的日期时间 */
    private static void demo01(){
   
        Date date = new Date();
        System.out.println(date);//Mon Feb 17 17:57:28 CST 2020
    }
}

DateFormat类&SimpleDateFormat类介绍

package com.itheima.demo02.Date;
/* java.text.DateFormat:是日期/时间格式化子类的抽象类 作用： 格式化（也就是日期->文本）、解析（文本->日期） 成员方法： String format(Date date) 按照指定的模式，把Date日期，格式化为符合模式的字符串 Date parse(String source) 把符合模式的字符串，解析为Date日期 DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat的子类 java.text.SimpleDateFormat extends DateFormat 构造方法： SimpleDateFormat(String pattern) 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。 参数： String pattern:传递指定的模式 模式：区分大小写的 y 年 M 月 d 日 H 时 m 分 s 秒 写对应的模式，会把模式替换为对应的日期时间 “yyyy-MM-dd HH:mm:ss” “yyyy年MM月dd日 HH时mm分ss秒” 注意： 模式中的字母不能更改，连接模式的符号可以改变 */
public class Demo01DateFormat {
   
}

package com.itheima.demo02.Date;

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

/* java.text.DateFormat:是日期/时间格式化子类的抽象类 作用： 格式化（也就是日期->文本）、解析（文本->日期） 成员方法： String format(Date date) 按照指定的模式，把Date日期，格式化为符合模式的字符串 Date parse(String source) 把符合模式的字符串，解析为Date日期 DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat的子类 java.text.SimpleDateFormat extends DateFormat 构造方法： SimpleDateFormat(String pattern) 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。 参数： String pattern:传递指定的模式 模式：区分大小写的 y 年 M 月 d 日 H 时 m 分 s 秒 写对应的模式，会把模式替换为对应的日期时间 “yyyy-MM-dd HH:mm:ss” “yyyy年MM月dd日 HH时mm分ss秒” 注意： 模式中的字母不能更改，连接模式的符号可以改变 */
public class Demo01DateFormat {
   
    public static void main(String[] args) throws ParseException {
   
        demo01();
        System.out.println("============");
        demo02();
    }

    /* 使用DateFormat类中的方法parse，把文本解析为日期 Date parse(String source)把符合模式的字符串，解析为Date日期 使用步骤： 1.创建SimpleDateFormat对象，构造方法中传递指定的模式 2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串，解析为Date日期 注意： public Date parse(String source) throws ParseException parse方法声明了一个异常叫ParseException解析异常 如果字符串和构造方法中的模式不一样，那么程序就会抛出此异常 调用一个抛出异常的方法，就必须处理这个异常，要么throws继续声明抛出这一个异常，要么try...catch自己处理这个异常 */
    private static void demo02() throws ParseException {
   
        //1.创建SimpleDateFormat对象，构造方法中传递指定的模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串，解析为Date日期
        Date date = sdf.parse("2020年02月17日 20时14分48秒");//Mon Feb 17 20:14:48 CST 2020
// Date date = sdf.parse("2020年02月17日 20时14分48");//解析异常错误java.text.ParseException
        System.out.println(date);

    }
    /* 使用DateFormat类中的方法format，把日期格式化为文本 String format(Date date) 按照指定的模式，把Date日期，格式化为符合模式的字符串 使用步骤： 1.创建SimpleDateFormat对象，构造方法中传递指定的模式 2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本） */
    private static void demo01(){
   
        //1.创建SimpleDateFormat对象，构造方法中传递指定的模式
     // SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本）
        Date date = new Date();
        String text = sdf.format(date);
        System.out.println(date);//Mon Feb 17 20:13:14 CST 2020
        System.out.println(text);//2020-02-17 20:13:14||2020年02月17日 20时14分48秒

    }
}

练习使用日期时间相关的API，计算出一个人已经出生了多少天

package com.itheima.demo03.DateFormat;

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

/* 练习： 请使用日期相关的API，计算出一个人已经出生了多少天。 分析： 1.使用Scanner类中的方法next，获取出生日期 2.使用DateFormat类中的方法parse，把字符串的出生日期解析为Date格式 3.把Date格式的出生日期转换为毫秒值 4.获取当前的日期，转换为毫秒值 5.使用当前日期的毫秒值-出生日期的毫秒值 6.把毫秒值的差值转换为天（s/1000/60/24) */
public class Demo02Test {
   
    public static void main(String[] args) throws ParseException {
   
        //1.使用Scanner类中的方法next，获取出生日期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您得到的出生日期，格式为yyyy-MM-dd");
        String birthdayDateString = sc.next();
        //2.使用DateFormat类中的方法parse，把字符串的出生日期解析为Date格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sdf.parse(birthdayDateString);
        //3.把Date格式的出生日期转换为毫秒值
        long birthdayDateTime = birthdayDate.getTime();
        //4.获取当前的日期，转换为毫秒值
        long todayTime = new Date().getTime();
        //5.使用当前日期的毫秒值-出生日期的毫秒值
        long time = todayTime-birthdayDateTime;
        //6.把毫秒值的差值转换为天（s/1000/60/24)
        System.out.println(time/1000/60/24);
    }
}

Calendar类

package com.itheima.demo04.Calendar;

import java.util.Calendar;

/* java.util.Calendar类：日历类 Calendar类是一个抽象类，里边提供了很多操作日历字段的方法（YEAR、MONTH、DAY_OF_MONTH、HOUR） Calendar类无法直接创建对象使用，里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象 static Calendar getInstance() 使用默认时区和语言环境获得一个日历。 */
public class Demo01Calendar {
   
    public static void main(String[] args) {
   
        Calendar c = Calendar.getInstance();//多态
        System.out.println(c);
    }
}

Calendar类的常用成员方法

package com.itheima.demo04.Calendar;

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

/* 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; 年 public static final int MONTH = 2; 月 public static final int DATE = 5; 月中的某一天 public static final int DAY_OF_MONTH = 5;月中的某一天 public static final int HOUR = 10; 时 public static final int MINUTE = 12; 分 public static final int SECOND = 13; 秒 */
public class Demo02Calendar {
   
    public static void main(String[] args) {
   
        demo01();
        System.out.println("===========");
        demo02();
        System.out.println("===========");
        demo03();
        System.out.println("===========");
        demo04();
    }
    /* public Date getTime():返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。 把日历对象，转换为日期对象 */
    private static void demo04() {
   
       //使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        Date date = c.getTime();
        System.out.println(date);//Tue Feb 18 11:31:53 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);

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

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

    }
    

    /* 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);

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

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


    /* 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);

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

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

时间日期相关类总结

Date类 A.构造方法 Date(): 根据当前系统的时间创建日期对象 Date(long time): 根据传入的毫秒值时间创建日期对象 B.成员方法 long getTime(): 获取当前日期对象的毫秒时间 String toLocalString(): 根据本地格式转换日期对象
DateFormat类&SimpleDateFormat类 A.构造方法 SimpleDateFormat(String s); 根据指定模板创建日期格式化对象 B.成员方法 String format(Date d); 根据指定格式格式化日期对象 Date parse(String s); 根据指定格式解析字符串
Calendar类 A.创建对象方式 Calendar c =Calendar.newInstance(); 获取日历类对象 B.成员方法 int get(int n); 获取指定日历字段信息 void set(int n,int value); 将指定日历字段设置为指定的值 void add(int n,int value); 将指定日历字段增加或减少指定的值

package exam.exam2;

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

public class Test01 {
   
    public static void main(String[] args) throws ParseException {
   
        //空参构造方法
        Date d = new Date(40000L);
        System.out.println(d.toLocaleString());//1970年1月1日 上午8:00:40

        //创建日期格式化对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String format = sdf.format(d);
        System.out.println(format);//1970年01月01日 08:00:40

        String str = "1970年01月01日 08:00:40";
        Date parse = sdf.parse(str);
        System.out.println(parse);//Thu Jan 01 08:00:40 CST 1970

    }
}

package exam.exam2;

import java.util.Calendar;

public class Test02 {
   
    public static void main(String[] args) {
   
        //获取日历对象
        Calendar c = Calendar.getInstance();

        //get方法
        int year = c.get(Calendar.YEAR);
        System.out.println(year);//2020

        int month = c.get(Calendar.MONTH)+1;
        System.out.println(month);//2

        System.out.println("=================");
        //set方法
        c.set(Calendar.YEAR,2088);
        year = c.get(Calendar.YEAR);
        System.out.println(year);//2088

        //add方法
        c.add(Calendar.YEAR,2);
        year = c.get(Calendar.YEAR);
        System.out.println(year);//2090

        c.add(Calendar.YEAR,-1);
        year = c.get(Calendar.YEAR);
        System.out.println(year);//2089
    }
}

System类的常用方法

package com.itheima.demo05.System;

import java.util.Arrays;

/* java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法由： - public static long currentTimeMillis():返回以毫秒为单位的当前时间。 - public static void arraycopy(Object src, int srcPos,int destPos ,int length): 将数组中指定的数据拷贝到另一个数组中。 */
public class Demo01System {
   
    public static void main(String[] args) {
   
     demo01();
        System.out.println("============");
        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));//复制前：[6, 7, 8, 9, 10]
        //使用System类的方法arraycopy将src数组中前3个元素
        System.arraycopy(src,0,dest,0,3);
        System.out.println("复制后："+Arrays.toString(dest));//复制后：[1, 2, 3, 9, 10]
    }

    /* 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)+"毫秒");//程序总耗时：1160毫秒
    }
}

StringBuilder类

StringBuilder的构造方法和append方法

package com.itheima.demo06.StringBuilder;

/* java.lang.StringBuilder类：字符串缓冲区，可以提高字符串的效率 根据StringBuilder的API文档，常用构造方法有2个： public StringBuilder() ：构造一个空的StringBuilder容器。 public StringBuilder(String str) ：构造一个StringBuilder容器，并将字符串添加进去。 */
public class Demo01StringBuilder {
   
    public static void main(String[] args) {
   
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);//bu1:

        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);//bu2:abc
    }

}

package com.itheima.demo06.StringBuilder;

/* StringBuilder类的成员方法： public StringBuilder append(...) ：添加任意类型数据的字符串形式，并返回当前对象自身。 参数： 可以是任意的数据类型 */
public class Demo02StringBuilder {
   
    public static void main(String[] args) {
   
        //创建StringBuilder对象
        StringBuilder bu1 = new StringBuilder();

        //使用append方法往StringBuilder中添加数据
// StringBuilder bu2 = bu1.append("abc");
// System.out.println(bu1);//abc
// System.out.println(bu2);//abc
// System.out.println(bu1==bu2);//true

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

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

StringBuilder的toString方法

package com.itheima.demo06.StringBuilder;
/* StringBuilder和String可以相互转换 String-->StringBuilder:可以使用StringBuilder的构造方法 StringBuilder(String str)构造一个字符串生成器，并初始化为指定的字符串内容。 StringBuilder-->String:可以使用StringBuilder中的toString方法 public String toString():将当前StringBuilder对象转换为String对象。 */
public class Demo03StringBuilder {
   
    public static void main(String[] args) {
   
        //String-->StringBuilder
        String str = "hello";
        System.out.println("str:"+str);//str:hello
        StringBuilder bu = new StringBuilder(str);
        //往StringBuilder中添加数据
        bu.append("world");
        System.out.println("bu:"+bu);//bu:helloworld

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

包装类 装箱与拆箱

package com.itheima.demo07Integer;
/* 装箱：把基本类型的数据，包装到包装类中（基本类型的数据-->包装类） 构造方法： Integer(int value)构造一个新分配的Integer对象，它表示int值 Integer(String s)构造一个新分配的Integer对象，它表示String参数所指示的int值 传递的字符串，必须是基本类型的字符串，否则会抛出异常“100”正确 “a"抛异常 静态方法： static Integer valueOf(int i)返回一个表示指定的int值的Integer实例。 static Integer valueOf(String s)返回保存指定的String的值的Integer对象。 拆箱：在包装类中取出基本类型的数据（包装类-->基本类型的数据） 成员方法： int intValue()以int类型返回该Integer的值。 */
public class Demo01Integer {
   
    public static void main(String[] args) {
   
        //装箱：把基本类型的数据，包装到包装类中（基本类型的数据-->包装类）
        //构造方法
        Integer in1 = new Integer(1);//方法上由横线，说明方法过时
        System.out.println(in1);//1 重写了toString方法

        Integer in2 = new Integer("1");
        System.out.println(in2);//1

        //静态方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3);//1

        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);//1

// Integer in4 = Integer.valueOf("a");
// System.out.println(in4);//NumberFormatException数字格式化异常

        //拆箱：在包装类中取出基本类型的数据（包装类-->基本类型的数据）
        int i = in1.intValue();
        System.out.println(i);//1

    }
}

自动装箱与拆箱

package com.itheima.demo07Integer;

import java.util.ArrayList;

/* 自动装箱与自动拆箱： 基本类型的数据和包装类之间可以自动的相互转换 JDK1.5之后出现的新特性 */
public class Demo02Integer {
   
    public static void main(String[] args) {
   
        /* 自动装箱：直接把int类型的整数赋值给包装类 Integer in = 1; 就相当于Integer in = new Integer(1); */
        Integer in = 1;
        /* 自动拆箱：in是包装类，无法直接参与计算，可以自动转换为基本类型的数据，再参与计算 in+2;就相当于 in.intValue()+2 = 3； in = in+2; 就相当于 in = new Integer(3) 自动装箱 */
        in = in + 2;
        System.out.println(in);//3

        //ArrayList集合无法直接存储整数，可以存储Integer包装类
        ArrayList<Integer> list = new ArrayList<>();

        list.add(1);//自动装箱 list.add(new Integer(1));
        
        int a = list.get(0);//自动拆箱 list.get(0).intValue();
    }
}

基本数据类型与字符串之间的转换

package com.itheima.demo07Integer;
/* 基本类型与字符串之间的转换 基本类型-->字符串 1.基本类型数据的值 +""最简单的方法（工作中常用） 2.使用包装类中的静态方法 static String toString(int i) 返回一个表示指定整数的 String 对象。 3.使用String类中的静态方法 static String valueOf(int i ) 返回int 参数的字符串表示形式。 字符串-->基本类型 常用包装类的静态方法 parseXX("字符串") Integer类： static int parseInt(String s) Double 类： static double parseDouble(String s) .... */
public class Demo03Integer {
   
    public static void main(String[] args) {
   
        //基本类型-->字符串
        String s1 = 100+"";
        System.out.println(s1+200);//100200

        String s2 = Integer.toString(100);
        System.out.println(s2+200);//100200

        String s3 = String.valueOf(100);
        System.out.println(s3+200);//100200

        //字符串-->基本类型
        int i = Integer.parseInt("100");
        System.out.println(i+200);//300

        double v = Double.parseDouble("100.0");

        int i2 = Integer.parseInt("a");//NumberFormatException: For input string: "a"数字格式化异常
        System.out.println(i2+200);

    }
}

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/100195.html原文链接：https://javaforall.cn

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2021年5月1，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法