Java中API常用类讲解

曾经终败给现在 2022-06-17 10:22 217阅读 0赞

## 一：基本数据类型包装类 ##

1.1  
如何完成以下需求：  
需求1：我有一个数据，请问如何判断是否是int范围内的呢?  
int范围 -2^31 ~ 2^31-1

package com.edu.integer;
    public class IntegerDemo {
        public static void main(String[] args) {
            //判断下面定义的值是否在int数据类型的范围内
            int i = 100000000;
            //输出int类型的最大值和最小值的范围
            System.out.println(Integer.MAX_VALUE);//2147483647
            System.out.println(Integer.MIN_VALUE);//-2147483648
    
            //使用if语句进行判断
            if (i>=Integer.MIN_VALUE&&i<=Integer.MAX_VALUE) {
                System.out.println("该数值在int的范围内");
            }       
        }
    }

需求2：我有一个数据，我要得到该数据的二进制，八进制，十六进制如何实现呢?  
按照以前讲过规律进行计算，但是比较麻烦。  
为了方便基本类型的数据做更多的操作，java就针对每种基本类型的数据 给出了对应的类类型。  
这就是我们说的基本类型的包装类。

public class IntegerDemo2 {
        public static void main(String[] args) {
            //求出该数据的二进制，八进制，十六进制
            int i = 100;
            //调用Integer里面以为我们提供的方法将上面的数据直接转换为该十进制对应的二进制
            //public static String toBinaryString(int i)
            //以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
            String i2 = Integer.toBinaryString(i);
            System.out.println(i2);
    
            System.out.println("---------------");
            //转换成8进制
            //public static String toOctalString(int i)
            //以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。 
            String i8 = Integer.toOctalString(i);
            System.out.println(i8);
    
            System.out.println("-----------------");
            //转换成16进制
            //public static String toHexString(int i)
            //以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。 
            String i16 = Integer.toHexString(i);
            System.out.println(i16);
        }
    
    }

基本类型 类类型  
byte Byte  
short Short  
int Integer  
long Long  
float Float  
double Double  
char Character  
boolean Boolean  
1.2 学习Integer类型（查看api进行学习）  
可以完成以上需求的所要用到的方法：

1.2.1  
字段：  
最大值：MAX\_VALUE  
最小值：MIN\_VALUE

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

1.2.3  
各种成员方法：  
转换为二进制：toBinaryString(int i)  
转换为八进制：toOctalString(int i)  
转换为十六进制：toHexString(int i)

public class IntegerDemo3 {
        public static void main(String[] args) {
            //Integer(int value) ,构造一个Integer对象
            Integer i = new Integer(100);
            System.out.println(i);
    
            //Integer(String s) 
           //Integer i2 = new Integer("hello");//java.lang.NumberFormatException
          //注意：这里的字符串形式必须是数字形式的字符串，如果不是就会抛出异常
         //System.out.println(i2);
    
            Integer i3 = new Integer("1000");
            System.out.println(i3);
            System.out.println("100000");
            System.out.println(100000);
        }

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

int – String  
方式1：  
String s = 100 +”“;  
方式2:  
String.valueOf(int)  
方式3：  
Integer.toString(100);

String – int  
方式1：  
Integer.parseInt(String)

public class IntegerDemo4 {
        public static void main(String[] args) {
            //int --->String类型的转换
            int i = 100;
            //方式1：(掌握)
            String str = i +"";
            System.out.println(str);
    
            //方式2：
            String str2 = String.valueOf(i);
            System.out.println(str2);
    
            //方式3：
            String str3 = Integer.toString(i);
            System.out.println(str3);
    
    
            //String-->int类型
            //方式1：
            int i2 = Integer.parseInt("100");
            System.out.println(i2);
    
            //方式2：
            //创建Integer对象，传入String类型的数据
            Integer integer = new Integer("1000");
            int i3 = integer.intValue();
            System.out.println(i3);
        }
    
    }

1.2.5  
JDK5的新特性：  
自动装箱：基本类型 – 包装类类型  
Integer.valueOf(100)  
自动拆箱：包装类类型 – 基本类型  
i.intValue()

public class IntegerDemo5 {
        
        public static void main(String[] args) {
            /**
             * jdk5的新特性：
             * 自动装箱：基本类型 -- 包装类类型
             * 自动拆箱：包装类型 -- 基本类型
             */
            //自动装箱：基本类型 -- 包装类类型
            //之前创建对象，将int类型的数据包装成Integer类型
            Integer in = new Integer(100);
    
            //自动装箱：基本类型 -- 包装类类型
            //注意：其实说白了就是直接自动将int类型的数据自动转换成Integer类型，这就叫自动装箱
            Integer in2 = 100;
            //自动拆箱：包装类型 -- 基本类型
            in2+=100;
            /**
             * 上面其实就做了一个自动拆箱动作：
             * 原因：因为我们在做加法的时候，必须首先统一一下数据类 型，才可以做加法
             * 但是现在in2是Integer类型，100这个值是int类型，上面的操作如果可以成功的话，
             * 说明首先将Integer类型的数据自动拆箱成了Int类型，再去执行的加法运算
             */
            System.out.println(in2);
    
        }
    
    }

## 二:Character类的讲解 ##

2.1  
Character:Character 类在对象中包装一个基本类型 char 的值  
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等 等），并将字符从大写转换成小写，反之亦然  
构造方法：  
public Character(char value)

2.2  
成员方法  
public static boolean isUpperCase(char ch) 判断是否是大写字符  
public static boolean isLowerCase(char ch) 判断是否是小写字符  
public static boolean isDigit(char ch) 判断是否是数字  
public static char toUpperCase(char ch) 转成大写  
public static char toLowerCase(char ch) 转成小写

public class CharaterDemo {
        public static void main(String[] args) {
            //构造方法：public Character(char value)
            char c = 'a';
            Character ch = new Character(c);
            System.out.println(ch);
            System.out.println("-------------------");
            // public static boolean isUpperCase(char ch) 判断是否是大写字符
            System.out.println(Character.isUpperCase('a'));
            System.out.println(Character.isUpperCase('A'));
            System.out.println(Character.isUpperCase('0'));
    
            System.out.println("-------------------");
            //  public static boolean isLowerCase(char ch) 判断是否是小写字符
            System.out.println(Character.isLowerCase('a'));
            System.out.println(Character.isLowerCase('A'));
            System.out.println(Character.isLowerCase('0'));
    
            System.out.println("-------------------");
            //  public static boolean isDigit(char ch) 判断是否是数字
            System.out.println(Character.isDigit('a'));
            System.out.println(Character.isDigit('A'));
            System.out.println(Character.isDigit('0'));
    
            System.out.println("-------------------");
            // public static char toUpperCase(char ch) 转成大写
            System.out.println(Character.toUpperCase('a'));
            System.out.println(Character.toUpperCase('A'));
    
            System.out.println("-------------------");
            // public static char toLowerCase(char ch) 转成小写
            System.out.println(Character.toLowerCase('a'));
            System.out.println(Character.toLowerCase('A')); 
    
        }
    
    }

2.3  
需求：键盘录入一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)  
请把以前的代码复制过来，修改成功即可。

这是老师写的

import java.util.Scanner;
    
    public class CharacterTest {
        
        public static void main(String[] args) {
            //2.3 需求：键盘录入一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
            /**
             * 思路：
             * 以后写代码，先别急着写，先屡一下思路，说白了就是这个需求分为几部完成，文字先表示出来
             * 
             * 分析：
             * 1.创建键盘录入对象，录入数据
             * 2.将字符创转换为字符数组
             * 3.遍历数据拿出每一个字符进行if判断
             * 4.创建统计变量，统计次数
             */
            //1.创建键盘录入对象，录入数
            Scanner sc = new Scanner(System.in);
    
            //1.2 录入字符串数据
            String str = sc.nextLine();
    
            //2.将字符创转换为字符数组
            char[] chs = str.toCharArray();
    
            //3.遍历数据拿出每一个字符进行if判断
            int bigChar = 0;
            int smallChar = 0;
            int number = 0;
    
            for (int i = 0; i < chs.length; i++) {
                //System.out.println(chs[i]);
                if (Character.isUpperCase(chs[i])) {
                    bigChar++;
                }
                if (Character.isLowerCase(chs[i])) {
                    smallChar++;
                }
                if (Character.isDigit(chs[i])) {
                    number++;
                }
            }
    
            System.out.println("大写字符出现的次数"+bigChar);
            System.out.println("小写字符出现的次数"+smallChar);
            System.out.println("数字字符出现的次数"+number);
    
        }
    
    }

如果不介意的话，请看看我的，确实没老师的好，在我看来，好的代码需要你去用心去感受，清晰的思路，简洁的代码，重要的是别人能看懂你的代码，必须要有注释，等等。天道酬勤，各位道友一起努力吧!

import java.util.Scanner;
    
    public class CharacterDemo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //2.3 需求：键盘录入一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
        String s = sc.nextLine();
        char[] chs = s.toCharArray();
        int bigNumber = 0;
        int smallNumber = 0;
        int Digit = 0;
        for (int i = 0; i < chs.length; i++) {
            if(Character.isUpperCase(chs[i]))
            {
                bigNumber++;
            }
            if(Character.isLowerCase(chs[i]))
            {
                smallNumber++;
            }
            if(Character.isDigit(chs[i]))
            {
                Digit++;
            }       
        }
        System.out.println("大写字符出现的次数");
        System.out.println(bigNumber);
        System.out.println("小写字符出现的次数");
        System.out.println(smallNumber);
        System.out.println("数字字符出现的次数");
        System.out.println(Digit);
    
        char c = 'a';
        char c1 = 'A';
        System.out.println(Character.toUpperCase(c));
        System.out.println(Character.toLowerCase(c1));
    }
    }

## 三. Math：用于执行数学运算的类。 ##

3.1  
成员方法：  
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()  
public static int round(float a) 参数为double的自学

public class MathDemo {
        public static void main(String[] args) {
            /**
             * 3. Math：用于执行数学运算的类。
                  3.1 
                  成员方法：
                  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()
                  public static int round(float a) 参数为double的自学
             */
            //public static int abs(int a),取绝对值
            System.out.println(Math.abs(100));
            System.out.println(Math.abs(-100));
    
            //public static double ceil(double a),向上取整
            System.out.println(Math.ceil(12.3));
            System.out.println(Math.ceil(12.7));
            System.out.println(Math.ceil(12.0));
    
            //public static double floor(double a),向下取整
            System.out.println(Math.floor(12.3));
            System.out.println(Math.floor(12.7));
            System.out.println(Math.floor(12.0));
    
            //public static int max(int a,int b) min自学
            System.out.println(Math.max(2, 3));
            //判断2，3，4的最大值
            System.out.println(Math.max(Math.max(2, 3), 4));
            //如果是多个数字求最大值：
            //1.创建数组，将数据存储到数组中，接着使用for+if取出最大值
            //2.冒泡排序，取出最后一个值
            //3.Arrays.sort(int[] arr),取出最后一个
    
            //public static double pow(double a,double b)  a的b次方
            System.out.println(Math.pow(2, 3));
    
            System.out.println("---------------");
    
            //public static double random(),产生的随机数在0-1之间，包括0包括1
            System.out.println(Math.random());
            //需求：产生1-100之间的随机数
            int radom = (int) (Math.random()*100+1);
            System.out.println(radom);
    
            // public static int round(float a) ,四舍五入
            System.out.println(Math.round(12.4));
            System.out.println(Math.round(12.6));
    
        }
    
    }

3.2  
案例：猜数字小游戏

import java.util.Scanner;
    
    public class GuessNumber {
        
        public static void main(String[] args) {
            /**
             * 猜数字小游戏分析：
             * 1.生成随机数
             * 2.获取键盘录入数据
             * 3.while死循环进行判断，并给予提示
             * 4.如果判断成功则跳出死循环
             */
            //1.生成随机数
            int ran = (int) (Math.random()*100+1);
            //创建键盘录入对象，并获取键盘录入数据
            Scanner sc = new Scanner(System.in);
            while (true) {
                System.out.println("请输入你猜测得数字");
                int guessNumber = sc.nextInt();
                //进行判断并给予提示
                if (ran>guessNumber) {
                    System.out.println("小了");
                }
    
                if (ran<guessNumber) {
                    System.out.println("大了");
                }
    
                if (ran==guessNumber) {
                    System.out.println("答对了");
                    break;
                }
    
            }
    
        }
    
    }

## 四.Object:是所有类的根类。所有的类都直接或者间接的继承自该类 ##

4.1  
创建学生对象打印学生对象的地址值（本质上是将地址通过哈希算法算出的哈希值）  
同一个对象的哈希值肯定是一样的。  
哈希值相同的对象的地址值未必一样。  
新华字典,zhu – 456(哈希值) – 猪(第三个)，朱(第5个)，珠(第9个)

4.2  
为什么重写toString()方法  
默认情况下，打印的是对象的字符串表示，意义不大。  
包名…类名+@+该对象的哈希值的十六进制  
所以，我们建议，所有子类重写该方法。  
至于如何重写，你就不要问了，自动生成即可。  
表示该对象的数据：  
\[类名 成员变量1=数据值1,成员变量2=数据值2,…\]

class Student{
        //姓名和年龄
        private String name;
        private int age;
        //自动生成的快捷键shift+alt+s
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public Student(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
        public Student() {
            super();
        }
        //重写Object类中的toString方法，自动生成即可
        @Override
        public String toString() {
            return "Student [name=" + name + ", age=" + age + "]";
        }
    
    }
    
    
    public class StudentDemo {
        
        public static void main(String[] args) {
            //创建学生对象，并打印学生对象
            Student s1 = new Student("林志玲", 50);
            Student s2 = new Student("刘德华", 55);
    
            //打印两个学生对象
            System.out.println(s1);//com.edu.object.Student@3cf5b814
            System.out.println(s2);//com.edu.object.Student@28084850
            /**
             * com.edu.object.Student@28084850,我们之前称他为地址值其实是不够准确的，
             * 因为当时为了让大家好理解，我们就暂且称他为地址值。
             * 注意：他其实说白了是一个对象的字符串表示形式--格式：包名+类名+@+该对象的哈希码值
             * 
             * 什么是哈希吗值呢？
             * 有一种哈希算法，可以将对象的哈希吗值算出来，同一个对象的哈希吗值是一样的，
             * 但是记住，哈希吗值一样不代表就是同一个对象
             * 
             * 举例：新华字典
             * zhu  465页(哈希吗值)       猪 （第1个）                住（第四个）                   祝（第六个）
             */
        }
    
    }

4.3  
equals():  
默认情况下，比较的是地址值。没有意义。  
所以，建议子类重写该方法。  
至于如何重写，你就不要问了，自动生成即可。  
这个生成的方法作用是比较对象的成员变量值是否相同。

class Student2{
        private String name;
        private int age;
        public Student2(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
        public Student2() {
            super();
            // TODO Auto-generated constructor stub
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + age;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
    
        //equals()方法在这里比较的是对象的成员变量值，当一个对象和另一个对象的成员变量值完全相同的时候，equals（）
        //就可以认为这两个对象时同一个对象
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Student2 other = (Student2) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
    }
    
    
    public class ObjectDemo {
        
        public static void main(String[] args) {
            //创建两个学生对象
            Student2 s1 = new Student2();
            Student2 s2 = new Student2();
            //equals()方法是Object类中的方法，默认比较的是对象的地址值
            System.out.println(s1.equals(s2));
            System.out.println(s1==s2);// ==完全就可以比较地址值
    
            //创建两个学生对象
            Student2 s3 = new Student2("刘德华", 55);
            Student2 s4 = new Student2("刘德华", 55);
            System.out.println(s3.equals(s4));
    
        }
    
    }

4.4  
面试题：  
==和equals()的区别?  
A:==的作用  
a:基本类型 数据值  
b:引用类型 地址值  
B:equals()  
只能比较引用类型。默认比较地址值。  
如果重写后，是按照重写后的规则进行的。

## 五：scanner类 ##

5.1  
Scanner:帮助我们从键盘获取数据。  
构造方法：  
Scanner(InputStream source)

Scanner sc = new Scanner(System.in);
    
            System.in   in是System类下面的一个静态的成员变量。
            现在我们并不知道in这个成员变量的数据类型。
            请看一下伪代码：
            Scanner {
                public Scanner(InputStream in){}
            }
    
            System {
                public static final InputStream in;
            }
            InputStream System.in

成员方法：  
int nextInt():获取int类型的数据  
String nextLine():获取String类型的数据  
InputMismatchException：输入的数据和最终的结果类型不匹配。  
建议：要什么类型，你就输入什么类型。反正将来也不用。

5.2  
当为同一个Scanner对象，数据的输入顺序问题：  
String,String  
String,int  
int,int  
int,String

出现的问题：  
先int再String就出现了问题。

解决：  
A:我把所有的数据都按照String来拿。  
String s1  
String s2  
String s3  
将来你要什么，我就把String的数据转换为什么类型。(明天就可以实现)  
B:重新创建一个新的对象。

public class ScannerDemo2 {
        public static void main(String[] args) {
            //String,String
    /*      Scanner sc = new Scanner(System.in);
            System.out.println("请输入第一个字符串");
            String str1 = sc.nextLine();
            System.out.println("请输入第二个字符串");
            String str2 = sc.nextLine();
            System.out.println(str1);
            System.out.println(str2);*/
    
            System.out.println("------------------");
            //String,int
    /*      Scanner sc = new Scanner(System.in);
            System.out.println("请输入第一个字符串");
            String str1 = sc.nextLine();
            System.out.println("请输入第二个数字");
            int str2 = sc.nextInt();
            System.out.println(str1);
            System.out.println(str2);*/
            System.out.println("---------------------------");
    
            //int,int
    /*      Scanner sc = new Scanner(System.in);
            System.out.println("请输入第一个数字");
            int str1 = sc.nextInt();
            System.out.println("请输入第二个数字");
            int str2 = sc.nextInt();
            System.out.println(str1);
            System.out.println(str2);*/
    
            System.out.println("--------------------");
            // int,String
    /*      Scanner sc = new Scanner(System.in);
            System.out.println("请输入第一个数字");
            int str1 = sc.nextInt();
            System.out.println("请输入第二个字符串");
            String str2 = sc.nextLine();
            System.out.println(str1);
            System.out.println(str2);*/
    
    
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第一个数字");
            int str1 = sc.nextInt();
            Scanner sc2 = new Scanner(System.in);
            System.out.println("请输入第二个字符串");
            String str2 = sc2.nextLine();
            System.out.println(str1);
            System.out.println(str2);
    
        }
    
    }

## 六：Random用于产生随机数的类。和种子相关（种子其实可以把它看成一个产生随机数的定义的规则）。 ##

构造方法：  
Random():没有指定种子，采用的是默认种子。  
Random(long seed):可以指定种子。种子相同，产生的随机数就相同。

需求：利用有无种子的方式创建对象，使用for循环产生十个随机数  
成员方法：  
public int nextInt():返回int范围内的数据  
public int nextInt(int n):返回\[0,n)之间的数据

public class RandomDemo {
        public static void main(String[] args) {
            //Random():没有指定种子，采用的是默认种子。
            //Random random = new Random();
    
            //采用指定种子的方式创建一个随机数生成器,种子就可以看成这个对随机数生成器产生随机数的规则
            Random random = new Random(20);
    
            //利用for循环产生10个随机数
            for (int i = 0; i < 10; i++) {
                System.out.println(random.nextInt());
            }
        }
    
    }

得到1-100之间的随机数：  
new Random().nextInt(100) + 1

public class RandomDemo2 {
        
        public static void main(String[] args) {
            //产生一个0-50之间的随机数数据
            Random random = new Random();
            System.out.println(random.nextInt(50));
    
            System.out.println("---------------");
            /**
             *   得到1-100之间的随机数：
                 new Random().nextInt(100) + 1
             */
            System.out.println(new Random().nextInt(100)+1);
        }
    
    }

## 七： System 类包含一些有用的类字段和方法。它不能被实例化。 ##

成员方法：  
public static void exit(int status):终止当前正在运行的 Java 虚拟机。根据惯例，非 0 的状态码表示异常终止。  
public static long currentTimeMillis():获取当前时间的毫秒值。  
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length):复制数组  
参数一：要复制的源数组  
参数二：从源数组那个索引开始复制  
参数三：需要复制到哪个数组中  
参数四：从哪个索引开始进行覆盖  
参数五：需要覆盖几个元素

public class SystemDemo {
        
        public static void main(String[] args) {
            // public static void exit(int status):
            //终止当前正在运行的 Java 虚拟机。根据惯例，非 0 的状态码表示异常终止。 
            //System.out.println("hello");
            //终止掉jvm虚拟机
            //System.exit(100);//只要是非0的状态码都表示异常终止
            //System.exit(0);//正常终止jvm虚拟机
            //System.out.println("world");
    
            System.out.println("----------------");
            // public static long currentTimeMillis():获取当前时间的毫秒值。
            //输出当前时间的毫秒之值
            //long currentTimeMillis = System.currentTimeMillis();
            //System.out.println(currentTimeMillis);
    
            //需求：求出打印1-10000之间的所有数字所需要的时间
            /**
             * 1.获取执行前的的毫秒值
             * 2.执行for循环
             * 3.执行完毕获取当前时间的毫秒值
             * 4.做减法
             */
    /*      long startTime = System.currentTimeMillis();
    
            //for循环执行1-10000之间的打印
            for (int i = 0; i < 10000; i++) {
                System.out.println(i);
            }
    
            long endTime = System.currentTimeMillis();
    
            System.out.println("执行时间是："+(endTime-startTime));*/
    
            System.out.println("-----------------");
        /**
         * public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length):复制数组
              参数一：要复制的源数组
              参数二：从源数组那个索引开始复制
              参数三：需要复制到哪个数组中
              参数四：从哪个索引开始进行覆盖
              参数五：需要覆盖几个元素
         */
            int[] arr = {
       1,2,3,4,5};
            int[] arr2 = {
       6,7,8,9,10};
            //需求：将arr2中的元素8，9使用arr数组中的3，4覆盖
            System.arraycopy(arr, 2, arr2, 2, 2);
            //打印这个数组
            System.out.println(Arrays.toString(arr2));
        }
    
    }

## 八： Date:类 Date 表示特定的瞬间，精确到毫秒 ##

构造方法：  
Date():默认获取的是当前的日期时间  
Date(long date):把当前日期按照指定的毫秒值进行设定

成员方法：  
public long getTime()：获取日期对象的毫秒值  
public void setTime(long time):设置日期对象的毫秒值

public class DateDemo {
        public static void main(String[] args) {
            //Date():默认获取的是当前的日期时间
            Date d = new Date();
            System.out.println(d);
    
            //public long getTime()：获取日期对象的毫秒值
            System.out.println(System.currentTimeMillis());//1492847203378
            System.out.println(new Date().getTime());
    
            //Date(long date):把当前日期按照指定的毫秒值进行设定
            Date d2 = new Date(1492847203378L);
            System.out.println(d2);
    
            //public void setTime(long time):设置日期对象的毫秒值
            Date d3 = new Date();
            d3.setTime(1492847203378L);
            System.out.println(d3);
        }
    
    }

9.DateFormat(格式化和解析日期对象)  
9.1  
格式化：  
Date – String  
2015年9月27日 15:14:23

String format(Date d)

解析：  
String – Date  
“2015-12-12”

Date  parse(String s)

构造：  
SimpleDateFormat()用默认的模式格式化日期对象  
SimpleDateFormat(String pattern):用给定的模式格式化日期对象  
例如：  
yyyy年MM月dd日 HH:mm:ss  
yyyy-MM-dd HH:mm:ss

成员方法：  
public final String format(Date date)将一个 Date 格式化为日期/时间字符串  
public Date parse(String source)throws ParseException从给定字符串的开始解析文本，以生成一个日期对象

public class DateFormatDemo {
        
        public static void main(String[] args) {
            /**
             *  构造：
                 SimpleDateFormat()用默认的模式格式化日期对象
                 SimpleDateFormat(String pattern):用给定的模式格式化日期对象
                 例如：
                 yyyy年MM月dd日 HH:mm:ss
                 yyyy-MM-dd HH:mm:ss
             */
            //需求1：创建一个Date对象，格式化这个Date对象
            //创建日期对象
            Date d = new Date();
            //创建日期格式化对象,使用无参构造创建的日期格式化对象，格式化Date对象的时候，使用的是默认的格式
            SimpleDateFormat sdf = new SimpleDateFormat();
            //调用他的format(Date d)格式化这个Date对象
            String dateStr = sdf.format(d);
            System.out.println(dateStr);
    
            //需求：像自定义日期的格式化格式：2017-4-22  16:00:00
            //此时我们创建日期格式化对象的时候，就需要指定一个模式
            //2017-4-22  16:00:00对应的模式是：yyyy-MM-dd HH:mm:ss
            //重新创建一个日期的格式化对象，并指定相应的模式
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateStr2 = sdf2.format(d);
            System.out.println(dateStr2);
    
            //yyyy年MM月dd日 HH:mm:ss做成这种模式的日期
            SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
            String dateStr3 = sdf3.format(d);
            System.out.println(dateStr3);
    
    
        }
    
    }
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class DateFormatDemo2 {
        
        public static void main(String[] args) throws ParseException {
            //日期的解析：String -- > Date对象
            // public Date parse(String source)throws ParseException
            //从给定字符串的开始解析文本，以生成一个日期对象
    
            //创建日期的字符串
            String dateStr = "2017-04-22 16:11:56";
    
            //创建一个日期的格式化对象，并指定模式(和传入的需要解析的字符串格式吻合)
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
            //调用sdf的      Date  parse(String dateStr){}
            Date d = sdf.parse(dateStr);
            System.out.println(d);
        }
    
    }

9.2  
日期工具类DateUtils  
需求：  
1.让外界无法创建这个类的对象  
2.设置的方法直接可以通过类名调用  
3.可以获取 yy年MM月dd日  
4.可以获取 HH:mm:ss  
5.可以获取 yy-MM-dd HH:mm:ss

public class DateUtils {
        //私有化构造
        private DateUtils(){}
    
        //3.可以获取 yy年MM月dd日
        public static String getDate(){
            //创建日起对象
            Date d = new Date();
            //创建日期格式化对象
            SimpleDateFormat sdf = new SimpleDateFormat("yy年MM月dd日");
            //调用方法格式化日起对象
            String dateStr = sdf.format(d);
            return dateStr;
        }
    
    
        // 4.可以获取 HH:mm:ss
        public static String getTime(){
            //创建日起对象
            Date d = new Date();
            //创建日期格式化对象
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
            //调用方法格式化日起对象
            String dateStr = sdf.format(d);
            return dateStr;
        }
    
    
        // 5.可以获取 yy-MM-dd HH:mm:ss
        public static String getDateTime(){
            //创建日起对象
            Date d = new Date();
            //创建日期格式化对象
            SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
            //调用方法格式化日起对象
            String dateStr = sdf.format(d);
            return dateStr;
        }
    
    }
    public class DateUtilsTest {
        public static void main(String[] args) {
            //测试日期工具类
            System.out.println(DateUtils.getDate());
            System.out.println(DateUtils.getTime());
            System.out.println(DateUtils.getDateTime());
        }
    
    }

9.3  
案例：  
键盘录入出生日期，算一下你来到这个世界多少天?

import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Scanner;
    
    public class DateDemo2 {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的出生日期：yyyyMMdd");
        String s = sc.nextLine();
        //键盘录入出生日期，算一下你来到这个世界多少天?
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        Date s1 = sdf.parse(s);
        long startTime = s1.getTime();
        System.out.println(startTime);
        Date d = new Date();
        String s2 = sdf.format(d);
        Date d2 = sdf.parse(s2);
        long nowTime = d2.getTime();
        System.out.println(nowTime);
        int duringTime = (int)((nowTime - startTime)/1000/60/60/24);
        //做事情一定要细心，我当时少加了个括号，查了半天错所以说干什么事情千万不能粗心
        System.out.println(duringTime);
    }
    }

## 九：Calendar:它为特定瞬间与一组诸如 YEAR、MONTH、DAY\_OF\_MONTH、HOUR 等 日历字段之间的转换提供了一些方法 ##

Calendar(日历类) – 获取年，获取月，获取日，获取时，获取分，获取秒。  
public int get(int field):返回给定日历字段的值

public class CalendarDemo {
        public static void main(String[] args) {
            /**
             * 创建对象：
             * 1.new 类名();
             * 2.有一些类是抽象类，他为我们提供了一个成员方法，而这个成员方法的返回值就是这个抽象类的子类对象
             * 
             *   Calendar(日历类)  --  获取年，获取月，获取日，获取时，获取分，获取秒。
                 public int get(int field):返回给定日历字段的值
             */
            //public static Calendar getInstance()
            //使用默认时区和语言环境获得一个日历。返回的 Calendar 基于当前时间
            Calendar c = Calendar.getInstance();
    
            //获取年份
            System.out.println(c.get(Calendar.YEAR));
    
            //获取月份,注意值是从0-11月，我们想要显示的更加付给我们的阅读规则，就必须给月份加上1
            System.out.println(c.get(Calendar.MONTH)+1);
    
            //获取日期
            System.out.println(c.get(Calendar.DATE));
    
            //获取时
            System.out.println(c.get(Calendar.HOUR));
    
            //获取分
            System.out.println(c.get(Calendar.MINUTE));
    
            //获取秒数
            System.out.println(c.get(Calendar.SECOND));
    
            //使用字符串的拼接拼接成你想要的日期格式
    
    
        }
    
    }

9.2  
需求：获取当前时间的5年后的3个月前的7天后。  
public void add(int field,int amount):根据amount修改field的值  
public void set(int year,int month,int date):设置当前日历的年月日

public class CalendarDemo2 {
        public static void main(String[] args) {
            /**
             *  10.2
                  需求：获取当前时间的5年后的3个月前的7天后。
                  public void add(int field,int amount):根据amount修改field的值
                  public void set(int year,int month,int date):设置当前日历的年月日
             */
            //创建Calendar对象啊
            Calendar c = Calendar.getInstance();
    
    /*      //需求：要给当前的日历时间加上5天
            c.add(Calendar.DATE, 5);
            //输出一下日期
            System.out.println(c.get(Calendar.DATE));
    
            //需求：将年份向前推一年
            c.add(Calendar.YEAR, -1);
            System.out.println(c.get(Calendar.YEAR));*/
    
            System.out.println("-----------------");
    
            // public void set(int year,int month,int date):设置当前日历的年月日
            c.set(2016, 9, 9);
            System.out.println(c.get(Calendar.YEAR));
            System.out.println(c.get(Calendar.MONTH)+1);
            System.out.println(c.get(Calendar.DATE));
    
        }
    
    }

9.3  
键盘录入年份，获取任意一年的二月有多少天

public class CalendarTest {
        
        public static void main(String[] args) {
            // 10.3  键盘录入年份，获取任意一年的二月有多少天 
            /**
             * 1.获取年份
             * 2.将日历对象的时间调到，此年的3月的第一天
             * 3.将日期对象向前推一天
             * 4.获取此天的日期
             */
            System.out.println("请输入年份");
    
            Scanner sc = new Scanner(System.in);
            int year = sc.nextInt();
    
            // 2.将日历对象的时间调到，此年的3月的第一天
            Calendar c = Calendar.getInstance();
            c.set(year, 2, 1);
    
            //3.将日期对象向前推一天
            c.add(Calendar.DATE, -1);
    
            //4.获取此天的日期
            System.out.println("该年的二月有"+c.get(Calendar.DATE));
    
        }
    
    }

是不是觉得这个思路比较清晰，相信也有不少人会用除以四的方法，那样虽然可以做出来，但是比这个麻烦多了，所以说思路还是比较重要的。

## 十： 正则表达式 ##

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

案例：（用正则和代码两种方式实现）  
键盘录入qq号码，校验QQ号码。  
需求：  
1:要求必须是5-15位数字  
2:0不能开头

public class RegexDemo {
        
        public static void main(String[] args) {
            /**
             *   案例：（用正则和代码两种方式实现）
             键盘录入qq号码，校验QQ号码。
              需求：
                    1:要求必须是5-15位数字
                    2:0不能开头 
    
                    分析：(封装一个方法，这个方法的返回值是布尔类型，参数就是qq号码)
                    1.判断qq号码的长度，5-15位之间
                    2.不能以0开头
                    3.每一位的字符必须是数字
             */
            System.out.println("请输入你需要校验的qq号码");
            Scanner sc = new Scanner(System.in);
            String qq = sc.nextLine();
    
            //将获取到的qq号码传递给我这个方法
            //方式1：使用代码进行校验qq号码
            //System.out.println(isCheck(qq));
    
            //方式2：使用正则表达式校验qq号码
            System.out.println(isCheck2(qq));
        }
    
        private static boolean isCheck2(String qq) {
            //定义一个校验qq号码的正则表达式,这个正则表达式就是符合我的qq号码的校验规则的正杂表达式
            String reg = "[1-9][0-9]{4,14}";
            //使用正则表达式校验我的qq号码
            boolean flag = qq.matches(reg);
            return flag;
        }
    
        private static boolean isCheck(String qq) {
            //定义一个标记
            boolean flag = true;
            //在这里进行校验判断，但凡有一个条件不满足，就更该flag的值为false
            //1.判断qq号码的长度，5-15位之间
            if (qq.length()>=5&&qq.length()<=15) {
                //2.不能以0开头
                if (!qq.startsWith("0")) {
                    //3.每一位的字符必须是数字
                    char[] qqChs = qq.toCharArray();
                    //遍历字符数组
                    for (int i = 0; i < qqChs.length; i++) {
                        if (Character.isDigit(qqChs[i])) {
    
                        }else {
                            flag = false;
                        }
                    }
    
                }else {
                    flag = false;
                }
    
            }else {
                //更改flag的值
                flag = false;
            }
    
            return flag;
        }
    
    }

10.2  
规则字符在java.util.regex Pattern类中

A:字符
        x 字符x(举例：a,1)
        \\ 反斜线字符
    
    B:字符类
        [abc] a、b 或 c（简单类）
        [^abc] 任何字符，除了 a、b 或 c（否定） 
        [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） 
        [0-9] 0-9字符
    
    C:预定义字符类
        . 任何字符
        \d 数字：[0-9] 
        \w 单词字符：[a-zA-Z_0-9]
    
    
    D:Greedy 数量词 
    X? X，一次或一次也没有 
    X* X，零次或多次 
    X+ X，一次或多次 
    X{n} X，恰好 n 次 
    X{n,} X，至少 n 次 
    X{n,m} X，至少 n 次，但是不超过 m 次  
    
    结论：以后需要匹配的正则表达式怎么写呢？
    答：不用写，直接网上百度

10.3  
判断功能:  
public boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。  
需求1：找出规则，写出正则(1\[38\]\[0-9\]\{9\})，校验电话号码  
13245678901 13332345678 13456789012 18812345678 18999999999  
18666666666 18786868686

需求2：找出规则，写出正则(String reg = “\[a-zA-Z\_0-9\]+@\[a-zA-Z\_0-9\]\{2,8\}(\\.\[comnet\]\{2,3\})+”)，校验邮箱  
sunmeng@163.com zhangsan@126.com lisi@sina.com wxd1221@sina.com.cn  
csf@gmail.com 1512345@qq.com

public class RegexDemo3 {
        
        public static void main(String[] args) {
            /**
             *需求2：找出规则，写出正则(String reg = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,8}(\\.[comnet]{2,3})+")，校验邮箱
              sunmeng@163.com   
              zhangsan@126.com  
              lisi@sina.cn   
              wxd1221@sina.com.cn
              csf@gmail.net
              1512345@qq.com
             */
            String email = "zhangsan@126.com";
            //写一个正则表达式验证这些个邮箱
            String reg = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,8}(\\.[comnet]{2,3})+";
            //依据正则表达式来验证上面的邮箱
            System.out.println(email.matches(reg));
        }
    
    }

10.4  
分割功能  
public String\[\] split(String regex):根据给定正则表达式的匹配拆分此字符串。  
需求1：  
分割如下字符串：  
String s = “aa,bb,cc”;  
String s2 = “aa.bb.cc”;  
String s3 = “aa bb cc”;  
String s4 = “aa bb cc”;  
String s5 = “D:\\baidu\\20150826\\day14”;

public class RegexDemo4 {
        public static void main(String[] args) {
            /**
             * public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。
             *    需求1：
                       分割如下字符串：
                       String s = "aa,bb,cc";
                       String s2 = "aa.bb.cc";
                       String s3 = "aa bb cc";
                       String s4 = "aa   bb                     cc";
                       String s5 = "D:\\baidu\\20160826\\day14";
             */
            // String s = "aa,bb,cc";
            //定以一个可以匹配到,的正则表达式
    /*      String reg = ",";
            String s = "aa,bb,cc";
            //使用split(String reg)切割字符串
            String[] strs = s.split(reg);
            for (int i = 0; i < strs.length; i++) {
                System.out.println(strs[i]);
            }*/
    
            System.out.println("----------------");
            /*String s2 = "aa.bb.cc";
            String reg = "\\.";
            String[] strs = s2.split(reg);
            for (int i = 0; i < strs.length; i++) {
                System.out.println(strs[i]);
            }*/
    
            System.out.println("----------------");
    /*      String s3 = "aa bb cc";
            String reg = " ";
            String[] strs = s3.split(reg);
            for (int i = 0; i < strs.length; i++) {
                System.out.println(strs[i]);
            }*/
    
            System.out.println("----------------");
    /*      String s4 = "aa    bb                     cc";
            String reg = " +";
            String[] strs = s4.split(reg);
            for (int i = 0; i < strs.length; i++) {
                System.out.println(strs[i]);
            }*/
            System.out.println("----------------");
            String s5 = "D:\\baidu\\20160826\\day14";
            String reg = "\\\\";
            String[] strs = s5.split(reg);
            for (int i = 0; i < strs.length; i++) {
                System.out.println(strs[i]);
            }
        }
    
    }

需求2：  
我有如下一个字符串:”91 27 46 38 50”  
请写代码实现最终输出结果是：”27 38 46 50 91”

public class RegexDemo5 {
        
        public static void main(String[] args) {
            /**
             *    需求2：
                   我有如下一个字符串:”91 27 46 38 50”
                   请写代码实现最终输出结果是：”27 38 46 50 91”
             */
            //切割字符串
            String s = "91 27 46 38 50";
            String reg = " ";
            String[] strs = s.split(reg);
    
            //遍历字符串数组，并定义一个int[]
            int[] arr = new int[strs.length];
            for (int i = 0; i < strs.length; i++) {
                arr[i] = Integer.parseInt(strs[i]);
            }
    
            //排序int[]
            Arrays.sort(arr);
    
            //遍历数组
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]+" ");
            }
    
            //将sb转换为String类型
            System.out.println(sb.toString());
    
        }
    
    }

10.5  
替换功能  
public String replaceAll(String regex,String replacement):把符合regex的用replacement替换  
需求：字符串中的数字使用\*代替

public class RegexDemo6 {
        
        public static void main(String[] args) {
            /**
             *   替换功能
                 public String replaceAll(String regex,String replacement):
                   把符合regex的用replacement替换
                   需求：字符串中的数字使用*代替
             */
            String s = "我的银行卡号是:6102344354565";
            String reg = "[0-9]";
            String newStr = s.replaceAll(reg, "*");
            System.out.println(newStr);
        }
    
    }