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