JavaSE Object类、常用API（二）

最新推荐文章于 2021-06-10 16:27:00 发布

天阳在线€

最新推荐文章于 2021-06-10 16:27:00 发布

阅读量1.5k

点赞数

分类专栏： javaSE

本文链接：https://blog.csdn.net/yangbo_CSDN/article/details/116235798

版权

javaSE 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1 Object类

1.1 概述

java.lang.Object 类是Java语⾔中的根类，即所有类的⽗类。它中描述的所有⽅法⼦类都可以使⽤。在对象实例化的时候，最终找的⽗类就是Object。
在这里插入图片描述

1.2 toString⽅法

⽅法摘要

public String toString() ：返回该对象的字符串表示。

Java语⾔中很多地⽅会默认调⽤对象的toString⽅法：

“” + 对象：⾃动调⽤对象的toString⽅法

System.out.print（对象）：直接调⽤toString⽅法

toString⽅法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString⽅法返回的结果是内存地址，⽽在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

覆盖重写

如果不希望使⽤toString⽅法的默认⾏为，则可以对它进⾏覆盖重写。例如⾃定义的Person类：

public class Person { 
 private String name;
 private int age;
 @Override
 public String toString() {
 return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
 }
 // 省略构造器与Getter Setter
}

在这里插入图片描述

1.3 equals⽅法

⽅法摘要

public boolean equals(Object obj) ：指示其他某个对象是否与此对象“相等”。

调⽤成员⽅法equals并指定参数为另⼀个对象，则可以判断这两个对象是否是相同的。这⾥的“相同”有默认和⾃定义两种⽅式。

默认地址⽐较

如果没有覆盖重写equals⽅法，那么Object类中默认进⾏ == 运算符的对象地址⽐较，只要不是同⼀个对象，结果必然为false。

对象内容⽐较

如果希望进⾏对象的内容⽐较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals⽅法。例如：

import java.util.Objects;
public class Person {
 private String name;
 private int age;
 
 @Override
 public boolean equals(Object o) {
 // 如果对象地址⼀样，则认为相同
 if (this == o)
 return true;
 // 如果参数为空，或者类型信息不⼀样，则认为不同
 if (o == null || getClass() != o.getClass())
 return false;
 // 转换为当前类型
 Person person = (Person) o;
 // 要求基本类型相等，并且将引⽤类型交给java.util.Objects类的equals静态⽅
法取⽤结果
 return age == person.age && Objects.equals(name, person.name);
 }
}

好的，

1.4 Objects类

在刚才IDEA⾃动重写equals代码中，使⽤到了 java.util.Objects 类，那么这个类是什么呢？

在JDK7添加了⼀个Objects⼯具类，它提供了⼀些⽅法来操作对象，它由⼀些静态的实⽤⽅法组成，这些⽅法是null-save（空指针安全的）或null-tolerant（容忍空指针的），⽤于计算对象的hashcode、返回对象的字符串表示形式、⽐较两个对象。

在⽐较两个对象的时候，Object的equals⽅法容易抛出空指针异常，⽽Objects类中的equals⽅法就优化了这个问题。⽅法如下：

public static boolean equals(Object a, Object b) ：判断两个对象是否相等。

在这里插入图片描述

2 ⽇期时间类

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) {
 // 创建⽇期对象，把当前的时间
 System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2019
 // 创建⽇期对象，把当前的毫秒值转成⽇期对象
 System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
 }
}

tips：在使⽤println⽅法时，会⾃动调⽤Date类中的toString⽅法。

Date类对Object类中的 toString⽅法进⾏了覆盖重写，所以结果为指定格式的字符串。

常⽤⽅法

Date类中的多数⽅法已经过时，常⽤的⽅法有：

public long getTime() ：把⽇期对象转换成对应的时间毫秒值。

package b_dateClass.a_date;


import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        //获取当前系统时间
        long time = System.currentTimeMillis();
        System.out.println(time);

        //Date -> 专门用来显示时间的类
        //获得当前系统时间
        Date date = new Date();
        //Sat Mar 13 11:07:42 CST 2021
        System.out.println(date);

        //Date(long)
        Date date2 = new Date(time);
        System.out.println(date2);

        // int类型超出范围得到的是一个 负数
        //所以计算前必须将所有的类型进行统一 -> long类型
        Date date1 = new Date(0l + 30l*60*60*60*1000);
        System.out.println(date1);
    }
}

package b_dateClass.a_date;
import java.util.Date;

/*
    从当前日期往后推算5天,问7天后是星期几
 */
public class Demo02 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        //getTime() / setTime()
        long l1 = date.getTime();
        l1 = l1 + 5l*24*60*60*1000;
        //设置时间
        date.setTime(l1);
        System.out.println(date);
        //long l2 = System.currentTimeMillis();
    }
}

package b_dateClass.b_calendar;

import java.sql.SQLOutput;
import java.util.Calendar;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        //使用静态方法调用 - 获取当前系统时间
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);

        /*
            add - 时间的推算
            set - 时间的跳转
            get - 获得时间
            getTime
            setTime
         */
        System.out.println("年:" + cal.get(Calendar.YEAR));
        //月份从0开始计算
        System.out.println("月:" + cal.get(Calendar.MONTH));
        //按国外工作日计算
        System.out.println("星期:" + cal.get(Calendar.DAY_OF_WEEK));
        System.out.println("日" + cal.get(Calendar.DATE));
        System.out.println("时:" + cal.get(Calendar.HOUR));
        System.out.println("分:" + cal.get(Calendar.MINUTE));
        System.out.println("秒:" + cal.get(Calendar.SECOND));

        //从今天起往后往前推算15天
        cal.add(Calendar.DATE,-15);
        cal.add(Calendar.DATE,15);
        System.out.println(cal);

        //Calendar -> Date
        Date time = cal.getTime();
        System.out.println(time);

        //定位到下一周的星期4
        cal.set(Calendar.WEEK_OF_MONTH,1);

        /*
            商品生产日期: 2021年3月13日
            保质期:48天
            过期前的一周周四是促销日,问促销日是那一天
         */
        //获取当前系统时间
        Calendar cal1 = Calendar.getInstance();
        // 到期日
        cal1.add(Calendar.DATE,48);
        cal1.add(Calendar.WEEK_OF_MONTH,-1);
        cal1.set(Calendar.DAY_OF_WEEK,5);
        Date time1 = cal1.getTime();
        System.out.println(time1);


        Date date = new Date(0l);
        Calendar cal3 = Calendar.getInstance();
        cal3.setTime(date);


    }
}

2.2 DateFormat类

java.text.DateFormat 是⽇期/时间格式化⼦类的抽象类，我们通过这个类可以帮我们完成⽇期和⽂本之间的转换,也就是可以在Date对象与String对象之间进⾏来回转换。

格式化：按照指定的格式，从Date对象转换为String对象。
解析：按照指定的格式，从String对象转换为Date对象。

构造⽅法

由于DateFormat为抽象类，不能直接使⽤，所以需要常⽤的⼦类 java.text.SimpleDateFormat 。这个类需要⼀个模式（格式）来指定格式化或解析的标准。
构造⽅法为：

public SimpleDateFormat(String pattern) ：⽤给定的模式和默认语⾔环境的⽇期格式
符号构造SimpleDateFormat。

参数pattern是⼀个字符串，代表⽇期时间的⾃定义格式。

格式规则

常⽤的格式规则为：
在这里插入图片描述
创建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⽅法

使⽤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⽅法

使⽤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 = "2019年12⽉11⽇";
 Date date = df.parse(str);
 System.out.println(date); // Tue Dec 11 00:00:00 CST 2019
 }
}

2.3 练习

请使⽤⽇期时间相关的API，计算出⼀个⼈已经出⽣了多少天。

思路：

获取当前时间对应的毫秒值
获取⾃⼰出⽣⽇期对应的毫秒值
两个时间相减（当前时间– 出⽣⽇期）

代码实现：

public static void function() throws Exception {
 System.out.println("请输⼊出⽣⽇期 格式 YYYY-MM-dd");
 // 获取出⽣⽇期,键盘输⼊
 String birthdayString = new Scanner(System.in).next();
 // 将字符串⽇期,转成Date对象
 // 创建SimpleDateFormat对象,写⽇期模式
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 // 调⽤⽅法parse,字符串转成⽇期对象
 Date birthdayDate = sdf.parse(birthdayString); 
 // 获取今天的⽇期对象
 Date todayDate = new Date(); 
 // 将两个⽇期转成毫秒值,Date类的⽅法getTime
 long birthdaySecond = birthdayDate.getTime();
 long todaySecond = todayDate.getTime();
 long secone = todaySecond-birthdaySecond;
 if (secone < 0){
 System.out.println("还没出⽣呢");
 } else {
 System.out.println(secone/1000/60/60/24);
 } }

package api02;

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

public class Demo01 {
    public static void main(String[] args)  throws Exception{
        System.out.println("请输入出生日期 格式 YYYY-MM-dd");
        Scanner scanner=new Scanner(System.in);
        String s1=scanner.next();
        SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd");
        Date birthday=format.parse(s1);
        Date today=new Date();
        System.out.println(today);
        long birthday01=birthday.getTime();
        long today01=today.getTime();
        long cha=today01-birthday01;
        if (cha<0){
            System.out.println("还没有出生");
        }else{
            System.out.println("出生了"+cha/24/60/60/1000+"天");
        }


    }
}

package b_dateClass.b_calendar;

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

/*
    时间的格式化

 */
public class Demo02 {
    //向方法中抛出转换异常
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf =
                new SimpleDateFormat("yyyy-MM-dd");

        /*
            format() -> Date 转换成 String 输出
            parse() -> String 转换成 Date
                Date -> Calendar
         */
        Date date = new Date();
        System.out.println(date);
        String s = sdf.format(date);
        System.out.println(s);

        String str ="2021-11-11 11:11:11";
        /*try {
            sdf.parse(str);
        } catch (ParseException e) {//捕抓异常
            e.printStackTrace();
        }*/
        Date d = sdf.parse(str);
        System.out.println(d);

    }
}

2.4 Calendar类

概念

⽇历我们都⻅过
在这里插入图片描述

java.util.Calendar 是⽇历类，在Date后出现，替换掉了许多Date的⽅法。

该类将所有可能⽤到的时间信息封装为静态成员变量，⽅便获取。⽇历类就是⽅便获取各个时间属性的。

获取⽅式

Calendar为抽象类，由于语⾔敏感性，Calendar类在创建对象时并⾮直接创建，⽽是通过静态⽅法创建，返回⼦类对象，如下：
在这里插入图片描述

常⽤⽅法

根据Calendar类的API⽂档，常⽤⽅法有：

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对象。

Calendar类中提供很多成员常量，代表给定的⽇历字段：
在这里插入图片描述

get/set⽅法

get⽅法⽤来获取指定字段的值，set⽅法⽤来设置指定字段的值，代码使⽤演示：

import java.util.Calendar;
public class CalendarUtil {
 public static void main(String[] args) {
 // 创建Calendar对象
 Calendar cal = Calendar.getInstance();
 // 设置年
 int year = cal.get(Calendar.YEAR);
 // 设置⽉
 int month = cal.get(Calendar.MONTH) + 1;
 // 设置⽇
 int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
 System.out.print(year + "年" + month + "⽉" + dayOfMonth + "⽇");
 } 
}

add⽅法

add⽅法可以对指定⽇历字段的值进⾏加减操作，如果第⼆个参数为正数则加上偏移量，如果为负数则减去偏移量。代码如：

import java.util.Calendar;
public class Demo08CalendarMethod {
 public static void main(String[] args) {
 Calendar cal = Calendar.getInstance();
 System.out.print(year + "年" + month + "⽉" + dayOfMonth + "⽇"); //
2019年1⽉17⽇
 // 使⽤add⽅法
 cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
 cal.add(Calendar.YEAR, -3); // 减3年
 System.out.print(year + "年" + month + "⽉" + dayOfMonth + "⽇"); //
2016年1⽉19⽇;
 }
}

getTime⽅法

Calendar中的getTime⽅法并不是获取毫秒时刻，⽽是拿到对应的Date对象。

import java.util.Calendar;
import java.util.Date;
public class Demo09CalendarMethod {
 public static void main(String[] args) {
 Calendar cal = Calendar.getInstance();
 Date date = cal.getTime();
 System.out.println(date); // Tue Jan 16 16:03:09 CST 2019
 }
}

⼩贴⼠：
⻄⽅星期的开始为周⽇，中国为周⼀。
在Calendar类中，⽉份的表示是以0-11代表1-12⽉。
⽇期是有⼤⼩关系的，时间靠后，时间越⼤。

3 再谈String类

3.1 常⽤API（补充）

public String trim() ：返回⼀个字符串，其值为此字符串，并删除任何前导和尾随空格。
public boolean startsWith(String prefix) ：测试此字符串是否以指定的前缀开始。

public boolean endsWith(String suffix) ：测试此字符串是否以指定的后缀结束。
public String toLowerCase() ：使⽤默认语⾔环境的规则将此字符串中的所有字符都转换为⼩写。

public String toUpperCase() ：使⽤默认语⾔环境的规则将此字符串中的所有字符都转换为⼤写。
public static String valueOf(Object obj) ：返回 Object 参数的字符串表示形式。

⽅法演示，代码如下：

public class String_Demo01 {
 public static void main(String[] args) {
 // 创建字符串
 String s = " \tHello World! \n";
 // String trim():去除头尾两边空格字符,例如'\t','\n','\r'等⼩
于'\u0020'的字符
 System.out.println(s.trim()); // Hello World!
 s = "hello world";
 // String toUpperCase(): 将所有字符都变成⼤写
 System.out.println(s.toUpperCase()); // HELLO WORLD!
 // String toLowerCase(): 将所有字符都变成⼩写
 System.out.println(s.toLowerCase());// hello world!
 // boolean startsWith(String perfix): 是否以指定前缀开始
 System.out.println(s.startsWith("hello")); // true
 // boolean endsWith(String suffix): 是否以指定后缀结尾
 System.out.println(s.endsWith("ld")); // true
 // static String valueOf(Object obj): 返回obj的字符串形式
 System.out.println(String.valueOf(new Date())); // Thu Dec 05
10:38:47 CST 2019
 }
}

3.2 正则表达式

实际开发中，经常需要对字符串数据进⾏⼀些复杂的匹配、查找、替换等操作。通过“正则表达式”，可以⽅便的实现字符串的复杂作。

正则表达式是⼀串特定字符，组成⼀个“规则字符串”，这个“规则字符串”是描述⽂本规则的⼯具。
正则表达式就是记录⽂本规则的代码。

例如：

“[a-z]”：表示a到z的任意⼀个字符
“[a-z]+”：表示由1个或多个a-z字符组成的字符串

字符集合

在这里插入图片描述

数量词

在这里插入图片描述

分组“()”

分组： () 圆括号表示分组，可以将⼀系列正则表达式看做⼀个整体，分组时可以使⽤ | 表示“或”关系，例如：匹配⼿机号码前⾯的区号： (+86|0086)?\s?\d{11}
在这里插入图片描述

边界匹配 “^” 和 “$”

在这里插入图片描述

常⽤API

public boolean matches(String regex) ：告知此字符串是否匹配给定的正则表达式。

⽅法演示，代码如下：

public class String_Demo02 {
 public static void main(String[] args) {
 // 测试email是否合法
 String emailRegEx = "^[a-zA-Z0-9_.-]+@([a-zA-Z0-9-]+\\.)+[a-zAZ0-9]{2,4}$";
 String email = "liuzb@bonnie.com.cn";
 System.out.println(email.matches(emailRegEx)); // true
 }
}

public String[] split(String regex) ：根据给定正则表达式的匹配拆分此字符串。

⽅法演示，代码如下：

public class String_Demo03 {
 public static void main(String[] args) {
 // 按空格拆分
 String str = "java cpp php c# python";
 String[] strArr = str.split("\\s");
 System.out.println(Arrays.toString(strArr)); // [java, cpp,
php, c#, python]
 // 按 + - = 符号拆分
 String line = "100+200-150=150";
 strArr = line.split("[\\+\\-=]");
 System.out.println(Arrays.toString(strArr)); // [100, 200, 150,
150]
 }
}

public String replaceAll(String regex, String replacement)
：使⽤给定的replacement 替换此字符串所有匹配给定的正则表达式的⼦字符串

。
⽅法演示，代码如下：

public class String_Demo04 {
 public static void main(String[] args) {
 // 将str中的所有数字替换为 "数字" ⼆字
 String str = "abc123bcd45ef6g7890";
 str = str.replaceAll("\\d+", "数字");
 System.out.println(str); // abc数字bcd数字ef数字g数字
 }
}

4 StringBuilder类

4.1 字符串拼接问题

由于String类的对象内容不可改变，所以每当进⾏字符串拼接时，总是会在内存中创建⼀个新的对象。例如：

public class StringDemo {
 public static void main(String[] args) {
 String s = "Hello";
 s += "World";
 System.out.println(s);
 }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。

根据这句话分析我们的代码，其实总共产⽣了三个字符串，即 “Hello” 、 “World” 和 “HelloWorld” 。引⽤变量s⾸先指向 Hello 对象，最终指向拼接出来的新字符串对象，即 HelloWord 。
在这里插入图片描述
由此可知，如果对字符串进⾏拼接操作，每次拼接，都会构建⼀个新的String对象，既耗时，⼜浪费空间。为了解决这⼀问题，可以使⽤ java.lang.StringBuilder 类。

4.2 StringBuilder概述

查阅 java.lang.StringBuilder 的API，StringBuilder⼜称为可变字符序列，它是⼀个类似于String 的字符串缓冲区，通过某些⽅法调⽤可以改变该序列的⻓度和内容。

原来StringBuilder是个字符串的缓冲区，即它是⼀个容器，容器中可以装很多字符串。并且能够对其中的字符串进⾏各种操作。
在这里插入图片描述

4.3 构造⽅法

根据StringBuilder的API⽂档，常⽤构造⽅法有2个：

public StringBuilder() ：构造⼀个空的StringBuilder容器。
public StringBuilder(String str) ：构造⼀个StringBuilder容器，并将字符串添加进去。

public class StringBuilderDemo {
 public static void main(String[] args) {
 StringBuilder sb1 = new StringBuilder();
 System.out.println(sb1); // (空⽩)
 // 使⽤带参构造
 StringBuilder sb2 = new StringBuilder("itcast");
 System.out.println(sb2); // itcast
 }
}

4.4 常⽤⽅法

StringBuilder常⽤的⽅法有2个：

public StringBuilder append(…) ：添加任意类型数据的字符串形式，并返回当前对象⾃身。
public String toString() ：将当前StringBuilder对象转换为String对象。

append⽅法

append⽅法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。例如：

public class Demo02StringBuilder {
 public static void main(String[] args) {
 //创建对象
 StringBuilder builder = new StringBuilder();
 //public StringBuilder append(任意类型)
 StringBuilder builder2 = builder.append("hello");
 //对⽐⼀下
 System.out.println("builder:" + builder);
 System.out.println("builder2:" + builder2);
 System.out.println(builder == builder2); //true
 // 可以添加 任何类型
 builder.append("hello");
 builder.append("world");
 builder.append(true);
 builder.append(100);
 // 在我们开发中，会遇到调⽤⼀个⽅法后，返回⼀个对象的情况。然后使⽤返回的对象
继续调⽤⽅法。
 // 这种时候，我们就可以把代码现在⼀起，如append⽅法⼀样，代码如下
 //链式编程
 builder.append("hello").append("world").append(true).append(100);
 System.out.println("builder:" + builder);
 } }

备注：StringBuilder已经覆盖重写了Object当中的toString⽅法。

toString⽅法

通过toString⽅法，StringBuilder对象将会转换为不可变的String对象。如：

public class Demo16StringBuilder {
 public static void main(String[] args) {
 // 链式创建
 StringBuilder sb = new
StringBuilder("Hello").append("World").append("Java");
 // 调⽤⽅法
 String str = sb.toString();
 System.out.println(str); // HelloWorldJava
 }
}

5 包装类

5.1 概述

Java提供了两个类型系统，基本类型与引⽤类型，使⽤基本类型在于效率，然⽽很多情况，会创建对象使⽤，因为对象可以做更多的功能，如果想要我们的基本类型像对象⼀样操作，就可以使⽤基本类型对应的包装类，如下：
在这里插入图片描述

5.2 装箱与拆箱

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

装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

⽤Integer与 int为例：（看懂代码即可）
在这里插入图片描述

5.3⾃动装箱与⾃动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以⾃动完成。例如：
在这里插入图片描述

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

基本类型转换为String

基本类型转换String总共有三种⽅式，查看课后资料可以得知，这⾥只讲最简单的⼀种⽅式：
在这里插入图片描述
除了Character类之外，其他所有包装类都具有parseXxx静态⽅法可以将字符串参数转换为对应的基本类型：

public static byte parseByte(String s) ：将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s) ：将字符串参数转换为对应的short基本类型。

public static int parseInt(String s) ：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s) ：将字符串参数转换为对应的long基本类型。

public static float parseFloat(String s) ：将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s) ：将字符串参数转换为对应的double基本类型。

public static boolean parseBoolean(String s) ：将字符串参数转换为对应的boolean基本类型。

代码使⽤（仅以Integer类的静态⽅法parseXxx为例）如：

public class Demo18WrapperParse {
 public static void main(String[] args) {
 int num = Integer.parseInt("100");
 }
}

注意：如果字符串参数的内容⽆法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException 异常。

天阳在线€

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE Object类、常用API（二）

自动目录1 Object类1.1 概述1.2 toString⽅法⽅法摘要覆盖重写1.3 equals⽅法⽅法摘要默认地址⽐较对象内容⽐较1.4 Objects类2 ⽇期时间类2.1 Date类概述常⽤⽅法2.2 DateFormat类构造⽅法格式规则常⽤⽅法format⽅法parse⽅法2.3 练习2.4 Calendar类概念获取⽅式常⽤⽅法get/set⽅法add⽅法getTime⽅法3 再谈String类3.1 常⽤API（补充）3.2 正则表达式字符集合数量词分组“()”边界匹配 "^" 和 "$
复制链接

扫一扫