17：常见的API

最新推荐文章于 2024-04-02 18:48:49 发布

是翼不是一

最新推荐文章于 2024-04-02 18:48:49 发布

阅读量183

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/Hhytyq/article/details/104143359

版权

java基础专栏收录该内容

43 篇文章 0 订阅

订阅专栏

1：Object类的toString方法

java.lang.Object类是java语言中的根类，即所有类的父类。描述的所有方法子类都可以使用。在对象实例化的时候，最终找到的父类就是Object.
如果一个类没有特别指定父类，那么默认则继承Object类，例如:
public class MyClass /*extends Object*/{
	//....
}

根据JDK源代码即OBJECT类的API文档，Object类当中包含的方法有11个。主要有;
public String toString()://返回该对象的字符串表示。
public boolean equals(Object obj);//指示其他某个对象是否与该对象“相等”

Person类

package cn.itcast.day10.red;

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();
    打印对象的属性。
    */
    /*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;
    }

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

主类

package cn.itcast.day10.red;

import java.util.Random;

/*
java.lang.Object
类Obeject是类层次结构的根类
每个类都在使用Object作为超（fu)类
所有对象（包括数组）都实现这个类的方法。
*/
public class DemoToString {
    public static void main(String[] args) {
        /*
        Person类默认继承了Objectl类，所以可以使用Object类中的toString方法。
        String toString()  返回该对象字符串表示。
        */
        Person p = new Person();
        String s = p.toString();
        System.out.println(s);  //cn.itcast.day10.red.Person@1b6d3586

        //直接打印对象的名字，其实就是调用对象的toString   p = p.toString();
        System.out.println(p);//cn.itcast.day10.red.Person@1b6d3586

        //看一个类是否重写了toString，直接打印这个类的对象即可，如果没有重写toString方法那么打印的对象的地址值。
        Random r =new Random();
        System.out.println(r);//java.util.Random@4554617c

    }
}

在这里插入图片描述

2:Object类的equals方法

方法摘要:
	public boolean equals(Object obj);指示其他某个对象是否与此对象“相等”
调用成员方法equals并指定参数成为另外一个对象，则可以判断两个对象是否相同。这里的“相同"有默认的和自定义两种方式。
默认地址比较：
如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是一个对象，必然为false

对象内容比较。
如果希望进行对象的内容的比较，即所有或者指定部分成员变量相同就判定两个对象相同，就可以覆盖重写equals方法。

Person类

package cn.itcast.day10.red;

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();
    打印对象的属性。
    */
    /*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;
    }

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

    @Override
    public int hashCode() {

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

主类

package cn.itcast.day10.red;

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
        */
        Person p1 = new Person("一",18);//
        Person p2 = new Person("一",18);
        System.out.println("p1"+p1);//p1cn.itcast.day10.red.Person@1b6d3586
        System.out.println("p2"+p2);//p2cn.itcast.day10.red.Person@4554617c
        boolean b =p1.equals(p2);
        System.out.println(b);
      //  p1 = p2;
        boolean b1 =p1.equals(p2);
        System.out.println(b1);
    }
}

在这里插入图片描述

3：Objects类的equals方法

package cn.itcast.day10.red;

import java.util.Objects;

public class Demo03ObjectS {
    public static void main(String[] args) {
        String s1 =null;
        String s2 ="abc";
        //boolean b =s1.equals(s2);//NullPointException null是不能调用方法的，就会抛出空指针异常。
        /*
        Objects类的equals():对两个对象进行比较，防止空指针异常。
        public static boolean equals(Object a,Object b){
            return (a == b ) || (a! =null && a.quals(b));
            }
        */
        boolean b2 = Objects.equals(s1,s2);
        System.out.println(b2);
    }
}

在这里插入图片描述

4:Date类

概述：
java.util.Date类 表示特定的瞬间，精确到毫秒。
继续查询Date类的描述，发现Date拥有多个构造方法，只是部分已经过时，但是其中有未过时的构造方法可以把毫秒值转成日期对象。
	public Date();分配Date对象并初始化此对象，以此表示它的时间（精确到毫秒）。
	public Date(long date):分配Date对象并初始化此对象，以表示自从标准基准时间（称为”历元“ (epoch)",即1970年1月1日00：00：00 GMT)以来的指定毫秒数。
	tips：由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。
	简单来说:使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。
package cn.itcast.day10.red;
/*
java.util。Date：表示日期和时间的类。
类Date表示特定的瞬间,精确到毫秒。
毫秒：千分之一秒 1000毫秒=1秒。
特定的瞬间：一个时间点，一刹那时间
20888-08-08 09:55:33:333瞬间

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

把日期转换为毫秒：
    当前的日期：2088-01-01
    时间原点（0毫秒）：1970年1 月1日 00：00：00（英国格林威治）。
    就是计算当前日期到时间原点之间一共经历了多少毫秒（3742767540068L）
    注意：
    中国属于东八区，会把时间增加8个小时。
    把毫秒转换为日期：
    1天 = 24*60*60=86400秒 =86400*1000毫秒
*/
public class Demo01Date {
}

package cn.itcast.day10.red;

import cn.itcast.day10.Demo2.DemoMain1;

import java.util.Date;

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

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

把日期转换为毫秒：
    当前的日期：2088-01-01
    时间原点（0毫秒）：1970年1 月1日 00：00：00（英国格林威治）。
    就是计算当前日期到时间原点之间一共经历了多少毫秒（3742767540068L）
    注意：
    中国属于东八区，会把时间增加8个小时。
    把毫秒转换为日期：
    1天 = 24*60*60=86400秒 =86400*1000毫秒
*/
public class Demo01Date {
    public static void main(String[] args) {
        demo03();
    }
    /*
    *long getTime()把日期转换为毫秒值（相当System.currentTimeMILLis()方法）
    * 返回自1970年1月1日00：00：00 GMT以来此Date对象表示的毫秒数。
    * */
    public static void demo03(){
        Date date =new Date();
        long time=date.getTime();
        System.out.println(time);//1580634222015

    }
    /*
    Date类的带参数的构造方法
    Date(long date):传递毫秒值，把毫秒转换为日期。
    */
    private  static void demo02(){
        Date date =new Date(0L);
        System.out.println(date);//Thu Jan 01 08:00:00 CST 1970
        date = new Date(3742767540068L);//Sun Aug 08 09:39:00 CST 2088
        System.out.println(date);
    }
    /*
    *Date类的空参构造方法
    * Date()获取当前系统的日期和时间。
    * */
    private static void demo01(){
        Date date =new Date();
        System.out.println(date);
    }
}

在这里插入图片描述

5：DateFormat类

java.text.DateFormat是日期/时间格式化子类的抽象类，我们通过这个类可以帮助我们完成日期和文本之间转换，也就是可以在Date对象与String对象之间进行转换。
格式化：按照指定的格式，从Date对象转换String对象。
解析：按照指定的格式,从String对象转换为Date对象。
构造方法：
由于DateFormat为抽象类，不能直接使用，所以我们需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：
public SimpleDateFormat(String pattern):用给定的模式和默认语言环境的日期格式构造SimpleDateFormat.
参数pattern是一个字符串，代表日期时间的自定义格式。

package cn.itcast.day10.red;

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

/*
java.text.Demo01DateFormat
作用：
    格式化（也就是日期 ->文本），解析（文本 ->日期）
    成员方法：
        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 {
        demo02();
    }
    /*
    使用DateFormat类中的format,把日期格式化为文本
    使用步骤：
        1:创建SimpleDateFormat对象，构造方法中传递指定的模式。
        2:调用SimpledateFormat对象中方法format，按照构造方法指定的模式，把Date日期格式化符合模式的字符串（文本）。
    */
    private  static void demo01(){
        //1:创建SimpleDateFormat对象，构造方法中传递指定的模式。
        SimpleDateFormat sdf =new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //2:调用SimpledateFormat对象中方法format，按照构造方法指定的模式，把Date日期格式化符合模式的字符串（文本）。
        //String format(Date date) 按照指定的格式，把Date日期，格式化符合模式的字符串。
        Date date =new Date();
        String d =sdf.format(date);
        System.out.println(date);//Tue Feb 04 16:18:56 CST 2020
        System.out.println(d);//2020年02月04日 16时18分56秒
    }
    /*
    使用DateFormat类中的方法parse，把文本解析为文本
    使用步骤:
        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 parse(String source) 把符合模式的字符串，解析为Date日期
        Date date =sdf.parse(("2020年2月4日 00时00分00秒"));
        System.out.println(date);
    }
}

在这里插入图片描述
练习：

package cn.itcast.day10.red;

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/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/60/24):
        System.out.println(time/1000/60/60/24);
    }
}

在这里插入图片描述

6:Calendar类

1：获取对象的方式

package cn.itcast.day10.red;

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();//d多态
        System.out.println(c);
    }
}

在这里插入图片描述
2:常用方法

public int get(int field):返回给定日历字段的值。
public void set(int field,int value):将给定的日历字段设置为给定值。
public abstract void add(int field,int amount):根据日历的规则，为给定的日历字段添加或减小指定的时间量。
Calendar类中提供很多成员方法，代表给定的日历字段：
字段值       含义
YEAR         年
MONTH        月(从0开始，可以+1使用）
DAY_OF_MONTH    月中的天(几号).

package cn.itcast.day10.red;

import javax.swing.plaf.synth.SynthOptionPaneUI;
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 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) {
        demo04();
    }
    /*
    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);
        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);//西方的月份0-11，东方：1- 12
    }
    /*
     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);
        System.out.println(date);
    }
    /*
     public Date getTime():返回一个表示此Calendar时间值（从历元到现在的毫秒偏移值）DATE对象。
     把日历对象，转换为日期对象。
    */
    private static void demo04(){
        //使用getInstance方法获取Calendar对象。
        Calendar c =Calendar.getInstance();
        Date date = c.getTime();
        System.out.println(date);
    }
}

在这里插入图片描述

7:System类

package cn.itcast.day10.red;

import java.util.Arrays;

/*
    java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有:
        public static long currentTimeMills();返回以毫秒为单位的当前时间。
        public static void arraycopy(Object src,int scrPos,Object dest,int destPos,int length);将数组中指定的数据拷贝到里一个数组中。
*/
public class Demo15System {
    public static void main(String[] args) {
        demo02();
    }
    /*
     public static long currentTimeMills();返回以毫秒为单位的当前时间。
     可以用来测试程序的效率。
     验证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)+"毫秒");//程序共耗时：100毫秒。
    }

    /*
     public static void arraycopy(Object src,int scrPos,Object dest,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));
        //将src数组中的前3个元素，复制到dest数组的前3个位置上。
        System.arraycopy(src,0,dest,0,3);
        System.out.println("复制后:"+ Arrays.toString(dest));
    }
}

在这里插入图片描述

8:StringBuilder类

Strin类:
	字符串是常量;它们的值在创建之后不能更改。
	字符串的底层是一个被final修饰的数组，不能改变，是一个常量。
	private final byte[] value;
	进行字符串的相加，内存中就会有多个字符串，占用空间多，效率低下。
	String s="a"+"b"+"c"="abc"
	String s     "a","b",“c"   3个字符串
	             “a"+"b"  "ab"  1个字符串
	             ”ab"+"c"   "abc"  1个字符串。

StringBuilder类
	字符串缓冲区，可以提高字符串的操作效率(看成一个长度可以变化的字符串）
	底层也是一个数组。但是没有被final修饰，可以改变长度
	byte[] value =new byte[16];

StringBuilder构造方法：

package cn.itcast.day10.red;
/*
java.lang.StringBuilder类：字符串缓冲区，可以提高字符串的效率。构造方法：
    StrngBuilder（）构造一个不带任何字符的字符生成器，其初始容量为16个字符。
    StringBuilder(String str)构造方法生成器，并且初始化指定的字符串内容。
*/
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);
    }
}

在这里插入图片描述
StringBuilder类的常用方法：

package cn.itcast.day10.red;
/*
StringBuilder的常用方法：
public StringBuilder append(..):添加任意类型数据的字符串形式，并返回当前对象自身。
*/
public class Demo02StringBuilder {
    public static void main(String[] args) {
        //创建StringBuilder对象。
        StringBuilder bu = new StringBuilder();
     /*   //使用append方法往StringBuilder中添加数据。
        //append方法返回this,调用方法的对象bu,this--bu
        StringBuilder bu2 = bu.append("abc");//把bu的地址赋值给了bu2
        System.out.println(bu);//"abc"
        System.out.println(bu2);//"abc"
        System.out.println(bu== bu2);//比较的是地址 true*/
        //使用append方法无需接收返回值。
        bu.append("abc");
        bu.append(1);
        bu.append(true);
        bu.append(8.8);
        bu.append("中");
        System.out.println(bu);//abc1true8.8中

        /*
        链式编程:方法返回值是一个对象，可以继续调用方法。
        */
        StringBuilder bu3 =new StringBuilder();
        System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase());
        bu3.append("abc").append(1).append(true).append(8.8).append("中");
        System.out.println(bu3);
    }
}

在这里插入图片描述
StringBuilder中toString方法

package cn.itcast.day10.demo1;
/*
StringBuilder和String可以相互转换；
String ->StringBuilder：可以使用StrngBuilder的构造方法。
    StringBuilder(String str)  构造方法，并且初始化为指定的字符串内容。
StringBuilder --->String:可以使用StringBuilder中的toString方法
*/
public class Demo03StringBuilder {
    public static void main(String[] args) {
        //String ->StringBuilder：
        String string ="hello";
        System.out.println("str:"+string);
        StringBuilder bu =new StringBuilder(string);
        //往StringBuilder中添加数据。
        bu.append("world");
        System.out.println("bu:"+bu);

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

9:基本类型包装类

概述：

基本类型	对应的包装类(位于java.lang包中
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double-	Double
char	Character
boolean	Boolean

基本类型与对应的包装类对象之间，来回转换的过程称为“装箱”与‘拆箱“；
。装箱：从基本类型转换为对应的包装类对象。
。拆箱：从包装类对象转换为对应的基本类型。

package cn.itcast.day10.demo1;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

/*
装箱：把基本类型的数据，包装到包装类中(基本类型的数据  --》包装类）
    构造方法
        Integer(int value)  构造一个新分配的Integer对象，它表示指定int值。
        Integer(String s）构造一个新分配的Integer对象，它表示String参数所指示的int值传递的字符串，必须是基本类型的字符串，否则会抛出
        异常 "100"正确，"a"抛出异常。
    静态方法:
        static Integer valueOf(int t)返回一个表示指定的int值的Integer实例。
        static Integer valueOF(String s)返回保存指定String的值的Integer对象。
拆箱：在包装类中取出基本类型的数据（包装类 ===>基本类型的数据)
    成员方法：
        int intValue()以interesting类型返回Integer的值。
*/
public class Demo01Integer {
    public static void main(String[] args) {
        //装箱：把基本类型的数据，包装到包装类中(基本类型的数据  --》包装类）
        //构造方法
        Integer inl =new Integer(1);
        System.out.println(inl);//1
        Integer in2 = new Integer("1");
        System.out.println(in2);

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

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

在这里插入图片描述
包装类_自动装箱与自动拆箱

package cn.itcast.day10.demo1;

import jdk.nashorn.internal.runtime.arrays.ArrayLikeIterator;

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.invalue()+2 =3;
        in = in.invalue()+ 2=3又是一个自动装箱。
        */
        in = in+2;
        ArrayList<Integer> list =new ArrayList<>();
        /*
        ArrayList集合无法直接存储整数，可以存储Integer包装类。
        */
        list.add(1);//自动装箱）list.add(new Integer(1));
        int a =list.get(0);//自动拆箱  list.get(0).intValue();
        
    }
}

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

package cn.itcast.day10.demo1;
/*
基本类型与字符串之间的相互转换
基本类型 ->字符串(String)
    1:基本类型的值+“”，最简单的方法（工作中常用）
    2:包装类的静态方法tosTRING(参数),不是Object类的toString()重载。
        static String toString(int i)返回一个表示指定整数的String对象
    3：String类的静态方法valueOf(参数)
        static String valueOf(int i)返回int参数的字符串形式。
字符串（Strng)  ->基本类型
    使用包装类的静态方法parsexxx("数值类型的字符串");
    Integer类：static int parseInt(String s）
    Double类:  static double parseDouble(String s0；
*/
public class Demo03Inter {
    public static void main(String[] args) {
        //基本类型-》字符串(String)
        int i1 =100;
        String s1 =i1+"";
        System.out.println(s1+200);//100200

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

        //字符串(String )  -->基本类型
        int i =Integer.parseInt(s1);
        System.out.println(i-10);
    }
}

在这里插入图片描述

是翼不是一

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
17：常见的API

1：Object类的toString方法java.lang.Object类是java语言中的根类，即所有类的父类。描述的所有方法子类都可以使用。在对象实例化的时候，最终找到的父类就是Object.如果一个类没有特别指定父类，那么默认则继承Object类，例如:public class MyClass /*extends Object*/{ //....}根据JDK源代码即OBJECT...
复制链接

扫一扫

专栏目录