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