Object类、常用API

Object类、常用API

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

    }
}
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/100195.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号