龙空技术网

从零学大数据系列之Java篇---第十章:包装类和常用类

千锋IT小助手 102

前言:

此刻姐妹们对“java引入其他包的类”都比较注重,朋友们都想要分析一些“java引入其他包的类”的相关资讯。那么小编也在网上网罗了一些对于“java引入其他包的类””的相关资讯,希望大家能喜欢,朋友们快快来学习一下吧!

课程重点:

包装类(会用)装箱拆箱(会用)字符串与基本数据类型的转换(会用)常用类Math(常用的几个方法会用)常用类Random(会用)常用类BigInteger,BigDecimal(会用)常用类Date(会用)常用类SimpleDateFormat(会用)(重点)常用类Calendar(了解)10.1. 包装类的简介10.1.1. 包装类的概念

包装类, 就是在基本数据类型的基础上, 做一层包装。 每一个包装类的内部都维护了一个对应的基本数据类型的属性, 用来存储管理一个基本数据类型的数据。

包装类是一种引用数据类型, 使用包装类, 可以使得基本数据类型数据有着引用类型的特性。 例如, 可以存储在集合中。 同时, 包装类还添加了若干个特殊的方法。

10.1.2. 基本数据类型对应的包装类型

10.2. 装箱拆箱

10.2.1. 手动装箱

概念:由基本数据类型, 完成向对应的包装类型进行转换。

方式1: 可以通过每一个包装类的构造方法来完成。 在每一个包装类的构造方法中,都有一个与之对应的基本数据类型作为参数的重载方法。 此时, 直接将需要包装起来的基本数据类型, 写到构造方法的参数中即可完成装箱。

Byte n1 = new Byte((byte)1);Short n2 = new Short((short)2);		Integer n3 = new Integer(3);Long n4 = new Long(4L);Float n5 = new Float(3.14f);Double n6 = new Double(3.14);Character n7 = new Character('a');Boolean n8 = new Boolean(false);

【推荐使用】方式2: 可以通过包装类的静态方法 valueOf() 完成装箱。 每一个包装类中, 都有一个静态方法 valueOf, 这个方法的参数是包装类型对应的基本数据类型的参数。 直接将需要包装起来的基本数据类型的数据, 写到这个方法的参数中, 即可完成对这个基本数据类型数据的装箱。

Byte n1 = Byte.valueOf((byte)1);Short n2 = Short.valueOf((short)2);Integer n3 = Integer.valueOf(3);Long n4 = Long.valueOf(4);Float n5 = Float.valueOf(3.14f);Double n6 = Double.valueOf(3.14);Character n7 = Character.valueOf('a');Boolean n8 = Boolean.valueOf(true);
10.2.2. 手动拆箱

概念: 由包装类型, 完成向对应的基本数据类型进行转换。

方式: 使用每一个包装类对象的 xxxValue 可以实现。 这里的 xxx 就是需要转型的基本数据类型。 例如, 如果需要转型为int类型, 则直接调用 intValue 即可。

Byte i1 = Byte.valueOf((byte) 100);byte n1 = i1.byteValue();Short i2 = Short.valueOf((short) 100);short n2 = i2.shortValue();Integer i3 = Integer.valueOf(100);int n3 = i3.intValue();Long i4 = Long.valueOf(100);long n4 = i4.longValue();Float i5 = Float.valueOf(3.14f);float n5 = i5.floatValue();Double i6 = Double.valueOf(3.14);double n6 = i6.doubleValue();Character i7 = Character.valueOf('a');char n7 = i7.charValue();Boolean i8 = Boolean.valueOf(true); boolean n8 = i8.booleanValue();

备注: 某些包装类对象, 除了可以拆箱成对应的基本数据类型的数据之外。 还可以将包装起来的数字转成其他的基本数据类型的数据。 例如, Integer,除了有 intValue 之外, 还有 byteValue 等方法。 其实, 就是将包装类中包装起来的int数据, 强转成byte类型返回结果。 在使用的时候, 找自己需要的方法去转型即可。

10.2.3. 自动装箱拆箱

概念: 所谓的自动装箱和自动拆箱, 指的是在进行装箱和拆箱的时候, 不用再使用上面的方法完成装箱和拆箱的操作。 在JDK1.5之后, 装箱和拆箱是可以自动完成的! 只需要一个赋值语句即可!

方式: 没有什么特殊语法, 直接去进行赋值即可。

// 自动装箱:由一个基本数据类型,到对应的包装类型的转换。只需要一个赋值语句即可完成。Integer i1 = 10;// 自动拆箱:由一个包装类型,到对应的基本数据类型的转换。只需要一个赋值语句即可完成。int a = i1;

注意: 既然已经有了自动的装箱和拆箱, 为什么还要掌握手动的装箱和拆箱。 因为, 在有些情况下, 自动的装箱和拆箱是不能使用的。

示例: 如果在一个类的重载方法中, 有两个方法的参数类型, 一个是基本数据类型, 一个是对应的包装类型。 此时, 将无法使用自动装箱和拆箱。 必须通过手动的装箱和拆箱完成对应的方法的调用。

/** * @Description      自动的装箱和拆箱不能完成的逻辑: */public class Program2 {    public static void main(String[] args) {        // 此时,10会最优先匹配到int类型的参数        show(10);        show(Integer.valueOf(10));    }    public static void show(int a) {        System.out.println(a);    }    public static void show(Integer a) {        System.out.println(a);    }}
10.2.4. 享元原则

概念: 是程序设计的一个基本原则。 当我们需要在程序中频繁的用到一些元数据的时候, 此时, 我们可以提前将这些元数据准备好, 当需要的时候, 直接拿过来使用即可。 使用完成之后, 也不进行销毁, 以便下次继续使用。

包装类中的享元: 将常用到的基本数据类型对应的包装类对象,预先存储起来。 当使用到这些基本数据类型对应的包装类对象的时候, 可以直接拿过来使用, 不用再实例化新的对象了。

示例: Integer类中, 将 [-128, 127] 范围内的数字对应的包装类对象预存到了一个 Integer.cache 数组中, 每当我们用到这个范围内的数字的时候, 可以直接从这个数组中获取到元素。 如果用到了不在这个范围内的数字, 再去进行新的包装类对象的实例化。 这样, 不用频繁的开辟空间、销毁空间, 节省了CPU资源。

Integer i1 = Integer.valueOf(10);Integer i2 = Integer.valueOf(10);System.out.println(i1 == i2);		// 此时, 由于10在缓存范围内, 因此可以直接从数组中获取包装类对象。 true。Integer i3 = Integer.valueOf(200);Integer i4 = Integer.valueOf(200);System.out.println(i3 == i4);		// 此时, 由于200不在缓存范围内, 因此这个方法会返回一个新的包装类对象。 false。
10.3. 字符串与基本数据类型的转换10.3.1. 基本数据类型转型字符串类型

概念: 基本数据类型, 转成字符串, 希望得到的结果是这个数值转成字符串的样式。 其实, 就是直接给这个数值添加上双引号。

方式1: 可以利用字符串拼接运算符完成。 当加号两端有任意一方是字符串的时候, 此时都会自动的把另一方也转成字符串, 完成字符串的拼接。 所以, 当需要把一个基本数据类型的数据转成字符串的时候, 只需要在另一端拼接上一个空的字符串即可。

int a = 10;String str = a + "";

【推荐使用】方式2: 使用字符串的静态方法 valueOf 完成。

String str = String.valueOf(10);

方式3: 借助包装类的实例方法 toString 方法。

String str = Integer.valueOf(10).toString();

方式4: 借助包装类的静态方法 toString 方法。

String str = Integer.toString(10);

10.3.2. 字符串类型转型基本数据类型

概念: 字符串类型转基本数据类型, 其实就是解析出这个字符串中的内容,转型成对应的基本数据类型的表示。

注意事项1: 基本数据类型转字符串肯定是没问题的, 但是由字符串类型转到基本数据类型的时候, 可能会出现问题。字符串中的内容, 不一定能够转成希望转换的基本数据类型。 如果转换失败, 会出现 NumberFormatException 异常。

注意事项2: 对于整数来说,字符串中如果出现了其他的非数字的字符, 都会导致转整数失败, 即便是小数点, 也不可以转。 这里并没有转成浮点数字, 再转整数的过程。

方式1: 使用包装类的静态方法 valueOf 方法

Integer num = Integer.valueOf("123");

方式2: 使用包装类的静态方法 parseXXX 方法。 这里的XXX就是要转换的基本数据类型。

int number = Integer.parseInt("123");

备注: 以上两种方式,都可以完成字符串类型到基本数据类型之间的转换。 如果希望直接转成基本数据类型, 推荐使用方式2; 如果希望转成包装类型, 推荐使用方式1。

关于字符类型的特殊说明:

字符串类型, 没有类似于上面的方式, 可以直接转成字符类型。 如果一个字符串, 要转成字符, 需要使用字符串的一个实例方法 charAt() 方法。 使用这个方法, 获取字符串中的指定下标位的字符。

10.4. 常用类Math

10.4.1. 概念

是一个数学类, 这个类中封装了很多用来做数学计算的方法。 当我们需要使用到数学计算的时候, 要能够想到这个类。 这个类中有很多封装好的数学公式, 而且, 都是静态方法, 方便调用。

10.4.2. 常用静态常量

10.4.3. 常用方法

10.4.4. 示例代码

/** * @Description Math类 */public class MathUsage {    public static void main(String[] args) {        System.out.println(Math.abs(-3));		// 计算一个数字的绝对值        System.out.println(Math.max(10, 20));	// 计算两个数字的最大值        System.out.println(Math.min(10, 20));	// 计算两个数字的最小值        System.out.println(Math.round(3.14));   // 四舍五入        System.out.println(Math.floor(3.14));   // 向下取整,找到比这个数字小的第一个整数        System.out.println(Math.ceil(3.14));    // 向上取整,找到比这个数字大的第一个整数        System.out.println(Math.pow(2, 3));     // 计算2的3次方        System.out.println(Math.sqrt(4));       // 计算4开平方        // 需求:计算27的立方根        System.out.println(Math.pow(27, 1/3.0));                System.out.println(Math.random());              	// [0, 1)        System.out.println((int)(Math.random() * 100)); 	// [0, 100) 整型随机数    }}

10.5. 常用类Random

10.5.1. 概念

是一个专门负责产生随机数的类。 在Java中, Random类在 java.util 包中。 在使用之前, 需要先导包。

其实, 随机数的产生, 是有一个固定的随机数算法的。 代入一个随机数种子, 能够生成一个随机数列。 但是由于算法是固定的, 因此会有一个“BUG”: 如果随机数的种子相同, 则生成的随机数列也完全相同。

10.5.2. 常用方法

10.5.3. 示例代码

/** * @Description Math类 */public class RandomUsage {    public static void main(String[] args) {        // 1. 实例化一个Random对象        Random random = new Random(1);        // 2. 产生随机数        for (int i = 0; i < 20; i++) {            // 产生 [0, 50) 范围内的随机数            System.out.print(random.nextInt(50) + ", ");        }    }}

10.6. 常用类BigInteger、BigDecimal

10.6.1. 概念

这两个类,都是用来表示数字的类。 BigInteger表示整型数字, BigDecimal表示浮点型数字。 这两个类, 可以用来描述非常、非常、非常大的数字。 例如整数, long是最大的表示范围, 但是即便是long型, 也有它表示不了的情况。 BigInteger就是可以表示任意大小的数字。

BigInteger: 表示整型数字, 不限范围。

BigDecimal: 表示浮点型数字,不限范围, 不限小数点后面的位数。

10.6.2. 常用方法

10.6.3. 示例代码

/** * @Description BigInteger、BigDecimal */public class BigIntegerAndBigDecimal {    public static void main(String[] args) {        // 1. BigInteger类        BigInteger n1 = new BigInteger("12347328461827364812736481726348712643872634871263293413648273684716238746");        BigInteger n2 = new BigInteger("38242374871238471987349872317623864716237591263875628764381239847198738763");        // 2. 四则运算        BigInteger add = n1.add(n2);                    // 加法        System.out.println(add);        BigInteger subtract = n1.subtract(n2);          // 减法        System.out.println(subtract);        BigInteger multiply = n1.multiply(n2);          // 乘法        System.out.println(multiply);        BigInteger divide = n1.divide(n2);              // 除法        System.out.println(divide);        // 用n1除n2, 保留商和余数        // 将商存到结果数组的第0位        // 将余数存到结果数组的第1位        BigInteger[] bigIntegers = n1.divideAndRemainder(n2);        System.out.println(bigIntegers[0]);     // 输出商        System.out.println(bigIntegers[1]);     // 输出余数        long ret = bigIntegers[0].longValue();    }}

10.7. 常用类Date

10.7.1. 概念

是一个用来描述时间、日期的类。 在 java.util 包中!!!

10.7.2. 常用方法10.7.3. 示例代码

/* * @Description Date日期类 */public class DateUsage {    public static void main(String[] args) {        // 1. 实例化一个Date对象        Date date = new Date();        // 2. 获取一个日期的对应的时间戳 (从 1970年 1月 1日 0时开始的毫秒数)        long timestamp = date.getTime();        // 3. 实例化一个Date对象        Date date1 = new Date(1586587414273L);        System.out.println(date1);        // 4. 通过设置一个时间戳,修改这个对象描述的时间        date1.setTime(1586587414273L);        System.out.println(date.equals(date1));     // 判断两个时间是否相同        System.out.println(date.before(date1));     // 判断一个时间是否在另一个时间之前        System.out.println(date.after(date1));      // 判断一个时间是否在另一个时间之后    }}

10.8. 常用类SimpleDateFormat

10.8.1. 概念

是一个用来格式化时间的类。 使用这个类, 一般有两种操作:

将一个 Date 对象, 转成指定格式的时间字符串。将一个指定格式的时间字符串, 转成 Date 对象。10.8.2. 常用时间格式

在时间格式中, 有几个常见的时间占位符。

10.8.3. 常用方法

parse 方法

会抛出一个编译时的异常。 在使用的时候, 目前, 直接使用一键修复(alt + Enter), 用 try-catch 包围即可。

将一个字符串, 按照指定的格式进行解析。 如果字符串中的时间格式, 和对象实例化的时候给定的格式不同, 此时会出现异常。

10.8.4. 示例代码

import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;/** * @Description */public class SimpleDateFormatUsage {    public static void main(String[] args) {        // format();        // parse();        System.out.println(getDeltaDays("2002-09-28", "2020-04-11"));    }    // 将一个时间对象,转成指定格式的字符串    private static void format() {        // 1. 获取系统当前时间        Date now = new Date();        // 2. 指定一个时间格式,例如: 2020年4月11日 18:09:49        String format = "yyyy年M月d日 HH:mm:ss";        // 3. 通过一个时间格式,实例化一个SimpleDateFormat对象        SimpleDateFormat sdf = new SimpleDateFormat(format);        // 4. 转换成指定格式的字符串        String str = sdf.format(now);        System.out.println(str);    }    // 将一个指定格式的字符串,转成时间对象    private static void parse() {        // 1. 通过一个时间格式,实例化一个对象        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        // 2. 将一个指定格式的字符串,解析成Date对象        try {            Date date = sdf.parse("2019-09-27 22:18:05");            System.out.println(date);        } catch (ParseException e) {            e.printStackTrace();        }    }    // 小练习:设计方法,计算两个日期之间相差多少天    private static int getDeltaDays(String from, String to) {        // 1. 限定一个时间格式        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");        // 2. 将两个时间转成Date对象        try {            Date fromDate = sdf.parse(from);            Date toDate = sdf.parse(to);            // 3. 计算相差多少天            long days = (toDate.getTime() - fromDate.getTime()) / 1000 / 60 / 60 / 24;            return (int)Math.abs(days);        } catch (ParseException e) {            e.printStackTrace();        }        return 0;    }}

10.9. 常用类Calendar

10.9.1. 概念

是一个用来描述时间、日期的类。 比Date的功能更加完善。 在Date类中, 有很方法都已经被废弃了。 用Caleendar类中的某些方法来替代。

10.9.2. 常用方法

10.9.3. 示例代码

import java.util.Calendar;import java.util.Date;/** * @Description Calendar类 */public class CalendarUsage {    public static void main(String[] args) {        // 1. Calendar是一个抽象类,无法直接进行实例化        Calendar calendar = Calendar.getInstance();        // 2. 通过指定的字段,获取对应的值。        //    在 Calendar 类中,已经封装好了若干个静态常量,来表示不同的字段。        System.out.println(calendar.get(Calendar.YEAR));        System.out.println(calendar.get(Calendar.MONTH));           // 在Calendar中,月份是从0开始的。        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));        System.out.println(calendar.get(Calendar.HOUR_OF_DAY));        System.out.println(calendar.get(Calendar.MINUTE));        System.out.println(calendar.get(Calendar.SECOND));        // 3. 通过指定的字段,设置对应的值        calendar.set(Calendar.YEAR, 2022);        calendar.set(Calendar.DAY_OF_MONTH, 29);        // 4. 同时设置年月日        calendar.set(2021, Calendar.SEPTEMBER, 7);        //    同时设置年月日时分        calendar.set(2022, Calendar.NOVEMBER, 12, 23, 59);        //    同时设置年月日时分秒        calendar.set(2022, Calendar.NOVEMBER, 12, 23, 59, 59);        // 5. 获取日期(Date对象)        Date date = calendar.getTime();        // 6. 设置日期(Date对象)        calendar.setTime(new Date());        // 7. 获取时间戳        long timestamp = calendar.getTimeInMillis();        // 8. 设置时间戳        calendar.setTimeInMillis(timestamp);        // 9. 判断一个日期是否在另外一个日期之前        //    类似的方法还有 equals、after        calendar.before(Calendar.getInstance());        // 10. 对一个日期进行加法操作        calendar.add(Calendar.MONTH, 3);        calendar.add(Calendar.DAY_OF_MONTH, 21);        System.out.println(calendar);    }}

标签: #java引入其他包的类