包装类，日期，异常

最新推荐文章于 2023-12-11 21:35:42 发布

岿然如故

最新推荐文章于 2023-12-11 21:35:42 发布

阅读量191

点赞数

分类专栏：基础知识文章标签： java

本文链接：https://blog.csdn.net/cl66666666/article/details/109753183

版权

基础知识专栏收录该内容

32 篇文章 1 订阅

订阅专栏

包装类

基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一：用于基本数据类型与字符串之间的转换

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer类

方法名	说明
public Integer(int value)	根据 int 值创建 Integer 对象 (过时)
public Integer(String s)	根据 String 值创建 Integer 对象 (过时)
public static Integer valueOf(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)	返回一个保存指定值的 Integer 对象 String

package com.itxuexi.it13.Packaging01;

public class IntegerDemo {
    public static void main(String[] args) {
        Integer i1 = new Integer(100);   //过时
        System.out.println(i1);

//        Integer i2 = new Integer("abc"); 报错，必须是数字字符串
        Integer i2 = new Integer("100");  //过时
        System.out.println(i2);

        Integer i3 = Integer.valueOf(100);
        System.out.println(i3);


        Integer i4 = Integer.valueOf("100"); //必须是数字字符串
        System.out.println(i4);
        
    }
}

int和String的相互转换

int转换为String：
public static String valueOf(int i)：返回 int 参数的字符串表示形式。该方法是 String 类中的方法
String 转换为int：
public static int parseInt (String s)：将字符串解析为 int 类型。该方法是 Integer 类中的方法

package com.itxuexi.it13.Packaging01;

public class IntegerDemo2 {
    public static void main(String[] args) {
        //int  ----  String
        int number = 100;
        //方式一 不建议
        String s1 = "" + number;
        System.out.println(s1);

        //方式二
        String s2 = String.valueOf(number);    
        System.out.println(s2);

        System.out.println("----------------");

        //String --- int
        String s = "100";
        //方式一 不建议
        Integer i = Integer.valueOf(s);
        int x = i.intValue();
        System.out.println(x);

        //方式二
        int y = Integer.parseInt(s);
        System.out.println(y);

    }
}

package com.itxuexi.it13.Packaging01;

import java.util.Arrays;

public class IntegerTste {
    public static void main(String[] args) {
        String s = "22 54 15 35 16";

        //把字符串的数字数据存储到一个int类型的数组中
        //用空格切割字符串
        String [] strArray = s.split(" ");

        //定义一个int数组，把String[]数组中的每一个元素存储到int数组中；
        int [] arr = new int [strArray.length];
        for (int i=0;i<arr.length;i++){
            arr[i] = Integer.parseInt(strArray[i]);

        }
        //对数组进行排序
        Arrays.sort(arr);

        //将排序后的元素进行拼接，使用StringBuilder
        StringBuilder sb = new StringBuilder();
        for(int i = 0;i<arr.length;i++){
            if (arr[i] == arr.length -1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();

        //输出结果
        System.out.println("result:" + result);

    }
}

装箱和拆箱（基本数据类型与包装类类型装换过程）

装箱：把基本数据类型转换为对应的包装类类型

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

**注意：**在使用包装类类型的时候，如果做操作，最好先判断是否为 null,

        我们推荐的是，只要是对象，在使用前就必须进行不为null的判断

package com.itxuexi.it13.Packaging02;

public class IntegerDemo {
    public static void main(String[] args) {
        //装箱：
        Integer i = Integer.valueOf(100);   //装箱
        Integer ii = 100;                   //自动装箱 包含Integer.valueOf动作

        //拆箱
        ii += 200;                      // 自动拆箱和自动装箱
        ii = ii.intValue() + 200;       //拆箱  ii.intValue  ；+200 自动装箱
        System.out.println(ii);


        Integer iii = null;          //不能为null
        if(iii != null);
            iii +=200;
        }

    }
}

package com.itxuexi.it13.Packaging02;

public class IntegerDemo3 {
    public static void main(String[] args) {
        int i1 = 3;
        Integer i2 = new Integer(3);
        Integer i3 = 3;

        System.out.println(i1 == i2);  //true   i2 与 i1 比较，会将Integer类型转换为 int类型；两个常量比较数值
        System.out.println(i1 == i3);  //true
        System.out.println(i2 == i3);  //false  i2 与 i2 比较 地址，i2为新开辟空间，i3指向i1的常量次地址 所有不相等

    }

}

时间日期类

日期类(Date)

Date类概述

Date 代表了一个特定的时间，精确到毫秒

创建Date类

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

package com.itxuexi.it13.Data01;

import java.util.Date;

public class DateDome {
    public static void main(String[] args) {
        //   public Date()   分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
        Date d1 = new Date();
        System.out.println(d1);

        //public Date(long date)  将其初始化为表示从标准基准时间起指定的毫秒数
        long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);

    }
}

Date类常见方法

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

package com.itxuexi.it13.Data01;

import java.util.Date;

public class DateDome2 {
    public static void main(String[] args) {
        Date d = new Date();

        //获取从1970年1月1日00：00：00 到现在的毫秒值
        System.out.println(d.getTime());
        System.out.println(d.getTime()*1.0 /1000 /60 /60 /24/365);  //年

        //设置时间，给的是毫秒值
        long time = System.currentTimeMillis();   //等同于d.getTime() 毫秒值
        d.setTime(time);
        System.out.println(d);
    }
}

SimpleDateFormat类

SimpleDateFormat类概述

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。我们重点学习日期格式化和解析

y M d H m s 年月日时分秒

SimpleDateFormat类构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

package com.itxuexi.it13.Data01;

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

public class DateDome3 {
    public static void main(String[] args) throws ParseException {
        //格式化：从Date 到String
        Date d = new Date();
        // 20-11-10 下午12:11
        SimpleDateFormat sdf = new SimpleDateFormat();
        String s = sdf.format(d);
        System.out.println(s);

        //2020年11月10日 12:11:45
        SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s1 = sd.format(d);
        System.out.println(s1);

        //解析 String 到 date
        String ss = "2020-05-12 11:11:11";
        SimpleDateFormat sd2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  //注意格式要一致
        Date aa = sd2.parse(ss);   //  parse爆红；选中 parse  alt + enter 选择第一个，抛出异常
        System.out.println(aa);


    }
}

日期工具类

package com.itxuexi.it13.Data02;

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

/*
工具类

构造方法私有
成员方法静态
        */
public class DateUtils {
    private DateUtils() {}

    /*
    把日期转化为指定格式的字符串
    返回值类型：String
    参数：Date date，String format
     */
    public static String dateToString(Date date,String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }

    /*
    把字符串转化为指定格式的日期
    返回值类型：String
    参数：String str，String format
     */
    public static Date stringToDate(String str,String format) throws ParseException {
        SimpleDateFormat sd2 = new SimpleDateFormat(format);
        Date aa = sd2.parse(str);
        return aa;
    }

}

//---------------------------------------------------------------------------
package com.itxuexi.it13.Data02;

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

public class DateDome {
    public static void main(String[] args) throws ParseException {
        //
        Date d = new Date();

        String s1 = DateUtils.dateToString(d,"yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        String s2 = DateUtils.dateToString(d,"yyyy年MM月dd日");
        System.out.println(s2);

        String s3 = DateUtils.dateToString(d,"HH:mm:ss");
        System.out.println(s3);

        System.out.println("---------------------------------------");

        String s = "2020-10-15 05:15:36";
        Date d1 = DateUtils.stringToDate(s,"yyyy-MM-dd HH:mm:ss");
        System.out.println(d1);

    }
}

Calendar类

Calendar 为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

Calendar 提供了一个类方法 getInstance 用于获取 Calendar 对象，其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance();

Calendar 类基本使用

package com.itxuexi.it13.Calendar01;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        Calendar c = Calendar.getInstance();  //多态的形式
        System.out.println(c);

        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;   //从0开始的，需要加1
        int date = c.get(Calendar.DATE);

        System.out.println(year + "年" + month + "月" + date + "日");


    }
}

Calendar 类常用方法

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstract void add(int field, int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year,int month,int date)	设置当前日历的年月日

package com.itxuexi.it13.Calendar01;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        Calendar c = Calendar.getInstance();  //多态的形式
        System.out.println(c);

        //public int  get(int field)
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;   //从0开始的，需要加1
        int date = c.get(Calendar.DATE);

        System.out.println(year + "年" + month + "月" + date + "日");   //2020年11月10日


        // void add ;10年后的5天前
        c.add(Calendar.YEAR,+10);   //加10年
        c.add(Calendar.DATE,-5);   //减5天
        int year_10 = c.get(Calendar.YEAR);
        int date_5 = c.get(Calendar.DATE);   //从0开始的，需要加1
        System.out.println(year_10 + "年" + month + "月" + date_5 + "日");     //2030年11月5日

        //void set 
        c.set(2048,11,10);
        int year_set = c.get(Calendar.YEAR);
        int month_set = c.get(Calendar.MONTH)+1;   //从0开始的，需要加1
        int date_set = c.get(Calendar.DATE);
        System.out.println(year_set + "年" + month_set + "月" + date_set + "日");   //2048年12月10日

    }
}

package com.itxuexi.it13.Calendar01;
/*
键盘录入任意一年获取二月有多少天
 */

import java.util.Calendar;
import java.util.Scanner;

public class CalendarDemo2 {
    public static void main(String[] args) {
        //键盘录入任意年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = sc.nextInt();

        //设置日历对象的年，月，日
        Calendar c = Calendar.getInstance();
        c.set(year,2,1);

        //3月1日往前推1天就是2月的最后一天
        c.add(Calendar.DATE,-1);

        //获取这一天输入
        int date = c.get(Calendar.DATE);

        System.out.println(year + "年2月份有" + date + "天");
    }
}

异常

异常定义

异常：就是程序出现了不正常的情况

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lkcP1YSM-1605617218531)(E:\my_projest\python爬虫\java-img\image-20201110140158588.png)]

Error：严重问题，不需要处理

Exception：称为异常类，它表示程序本身可以处理的问题

	RuntimeException：在编译期是不检查的，出现问题后，需要我们回来修改代码 

	非 RuntimeException：编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了

JVM的默认处理方案

如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理，处理方式有如下两个步骤：

把异常的名称，错误原因及异常出现的位置等信息输出在了控制台

程序停止执行

package com.itxuexi.it13.ExceptionDemo;

public class ExceptionDemo01 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");

    }

    public static void method(){
        int [] arr = {1,2,3};
        System.out.println(arr[3]);
    }
}

/*
开始
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3       //异常原因
	at com.itxuexi.it13.ExceptionDemo.ExceptionDemo01.method(ExceptionDemo01.java:13) 
	                                                                         //异常位置
	at com.itxuexi.it13.ExceptionDemo.ExceptionDemo01.main(ExceptionDemo01.java:6)
																		     //程序停止执行
*/

异常处理(异常处理之try…catch…)

异常处理之try…catch…

格式：
try {
	可能出现异常的代码;
} catch(异常类名 变量名) {
	异常的处理代码;
}

执行流程：

程序从 try 里面的代码开始执行

出现异常，就会跳转到对应的 catch 里面去执行

执行完毕之后，程序还可以继续往下执行

package com.itxuexi.it13.ExceptionDemo;

public class ExceptionDemo01 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");

    }

    public static void method(){
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        } catch(ArrayIndexOutOfBoundsException e){
//            System.out.println("你访问的数组的索引不存在");
              throw new ExceptionDemo05("你给的分数有误，分数应该在0-100之间");
            e.printStackTrace();
        }
    }
}

/*

开始
结束
java.lang.ArrayIndexOutOfBoundsException: 3
	at com.itxuexi.it13.ExceptionDemo.ExceptionDemo01.method(ExceptionDemo01.java:14)
	at com.itxuexi.it13.ExceptionDemo.ExceptionDemo01.main(ExceptionDemo01.java:6)

Process finished with exit code 0

*/

异常处理(Throwable)–打印异常

方法名	说明
public String getMessage()	返回此 throwable 的详细消息字符串
public String toString()	返回此可抛出的简短描述
public void printStackTrace()	把异常的错误信息输出在控制台

package com.itxuexi.it13.ExceptionDemo;

public class ExceptionDemo02 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");

    }

    public static void method(){
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        } catch(ArrayIndexOutOfBoundsException e){
			// getMessage()  返回此 throwable 的详细消息字符串
            System.out.println(e.getMessage());
			//toString()    返回此可抛出的简短描述  
            System.out.println(e.toString());
			//printStackTrace()  输出错误信息最全 --推荐使用此方法（包含上面的内容）
            e.printStackTrace();

        }
    }
}

编译时异常和运行时异常的区别

Java 中的异常被分为两大类：编译时异常和运行时异常，也被称为受检异常和非受检异常

所有的 RuntimeException 类及其子类被称为运行时异常，其他的异常都是编译时异常

编译时异常：

	都是Exception类及其子类 必须显示处理，否则程序就会发生错误，无法通过编译

运行时异常：

	都是RuntimeException类及其子类 无需显示处理，也可以和编译时异常一样处理

package com.itxuexi.it13.ExceptionDemo;

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

public class ExceptionDemo03 {
    public static void main(String[] args) {
        method();
        method2();

    }

    //编译异常 ;有可能有问题，不代表一定会出问题;但是必须处理
    public static void method2(){
        try {
            String s = "2048-12-11";
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date d = sdf.parse(s);  //Error:(17, 27) java: 未报告的异常错误java.text.ParseException; 必须对其进行捕获或声明以便抛出
            System.out.println(d);
        }catch (ParseException e){
            e.printStackTrace();
        }
    }


    //运行时异常；可能有异常
    public static void method(){
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);   //ArrayIndexOutOfBoundsException
        } catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}

异常处理(throws)

虽然我们通过 try…catch…可以对异常进行处理，但是并不是所有的情况我们都有权限进行异常的处理

这个throws格式是跟在方法的括号后面的

编译时异常必须要进行处理

	两种处理方案：try...catch …或者 throws，如果采用 throws 这种方案， 将来谁调用谁处理

运行时异常可以不处理

	出现问题后，需要我们回来修改代码

package com.itxuexi.it13.ExceptionDemo;

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

public class ExceptionDemo04 {
    public static void main(String[] args) {
        System.out.println("开始");
//        method1();
        try {
            method2();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("结束");
        
    }

    //编译时异常   throws 没有继续运行 ；后面还是要用try处理
    public static void method2() throws ParseException {
        String  s = "2020-11-10";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d =sdf.parse(s);
        System.out.println(d);

    }

    
/*
    //运行时异常   throws 没有继续运行 ；后面还是要用try处理
    public static void method1() throws ArrayIndexOutOfBoundsException{
        int [] arr = {1,2,3};
        System.out.println(arr[3]);
    }

 */
    
}

自定义异常 --抛出异常（到main方法层面）

try…carch… 与throwable,throws都是打印异常，不会到main()方法层面，为程序员运行时才能看到的；

throw new为抛出异常，一定要处理的，类似接口提示:4028参数错误

格式

public class 异常类名 extends Exception {
	无参构造
	带参构造
}

package com.itxuexi.it13.ExceptionDemo02;

public class ExceptionDemo05 extends Exception {
    public ExceptionDemo05(){ }

    public ExceptionDemo05(String message){
        super(message);
    }
}
//-----------------------------------------

package com.itxuexi.it13.ExceptionDemo02;

public class Teacher {

    public void cheackScore(int score) throws ExceptionDemo05 {
        if (score < 0 || score > 100) {
//            throw new ExceptionDemo05();
            throw new ExceptionDemo05("你给的分数有误，分数应该在0-100之间");
        } else {
            System.out.println("分数正常");
        }
    }
}
//------------------------------------package com.itxuexi.it13.ExceptionDemo02;

import java.util.Scanner;

public class TeachTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入分数");
        int score = sc.nextInt();

        Teacher t = new Teacher();
        try {
            t.cheackScore(score);
        } catch (ExceptionDemo05 exceptionDemo05) {
            exceptionDemo05.printStackTrace();
        }

    }
}

/*

请输入分数
120
com.itxuexi.it13.ExceptionDemo02.ExceptionDemo05: 你给的分数有误，分数应该在0-100之间
	at com.itxuexi.it13.ExceptionDemo02.Teacher.cheackScore(Teacher.java:9)
	at com.itxuexi.it13.ExceptionDemo02.TeachTest.main(TeachTest.java:13)

*/

throws和throw的区别

throws	throw
用在方法声明后面，跟的是异常类名	返回此 throwable 的详细消息字符串
表示抛出异常，由该方法的调用者来处理	表示抛出异常，由方法体内的语句处理
表示出现异常的一种可能性，并不一定会发生这些异常	执行 throw 一定抛出了某种异常