Object类、常用API

最新推荐文章于 2022-02-25 09:11:34 发布

weixin_41675900

最新推荐文章于 2022-02-25 09:11:34 发布

阅读量113

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_41675900/article/details/104345780

版权

Java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

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

    }
}

weixin_41675900

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
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作为超（父）类。 ...
复制链接

扫一扫

专栏目录