java基础（9）- java的工具(Util)包（1）

注 ： 参考自https://mp.weixin.qq.com/s/MrrN7BDcKMu8SCKs6zij_g

9.1Date类

9.2Calendar类

9.3Random随机数类

9.4ArrayList

9.5LinkedList

9.1Date类

Date类

util是utility(即：中文工具)的简写，也就是java的实用工具集包，该包提供了大量的实用工具类，常用工具如日期与时间操作、随机数、正则表达式、国际化等，而在util包中比较核心的应该是Collection类集工具，java系统提供了丰富的数据结构用于出集合的操作。

一、Date类简介

日期类主要包括Date类与Calendar类，这一节我们先介绍Date类， Date 表示特定的瞬间，精确到毫秒。Date类用于表示日期和时间，在计算机中的表示和我们现实世界使用差不多，但是还是有点区别的，而且还有中西文化之间的差异，所以在学习这个类之前，我们清楚Date类和现实世界之间对世界的之间的差异：

• 年份由整数表示，但是Date类的年份由1900开始算，也就是Date类的年份为y，那么现实世界就是 y + 1900 表示。

• 月份由从 0 至 11 的整数表示，也就是0 是一月、1 是二月等等；因此 11 是十二月。

• 日期（一月中的某天）按通常方式由整数 1 至 31 表示，这点和现实世界一致。

• 小时由从 0 至 23 的整数表示。因此，从午夜到 1 a.m. 的时间是 0 点，从中午到 1 p.m. 的时间是 12 点，这点和现实世界一致。

• 分钟按通常方式由 0 至 59 的整数表示，这点和现实世界一致。

• 秒由 0 至 61 的整数表示；值 60 和 61 只对闰秒发生，尽管那样，也只用在实际正确跟踪闰秒的 Java 实现中。于按当前引入闰秒的方式，两个闰秒在同一分钟内发生是极不可能的，但此规范遵循 ISO C 的日期和时间约定。

• Date可是精确到毫秒，Date的元毫秒从1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

二、Date类常用方法

在java中，日期时间用java.util.Date来表示，调用默认构造器Data()，将会创建一个当前系统时间的Date对象，时间精确到毫秒。Date类常用方法是：

Date()

分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

boolean after(Date when)

测试此日期是否在指定日期之后。

boolean before(Date when)

测试此日期是否在指定日期之前。

int compareTo(Date anotherDate)

比较两个日期的顺序。

其它的还有很多获得年月日时分秒的函数，但是这些方法都已经过期，这些方法都已经Calendar.get(...)方法替代了，当然虽然过期了，但是还是可以使用的。示例代码如下：

public class DateStu {
    public static void main(String[] args) {
        // 获得操作系统的当前时间
        Date date = new Date();
        Date date2=new Date(1997,6,7);
        System.out.println(date.before(date2));
        
        //如果date2大于date返回 1  等于返回 0  小于 -1
        System.out.println(date2.compareTo(date));
        //
        System.out.println("年：" + (date.getYear()+1900) + ",月：" + (date.getMonth()+1)
                + ",日：" + date.getDate() + ",星期:" + date.getDay() + ",时："
                + date.getHours() + ",分：" + date.getMinutes() + ",秒："
                + date.getSeconds());
        
        System.out.println("现在的毫秒："+date.getTime()/1000);
        
        System.out.println(date.toString());
        
        System.out.println(date.toLocaleString());//本地时间格式

    }

}

程序输出如下：

true

1

年：2014,月：2,日：20,星期:4,时：23,分：3,秒：5

现在的毫秒：1392908585

三、时间的格式化显示

各系统在显示时间的格式是不统一的，在中国一般采用英式日期，如“2013-02-02 17:30:24”的格式,而在美国时间的显示则为“月-日-年”的格式“02-02-2013 17:30:24”。要想格式化时间或者把字符串转换为Date类，可以使用java.text.Dateformat抽象类规定日期格式化的操作，具体常用的实现是java.text.SimpleDateformat类。

示例代码如下：

//1990年  9 月 4 日
//"yyyy.MM.dd G 'at' HH:mm:ss z"  2001.07.04 AD at 12:08:56 PDT  
//HH 24 小时，hh 12小时
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd");
String dateFromt= sdf.format(date);//日期转换为字符串
System.out.println(dateFromt);
        
//把字符串转换为日期
String inputdateFString="2013年09月8";
try {
    Date inputDate=sdf.parse(inputdateFString);
    System.out.println(inputDate);
} catch (ParseException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

程序输出如下：

Thu Feb 20 23:03:05 CST 2014

2014-2-20 23:03:05

9.2Calendar类

一、Calendar简介

java.util.Calendar意为日历，跟Date类有很多类似的地方，但是也有区别的，Date类主要用于时间的表示，而Calendar侧重于时间的计算。Calendar类是一个抽象基类，需要通过工厂方法去取得当前系统日历：

    Calendar calendar =  Calendar.getInstance();

Calendar 与 Date 的转换非常简单，代码如下：

Calendar calendar = Calendar.getInstance();
// 从一个 Calendar 对象中获取 Date 对象
Date date = calendar.getTime();
// 将 Date 对象反应到一个 Calendar 对象中，
// Calendar/GregorianCalendar 没有构造函数可以接受 Date 对象
// 所以我们必需先获得一个实例，然后设置 Date 对象
calendar.setTime(date);

二、示例方法

Calendar类中提供了大量各种用于日期计算的方法

public class CalStu {
    public static void main(String[] args) {

        // 获得实例对象使用 getInstance
        Calendar cal = Calendar.getInstance();
        //设置值
        //cal.set(Calendar.YEAR, 1997);
        //cal.set(Calendar.MINUTE, 3);
        //可以使用add计算
        cal.add(Calendar.YEAR, -30);//
                //获得年月日，时分秒，日期等
        System.out.println("年：" + cal.get(Calendar.YEAR) + ",月："
                + (cal.get(Calendar.MONTH)+1) + "，日：" + cal.get(Calendar.DATE)
                + ",时：" + cal.get(Calendar.HOUR_OF_DAY) + ":分："
                + cal.get(Calendar.MINUTE) + ",秒：" + cal.get(Calendar.SECOND)
                + ",星期：" + cal.get(Calendar.DAY_OF_WEEK));
        System.out.println(cal.get(Calendar.DAY_OF_YEAR));
        System.out.println(cal.get(Calendar.WEEK_OF_YEAR));
        
        System.out.println(cal.getTime());//把calendar转换为date对象
        System.out.println(cal.getTimeInMillis());
        
        //实例
        //计算每个月的天数
        //9 月份的天数  
        for(int i=0;i<12;i++){
            cal.set(Calendar.MONTH, i+1);
            cal.set(Calendar.DATE, 1);
            
            cal.add(Calendar.DATE, -1);
            
            System.out.println("第"+(i+1)+"月的天数："+cal.get(Calendar.DATE));
        }
        

    }

}

当然这个输出，会因为你的因为你当前的运行时间不同而不同，程序输出如下：

年：1984,月：2，日：20,时：23:分：8,秒：25,星期：2

51

8

Mon Feb 20 23:08:25 CST 1984

446137705832

第1月的天数：31

第2月的天数：29

第3月的天数：31

第4月的天数：30

第5月的天数：31

第6月的天数：30

第7月的天数：31

第8月的天数：31

第9月的天数：30

第10月的天数：31

第11月的天数：30

第12月的天数：31

三、完成以下练习

1、格式化输出当期日期。如：2012年3月13日 21：30：30

package Exe;import java.text.SimpleDateFormat;import java.util.Date;/** 1、格式化输出当期日期。如：2012年3月13日 21：30：30*/public class Exe1 {public static void main(String[] args) {SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); // 设置输出格式System.out.println(sdf.format(new Date())); // 将当地时间按输出格式输出}}

2、把字符串“2012-3-6 20：78：1”解释为日期，并输出。

package Exe;import java.text.SimpleDateFormat;public class Exe2 {public static void main(String[] args) {String str = "2012-3-6 20：78：1";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH：mm：ss");// 解析用格式try {System.out.println(sdf.parse(str));} catch (Exception e) {e.printStackTrace();}}}

3、请问今年是闰年了吗？

package Exe;import java.text.SimpleDateFormat;import java.util.Calendar;public class Exe3 {public static void main(String[] args) {int year;Calendar cal = Calendar.getInstance();year = cal.get(Calendar.YEAR);if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) { // 判断是否润年System.out.println(year + "年是润年！");} else {System.out.println(year + "年是不润年！");}}}

4、请用程序测试使用循环计算1+2+...100000所用的时间(以秒为单位)。

public class Exe4 {public static void main(String[] args) {Date beginDate=new Date();long sum=0;for(long i=1;i<=100000000;i++){sum+=i;}System.out.println(sum);Date endDate=new Date(); long result=endDate.getTime()-beginDate.getTime(); System.out.println("总时间："+result+"毫秒");}}

5、小明是1992年7月2日生日的，国家规定22岁就可以去结婚，请问小明什么时候可以去结婚？

package Exe;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Calendar;public class Exe5 {public static void main(String[] args) throws NumberFormatException, ParseException {int y1, y2, age;String str = "1992年7月2日"; // 定义小明的生日Calendar cal = Calendar.getInstance();SimpleDateFormat year = new SimpleDateFormat("yyyy");y1 = Integer.parseInt(year.format(cal.getTime())); // 提取当前年份y2 = Integer.parseInt(year.format(year.parse(str))); // 提取小明的出生年份age = (y1 - y2); // 小明的岁数if (age >= 22) {System.out.println(age + "岁可以结婚了！");} else {System.out.println(age + "岁还不可以结婚！");}}}

6、计算下一年的今天是星期几，请用程序打印输出。

package Exe;import java.util.Calendar;/*** 6、计算下一年的今天是星期几，请用程序打印输出。** @author Administrator**/public class Exe6 {public static void main(String[] args) {Calendar calendar = Calendar.getInstance();System.out.println(calendar.get(Calendar.YEAR) + "年");calendar.add(Calendar.YEAR, 1);int week = calendar.get(Calendar.DAY_OF_WEEK);switch (week) {case 1:System.out.println("星期日");break;case 2:System.out.println("星期一");break;case 3:System.out.println("星期二");break;case 4:System.out.println("星期三");break;case 5:System.out.println("星期四");break;case 6:System.out.println("星期五");break;case 7:System.out.println("星期六");break;}}}

7、输出2012年4月的日历。类似日历的格式输出。

输出：

日 一 二 三 四 五 六

1 2 3 4 5 6 7

package Exe;import java.util.Calendar;public class Exe7 {public static void main(String[] args) {Calendar time = Calendar.getInstance();// 设置日期2013.11.1time.set(2013, 1, 1);int a = (time.get(Calendar.DAY_OF_WEEK));//星期System.out.println(" Sun Mon Thu Wed Thu Fri Sat");// 根据1号在星期几输出空格for (int i = 0; i < time.get(Calendar.DAY_OF_WEEK) - 1; i++)System.out.print(" ");//获得最大天数time.add(time.MONTH, 1);time.add(time.DATE, -1);for (int i = 1; i <= time.get(Calendar.DATE); i++) {if ((i + a) % 7 == 2)System.out.println();System.out.printf("%4d", i);}}}

8、输出2013年整年的日历。

package Exe;import java.util.Calendar;public class Exe8 {public void output(int year,int month){Calendar time = Calendar.getInstance();// 设置日期2013.11.1time.set(year, month, 1);int a = (time.get(Calendar.DAY_OF_WEEK));//星期System.out.println(" Sun Mon Thu Wed Thu Fri Sat");// 根据1号在星期几输出空格for (int i = 0; i < time.get(Calendar.DAY_OF_WEEK) - 1; i++)System.out.print(" ");//获得最大天数time.add(time.MONTH, 1);time.add(time.DATE, -1);int lastDate=time.get(Calendar.DATE);time.set(Calendar.DATE, 1);for (int i = 1; i <=lastDate ; i++) {System.out.printf("%4d", time.get(Calendar.DATE));if (time.get(Calendar.DAY_OF_WEEK) == 7)System.out.println();time.add(Calendar.DATE, 1);}}public static void main(String[] args) {Exe8 exe8=new Exe8();int year=2013;for(int month=0;month<12;month++){exe8.output(year, month);System.out.println();System.out.println();}}}

9.3Random随机数类

一、Random随机数类

1、简介

Random随机数类是一个非常简单和实用类，用于生成伪随机数，在一些游戏获得某些应用中都会大量使用到随机数，构造方法有两个，分别是：

Random() 创建一个新的随机数生成器。

Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。

如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列，所以一般我们在一段程序中使用一个Random示例，或者为每个Random示例使用不同的种子。

我们在讲解Math类的时候也讲过一个随机方法random()，这个方法事实上也就是使用Random类实现的。事实上使用Math.random()可能还更容易点。

2、随机数的常用方法：

protected int next(int bits)

生成下一个伪随机数。

boolean nextBoolean()

返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值。

void nextBytes(byte[] bytes)

生成随机字节并将其置于用户提供的 byte 数组中。

double nextDouble()

返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。

float nextFloat()

返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值。

double nextGaussian()

返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。

int nextInt()

返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

int nextInt(int n)

返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

long nextLong()

返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。

void setSeed(long seed)

使用单个 long 种子设置此随机数生成器的种子。

二、示例

生成10个100以内的随机数，代码如下：

public class Bac {

    public static void main(String[] args) {
        // System.out.println(Math.random());//<1
        // 随机打印 1 -- 10
        Random random = new Random(System.currentTimeMillis());
        for (int i = 0; i < 10; i++) {
            System.out.println(random.nextInt(100));
        }
    }

}

完成一个玩筛子的游戏。

代码如下：

public static void main(String[] args) {
        //
        Scanner scanner = new Scanner(System.in);
        System.out.println("买大还是小：");
        String input = scanner.nextLine();

        // 随机生成三个数 1- 6
        Random random = new Random(System.currentTimeMillis());// 以当前时间作为种子
        int num1 = random.nextInt(6) + 1;
        int num2 = random.nextInt(6) + 1;
        int num3 = random.nextInt(6) + 1;

        // 测试:
        System.out.println(num1 + ":" + num2 + ":" + num3);

        // 判定
        String result;
        if (num1 == num2 && num1 == num3) {
            System.out.println("豹子");
            result = "豹子";
        } else if (num1 + num2 + num3 > 9) {
            System.out.println("大");
            result = "大";
        } else {
            System.out.println("小");
            result = "小";
        }

        // 赢了吗？
        if (input.equals(result)) {
            System.out.println("赢了");
        } else {
            System.out.println("输了");
        }
    }

运行代码，要先输入大小，然后程序随机生成三个数，并判断输赢。

9.4ArrayList

一、集合框架介绍

集合框架有一个共有的接口Collection，集合对象就是将多个元素组成一个单元的对象，集合数据的一般操作就是用于存储、检索、删除和修改等操作。集合框架是用于表示和操纵集合的统一体系结构。

java集合框架的优点：

• 提供有用的数据结构和算法，从而减少编程工作

• 提高了程序速度和质量,因为它提供了高性能的数据结构和算法

• 允许不同 API 之间的互操作，API之间可以来回传递集合

• 可以方便地扩展或改写集合

java集合框架提供了四种容器可以选择使用，分别是Queue、List、Set和Map。为了该框架的高效/规范和易于扩展性，集合框架被设计成一组层次分明的标准化接口与实现，接口图如下：

二、ArrayList

List表示的是一种有序的对象容器数据结构，java中使用List接口来规定这类数据结构。List接口实现了Collection<E>, Iterable<E>。常用的实现类主要有ArrayLis<E>t和LinkedList<E>。

ArrayList和我们之前介绍的数组有很多的优势，ArrayList的特点总结如下：

• ArrayList 对象是长度可变的对象引用数组,类似于动态数组

• 继承 AbstractList 并实现 List 接口，方法统一

• 动态扩展，随着元素的添加，元素的数目会增加，列表也会随着扩展

• 访问和遍历对象时，它提供更好的性能

三、常用方法举例

对ArrayList的常用方法，无非就是添加、删除数据，和访问数据，这里就不做太多论述了，你可以阅读以下下面的的代码：

package com;

import java.util.ArrayList;

import com.pojo.Student;

public class ArrayListStr {
    
    public static void main(String[] args) {
        //线性结构  在这里你可以和数组对比一下
        int nums[]={1,3,4,4};
        System.out.println(nums[3]);
        
        //初始化三个学生对象。
        Student stu1=new Student();
        stu1.setAge(23);
        stu1.setName("张三1");
        
        Student stu2=new Student();
        stu2.setAge(24);
        stu2.setName("张三2");
        
        Student stu3=new Student();
        stu3.setAge(25);
        stu3.setName("张三3");
        
        //定义一个ArrayList对象，
        ArrayList stus=new ArrayList();
        //把三个学生对象添加到一个ArrayList对象中
        stus.add(stu1);
        stus.add(stu2);
        stus.add(stu3);
        //也可以添加一个字符串对象
        stus.add("1234");
        
        System.out.println(stus.size());//ArrayList大小
        System.out.println(stus.isEmpty());//判断是否为空
        System.out.println(stus.contains(stu2));//是否包含某个对象
        

                //访问  随机访问
        Student temp=(Student)stus.get(2);    
        System.out.println(temp.getName());
        
        //动态添加
        Student stu4=new Student();
        stu4.setAge(25);
        stu4.setName("张三4");
        stus.add(stu4);
        //删除
        stus.remove(stu2);

        
        //顺序访问  访问全部
        for(int i=0;i<stus.size();i++){
            Object object=stus.get(i);
            //以后会使用泛型优化，现在最好先判断
            if(object instanceof Student){
                Student stu=(Student)object;
                System.out.println(stu.getName());
            }    
        }
        
            //转换为数组。
        Student [] stuarray=(Student [])stus.toArray();
        
    }

}

9.5LinkedList

一、linkedlist介绍

LinkedList实现了链表的数据结构，链式结构使得LinkedList相对于顺序结构的ArrayList来说，在列表中插入数据或删除数据时效率更高。它实现了List接口并继承于AbstractSequentialList。构造方法如下：

LinkedList(); //创建默认的空链表

LinkedList(Collection c); //创建链表，将现有集合c放入链表

由于都是实现List接口，所以和ArrayList的很多方法都是一致，其实现虽然完全不同，不过方法的调用和含义是一致的，所以这里我们就介绍几个ArrayList所不同的方法：

void addFirst(Object obj); //在头部添加数据

void addLast(Object obj); //在尾部添加数据

void add(int index,Object obj); //指定位置添加数据

Object getFirst( ); //从头部读取数据

Object getLast( ); //从尾部读取数据

Object removeFirst( ); //从头部移除数据

Object removeLast( ); //从尾部移除数据

二、常用方法举例

package com.stu;

import java.util.LinkedList;
import java.util.Vector;

import com.pojo.Student;

public class LinkedListStu {
    
    public static void main(String[] args) {
        LinkedList linkedList=new LinkedList();
    
        Student stu1=new Student();
        stu1.setName("张三1");
        linkedList.add(stu1);
        
        Student stu2=new Student();
        stu2.setName("张三2");
        
        Student stu3=new Student();
        stu3.setName("张三3");
        
        linkedList.add(stu3);//默认添加到末尾
        
        linkedList.remove(stu3);
        
        System.out.println("大小："+linkedList.size());
        System.out.println("是否为空："+linkedList.isEmpty());
        System.out.println("是否包含："+linkedList.contains(stu2));
        
        System.out.println(linkedList.get(2));
        
        //linkedList比较特有的方法
        linkedList.add(0, stu2);//指定位置添加
        linkedList.removeFirst();
        linkedList.removeLast();
        linkedList.addFirst(stu1);
        linkedList.addLast(stu3);
        
        for(int i=0;i<linkedList.size();i++){
            Object object=linkedList.get(i);
            if(object instanceof Student){
                Student stu=(Student)object;
                System.out.println(stu.getName());
            }
        }
        
        
    }

}

三、ArrayList和LinkList的区别

ArrayList和LinkList的区别实际上就是数据结构中顺序表和链表直接的区别。

顺序表的特点是逻辑上相邻的数据元素，物理存储位置也相邻，ArrayList的存储空间需要预先分配，并在运行中可以动态在扩充，它的优点是：

1. 节省空间，不用为表示节点间的逻辑关系而增加额外的存储开销。

2. 随机访问速度高，顺序表具有按元素序号随机访问。

缺点：

1. 在顺序表中做插入、删除操作时，平均移动表中的一半元素，因此对较大的顺序表效率低。

2. 需要预先分配足够大的存储空间，估计过大，可能会导致顺序表后部大量闲置；预先分配过小，又会造成溢出。

在链表中逻辑上相邻的数据元素，物理存储位置不一定相邻，它使用指针实现元素之间的逻辑关系。并且，链表的存储空间是动态分配的。LinkList采用双向链表的方式实现，它的最大特点是：

1. 插入、删除运算方便。

2. 不需要预先分布连续的存储空间。

缺点：

1. 要占用额外的存储空间存储元素之间的关系，存储密度降低。

2. 链表不是一种随机存储结构，不能随机存取元素。

可见ArrayList和LinkList的优缺点是互补的，要看实际的应用需要来决定使用哪一种存储方式，例如，要经常查找线性表中的第i个元素，对于顺序表可以直接计算出a(i)的的地址，不用去查找，其时间复杂度为0(1).而链表必须从链表头开始，依次向后查找，平均需要0(n)的时间。所以，如果经常做的运算是按序号访问数据元素，显然顺表优于链表。反之，如果经常需要增删数据的，那么在顺序表中平均移动表中一半的元素，当数据元素的信息量较大而且表比较长时，而在链表中作插入、删除，虽然要找插入位置，但是不需要移动数据，所以LinkList又比ArrayList效率要高。