首页 > 编程语言> > java14-基本类型包装类-Integer类-int和String的相互转换-Date类-SimpleDateFormat-

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

2022-02-01 23:02:01 作者：互联网

基本类型包装类

概述

将基本数据类型封装成对象的好处：可以在对象中定义更多的功能方法操作该数据
常见的操作之一：用于基本数据类型与字符串之间的转换

基本数据类型	包装类
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
    }
}

标签：java14,String,int,println,Date,Integer,public
来源： https://blog.csdn.net/LXMXHJ/article/details/122764814