【Java基础】10_包装类和工具类

Arrays工具类

Arrays类的概述和使用

Arrays:提供了对数组操作的各种方法。

public static String toString(int[] a):把数组转成字符串

public static void sort(int[] a):对数组进行升序排序

public class ArraysDemo {
	public static void main(String[] args) {
		//定义一个数组
		int[] arr = {24,69,80,57,13};
		
		//public static String toString(int[] a):把数组转成字符串
		System.out.println("排序前："+Arrays.*toString*(arr));
		
		//public static void sort(int[] a):对数组进行升序排序
		Arrays.*sort*(arr);
		
		System.out.println("排序后："+Arrays.*toString*(arr));
	}

}

Arrays类中构造方法的问题

Arrays类中真的没有构造方法吗?

一个类中没有构造方法，系统将提供一个无参构造方法。

而我们在帮助文档中没有看到Arrays类的构造方法，这是为什么呢?

Arrays类中有构造方法，只不过构造方法被private修饰，外界是无法使用的。因为外界无法使用，所以帮助文档中就看不到。

通过查看源码，我们找到了如下的内容：

private Arrays() {}

Arrays类的这种设计是常用的工具类的设计思想：

	构造方法私有。

	成员都用static修饰。

Math，Collections等

包装类

概述

需求：我要判断一个数据是否在int范围内?

要想判断一个数据是否在int范围内，首先我们得知道int范围，在前面我们讲解基本数据类型的时候说过了：

​ -2147483648 到 2147483647

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

基本数据类型包装类最常见的用法就是用于和字符串之间进行相互转换。

Integer类的概述和构造方法

Integer:Integer类在对象中包装了一个基本类型 int 的值。

构造方法：

	Integer(int value) 

	Integer(String s) 

		注意：这个字符串必须由数字字符组成

Integer:Integer类在对象中包装了一个基本类型 int 的值。

构造方法：
Integer(int value)
Integer(String s)
注意：这个字符串必须由数字字符组成

public static void main(String[] args) {
	//Integer(int value) 
	int value = 100;
	Integer i = new Integer(value);
	System.out.println(i); //100
	System.out.println("------------");
	
	//Integer(String s) 
	String s = "100";
	//NumberFormatException:数据格式化异常
	//String s = "abc";
	Integer ii = new Integer(s);
	System.out.println(ii);
}

int类型和String类型的相互转换

int类型和String类型的相互转换

int – String

String类中：public static String valueOf(int i)

String – int

Integer类中：public static int parseInt(String s)

基本类型转换为String

基本类型转换String总共有三种方式，查看课后资料可以得知，这里只讲最简单的一种方式：

基本类型直接与””相连接即可；如：34+""

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异常。

public class IntegerDemo {
	public static void main(String[] args) {
		//int	--	String
		int number = 100;
		//方式1
		String s1 = "" + number;
		System.out.println(s1);
		//方式2
		//public static String valueOf(int i)
		String s2 = String.valueOf(number);
		System.out.println(s2);
		System.out.println("--------------");
		
		//String  -- int
		String s = "100";
		//方式1
		//String -- Integer -- int
		Integer i = new Integer(s);
		//public int intValue()
		int x = i.intValue();
		System.out.println(x);
		//方式2
		//public static int parseInt(String s)
		int y = Integer.parseInt(s);
		System.out.println(y);
		
	}

}

Integer的练习之把字符串中的数据排序

需求:

我有如下一个字符串:”91 27 46 38 50”

请写代码实现最终输出结果是：”27 38 46 50 91”

提示：这里需要参考String类中的方法

public String[] split(String regex) 

我有如下一个字符串:”91 27 46 38 50”
请写代码实现最终输出结果是：”27 38 46 50 91”
提示：这里需要参考String类中的方法
public String[] split(String regex)

分析：
A:定义一个字符串对象
B:把字符串中的数字数据存储到一个int类型的数组中
C:对int数组进行排序
D:把排序后的数组中的元素进行拼接得到一个字符串
E:输出字符串

public class IntegerDemo {
	public static void main(String[] args) {
		//定义一个字符串对象
		String s = "91 27 46 38 50";
		
		//把字符串中的数字数据存储到一个int类型的数组中
		//public String[] split(String regex)
		String[] strArray = s.split(" ");
		/*
		for(int x=0; x<strArray.length; x++) {
			System.out.println(strArray[x]);
		}
		*/
		
		//定义一个int类型的数组
		int[] arr = new int[strArray.length];
		for(int x=0; x<arr.length; x++) {
			arr[x] = Integer.*parseInt*(strArray[x]);
		}
		
		//对int数组进行排序
		Arrays.*sort*(arr);
		
		//把排序后的数组中的元素进行拼接得到一个字符串
		StringBuilder sb = new StringBuilder();
		for(int x=0; x<arr.length; x++) {
			if(x==arr.length-1) {
				sb.append(arr[x]);
			}else {
				sb.append(arr[x]).append(" ");
			}
		}
		String result = sb.toString();
		
		//输出字符串
		System.out.println("result:"+result);
	}

}

自动装箱和拆箱

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

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

用Integer与 int为例：

基本数值---->包装对象

public static Integer valueOf(int i)

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

public int intValue()

int num = i.intValue();

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

Java程序的运行：

​ 编写java文件 – 编译生成class文件 – 执行

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

开发中的原则：

​ 只要是对象，在使用前就必须进行不为null的判断。

public static void main(String[] args) {
	//创建一个包装类类型的对象
	//Integer i = new Integer(100);
	Integer ii = 100; //自动装箱	
	//public static Integer valueOf(int i)
	ii += 200; //ii = ii + 200; 自动拆箱,自动装箱
	//public int intValue()
	System.out.println(ii);
	
	/*
	Integer ii = Integer.valueOf(100);
	ii = Integer.valueOf(ii.intValue() + 200);
	System.out.println(ii);
	*/
	
	Integer iii = null;
	if(iii != null) {
		iii += 300; //NullPointerException
		System.out.println(iii);
	}
}

Date类和SimpleDateFormat类

Date类的概述和构造方法

Date:Date表示特定的瞬间，精确到毫秒。

构造方法：

Date():根据当前时间创建的日期对象

Date(long date):根据给定的毫秒值创建对象，从1970 年 1 月 1 日 00:00:00

Date:Date表示特定的瞬间，精确到毫秒。

构造方法：
Date():根据当前时间创建的日期对象
Date(long date):根据给定的毫秒值创建对象，从1970 年 1 月 1 日 00:00:00

public class DateDemo {
	public static void main(String[] args) {
		//Date()
		Date d = new Date();
		System.out.println(d);
		
		//Date(long date) 
		long date = 1000 * 60 * 60;
		Date dd = new Date(date);
		System.out.println(dd);
	}

}

Date类的成员方法getTime()和setTime()

成员方法:

public long getTime():获取的是毫秒值。从1970年1月1日 00:00:00开始的。

public void setTime(long time):设置时间，给的是毫秒值。

从Date得到一个毫秒值：

​ getTime()

从一个毫秒值得到一个Date对象

​ 构造方法

​ setTime(long time)

public long getTime():获取的是毫秒值。从1970年1月1日 00:00:00开始的。
public void setTime(long time):设置时间，给的是毫秒值。

从Date得到一个毫秒值：
getTime()

从一个毫秒值得到一个Date对象
构造方法
setTime(long time)

public class DateDemo2 {
	public static void main(String[] args) {
		//创建对象
		Date d = new Date();
		
		//public long getTime()
		System.out.println(d.getTime());
		
		//public void setTime(long time)
		d.setTime(1000*60*60);
		System.out.println(d.getTime());
	}

}

SimpleDateFormat类的概述和使用

SimpleDateFormat:是一个以与语言环境有关的方式来格式化和解析日期的具体类。

它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）

格式化（日期 -> 文本）: Date – String

​ public final String format(Date date)

解析（文本 -> 日期）: String – Date

​ public Date parse(String source)

package com.itheima_01;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

SimpleDateFormat:是一个以与语言环境有关的方式来格式化和解析日期的具体类。
它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）

格式化（日期 -> 文本）: Date – String
public final String format(Date date)

解析（文本 -> 日期）: String – Date
public Date parse(String source)

public class SimpleDateFormatDemo {
	public static void main(String[] args) throws ParseException {
		/*
		//Date -- String
		Date d = new Date();
		//SimpleDateFormat(): 用默认的模式
		//SimpleDateFormat sdf = new SimpleDateFormat();
		//SimpleDateFormat(String pattern):用给定的模式
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		String s = sdf.format(d);
		//现在虽然实现了把日期格式化成一个字符串，但是不是我们想要的格式
		//我们想要的格式是：xxxx年xx月xx日 xx:xx:xx
		System.out.println(s);
		*/
		
		//String -- Date
		String str = "2080-08-08 12:23:45";
		//把一个字符串解析为日期的时候，请注意模式字符串和给定的日期字符串的格式要匹配
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d = sdf.parse(str);
		System.out.println(d);
	}

}

Date的练习之日期工具类的定义和使用

制作工具类DateUtil

工具类

构造方法私有
成员方法静态

public class DateUtil {
	private DateUtil() {}
	
	/*
	 * 把日期转换为指定格式的字符串
	 * 两个明确：
	 * 		返回值类型：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;
	}
	
	/*
	 * 把指定格式的字符串解析为日期
	 * 两个明确：
	 * 		返回值类型：Date
	 * 		参数列表：String s, String format
	 */
	public static Date stringToDate(String s,String format) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Date d= sdf.parse(s);
		return d;
	}

}

测试工具类

import java.text.ParseException;

import java.util.Date;

public class DateUtilTest {
	public static void main(String[] args) throws ParseException {
		Date d = new Date();
		
		String s = DateUtil.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
		System.out.println(s);
		
		String s2 = DateUtil.dateToString(d, "yyyy年MM月dd日");
		System.out.println(s2);
		
		String s3 = DateUtil.dateToString(d, "HH:mm:ss");
		System.out.println(s3);
		
		String str = "2080-08-08 12:23:34";
		Date dd = DateUtil.stringToDate(str, "yyyy-MM-dd HH:mm:ss");
		System.out.println(dd);
	}

}

Calendar类

概念

日历我们都见过

java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

获取方式

Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象，如下：

Calendar静态方法

• public static Calendar getInstance()：使用默认时区和语言环境获得一个日历

例如：

import java.util.Calendar;

public class Demo06CalendarInit {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
    }    
}

常用方法

根据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类中提供很多成员常量，代表给定的日历字段：

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，可以-1使用）

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 + "日");
    }    
}

import java.util.Calendar;

public class Demo07CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2020);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2020年1月17日
    }
}

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 + "日"); // 2018年1月17日
        // 使用add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 减3年
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日; 
    }
}

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 2018
    }
}

小贴士：

​ 西方星期的开始为周日，中国为周一。

​ 在Calendar类中，月份的表示是以0-11代表1-12月。

​ 日期是有大小关系的，时间靠后，时间越大。**

System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

• public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

currentTimeMillis方法

实际上，currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) {
       	//获取当前时间毫秒值
        System.out.println(System.currentTimeMillis()); // 1516090531144
    }
}

练习

验证for循环打印数字1-9999所需要使用的时间（毫秒）

public class SystemTest1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时毫秒：" + (end - start));
    }
}

arraycopy方法

• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

练习

将src数组中前3个元素，复制到dest数组的前3个位置上复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

import java.util.Arrays;

public class Demo11SystemArrayCopy {
    public static void main(String[] args) {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);
        /*代码运行后：两个数组中的元素发生了变化
         src数组元素[1,2,3,4,5]
         dest数组元素[1,2,3,9,10]
        */
    }
}