传智播客-Java学习笔记day14

1.正则表达式：是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。

举例：校验qq号码.

  1:要求必须是5-15位数字

  2:0不能开头

=================================================================

不用正则表达式的做法

import java.util.Scanner;

 

/*

 * 校验qq号码.

 *         1:要求必须是5-15位数字

 *         2:0不能开头

 * 

 * 分析：

 *         A:键盘录入一个QQ号码

 *         B:写一个功能实现校验

 *         C:调用功能，输出结果。

 */

public class RegexDemo {

    public static void main(String[] args) {

        // 创建键盘录入对象

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入你的QQ号码：");

        String qq = sc.nextLine();

 

        System.out.println("checkQQ:"+checkQQ(qq));

    }

 

    /*

     * 写一个功能实现校验 两个明确： 明确返回值类型：boolean 明确参数列表：String qq

     */

    public static boolean checkQQ(String qq) {

        boolean flag = true;

 

        // 校验长度

        if (qq.length() >= 5 && qq.length() <= 15) {

            // 0不能开头

            if (!qq.startsWith("0")) {

                // 必须是数字

                char[] chs = qq.toCharArray();

                for (int x = 0; x < chs.length; x++) {

                    char ch = chs[x];

                    if (!Character.isDigit(ch)) {

                        flag = false;

                        break;

                    }

                }

            } else {

                flag = false;

            }

        } else {

            flag = false;

        }

 

        return flag;

    }

}

 

用正则表达式改进

下图---String类中的API

 

/*

 * 正则表达式：符合一定规则的字符串。

 */

public class RegexDemo2 {

    public static void main(String[] args) {

        // 创建键盘录入对象

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入你的QQ号码：");

        String qq = sc.nextLine();

 

        System.out.println("checkQQ:" + checkQQ(qq));

    }

 

    public static boolean checkQQ(String qq) {

        // String regex ="[1-9][0-9]{4,14}";

        // //public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式

        // boolean flag = qq.matches(regex);

        // return flag;

 

        //return qq.matches("[1-9][0-9]{4,14}");//简化版，一行代码

 

        return qq.matches("[1-9]\\d{4,14}");

    }

}

 

2.正则表达式的规则 

规则字符在java.util.regexPattern类中

A:字符

    x 字符 x。举例：'a'表示字符a(任意的字符表示它本身)

    \\ 反斜线字符。("\\"表示反斜线\)

    \n 新行（换行）符 ('\u000A') 

    \r 回车符 ('\u000D')

B:字符类(把很多字符都放到一起)

    [abc] a、b 或 c（简单类）(意为匹配三选一，但不能同时匹配两个，例如ab) 

    [^abc] 任何字符，除了 a、b 或 c（否定） 

    [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） (这个写法就意味着包括了所有英文字母)

    [0-9] 0到9的字符都包括

 

例如上面：[1-9][0-9]{4,14}

代表qq号码第一个数字在1~9范围之内(也就是不能为零)，第二个数字开始(后面的{4,14}规定了除了第一个数字之外，还包含了4~14之间任意的数字个数，而这些数字的取值范围就在0-9之间)(总的来说就是qq号码一共是5-15个数字，其中第一个数字不能为零，剩余的4-14个数字可以为零)

 

C:预定义字符类(\有转义字符的意思)

    . 任何字符。我的就是.字符本身，怎么表示呢? \.

    \d 数字：[0-9]

例如上面：[1-9][0-9]{4,14}可以改写为[1-9]\\d{4,14}

    \w 单词字符：[a-zA-Z_0-9]

        在正则表达式里面组成单词的东西必须有这些东西组成

D:边界匹配器

    ^ 行的开头 

    $ 行的结尾 

    \b 单词边界

        就是不是单词字符的地方。(单词与单词之间隔开的东西，如下面单词与单词之间的空格，还有？;)

        举例：hello world?haha;xixi

E:Greedy 数量词 

    X? X，一次或一次也没有(0次或者1次)

    X* X，零次或多次（0次或者1次以上）

    X+ X，一次或多次

    X{n} X，恰好 n 次 

    X{n,} X，至少 n 次 

    X{n,m} X，至少 n 次，但是不超过 m 次 

例如上面：[1-9][0-9]{4,14}代表[0-9]至少出现4次但不超过14次([1-9]不给出次数，默认为一次)

3.

 * 判断功能

 *        String类的public boolean matches(String regex)

 *

 * 需求：

 *         判断手机号码是否满足要求?

 * 

 * 分析：

 *         A:键盘录入手机号码

 *         B:定义手机号码的规则

 *             13436975980

 *             13688886868

 *             13866668888

 *             13456789012

 *             13123456789

 *             18912345678

 *             18886867878

 *             18638833883

 *         C:调用功能，判断即可

 *         D:输出结果

 */

public class RegexDemo {

    public static void main(String[] args) {

        //键盘录入手机号码

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入你的手机号码：");

        String phone = sc.nextLine();

 

        //定义手机号码的规则

        String regex = "1[38]\\d{9}";

 

        //调用功能，判断即可

        boolean flag = phone.matches(regex);

 

        //输出结果

        System.out.println("flag:"+flag);

    }

}

4.校验邮箱案例(判断功能)

import java.util.Scanner;

 

/*

 * 校验邮箱

 * 

 * 分析：

 *         A:键盘录入邮箱

 *         B:定义邮箱的规则

 *             [e-mail]

 *             [e-mail]

 *             [e-mail]

 *             [e-mail]

 *             [e-mail]

 *         C:调用功能，判断即可

 *         D:输出结果

 */

public class RegexTest {

    public static void main(String[] args) {

        //键盘录入邮箱

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入邮箱：");

        String email = sc.nextLine();

 

        //定义邮箱的规则

        //String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z_0-9]{2,3})+";

        String regex = "\\w+@\\w{2,6}(\\.\\w{2,3})+";

 

        //调用功能，判断即可

        boolean flag = email.matches(regex);

 

        //输出结果

        System.out.println("flag:"+flag);

    }

}

5.正则表达式 分割功能

String类的public String[] split(String regex)

    根据给定正则表达式的匹配拆分此字符串。

 

/*举例：

          百合网，世纪佳缘,珍爱网,QQ

        搜索好友

            性别：女

              范围："18-24"

 

         age>=18 && age<=24

*/

public class RegexDemo {

    public static void main(String[] args) {

        //定义一个年龄搜索范围

        String ages = "18-24";

 

        //定义规则

        String regex = "-";

 

        //调用方法

        String[] strArray = ages.split(regex);

 

//        //遍历

//        for(int x=0; x<strArray.length; x++){

//            System.out.println(strArray[x]);

//        }

 

        //如何得到int类型的呢?

        int startAge = Integer.parseInt(strArray[0]);

        int endAge = Integer.parseInt(strArray[1]);

 

        //键盘录入年龄

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入你的年龄：");

        int age = sc.nextInt();

 

        if(age>=startAge && age<=endAge) {

            System.out.println("你就是我想找的");

        }else {

            System.out.println("不符合我的要求，gun");

        }

    }

}

6.分隔功能练习

 

public class RegexDemo2 {

    public static void main(String[] args) {

        // 定义一个字符串

        String s1 = "aa,bb,cc";

        // 直接分割   split(regex)

        String[] str1Array = s1.split(",");

        for (int x = 0; x < str1Array.length; x++) {

            System.out.println(str1Array[x]);

        }

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

 

        String s2 = "aa.bb.cc";

        String[] str2Array = s2.split("\\.");//注意这里不能直接写点号，因为在正则表达式里面点号表示任意字符

                                                              //，应该用\\.

        for (int x = 0; x < str2Array.length; x++) {

            System.out.println(str2Array[x]);

        }

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

 

        String s3 = "aa    bb                cc";

        String[] str3Array = s3.split(" +");//这里写的regex的意思是任意多个的空格(+前面的空格代表空格，而+表示

                                                               //空格 有 一次或者一次以上)

        for (int x = 0; x < str3Array.length; x++) {

            System.out.println(str3Array[x]);

        }

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

 

        //硬盘上的路径，我们应该用\\替代\

        String s4 = "E:\\JavaSE\\day14\\avi";

        String[] str4Array = s4.split("\\\\");//注意这里是4个杠！！

        for (int x = 0; x < str4Array.length; x++) {

            System.out.println(str4Array[x]);

        }

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

    }

}

7.分隔功能案例

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

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

import java.util.Arrays;

 

/*

 * 分析：

 *         A:定义一个字符串

 *         B:把字符串进行分割，得到一个字符串数组

 *         C:把字符串数组变换成int数组

 *         D:对int数组排序

 *         E:把排序后的int数组在组装成一个字符串

 *         F:输出字符串

 */

public class RegexTest {

    public static void main(String[] args) {

        // 定义一个字符串

        String s = "91 27 46 38 50";

 

        // 把字符串进行分割，得到一个字符串数组

        String[] strArray = s.split(" ");

 

        // 把字符串数组变换成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);

 

       // 把排序后的int数组在组装成一个字符串(不能直接调用toString方法，因为数字之间由空格隔开而不是逗号隔开)

        StringBuilder sb = new StringBuilder();

        for (int x = 0; x < arr.length; x++) {

            sb.append(arr[x]).append(" ");

        }

        //转化为字符串

        String result = sb.toString().trim();//这里的toString方法是StringBuilder 转换成String类型的过程,

                                                                //trim()方法旨在去掉字符串最后一个空格

 

        //输出字符串

        System.out.println("result:"+result);

    }

}

8.正则表达式替换功能

     String类的public String replaceAll(String regex,String replacement)

     使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

public class RegexDemo {

    public static void main(String[] args) {

        // 定义一个字符串

        String s = "helloqq12345worldkh622112345678java";

 

        // 我要去除所有的数字,用*给替换掉

        // String regex = "\\d+";

        // String regex = "\\d";

        //String ss = "*";

 

 

        // 直接把数字干掉

        String regex = "\\d+";

        String ss = "";

 

        String result = s.replaceAll(regex, ss);

        System.out.println(result);

    }

}

 

9.Pattern和Matcher的概述

 

10.正则表达式的获取功能

 

 

 

 

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

/*

 * 获取功能：

 * 获取下面这个字符串中由三个字符组成的单词

 * da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?

 */

public class RegexDemo2 {

    public static void main(String[] args) {

        // 定义字符串

        String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";

        // 规则

        String regex = "\\b\\w{3}\\b";

 

        // 把规则编译成模式对象

        Pattern p = Pattern.compile(regex);

        // 通过模式对象得到匹配器对象

        Matcher m = p.matcher(s);

        // 调用匹配器对象的功能

        // 通过find方法就是查找有没有满足条件的子串

        // public boolean find()

        // boolean flag = m.find();

        // System.out.println(flag);

        // // 如何得到值呢?

        // // public String group()

        // String ss = m.group();

        // System.out.println(ss);

   

         while (m.find()) {

            System.out.println(m.group());

        }

 

        // 注意：一定要先find()，然后才能group()

        // IllegalStateException: No match found

        // String ss = m.group();

        // System.out.println(ss);

    }

}

 

简化如下

public class RegexDemo2 {

    public static void main(String[] args) {

        // 定义一个字符串

        String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";

 

        // 定义规则

        String regex = "\\b\\w{3}\\b";

 

        Pattern p = Pattern.compile(regex);

        Matcher m = p.matcher(s);

        // boolean b = m.find();

        while (m.find()) {

            System.out.println(m.group());

        }

 

    }

}

 

11.Math类

Math:用于数学运算的类。

  成员变量：

          public static final double PI

         public static final double E

  成员方法：

          public static int abs(int a)：绝对值

         public static double ceil(double a):向上取整

         public static double floor(double a):向下取整

        public static int max(int a,int b):最大值 (min自学)

         public static double pow(double a,double b):a的b次幂

         public static double random():随机数 [0.0,1.0)

         public static int round(float a) 四舍五入(参数为double的自学)

         public static double sqrt(double a):正平方根

举例：

 

        // public static double ceil(double a):向上取整(与四舍五入无关)

        System.out.println("ceil:" + Math.ceil(12.34));//ceil:13.0

        System.out.println("ceil:" + Math.ceil(12.56));//ceil:13.0

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

 

        // public static double floor(double a):向下取整(与四舍五入无关)

        System.out.println("floor:" + Math.floor(12.34));//floor:12.0

        System.out.println("floor:" + Math.floor(12.56));//floor:12.0

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

 

 

最大值应用举例

// public static int max(int a,int b):最大值

        System.out.println("max:" + Math.max(12, 23));

        // 需求：我要获取三个数据中的最大值

        // 方法的嵌套调用

        System.out.println("max:" + Math.max(Math.max(12, 23), 18));

        // 需求：我要获取四个数据中的最大值

        System.out.println("max:"

                + Math.max(Math.max(12, 78), Math.max(34, 56)));

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

 

随机数举例

// 获取一个1-100之间的随机数

        System.out.println("random:" + ((int) (Math.random() * 100) + 1));//注意这里的优先级！！少了外层的括号 

                                                                                                // random将与前面的字符串拼接形成类似于981的数

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

 

 

四舍五入举例

System.out.println("round:" + Math.round(12.34f));//round:12

  System.out.println("round:" + Math.round(12.56f));//round:13

round原理如下图：

 

12.一道面试题

需求：请设计一个方法，可以实现获取任意范围内的随机数。

 

  分析：

          A:键盘录入两个数据。

              int start;

              int end;

          B:想办法获取在start到end之间的随机数

              我写一个功能实现这个效果，得到一个随机数。(int)

          C:输出这个随机数

 

public class MathDemo {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入开始数：");

        int start = sc.nextInt();

        System.out.println("请输入结束数：");

        int end = sc.nextInt();

 

        for (int x = 0; x < 100; x++) {      //这里的for循环是为了多测试几组数据，非必要。

            // 调用功能

            int num = getRandom(start, end);

            // 输出结果

            System.out.println(num);

        }

    }

 

    /*

     * 写一个功能 两个明确： 返回值类型：int 参数列表：int start,int end

     */

    public static int getRandom(int start, int end) {

        // 回想我们讲过的1-100之间的随机数

        // int number = (int) (Math.random() * 100) + 1;

        // int number = (int) (Math.random() * end) + start;

        // 发现有问题了，怎么办呢?

        int number = (int) (Math.random() * (end - start + 1)) + start;

        return number;

    }

}

13.Random类

Random:产生随机数的类

import java.util.Random;

构造方法：

         public Random():没有给种子，用的是默认种子，是当前时间的毫秒值

         public Random(long seed):给出指定的种子

 

        给定种子后，每次得到的随机数是相同的。

 

  成员方法：

          public int nextInt()：返回的是int范围内的随机数

         public int nextInt(int n):返回的是[0,n)范围的内随机数

 

举例

public class RandomDemo {

    public static void main(String[] args) {

        // 创建对象

        // Random r = new Random();

        Random r = new Random(1111);

 

        for (int x = 0; x < 10; x++) {

            // int num = r.nextInt();

            int num = r.nextInt(100) + 1;

            System.out.println(num);

        }

    }

}

 

14.System类

 

 

System.gc()

System.gc()可用于垃圾回收。当使用System.gc()回收某个对象所占用的内存之前，通过要求程序调用适当的方法来清理资源。在没有明确指定资源清理的情况下，Java提高了默认机制来清理该对象的资源，就是调用Object类的finalize()方法。finalize()方法的作用是释放一个对象占用的内存空间时，会被JVM调用。而子类重写该方法，就可以清理对象占用的资源，该方法有没有链式调用，所以必须手动实现。

 

 

 

从程序的运行结果可以发现，执行System.gc()前，系统会自动调用finalize()方法清除对象占有的资源，通过super.finalize()方式可以实现从下到上的finalize()方法的调用，即先释放自己的资源，再去释放父类的资源。

但是，不要在程序中频繁的调用垃圾回收，因为每一次执行垃圾回收，jvm都会强制启动垃圾回收器运行，这会耗费更多的系统资源，会与正常的Java程序运行争抢资源，只有在执行大量的对象的释放，才调用垃圾回收最好

15.System.exit(0)

public static void exit(int status):终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。(0表示正常)

所以，建议用exit(0);

16.System类 currentTimeMillis()

 

System.out.println(System.currentTimeMillis());

 

        单独得到这样的实际目前对我们来说意义不大

         那么，它到底有什么作用呢?

         要求：请大家给我统计这段程序的运行时间

        long start = System.currentTimeMillis();

        for (int x = 0; x < 100000; x++) {

            System.out.println("hello" + x);

        }

        long end = System.currentTimeMillis();

        System.out.println("共耗时：" + (end - start) + "毫秒");

    }

 

 

17.system类 arraycopy(注意，arraycopy并不符合命名规则(since JDK1.0)，但是不改了)

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

   从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

举例

 

        int[] arr = { 11, 22, 33, 44, 55 };

        int[] arr2 = { 6, 7, 8, 9, 10 };

 

        System.arraycopy(arr, 1, arr2, 2, 2);

 

        System.out.println(Arrays.toString(arr));//[11, 22, 33, 44, 55]

 

        System.out.println(Arrays.toString(arr2));//[6, 7, 22, 33, 10]

 

注意Arrays.toString(……)方法

 

18.BigInteger类---可以让超过Integer范围内的数据进行运算(即超过2147483647)

java.math.BigInteger

public BigInteger add(BigInteger val):加

 public BigInteger subtract(BigInteger val):减

  public BigInteger multiply(BigInteger val):乘

 public BigInteger divide(BigInteger val):除

  public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组

 

 

BigInteger bi1 = new BigInteger("100");

 BigInteger bi2 = new BigInteger("50");

 

BigInteger[] bis = bi1.divideAndRemainder(bi2);

 System.out.println("商：" + bis[0]);//2

 System.out.println("余数：" + bis[1]);//0

 

19.  BigDecimal

由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

 

public BigInteger add(BigInteger val):加

 * public BigInteger subtract(BigInteger val):减

 * public BigInteger multiply(BigInteger val):乘

 * public BigInteger divide(BigInteger val):除

 * public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组

 


divisor - 此 BigDecimal 要除以的值。scale - 要返回的 BigDecimal 商的标度。(也就是保留多少位小数)roundingMode - 要应用的舍入模式。(一般用ROUND_HALF_UP----即四舍五入)

 

 

20.Date类

 

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

Date的构造方法

        Date():根据当前的默认毫秒值创建日期对象

       Date(long date)：根据给定的毫秒值创建日期对象

 

获取当前时间

long time = System.currentTimeMillis();

Date d2 = new Date(time);

System.out.println("d2:" + d2);

 

21.Date类的一些方法

public long getTime():获取时间，以毫秒为单位

 public void setTime(long time):设置时间

 

掌握两个方法(转换)

从Date得到一个毫秒值

          getTime()

  把一个毫秒值转换为Date

         构造方法

         setTime(long time)

 

/ 创建对象

        Date d = new Date();

 

        // 获取时间

        long time = d.getTime();

        System.out.println(time);

        // System.out.println(System.currentTimeMillis());

 

        System.out.println("d:" + d);

        // 设置时间

        d.setTime(1000);//1000代表1000毫秒

        System.out.println("d:" + d);

 

22.DateFormat

String和Date的相互转换理解

 

Date     --     String(格式化)

          public final String format(Date date)(这个是具体子类SimpleDateFormat的父类DateForamt中的一个方法)

  

  String -- Date(解析)

         public Date parse(String source)

 

  DateForamt:可以进行日期和字符串的格式化和解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat。

 

// Date -- String

        // 创建日期对象

        Date d = new Date();

        // 创建格式化对象

        // SimpleDateFormat sdf = new SimpleDateFormat();

        // 给定模式

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

        // public final String format(Date date)

        String s = sdf.format(d);//子类调用父类的方法

        System.out.println(s);

基础输出

 

总结：

Date     --     String(格式化)

         public final String format(Date date)

  

  String -- Date(解析)

          public Date parse(String source)

  

  DateForamt:可以进行日期和字符串的格式化和解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat。

  

  SimpleDateFormat的构造方法：

         SimpleDateFormat():默认模式

         SimpleDateFormat(String pattern):给定的模式

              这个模式字符串该如何写呢?

             通过查看API，我们就找到了对应的模式

             

 年 y

              月 M    

              日 d

              时 H

              分 m

              秒 s

           2014年12月12日 12:12:12

 

具体方法

-1-.日期转字符串

Date d = new Date();

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");//给定模式

String s = sdf.format(d);//format意为格式化

System.out.println(s);

输出如下

 

-2-字符串转日期

String str = "2008-08-08 12:12:12";

//在把一个字符串解析为日期的时候，请注意格式必须和给定的字符串格式匹配

SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date dd = sdf2.parse(str);//parse意为解析

 

 

23.Date类一个综合案例----你来到这个世界多少天

你来到这个世界多少天

分析：

          A:键盘录入你的出生的年月日

          B:把该字符串转换为一个日期

          C:通过该日期得到一个毫秒值

          D:获取当前时间的毫秒值

          E:用D-C得到一个毫秒值

          F:把E的毫秒值转换为年

                                 /1000/60/60/24

本人写法

输出测试结果

 

24.Calendar类(抽象类)以及getInstance()和get()方法

Calendar:它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

  

  public int get(int field):返回给定日历字段的值。日历类中的每个日历字段都是静态的成员变量，并且是int类型。

下图解析 Calendar rightNow = Calendar.getInstance(); （运用了多态）（具体可查API）

 

// 其日历字段已由当前日期和时间初始化：

        Calendar rightNow = Calendar.getInstance(); // 子类对象

 

        // 获取年

        int year = rightNow.get(Calendar.YEAR);

        // 获取月

        int month = rightNow.get(Calendar.MONTH);

        // 获取日

        int date = rightNow.get(Calendar.DATE);

 

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

 

25.Calendar类另外两个方法

public void add(int field,int amount):根据给定的日历字段和对应的时间，来对当前的日历进行操作。（amount可以是负的）

 public final void set(int year,int month,int date):设置当前日历的年月日

 

承接上一节的获取时间

三年前的今天

 

5年10天前

 

注意set 方法中的month小问题(month从0开始)

 

附：Calendar也有获得毫秒值的方法(具体看API)

 

26.一个小案例------获取任意一年的二月有多少天

 

import java.util.Calendar;

import java.util.Scanner;

 

/*

 * 获取任意一年的二月有多少天(注意month从0开始)

 * 

 * 分析：

 *         A:键盘录入任意的年份

 *         B:设置日历对象的年月日

 *             年就是A输入的数据

 *             月是2

 *             日是1

 *         C:把时间往前推一天，就是2月的最后一天

 *         D:获取这一天输出即可

 */

public class CalendarTest {

    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日

        // 把时间往前推一天，就是2月的最后一天

        c.add(Calendar.DATE, -1);

 

        // 获取这一天输出即可

        System.out.println(c.get(Calendar.DATE));

    }

}

 

day14补充

Calendar

    (1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。

    (2)如何得到一个日历对象呢?

        Calendar rightNow = Calendar.getInstance();

        本质返回的是子类对象。