java14-基本类型包装类-Integer类-int和String的相互转换-Date类-SimpleDateFormat-

2022-05-03 09:44:20

基本类型包装类

概述

  • 将基本数据类型封装成对象的好处：可以在对象中定义更多的功能方法操作该数据
  • 常见的操作之一：用于基本数据类型与字符串之间的转换
基本数据类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

integer类

概念
  • 软件包是 java.lang 使用是不需要导包
  • integer类 间接 继承于 Number、Object
  • public final class Integer 说明Integer是最终类，不能被继承，也就是不能有子类
  • 包装一个对象中的原始类型int的值
常用方法
方法名 说明
public Integer（int value） 根据jint值创建Integer对象（过时）
public Integer（String s） 根据String值创建Integer对象（过时）（这里的字符串只能是数组的不能是字符的）
public static Integer valueOf（int i） 返回表示指定的int值的Integer实例
public static Integer valueOf（String s） 返回一个保存指定String值的Integer对象

案例：

public class IntegerDEmo {
    public static void main(String[] args) {
        System.out.println("过时方式-----------");
        //通过构造方法，根据参数 创建Integer对象。
        Integer i = new Integer(100);
        System.out.println(i);

        Integer i2 = new Integer("100");
        System.out.println(i2);
        Integer i3 = new Integer("abc");
//        System.out.println(i3);//NumberFormatException
        //这里会报错

        System.out.println("推荐方式--------------");
        Integer i4 = Integer.valueOf(100);
        System.out.println(i4);
        Integer i5 = Integer.valueOf("563");
        System.out.println(i5);
        Integer i6 = Integer.valueOf("abc");
        System.out.println(i6);//NumberFormatException
    }
}

int和String的相互转换

int—String

①

String s = “” + int类型变量

②

public static String valueOf（int i）
返回int参数的字符串表示形式，该方法是String类中方法。

案例：

//int ---String
int number = 100;
//方式1:通过字符串加的形式
String s1 = "" + number;
System.out.println(s1);//100
//方式2：public static String valueOf（int i）
String s2 = String.valueOf(100);
System.out.println(s2);//100
String — int

① String—Integer—int

Integer i = Integer.valueOf(字符串)；
int x = i.intValue();
Integer基本类型包装类的对象.intValue（） --》 把Integer类的对象转成int类型。

②

public static int parseInt（String s）
将字符串解析为int类型，该方法是Integer类中的方法。

案例：

//String -- int
String s = "100";
// 方式1：String-Integer-int
Integer i = Integer.valueOf(s);
//public int intValue() Integer类中的方法
int x = i.intValue();
System.out.println(x);//100
//方式2:String -- int
//public static int parseInt（String s）
int y = Integer.parseInt(s);
System.out.println(y);//100

案例：字符串中数据排序
需求：有一个字符串，“91 27 46 38 50” 请写程序实现最终输出结果是“27 38 46 50 91”
分析理解：

1定义一个字符串
2得到字符串中的数字 组成一个数字数组 使用方法public String[] split(String regex)
通过【字符串.split（regex：“分隔符”）】
3把字符串数组中的每一个元素存储在int数组中
通过for循环，实现遍历字符串数组中的每一个元素；
方法public static int parseInt（String s）：将字符串转为int类型。是Integer基础类型包装类中的；
形式：int i = Integer.parseInt（String s）
4对int数组进行排序
使用方法Arrays.sort（数组名）；
5排序后的数组组成一个字符串
使用StringBuilder类的对象中的方法append（）方法。
创建StringBuilder对象，使用对象.append（），然后再使用对象.toString（）转为String类型。

public class Deno1 {
    public static void main(String[] args) {
        //定义一个字符串
        String s1 = "91 27 46 38 50";
        //把字符串中的数字数据存储到一个int类型的数组中
        //得到字符串中的每一个数字数组public String[] split(String regex)
        //此方法需要通过字符串.split调用
        String[] arrStr = s1.split(" ");
/*        for(int i = 0; i<arrStr.length ; i++){
            System.out.println(arrStr[i]);
        }*/
        //定义一个int数组，把String数组中的每一个元素存储到int数组中
        //public static int parseInt（String s）是Integer基础类型包装类中的
        int[] arr = new int[arrStr.length];
        for (int i = 0; i <arrStr.length; i++){
            arr[i] = Integer.parseInt(arrStr[i]);
        }
        //对int数组进行排序
        Arrays.sort(arr);

        //对排序后的int数组中的元素进行拼接得到一个字符串，这里的拼接采用StringBuilder实现
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i<arr.length; i++){
            if(i == arrStr.length - 1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(" ");
            }
        }
        String s2 = sb.toString();
        //输出结果
        System.out.println(s2);
    }
}

自动装箱和拆箱

概念：
①装箱：把基本数据类型转换为对应的包装类类型；
手动装箱：

Integer i = Integer.valueOf(100);

自动装箱：

Integer ii = 100;

②拆箱：把包装类类型转换为对应的基本数据类型；
手动拆箱：

ii = ii.intValue() + 100;
这个操作 包含了 自动拆箱 和 自动装箱

自动拆箱：

ii += 200;
同样也包含 自动拆箱ii+200 和 自动装箱ii = ii + 200

理解xhj：

Ingeter iii = null;
iii += 300;
//此时会报错NullPointerException

注意：
①在使用包装类类型的时候，如果做操作，最好先判断是否为null
②只要是对象，在使用前就必须进行不为null的判断

日期类

有三个：Date类、

Date类

概述：

  • 有多个包中有Date类，本次学习的是java.util包中的类
  • Date类代表了一个特定的时间，以毫秒为精度

构造方法：

方法名 说明
public Date（） 分配一个Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date（long date） 分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

构造方法说明：

Date d = new Date();
System.out.println(d);
//原本输出应该是xxxxxx@xxx的字符串，实际输出：Tue Feb 01 17:21:34 CST 2022 ==》 说明Date类中重写了toString方法

long date = 1000*60*60;//表示一小时 1秒=1000毫秒、1分钟=60秒、1小时=60分
 Date dd = new Date(date);//输出的时间应该是1970年1月1日1时，而不是原来的0时
 System.out.println(dd);
 //Thu Jan 01 09:00:00 CST 1970 输出结果
 //不是1时的原因：因为中国所处的位置是东八区，起始为8，所以此时加一个小时，输出为9

Date类的常用方法： 需要创建Date对象，对象.方法

方法名 说明
public long getTime（） 获取的是日期对象从1970年1月1日00:00：00到现在的毫秒值
public void setTime（long time） 设置时间，给的是毫秒值

常用方法说明：

System.out.println(d.getTime());//获取当前时间 以毫秒显示1643707950334
System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");//52.12164088527397年

long time = 1000*60*60;//一小时
d.setTime(time);
System.out.println(d);//Thu Jan 01 09:00:00 CST 1970
SimpleDateFormat类

概述：

  • 软件包是java.text 中
  • SimpleDateFormat 是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
  • SimpleDateFormat 允许选择日期时间格式化的任何用户定义的模式开始。
  • 日期和时间格式 = 日期和时间模式字符串指定，从A-Z以及a-z引号的字母被解释为表示日期或时间字符串的组件的模式字母。
  • 常用的模式字母表示含义：y年、M月、d日、H时、m分、s秒。
    构造方法：
方法名 说明
public SimpleDateFormat（）
public SimpleDateFormat（String pattern） 构造一个SimpleDateFormat使用给定的模式和默认的日期格式

格式化合解析 都是SimpleDateFormat类实例化对象.方法

方法名 说明
public final String format（Date date） 格式化（从Date到String）
将日期格式化成日期/时间字符串
public Date parse（String source） 解析（从String 到Date）
从给定字符串的开始解析文本以生成日期

格式说明：

1date 转 String
Date d = new Date();
SimpleDateFormat sd = new SimpleDateFormat();//采用默认构造方法
String s = sd.format(d);//此方法需要参数Date类型对象 作用将日期类型转换为字符串
System.out.println(s);//输出：22-2-1 下午6:03 默认日期格式就是这样的
System.out.println("-------------------");
SimpleDateFormat sd2 = new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");//采用有参构造方法创建对象，自定义日期的格式
String s2 = sd2.format(d);
System.out.println(s2);//输出： 2022年02月01日 18：06：48
System.out.println("------------------");

2String 转 Date
String s3 = "2022-2-1 19:46:12";
SimpleDateFormat sd3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//SimpleDateFormat类 实例化对象  的参数：日期格式=字符串的日期的格式，不然不能被解析
Date d1 = sd3.parse(s3);//这里会报错，有提示符号，点开选择第一个之后，报错消失，会在main方法后面加throws ParseException异常
System.out.println(d1);//Tue Feb 01 19:46:12 CST 2022
案例：日期工具类

需求：定义一个日期类（DateUtils），包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类（DateDemo），测试日期工具类的方法。
分析：

1工具类：构造方法私有；成员方法静态
2工具类中的构造方法是私有的，且被static修饰，要想使用其中的方法 ==》类名.方法名（）

代码：

public class DateUtils {
    private DateUtils(){}
    //定义一个日期类（DateUtils），包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类（DateDemo），测试日期工具类的方法。
    public static String DateString(Date d ,String format){
        // format参数 被当做 形参传入
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(d);
        return s;
    }

    public static  Date StringDate(String s,String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date dd = sdf.parse(s);
        return dd;
    }
}

public class DateDemo {
    public static void main(String[] args) throws ParseException {

        Date d = new Date();
        String sf = "yyyy年MM月dd日 HH:mm:ss";
        //类中的构造方法是私有的，直接使用类名.方法 对类中方法进行调用执行
        String s = DateUtils.DateString(d,sf);
        System.out.println(s);//2022年02月01日 20:55:23

        System.out.println("----------");
        String s2 = "2022年2月1日 21:20:23";
        String sf2 = "yyyy年MM月dd日 HH:mm:ss";
        //这里的s2定义格式要与DateUtils类中的StringDate方法中的SimpleDateFormat参数格式一样，否则不能转换
        Date dd = DateUtils.StringDate(s2,sf2);//这里调用也需要加ParseException
        System.out.println(dd);//Tue Feb 01 21:20:23 CST 2022
    }
}
上一篇：Java学习笔记：Integer和int的关系


下一篇：自动装箱与自动拆箱