Chapter13_Object类、常用API
Chapter13_Object类、常用API
主要内容
- Object类
- Date类
- DateFormat类
- Calendar类
- System类
- StringBuilder类
- 包装类
教学目标
-[ ] 能够说出Object类的特点
-[ ] 能够重写Object类的toString方法
-[ ] 能够重写Object类的equals方法
-[ ] 能够使用日期类输出当前日期
-[ ] 能够使用将日期格式化为字符串的方法
-[ ] 能够使用将字符串转换成日期的方法
-[ ] 能够使用System类的数组复制方法
-[ ] 能够使用System类获取当前毫秒时刻值
-[ ] 能够说出使用StringBuilder类可以解决的问题
-[ ] 能够使用StringBuilder进行字符串拼接操作
-[ ] 能够说出8种基本类型对应的包装类名称
-[ ] 能够说出自动装箱、自动拆箱的概念
-[ ] 能够将字符串转换为对应的基本类型
-[ ] 能够将基本类型转换为对应的字符串
第一章 Object类
1.1 概述
java.lang.object类是java语言中的根类,即所有类的父类。它中描述所有子类都可以使用。在实例化对象的时候,最终父类就是object。
如果一个类没有特别指定的父类,那么默认集成的就是object类。
代码如下:
public class MyClass /*extends Object*/{
// ...
}
根据JDK源代码及Object类的API文档,Object类当中包含的方法有11个。今天我们主要学习其中的2个:
- public String toString():返回改对象的字符串表示。
- public boolean eqals(object obj):指示其他某个对象是否与此对象“相等”
1.2 toString方法
方法摘要:
- public String toString():返回该对象的字符串表示。
toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型+@+内存地址值。
由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。
覆盖重写
如果不希望使用toString方法的默认行为,则可以对它进行覆盖重写。例如自定义的Person类:
public class Person{
private String name;
private int age;
@Override
public String toString(){
return "Person{"+"name"+name+'\''+",age="+age+'}';
}
public Person(){
}
public Preson(String name,int age){
this.name = name;
this.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;
}
}
重写toString快捷方法
在IntelliJ IDEA中,可以点击Code
菜单中的Generate...
,也可以使用快捷键alt+insert
,点击toString()
选项。选择需要包含的成员变量并确定。
小贴士: 在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。
1.3 equals方法
方法摘要
-
public boolean equals(Object obj)
:指示其他某个对象是否与此对象”相等“。 -
equals方法源码:
public Boolean equals(Object obj){
return(this == obj);
}
参数:
- object obj:可以传递任意的对象
- == 比较运算符,返回值是一个布尔值 true 或 false
- 基本数据类型:比较的是值
- 引用运算符:比较的是两个对象的地址值
- this是指:那个对象调用的方法,方法中的this就是那个对象。
- 如boolean b = p1.equals(p2);
- p1调用的equals方法所以this就是p1;
- obj就是p2
- this == obj --> p1 == p2
// 调用上边定义好的person类
Person p1 = new Person("迪丽热巴",19);
Person p2 = new Person("古力娜扎",20);
boolean b = p1.equals(p2);
结果为;false
默认地址比较
如果没有覆盖重写equals方法,那么Object类中默认进行==
运算符的对象地址比较,只要不是同一个对象,结果必然为false。
重写Object类的equals方法
在IntelliJ IDEA中,可以使用Code
菜单中的Generate…
选项,也可以使用快捷键alt+insert
,并选择equals() and hashCode()
进行自动代码生成。
1.4 Objects类
在JDK7添加了一个Objects工具类,它提供了一些方法来操作对象,它由一些静态的实用方法组成,这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的),用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候,Object的equals方法容易抛出空指针异常,而Objects类中的equals方法就优化了这个问题。
代码如下:
public class Demo03Objcets {
public static void main(String[] args) {
String s1 = null;
String s2 = "999";
// NullPointerException null是不能调用方法的会报空指针异常
/*boolean b = s1.equals(s2);
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);
}
}
第二章 日期时间类
2.1 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类型的构造参数,可以自定义毫秒时刻。
import java.util.Date;
public class Demo01Date {
public static void main(String[] args) {
demo01();
demo02();
demo03();
}
/**
* Date类空参的构造方法
* Date()获取当前的时间和日期
* */
private static void demo01() {
Date date = new Date();
// Mon Mar 09 13:02:04 CST 2020
System.out.println(date);
}
/**Date类带参的构造方法
* Date(Long date)传递毫秒值,把毫秒值转换为Date的日期
*/
private static void demo02() {
Date date = new Date(0L);
// Thu Jan 01 08:00:00 CST 1970
System.out.println(date);
}
/**
* long getTime() 把日期转换为毫秒值相当于(system.currentTime()方法)
* 返回自 1970年 1 月 1日00:00:00 GMT 以来此 Date 对象表示的毫秒数-
* */
public static void demo03(){
Date date = new Date();
long time = date.getTime();
// 1583731291264
System.out.println(time);
}
}
tips:在使用println方法时,会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写,所以结果为指定格式的字符串。
常用方法
Date类中的多数方法已经过时,常用的方法有:
public long getTime()
把日期对象转换成对应的时间毫秒值。
2.2 DateFormat类
java.text.DateFormat:是日期的/时间格式化子类的抽象类
作用:
格式化(也就是日期--> 文本)、解析(文本-->日期)
成员方法:
String format(Date date)按照指定的模式,把Date日期,格式化为符合模式的。
Date parse(String source) 把符合模式的字符串,解析为Date日期
注意
DateForamt类是一个抽象类,无法直接创建对象使用,可以使用DateFormat类的子类
java.text.SimpleDateFormat extends DateFormat.
构造方法
SimpleDateFarmat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
参数:
String pattern:传递指定的模式
模式:区分大小写
标识字母(区分大小写) | 含义 |
---|---|
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
备注:更详细的格式规则,可以参考SimpleDateFormat类的API文档0。
创建SimpleDateFormat对象的代码如:
import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class Demo02SimpleDateFormat {
public static void main(String[] args) {
// 对应的日期格式如:2018-01-16 15:06:38
DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
}
常用方法
DateFormat类的常用方法有:
public String format(Date date)
:将Date对象格式化为字符串。public Date parse(String source)
:将字符串解析为Date对象。
format方法
使用DateFormat类中的方法format,把日期格式转化为文本
使用步骤:
1.创建SimpleDateFormat对象,构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的方法format,按照构造方法中的指定模式,吧Fate日期转化为符合模式的字符串(文本)
使用format方法的代码为:
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
把Date对象转换成String
*/
public class Demo03DateFormatMethod {
public static void main(String[] args) {
Date date = new Date();
// 创建日期格式化对象,在获取格式化对象时可以指定风格
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
String str = df.format(date);
System.out.println(str); // 2008年1月23日
}
}
parse方法
使用DateFormat类中的parse方法,把文本转换为日期
使用步骤:
1.创建SimpleDateFormat对象,构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的方法parse,吧符合构造方法中模式的字符串,解析为Date日期
注意:
public Date parse(String source) throws ParseException
parse方法声明了一个异常叫ParseException
如果字符串和构造方法的模式不一样,那么程序就会出下异常
调出一个抛出了异常的方法,就必须得处理这个异常,要么throws继续抛出这个异常 要么try catch自己处理
使用parse方法的代码为:
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
把String转换成Date对象
*/
public class Demo04DateFormatMethod {
public static void main(String[] args) throws ParseException {
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
String str = "2018年12月11日";
Date date = df.parse(str);
System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
}
}
2.3 练习
请使用日期时间相关的API,计算出一个人已经出生了多少天。
思路:
1.获取当前时间对应的毫秒值
2.获取自己出生日期对应的毫秒值
3.两个时间相减(当前时间– 出生日期)
/*
*练习:
* 请使用日期相关的API,计算出一个人已经出生了多少天
*分析:
* 1.使用Scanner类中的next方法,获取出生日期
* 2.使用DateFormat类中的方法parse,把字符串解的出生日期析为Date格式
* 3.把Date格式的出生日期转换为毫秒值
* 4.获取当前日期转换为毫秒值
* 5.使用当前日期的毫秒值 - 出生日期的毫秒值
* 6.把毫秒值的差转换为天(s/1000/60/60/24)
* */
public class test{
public static void main(String[] args){
// 使用Scanner类中的方法next,获取出生日期
Scanner sc = new Scanner(System.in);
System.out.println("请输入出生日期");
String csrq = sc.next();
// 2.使用DateFormat类中的方法parse,把字符串解的出生日期析为Date格式
SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");
Date birtdayDate = sdf.parse(csrq);
// 3.把Date格式的出生日期转换为毫秒值
long time = birtdayDate.getTime();
// 4.获取当前日期转换为毫秒值
long todayTime = new Date().getTime();
// 5.使用当前日期的毫秒值 - 出生日期的毫秒值
long t = todayTime - time;
// 6.把毫秒值的差转换为天(s/1000/60/60/24)
System.out.println(time/1000/60/60/24);
}
}
2.4 Calendar类
日历类 java.util.Calender,在Date后出现,替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量,方便获取。日历类就是方便获取各个时间属性的。
获取方式
Calendar为抽象类,无法直接创建对象使用,里面有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象。
static Calendar getInstance() 使用默认时区和语言环境获取一个日历
// 导包
java.util.Calendar
public class Calendar{
public void main(String[] aegs){
// 多态
Calendar c = Calendar.getInstance();
Syste.out.println(c);
}
}
常用方法
get方法用来获取指定字段的值,set方法用来设置指定字段的值
Calendar类的常用成员方法
get方法
格式:
public int get(int field):返回给定日历字段的值
参数:传递指定的日历字段(YEAR,MONTH...)
返回值:日历字段代表的具体的值
public static void main(String[] args) {
demo01();
}
public static void demo01(){
// 使用getInstance方法获取Calendar对象
Calendar c = Calendar.getInstance();
System.out.println(c);
int year = c.get(Calendar.YEAR);
System.out.println(year);
int mouth = c.get(Calendar.MONTH);
// 西方月份0-11 东方月份1-12
System.out.println(mouth);
int date = c.get(Calendar.DAY_OF_MONTH);
System.out.println(date);
int date2 = c.get(Calendar.DATE);
System.out.println(date2);
}
set方法
格式:
public void set(int field,int value):将给定的日历字段设置为给定值
参数:
int field:传递指定的日历字段(YEAR,MONTH...)
int value:给指定的字段设置值
public static void main(String[] args) {
demo02();
}
public static void demo02(){
// 使用getInstance方法获取calendar对象
Calendar c = Calendar.getInstance();
System.out.println(c);
c.set(999,6,6);
// 获取年
c.set(Calendar.YEAR,666);
int year = c.get(Calendar.YEAR);
System.out.println("系统时间:"+year);
System.out.println("重新设置年::"+year);
// 重新设置月
c.set(Calendar.MONTH,6);
int month = c.get(Calendar.MONTH);
System.out.println("月份:"+month);
// 重新设置日
c.set(Calendar.DATE,11);
// 获取日
int date = c.get(Calendar.DATE);
System.out.println(date);
c.set(999,6,6);
System.out.println(year+"年"+month+"月"+date+"日");
}
add方法
格式:
public abstract void add(int field,int amount):根据日历的规则,得指定的日历字段添加或者减去指定的时间量把指定的字段量增加/减少指定的值
参数:
int field:传递指定的日历字段(YEAR,MONTH...)
int amount:增加/减少指定的值
正数:增加
负数:减少
public static void main(String[] args) {
demo03();
}
public static void demo03(){
Calendar c = Calendar.getInstance();
// 增加两年
c.add(Calendar.YEAR,2);
int year = c.get(Calendar.YEAR);
System.out.println(year);
// 减少两个月
c.add(Calendar.MONTH,-1);
int month = c.get(Calendar.MONTH);
System.out.println(month);
}
getTime方法
Calendar中的getTime方法并不是获取毫秒时刻,而是拿到对应的Date对象。
格式:
public Date getTime():返回一个表示此calendar时间值(从历元到现在的毫秒值偏移量)的Date对象
把日历对象,转换为日期对象
public static void main(String[] args) {
demo04();
}
public static void demo04(){
// 使用getInstance方法获取calendar对象
Calendar c = Calendar.getInstance();
Date date = c.getTime();
System.out.println(date);
// Thu Mar 12 23:20:35 CST 2020
}
小贴士:
西方星期的开始为周日,中国为周一。
在Calendar类中,月份的表示是以0-11代表1-12月。
日期是有大小关系的,时间靠后,时间越大。
练习
public void main(String[] args){
//Date
Date d = new Date();
System.out.println(d);
// Fri Mar 13 21:29:03 CST 2020
// 根据本地格式显示
System.out.println(d.toLocaleString());
//2020-3-13 21:29:03
// Date(Long date)传递毫秒值,把毫秒值转换为Date日期
d = new Date(66666L);
System.out.println(d);
// Thu Jan 01 08:01:06 CST 1970
// DateFormat类
// String format(Date date)按照指定的模式,把date日期转换为符合模式的
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);
// 1970年01月01日 08:01:06
// 把文本格式转换为日期
String str = "2088年08月08日 06:09:00";
Date parse = sdf.parse(str);
System.out.println(parse);
// Sun Aug 08 06:09:00 CST 2088
// Calendar类
//获取日历对象
Calendar c = Calendar.getInsance();
// get
int year = c.get(Calendar.YEAR);
System.out.println(year);
// set
c.set(Calendar.YEAR,2066);
year = c.get(Calendar.YEAR);
System.out.println(year);
// add
c.add(Calendar,YEAR,2);
year = c.get(Calendar.YEAR);
System.out.println(year);
}
第三章 System类
java.lang.System
类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作,在System类的API文档中,常用的方法有:
- public static long currentTimeMillis()`:返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
:将数组中指定的数据拷贝到另一个数组中。
3.1 currentTimeMillis方法
实际上,currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值
public static long currentTimeMillis();返回以毫秒为单位的当前时间
用来程序测试的效率
练习
验证for循环打印数字1-9999所需要使用的时间(毫秒)
public static void main(String[] args) {
demo01();
}
private static void demo01(){
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("程序运行时间为"+(end - start)+"毫秒");
}
3.2 arraycopy方法
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
:将数组中指定的数据拷贝到另一个数组中。
数组的拷贝动作是系统级的,性能很高。System.arraycopy方法具有5个参数,含义分别为:
参数序号 | 参数名称 | 参数类型 | 参数含义 |
---|---|---|---|
1 | src | Object | 源数组 |
2 | srcPos | int | 源数组索引起始位置 |
3 | dest | Object | 目标数组 |
4 | destPos | int | 目标数组索引起始位置 |
5 | length | int | 复制元素个数 |
练习
将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]
public static void main(String[] args) {
demo02();
}
/**
* 练习:
* 将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]
* public static void arrayCopy(Object src,int srcPos,Object dest,int destPos,int length):将数组指定数据拷贝到另一个数组中
* 参数:
* src - 源数组。
* srcPos - 源数组中的起始位置(起始索引)。
* dest - 目标数组。
* destPos - 目标数据中的起始位置。
* length - 要复制的数组元素的数量。
*/
private static void demo02(){
// 定义源数组
int[] src = {1,2,3,4,5};
// 定义目标数组
int[] dest = {6,7,8,9,10};
// 复制前
System.out.println("复制前"+ Arrays.toString(dest));
// 使用System类中的arrayCory把原数组的前三个元素复制到目标数组的前三个位置上
System.arraycopy(src,0,dest,0,3);
// 复制后
System.out.println("复制后:"+ Arrays.toString(dest));
}
第四章 StringBuilder类
4.1 字符串拼接问题
String类
字符串是常量,他们的值再创建后不能更改。
字符串底层是一个被final修饰的数组,不可改变,是一个常量
private final byte[] value;
进行字符串的相加,内存中就会有很多个字符串,占用空间多,效率低下:
比如
String s = "a"+"b"+"c" = "abc";
"a","b","c" 3个字符串
"a"+"b" "ab" 1个字符串
"ab"+"c" "abc" 1个字符串
4.2 StringBuilder类
字符串缓冲区,可以提高字符串的操作效率(看成一个长度可以变化的字符串)
底层也是一个数组,但是没有被final修饰,可以改变长度
byte[] value = new byte[16];
StringBuilder在内存中始终是一个数组,占用空间少,效率高
如果超出了StringBuilder的容量,会自动扩容
4.3 构造方法
根据StringBuilder的API文档,常用的两个构造方法:
public StringBuilder():
构造一个空的StringBuilder容器public StringBuilder(String str):
构造一个StringBuilder容器,并将字符串添加进去
public static void main(String[] args){
// 空参
StringBuilder bu1 = new StringBuilder();
System.out.println(bu1);// (空白)
// 带字符串的构造方法
StringBuilder bu2 = new StringBuilder("abc");
System.out.println(bu2);// (abc)
}
4.4 常用成员方法
StringBuilder常用的方法有两个:
append方法
-
public stringBuilder append(。。):添加任意数据类型的字符串形式,病返回自身
public static void main(String[] args){ // 创建StringBuilder对象 StringBuilder bu1 = new StringBuilder(); // 使用append方法添加数组 StringBuilder bu2 = bu1.append("abc");// 把bu1的地址值赋值给了bu2 Systom.out.println(bu1);// abc Systom.out.println(bu2);// abc Systom.out.println(bu1 == bu2); // ture // 使用appen方法无需接收返回值 bu1.appen("a"); bu1.appen("b"); bu1.appen("c"); Systom.out.println(bu1);// abc // 链式编程:方法返回值是一个对象,可以继续调用方法 bu1.appen("a").appen("b").appen("c"); Systom.out.println(bu1);// abc }
toString方法
- StringBuilder和string可以相互转换
- stringbuillder-->String:public String toString():将当前的StringBuilder对象转换为String对象
- string-->StringBuillder:可以使用StringBuilder的构造方法StringBuilder(String str)构造一个字符串生成器,并初始化指定字符串的内容
string-->StringBuillder
public static void main(String[] args){
// string-->StringBuillder
String str = "hello";
System.out.println("str"+str);// str
StringBuilder bu = new StringBuilder(str);
// 往StringBuilder里添加数据
bu.append("wold");
System.out.println("bu"+bu);// helloworld
// stringbuillder-->String
String s = bu.toString();
System.out.println("s"+s);// helloworld
}
-
reverse方法
public static void main(String[] args){ StringBuilder str = new StringBuilder(); str.append("j").append("a").append("va"); str.reverse(); System.out.println(str);// avaj }
第五章 包装类
5.1 概述
java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:
基本类型 | 对应的包装类(位于java.lang包中) |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
5.2 装箱拆箱
基本类型与对应的包装类对象之间,来回转换过称称为“装箱”与“拆箱”:
- 装箱:从基本类型转换为对应的包装类对象。(基本类型的数据-->包装类)
- 构造方法:
- 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 的值。
- 成员方法:
用Integer与int为例:
基本类型 -- > 包装对象
// 使用构造函数
Integer i= new Integer(6);
// 使用包装类中的valueOf方法
Integer ii = Integer.valueIf("6");
包装对象-->基本数值
int num = i.intvalue();
5.3 自动装箱与自动拆箱
自动装箱与自动拆箱:基本类型的数据和包装类之间可以进行相互转换
JDK1.5之后出现的新特性
-
自动装箱:直接把int类型的整数赋值于包装类
如:Integer in = 1;就相当于 Integer in = new Integer(1);
-
自动拆箱:int是包装类,无法直接参与运算,可以自动转换为基本数据类型,再进行计算
如:in + 2;就相当于 in.intVale() + 2 = 3;
int = in.intVale() + 2 = 3 又是一个自动装箱
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边:将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后,再次装箱,把基本数值转成对象。
5.4基本类型与字符串之间的转换
1.基本类型-->字符串(String)
-
基本类型的值+" " 最简单的方法(工作中常用)
-
包装类的静态方法toString(参数),不是Object类的toString方法()重载
static String toString(int i)返回一个表示指定整数的string 对象。
-
String类的静态方法valueOf(参数)
static String valueOf(int i)返回 int 参数的字符串表示形式。
2.字符串(String)--> 基本类型
使用包装类的静态方法parseXXX("字符串");
如:
Integer类: static int parseInt(Sting s)
Double类:static double parseDouble(String s);
public static void main(String[] args) {
// 基本类型-->字符串
int i1 = 100;
String s1 = i1 +"";
System.out.println(s1+999);
String s2 = Integer.toString(100);
System.out.println(s2+300);
String s3 = String.valueOf(100);
System.out.println(s3 + 100);
// 字符串(String)--> 基本类型
int i = Integer.parseInt(s1);
System.out.println(i - 10);
// 不能转换字符串报错 数字格式异常 NumberFormatException
/*int a = Integer.parseInt("a");
System.out.println(a);*/
}