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