19 常用API

API

什么是API？

API (Application Programming Interface) ：应用程序编程接口

简单来说：就是Java帮我们已经写好的一些方法，我们直接拿过来用就可以了

1.2 如何使用API帮助文档【应用】

打开帮助文档

找到索引选项卡中的输入框
在输入框中输入Random
看类在哪个包下
看类的描述
看构造方法
看成员方法

2.常用API

2.1 Math（应用）

1、Math类概述
- Math 包含执行基本数字运算的方法
2、Math中方法的调用方式
- Math类中无构造方法，但内部的方法都是静态的，则可以通过 类名.进行调用

3、Math类的常用方法

方法名方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)	返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)	按照四舍五入返回最接近参数的int
public static int max(int a,int b)	返回两个int值中的较大值
public static int min(int a,int b)	返回两个int值中的较小值
public static double pow (double a,double b)	返回a的b次幂的值
public static double random()	返回值为double的正值，[0.0,1.0)

package com.itheima.demo1;

public class MathDemo {

    public static void main(String[] args) {

//        public static int abs(int a)		返回参数的绝对值

        int abs = Math.abs(-10);

        System.out.println(abs);

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

        double ceil = Math.ceil(10.1);

        System.out.println(ceil);

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

        double floor = Math.floor(10.9);

        System.out.println(floor);

//        public static int round(float a)	四舍五入

        long round = Math.round(10.1);

        System.out.println(round);

//

        long round1 = Math.round(1.9);

        System.out.println(round1);

//        public static int max(int a,int b)	返回两个int值中的较大值

//        int max = Math.max(10, 20);

//        System.out.println(max);

//        public static int min(int a,int b)	返回两个int值中的较小值

//        int min = Math.min(10, 20);

//        System.out.println(min);

//        public static double pow(double a,double b)返回a的b次幂的值

        double pow = Math.pow(2, 3);

        System.out.println(pow);

//        public static double random()		返回值为double的正值，[0.0,1.0)

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

            double random = Math.random();

            System.out.println(random);

        }

    }

}

2.2 System（应用）

　　不能被实例化

System类的常用方法

方法名	说明
public static void exit(int status)	终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)

arraycopy（数据源数组，起始索引，目的地数组，起始索引，拷贝个数）数组copy

示例代码

package com.itheima.demo1;

public class SystemDemo {

    public static void main(String[] args) {

//        public static void exit(int status)	终止当前运行的 Java 虚拟机，非零表示异常终止

//        System.out.println(111);

//        //while(true){}

//        System.exit(0);  //当代码执行到这个方法的时候,就表示虚拟机已经停止了

//        System.out.println(2222);

//        public static long currentTimeMillis()  返回当前时间(以毫秒为单位)

//        long start = System.currentTimeMillis();//获取当前时间

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

//        for (int i = 0; i < 10000; i++) {

//            System.out.println(i);

//        }

//        long end = System.currentTimeMillis();//获取当前时间

//        System.out.println(end - start);//472 --- 得到的就是这个for循环运行的时间.

//        arraycopy(数据源数组, 起始索引, 目的地数组, 起始索引, 拷贝个数)	数组copy

        int [] arr1 = {1,2,3,4,5};

        int [] arr2 = new int[10];

        //需求:我要把arr1中的数据拷贝到arr2中.

//        System.arraycopy(arr1,0,arr2,0,arr1.length);

//

//        for (int i = 0; i < arr2.length; i++) {

//            System.out.println(arr2[i]);

//        }

        //我要把arr1最后两个元素,拷贝到arr2的最后两个索引上

        System.arraycopy(arr1,3,arr2,8,2);

        for (int i = 0; i < arr2.length; i++) {

            System.out.println(arr2[i]);

        }

    }

}

2.3 Object类的toString方法（应用）

Object类概述
- Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份
- 构造方法：public Object()
- 回想面向对象中，为什么说子类的构造方法默认访问的时父类的无参构造方法？因为它们的顶级父类只有无参构造方法
查看方法源码的方式
- 选中方法，按下Ctrl + B
重写toString方法的方式
- 1. Alt + Insert 选择toString
- 1. 在类的空白区域，右键 -> Generate -> 选择toString
toString方法的作用：
- 以良好的格式，更方便的展示对象中的属性值
示例代码：

结论：Object类时所有类的直接或者间接父类

直接打印一个对象就是打印这个对象的toString方法的返回值

Object类的toString方法得到的时对象的地址值

我们一般会对toString方法进行重写

2.4 Object类的equals方法（应用）

equals方法的作用
- 比较对象是否相等，默认比较地址，重写可以比较内容，自动生成
- 举例：s1.equals(s2); s1和s2是两个对象
重写equals方法的场景
- 不希望比较对象的地址值，想要结合对象属性进行比较的时候。
重写equals方法的方式
- 1. alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
- 1. 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。

Student类

package com.itheima.demo2;

public class Student {

    private String name;

    private int age;

    public Student() {

    }

    public Student(String name, int age) {

        this.name = name;

        this.age = age;

    }

    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 String toString() {

        return "Student{" +

                "name='" + name + '\'' +

                ", age=" + age +

                '}';

    }

    @Override

    public boolean equals(Object o) {

        if (this == o) return true;

        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;

        return name != null ? name.equals(student.name) : student.name == null;

    }

}

Demo类

package com.itheima.demo2;

public class Demo {

    public static void main(String[] args) {

        Student student1=new Student("张三",23);

        Student student2=new Student("张三",23);

        System.out.println(student1==student2);//false

        //Object类中的equals方法,底层也是用==号比较地址值

        System.out.println(student1.equals(student2));

    }

}

面试题

package com.itheima.demo3;

public class Interview {

    public static void main(String[] args) {

        String s1 = "abc";

        StringBuilder sb = new StringBuilder("abc");

        //1.此时调用的是String类中的equals方法.

        //保证参数也是字符串,否则不会比较属性值而直接返回false

        System.out.println(s1.equals(sb));//false

        //StringBuilder类中是没有重写equals方法,用的就是Object类中的.

        System.out.println(sb.equals(s1));//false

    }

}

2.5 Objects (应用)

常用方法

方法名	说明
public static String toString(对象)	返回参数中对象的字符串表示形式。
public static String toString(对象, 默认字符串)	返回对象的字符串表示形式。
public static Boolean isNull(对象)	判断对象是否为空
public static Boolean nonNull(对象)	判断对象是否不为空

示例代码

学生类

package com.itheima.demo4;

public class Student {

    private String name;

    private int age;

    public Student() {

    }

    public Student(String name, int age) {

        this.name = name;

        this.age = age;

    }

    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 String toString() {

        return "Student{" +

                "name='" + name + '\'' +

                ", age=" + age +

                '}';

    }

    @Override

    public boolean equals(Object o) {

        if (this == o) return true;

        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;

        return name != null ? name.equals(student.name) : student.name == null;

    }

}

MyObjectsDemo类

package com.itheima.demo4;

import java.util.Objects;

public class MyObjectsDemo {

    public static void main(String[] args) {

        //        public static String toString(对象): 返回参数中对象的字符串表示形式。

//                Student s = new Student("小罗同学",50);

//                String result = Objects.toString(s);

//                System.out.println(result);

//                System.out.println(s);

                //public static String toString(对象, 默认字符串): 返回对象的字符串表示形式。如果对象为空,那么返回第二个参数.

                //Student s = new Student("小花同学",23);

//                Student s = null;

//                String result = Objects.toString(s, "随便写一个");

//                System.out.println(result);

        //        public static Boolean isNull(对象): 判断对象是否为空

                //Student s = null;

//                Student s = new Student();

//                boolean result = Objects.isNull(s);

//                System.out.println(result);

        //        public static Boolean nonNull(对象): 判断对象是否不为空

        //Student s = new Student();

        Student s = null;

        boolean result = Objects.nonNull(s);

        System.out.println(result);

    }

}

2.6 BigDecimal (应用)

作用

可以用来进行精确计算

构造方法

方法名说明

BigDecimal(double val) 参数为double

BigDecimal(String val) 参数为String

方法名	说明
BigDecimal(double val)	参数为double
BigDecimal(String val)	参数为String

常用方法

方法名	说明
public BigDecimal add(另一个BigDecimal对象)	加法
public BigDecimal subtract (另一个BigDecimal对象)	减法
public BigDecimal multiply (另一个BigDecimal对象)	乘法
public BigDecimal divide (另一个BigDecimal对象)	除法
public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式)	除法

总结

BigDecimal是用来进行精确计算的
创建BigDecimal的对象，构造方法使用参数类型为字符串的。

四则运算中的除法，如果除不尽请使用divide的三个参数的方法。

BigDecimal divide = bd1.divide(参与运算的对象,小数点后精确到多少位,舍入模式);

参数1 ，表示参与运算的BigDecimal 对象。

参数2 ，表示小数点后面精确到多少位

参数3 ，舍入模式

  BigDecimal.ROUND_UP  进一法

  BigDecimal.ROUND_FLOOR 去尾法

  BigDecimal.ROUND_HALF_UP 四舍五入

代码示例：

package com.itheima.demo;

import java.math.BigDecimal;

public class MyBigDecimalDemo3 {

    public static void main(String[] args) {

        //如果想要进行精确运算,那么请使用字符串的构造

//        BigDecimal bd1 = new BigDecimal(0.1);

//        BigDecimal bd2 = new BigDecimal(0.2);

            BigDecimal bd1 = new BigDecimal("0.1");

            BigDecimal bd2 = new BigDecimal("0.2");

//        public BigDecimal add(另一个BigDecimal对象) 	加法

            BigDecimal add = bd1.add(bd2);

            System.out.println("和为" + add);

            //System.out.println(0.1 + 0.2);

//        public BigDecimal subtract (另一个BigDecimal对象)  减法

            BigDecimal subtract = bd1.subtract(bd2);

            System.out.println("差为" + subtract);

//        public BigDecimal multiply (另一个BigDecimal对象)  乘法

            BigDecimal multiply = bd1.multiply(bd2);

            System.out.println("积为" + multiply);

//        public BigDecimal divide (另一个BigDecimal对象)    除法

            BigDecimal divide = bd1.divide(bd2);

            System.out.println("商为"+divide);

    }

}

3.包装类

3.1 基本类型包装类（记忆）

基本类型包装类的作用

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一：用于基本数据类型与字符串之间的转换
基本类型对应的包装类

基本数据类型包装类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

3.2 Integer类（应用）

Integer类概述

包装一个对象中的原始类型 int 的值

package com.ieheima.myinteger;

public class MyIntegerDemo1 {

    public static void main(String[] args) {

        //需求:我们判断一个整数是否在int范围内?

        //Integer

        System.out.println(Integer.MAX_VALUE);

        System.out.println(Integer.MIN_VALUE);

    }

}

Integer类构造方法

方法名	说明
public Integer(int value)	根据 int 值创建 Integer 对象(过时)
public Integer(String s)	根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)	返回一个保存指定值的 Integer 对象 String

示例代码

package com.ieheima.myinteger;

public class MyIntegerDemo2 {

    public static void main(String[] args) {

        /*

        public Integer(int   value)根据 int 值创建 Integer 对象(过时)

        public Integer(String s)根据 String 值创建 Integer 对象(过时)

        public static Integer valueOf(int i)返回表示指定的 int 值的 Integer实例

        public static Integer valueOf(String s)返回一个保存指定值的 Integer对象 String

        * */

        Integer i1=new Integer(100);

        Integer i2=new Integer("100");

        System.out.println(i1);

        System.out.println(i2);

        Integer i3 = Integer.valueOf(200);

        Integer i4 = Integer.valueOf("200");

        System.out.println(i3);

        System.out.println(i4);

    }

}

3.3 自动拆箱和自动装箱（理解）

自动装箱

把基本数据类型转换为对应的包装类类型
自动拆箱

把包装类类型转换为对应的基本数据类型
示例代码

package com.ieheima.myinteger;

public class MyIntegerDemo3 {

    public static void main(String[] args) {

        Integer i1=100;

        //     对象   = 默认是一个基本数据类型

        //jdk1.5的特性 --- 自动装箱

        //装箱:把一个基本的数据类型变成对应包装类

        //自动:Java底层会自动调用valueof()方法.

        System.out.println(i1);

        //jdk1.5的特性 --自动拆箱

        //拆箱:把一个包装类型 变成对应的基本数据类型

        int i2=i1;

        System.out.println(i2);

        Integer i3=100;//自动装箱机制

        i3+=200;//i3=i3+200;

                //会把i3这个对象变成基本数据类型100.

                //100+200=300

                ///把基本数据类型300再次自动装箱变成Integer对象赋值给i3

        System.out.println(i3);

        //细节:

        Integer i4=null;

        if (i4 != null) {

            i4+=200;

            System.out.println(i4);

        }

    }

}

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

　　　　　我们推荐的是，只要是对象，在使用前就必须进行部位null的判断

Integer的成员方法

static int parseInt(String s) 将字符串类型的整数变成int类型的整数

3.4 int和String类型的相互转换（记忆）

基本类型包装类的最常见操作就是：用于基本类型和字符串之间的相互转换

int转换为String
- 转换方式
  - 方式一：直接在数字后加双引号
  - 方式二：通过String类静态方法valueOf()：返回int参数的字符串表示形式，该方法是String类中的方法

　　String转换为int

转换方式
- 方式一：先将字符串数字转成Integer，再调用valueOf()方法
- 方式二：通过Integer静态方法parseInt()进行转换，将字符串解析为int类型，该方法是Integer类中的方法

package com.ieheima.myinteger;

public class MyIntegerDemo4 {

    public static void main(String[] args) {

        String s1="100";

        int i1=200;

        System.out.println(s1+i1);//100200----字符串+任意的数据类型 结果都是一个字符串

        int i2=Integer.parseInt(s1);//可以将字符串类型的整数变成int类型的整数

        System.out.println(i2+i1);

        //int ----->String

        //方式一:+""

        int i3=100;

        String s2=i3+"";

        System.out.println(s2+100);//100100

        //方式二:可以调用String类中的valueof方法

        String s3=String.valueOf(i3);

        System.out.println(s3+100);

    }

}

3.5 字符串数据排序案例（应用）

案例需求

有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：27 38 46 50 91
思路

　　　　1.定义一个字符串

　　　　2.把字符串中的数字数据存储到一个int类型的数组中

　　　　　　　两个难点：如何获取到里面的每一个值

　　　　　　　　　　　　如何把每一位变成int类型再存入数组

　　　　3.遍历数组输出结果

代码实现

package com.ieheima.myinteger;

public class MyIntegerDemo5 {

    //需求：有一个字符串：“91 27 46 38 50”，把其中的每一个数存到int类型的数组中

    //步骤:

    //定义一个字符串

    //把字符串中的数字数据存储到一个int类型的数组中

    //遍历数组输出结果

    public static void main(String[] args) {

        String s = "91 27 46 38 50";

        //获取字符中的每一个数字

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

        //创建一个int类型的数组

        int[] numberarr=new int[strArr.length];

        //把strArr中的数据进行类型转换并存入到数组中

        for (int i = 0; i < strArr.length; i++) {

            int number = Integer.parseInt(strArr[i]);

            numberarr[i]=number;

        }

        //遍历int类型的数组

        for (int i = 0; i < numberarr.length; i++) {

            System.out.println(numberarr[i]);

        }

    }

}

5.数组的高级操作

5.1 二分查找 (理解)

二分查找概述
数组元素一定要按照大小排列
查找指定元素在数组中的位置时,以前的方式是通过遍历,逐个获取每个元素,看是否是要查找的元素,这种方式当数组元素较多时,查找的效率很低

二分查找也叫折半查找,每次可以去掉一半的查找范围,从而提高查找的效率

需求

在数组{1,2,3,4,5,6,7,8,9,10}中,查找某个元素的位置
实现步骤
1. 定义两个变量，表示要查找的范围。默认min = 0 ，max = 最大索引
2. 循环查找，但是min <= max
3. 计算出mid的值
4. 判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
5. 如果要查找的值在mid的左半边，那么min值不变，max = mid -1.继续下次循环查找
6. 如果要查找的值在mid的右半边，那么max值不变，min = mid + 1.继续下次循环查找
7. 当min > max 时，表示要查找的元素在数组中不存在，返回-1.

package com.ieheima.arrsearch;

public class MyBinarySearchDemo {

    public static void main(String[] args) {

        int [] arr={1,2,3,4,5,6,7,8,9,10};

        int number=11;

        //1.我现在要干什么?--二分查找

        //2.我干这件事情需要什么? --数组  元素

        //3.我干完了要不要将结果返回调用者-- 把索引返回给调用者

        int index= binarySearchForIndex(arr,number);

        System.out.println(index);

    }

    private static int binarySearchForIndex(int[] arr, int number) {

        //1.定义查找的范围

        int min=0;

        int max=arr.length-1;

        //2.循环查找  min<=max

        while(min<=max){

            //3.计算出中间的位置

            int mid=(min+max)>>1; //右移一位 除以2

            //mid指向的元素>number

            if (arr[mid] >number) {

                //表示查找的元素在左边

                max=mid-1;

            }else if(arr[mid] <number){

                //mid指向的元素<number

                //表示要查找 的元素在右边

                min=mid+1;

            }else{

                return mid;

            }

            //mid指向的元素==number

        }

        //如果min大于了max就表示元素不存在,返回-1.

        return -1;

    }

}

5.2 冒泡排序 (理解)

排序：将一组数据按照固定的规则进行排列

冒泡排序概述

一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较小的数放在前面，较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序

如果有n个数据进行排序，总共需要比较n-1次

每一次比较完毕，下一次的比较就会少一个数据参与
代码实现

1.相邻的元素两两比较，大的放右边，小的放左边，找到最大值

2.第一次循环结束，最大值已经找到，在数组的最右边

3.下一次只要在剩余的元素找最大值就可以了

4.因为已经确定了5是最大值，所以4跟5无需在进行比较了

5.因为已经确定了5是最大值，4是次大值，所以3无需跟4和5再进行比较了　　

6.同理3，4，5的位置已经确定了，2也无须这三个值进行比较了

7.最后只剩下一个值1了，肯定放在最后一个格子中

代码实现:

package com.itheima.mybubble;

public class MyBubbleSortDemo2 {

    public static void main(String[] args) {

        int[] arr = {3, 5, 2, 1, 4};

        //1,2,3,4,5

        bubbleSort(arr);

    }

    public static void bubbleSort(int[] arr) {

        //外层循环控制次数,比数组的长度少一次,

        for (int i = 0; i < arr.length-1; i++) { //shift+f6

            //内层循环就是实际循环比较的

            //-1 是为了让数组不要越界

            //-i每一轮结束之后,我们就会少比一个数字

            for (int j = 0; j < arr.length - 1-i; j++) {

                if (arr[j] > arr[j + 1]) {

                    int temp = arr[j];

                    arr[j] = arr[j + 1];

                    arr[j + 1] = temp;

                }

            }

        }

        printArr(arr);

    }

    public static void printArr(int[] arr) {

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

            System.out.print(arr[i] + " ");

        }

        System.out.println();

    }

}

4.递归

4.1 递归【应用】

递归的介绍
- 以编程的角度来看，递归指的是方法定义中调用方法本身的现象
- 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
- 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算
递归的基本使用
递归的注意事项
- 递归一定要有出口。否则内存溢出递归规则：与原问题相似的规模较小的问题
- 递归虽然有出口，但是递归的次数也不宜过多。否则内存溢出
//1- 100之间的和

package com.itheima.myfactorial;

public class MyFactorialDemo2 {

    public static void main(String[] args) {

        int sum=getSum(100);

        System.out.println(sum);

    }

    private static int getSum(int i) {

        //1-100之间的和

            //100+(1-99之间的和)

                //99+(1-98之间的和)

                    //...

                        //1

        //方法的作用:求1-i之间的和

        if (i == 1) {

            return 1;

        }else{

            return i+getSum(i-1);

        }

    }

}

4.2 递归求阶乘【应用】

案例需求

用递归求5的阶乘，并把结果在控制台输出

分析：

　　1.阶乘：一个正整数的阶乘是所有小于及等于该数的正整数的积，自然数n的阶乘写作n！

　　　　5！=5*4*3*2*1

　　2.递归出口：1！=1

　　3.递归的规则：n！=n*(n-1)!　

　　　　5!=5*4!

package com.itheima.myfactorial;

public class MyFactorialDemo3 {

    public static void main(String[] args) {

       int result=getJc(20);

        System.out.println(result);

    }

    private static int getJc(int i) {

        //一定要找到出口.

        if (i==1){

            return 1;

        }else{

            //2.就是递归的规则

            return i*getJc(i-1);

        }

    }

}

内存图　　

5.3 快速排序 (理解)

快速排序概述

冒泡排序算法中,一次循环结束,就相当于确定了当前的最大值,也能确定最大值在数组中应存入的位置

快速排序算法中,每一次递归时以第一个数为基准数,找到数组中所有比基准数小的.再找到所有比基准数大的.小的全部放左边,大的全部放右边,确定基准数的正确位置
核心步骤
1. 从右开始找比基准数小的
2. 从左开始找比基准数大的
3. 交换两个值的位置
4. 红色继续往左找，蓝色继续往右找，直到两个箭头指向同一个索引为止
5. 基准数归位

基准数左边的，都比基准数小

基准数右边的，都比基准数大

相当于已经找到基准数应该在的位置　　

package com.itheima.myquitesort;

public class MyQuiteSortDemo2 {

    //        1，从右开始找比基准数小的

//        2，从左开始找比基准数大的

//        3，交换两个值的位置

//        4，红色继续往左找，蓝色继续往右找，直到两个箭头指向同一个索引为止

//        5，基准数归位

    public static void main(String[] args) {

        int[] arr={6,1,2,7,9,3,4,5,10,8};

        quiteSort(arr,0,arr.length-1);

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

            System.out.print(arr[i]+" ");

        }

    }

    private static void quiteSort(int[] arr, int left, int right) {

        if (right<left){

            return;

        }

        int left0=left;

        int right0=right;

        //计算基准数

        int baseNumber=arr[left0];

        while(left!=right){

            //1，从右开始找比基准数小的

            while(arr[right]>=baseNumber&&right>left){

                right--;

            }

//        2，从左开始找比基准数大的

            while(arr[left]<=baseNumber&&right>left){

                left++;

            }

//        3，交换两个值的位置

            int temp=arr[left];

            arr[left]=arr[right];

            arr[right]=temp;

        }

        //基准数归位

        int temp=arr[left];

        arr[left]=arr[left0];

        arr[left0]=temp;

        quiteSort(arr,left0,left-1);

        quiteSort(arr,left+1,right0);

    }

}

5.4 Arrays (应用)

Arrays的常用方法

方法名	说明
public static String toString(int[] a)	返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	按照数字顺序排列指定的数组
public static int binarySearch(int[] a, int key)	利用二分查找返回指定元素的索引

示例代码

package com.itheima.myarrays;

import java.util.ArrayList;

import java.util.Arrays;

public class MyArraysDemo {

    public static void main(String[] args) {

//        public static String toString(int[] a)    返回指定数组的内容的字符串表示形式

//        int [] arr = {3,2,4,6,7};

//        System.out.println(Arrays.toString(arr));

//        public static void sort(int[] a)	  按照数字顺序排列指定的数组

//        int [] arr = {3,2,4,6,7};

//        Arrays.sort(arr);

//        System.out.println(Arrays.toString(arr));

//        public static int binarySearch(int[] a, int key) 利用二分查找返回指定元素的索引

        int [] arr = {1,2,3,4,5,6,7,8,9,10};

        int index = Arrays.binarySearch(arr, 0);

        System.out.println(index);

        //1,数组必须有序

        //2.如果要查找的元素存在,那么返回的是这个元素实际的索引

        //3.如果要查找的元素不存在,那么返回的是 (-插入点-1)

        //插入点:如果这个元素在数组中,他应该在哪个索引上.

    }

}

4.Optional

4.1获取对象(应用)

Optional概述

可能包含或不包含非null值的容器对象

方法介绍

方法名	说明
static <T> Optional<T> of(T value)	获取一个Optional对象，封装的是非null值的对象
static <T> Optional<T> ofNullable(T value)	获取一个Optional对象，Optional封装的值对象可以是null也可以不是null

示例代码

package com.itheima.optionaldemo1;

import java.util.Optional;

public class OptionalDemo1 {
    public static void main(String[] args) {
        //method1();

        //static <T> Optional<T> ofNullable(T value)   获取一个Optional对象，Optional封装的值对象可以是null也可以不是null
        //Student s=new Student("张三",23);
        Student s=null;
        //ofNullable方法，封装的对象可以是null，也可以不是null
        Optional<Student> s1 = Optional.ofNullable(s);
        System.out.println(s1);
    }

    public static void method1() {
        //static <T> Optional<T> of(T value)   获取一个Optional对象，封装的是非null值的对象
        //Student s=new Student("张三",23);
        Student s=null;
        //Optional可以看做是一个容器。里面装了一个引用数据类型的对象。
        //返回值就是Optional的对象
        //如果使用的of方法，封装的对象如果为空，那么还是会抛出空指针异常
        Optional<Student> optional1=Optional.of(s);
        System.out.println(optional1);
    }
}

4.2常用方法(应用)

方法介绍

方法名说明

T get() 如果存在值,返回值,否则抛出NoSuchElementException

boolean isPresent() 如果存在值,则返回true,否则为false
示例代码

方法名	说明
T get()	如果存在值,返回值,否则抛出NoSuchElementException
boolean isPresent()	如果存在值,则返回true,否则为false

package com.itheima.optionaldemo1;

import java.util.Optional;

public class OptionalDemo2 {
    public static void main(String[] args) {
        //T get()  如果存在值,返回值,否则抛出NoSuchElementException
        //boolean isPresent()  判断Optional所封装的对象是否不为空,如果不为空则返回true,否则为false
        //Student s=new Student("张三",23);
        Student s=null;
        Optional<Student> optional = Optional.ofNullable(s);
        //如果封装的是一个null，那么通过get方法再次获取会抛出NoSuchElementException
        if (optional.isPresent()) {
            Student student = optional.get();
            System.out.println(student);
        }else{
            System.out.println("Optional的对象为空");
        }

    }
}

4.3处理空指针的方法(应用)

方法介绍

方法名	说明
T orElse(T other)	如果不为空,则返回具体的值,否则返回参数中的值
T orElseGet(Supplier<? extends T> supplier)	如果不为空,则返回具体的值,否则返回由括号中函数产生的结果
void ifPresent (Consumer<? super T> action)	如果不为空,则使用该值执行给定的操作,否则不执行任何操作
void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)	如果不为空,则使用该值执行给定的操作,否则执行给定的基于空的操作

示例代码

package com.itheima.optionaldemo1;

import java.util.Optional;

public class OptionalDemo3 {
    public static void main(String[] args) {
        //method1();
        //method2();

        //method3();
        method4();

    }

    public static void method4() {
        //ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)    如果不为空,则使用该值执行给定的操作,否则执行给定的基于空的操作
        //Student s=new Student("张三",23);
        Student s=null;
        Optional<Student> optional = Optional.ofNullable(s);
        optional.ifPresentOrElse(student -> System.out.println(student),
                ()-> System.out.println("为空了"));
    }

    public static void method3() {
        //ifPresent (Consumer<? super T> action)如果不为空,则使用该值执行给定的操作,否则不执行任何操作
        //Student s=new Student("张三",23);
        Student s=null;
        Optional<Student> optional = Optional.ofNullable(s);
        optional.ifPresent(student -> System.out.println(student));
    }

    public static void method2() {
        //Student s=new Student("张三",23);
        Student s=null;
        Optional<Student> optional = Optional.ofNullable(s);
        //orElseGet(Supplier<? extends T> supplier)    如果不为空,则返回具体的值,否则返回由括号中函数产生的结果
        Student student = optional.orElseGet(() -> new Student("李四", 24));
        System.out.println(student);
    }

    public static void method1() {
        //Student s=new Student("张三",23);
        Student s=null;
        Optional<Student> optional = Optional.ofNullable(s);
        //orElse(T other)  如果不为空,则返回具体的值,否则返回参数中的值
        Student student = optional.orElse(new Student("李四", 24));
        System.out.println(student);
    }
}

1.时间日期类

1.1 Date类（应用）

世界标准时间：格林尼治时间/格林威治时间(Greenwich Mean Time)简称GMT

　　　　　　　　　　　　　　原子钟

中国的标准时间：世界标准时间+8小时

计算机中时间原点

1970年1月1日 00:00:00
时间换算单位

1秒 = 1000毫秒 1毫秒=1000微秒 1微秒=1000纳秒
Date类概述

Date 代表了一个特定的时间，精确到毫秒

Date类构造方法

方法名	说明
public Date()	分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)	分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

示例代码

package com.itheima.mydate;

import java.io.DataInputStream;

import java.util.Date;

public class DateDemo1 {

    public static void main(String[] args) {

        //        public Date()		创建一个Date对象，表示默认时间

        //public Date(long date)	创建一个Date对象，表示指定时间

        //那么这个时间就表示电脑中的当前时间

        Date date1=new Date();

        System.out.println(date1);

        //计算机的时间原点开始，过了制定毫秒的那个时间

        Date date2=new Date(0L);

        System.out.println(date2);//Thu Jan 01 08:00:00 CST 1970

        //从时间原点开始，过了0毫秒

        //因为我们是在中国，我们是在东八区需要+8小时。

        Date date3=new Date(3600L*1000);

        System.out.println(date3);//Thu Jan 01 09:00:00 CST 1970

    }

}

Date date1=new Date();  ----把当前时间封装成一个Date对象

Date date2=new Date(0L);----把从时间原点开始，过了指定毫秒的时间，需要考虑时差问题

1.2 Date类常用方法（应用）

常用方法

方法名说明

public long getTime() 获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值

public void setTime(long time) 设置时间，给的是毫秒值
示例代码

方法名	说明
public long getTime()	获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time)	设置时间，给的是毫秒值

package com.itheima.mydate;

import javax.swing.plaf.basic.BasicInternalFrameTitlePane;

import java.awt.desktop.SystemSleepEvent;

import java.util.Date;

public class DateDemo2 {

    public static void main(String[] args) {

       //public long getTime()	获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值

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

        method1();

        Date date1=new Date();

        date1.setTime(0l);

        System.out.println(date1);

    }

    public static void method1() {

        //把当前时间封装成一个date对象

        Date date1=new Date();

        //获取这个date对象的毫秒值 ---获取当前时间的毫秒值

        long time = date1.getTime();

        System.out.println(time);

        long l = System.currentTimeMillis();

        System.out.println(l);

    }

}

1.3 SimpleDateFormat类（应用）

SimpleDateFormat类概述
SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。

我们重点学习日期格式化和解析
y 年 M 月 d 日 H 时 m 分 s 秒
2020-11-11 13：27：06
yyyy-MM-dd HH:mm:ss
2020年11月11日 13：27：06
yyyy年MM月dd日 HH:mm:ss

SimpleDateFormat类构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

SimpleDateFormat类的常用方法
- 格式化(从Date到String)
  - public final String format(Date date)：将日期格式化成日期/时间字符串
- 解析(从String到Date)
  - public Date parse(String source)：从给定字符串的开始解析文本以生成日期需要对时间进行计算
示例代码

package com.itheima.mydate;

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateDemo3 {

    public static void main(String[] args) {

       Date date=new Date();

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

        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日");

        String result1 = sdf.format(date);

        System.out.println(result1);

    }

}

package com.itheima.mydate;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateDemo4 {

    public static void main(String[] args) throws ParseException {

        String s="2048-01-01";

        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

        Date date = sdf.parse(s);

        System.out.println(date);

    }

}

1.4 时间日期类练习 (应用)

需求

秒杀开始时间是2020年11月11日 00:00:00,结束时间是2020年11月11日 00:10:00,用户小贾下单时间是2020年11月11日 00:03:47,用户小皮下单时间是2020年11月11日 00:10:11,判断用户有没有成功参与秒杀活动
实现步骤
1. 判断下单时间是否在开始到结束的范围内
2. 把字符串形式的时间变成毫秒值
代码实现

package com.itheima.mydate;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateDemo5 {

    public static void main(String[] args) throws ParseException {

        //开始时间：2020年11月11日 0:0:0

        //结束时间：2020年11月11日 0:10:0

        //小贾2020年11月11日 0:03:47

        //小皮2020年11月11日 0:10:11

        //1.判断两位同学的下单时间是否在范围之内就可以了。

        //2.要把每一个时间都换算成毫秒值。

        String start="2020年11月11日 0:0:0";

        String end="2020年11月11日 0:10:0";

        String jia="2020年11月11日 0:03:47";

        String pi="2020年11月11日 0:10:11";

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

        long startTime = sdf.parse(start).getTime();

        long endtime = sdf.parse(end).getTime();

        long jiatime = sdf.parse(jia).getTime();

        long pitime = sdf.parse(pi).getTime();

        if(jiatime>=startTime&&jiatime<=endtime){

            System.out.println("小甲同学参加上了秒杀活动");

        }else{

            System.out.println("小甲同学没有参加上秒杀活动");

        }

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

        if(pitime>=startTime&&pitime<=endtime){

            System.out.println("小皮同学参加上了秒杀活动");

        }else{

            System.out.println("小皮同学没有参加上秒杀活动");

        }

    }

}

2.JDK8时间日期类

2.1 JDK8新增日期类 (理解)

LocalDate 表示日期（年月日）
LocalTime 表示时间（时分秒）
LocalDateTime 表示时间+ 日期（年月日时分秒）

2.2 LocalDateTime创建方法 (应用)

方法说明

方法名	说明
public static LocalDateTime now()	获取当前系统时间
public static LocalDateTime of (年, 月 , 日, 时, 分, 秒)	使用指定年月日和时分秒初始化一个LocalDateTime对象

package com.itheima.jdk8date;

import java.time.LocalDateTime;

public class JDK8DateDemo2 {

    public static void main(String[] args) {

        LocalDateTime now = LocalDateTime.now();

        System.out.println(now);

        LocalDateTime of = LocalDateTime.of(2020, 11, 11, 11, 11, 11);

        System.out.println(of);

    }

}

定义一个时间，String start=“2020年11月11日 00:00:00”　;

将这个时间+1天，再按照原来的格式进行输出

package com.itheima.jdk8date;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.Date;

public class JDK8DateDemo1 {

    public static void main(String[] args) throws ParseException {

        //JDKMethod();

        String s="2020年11月11日 00:00:00";

        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        LocalDateTime localDateTime = LocalDateTime.parse(s, pattern);

        LocalDateTime newlocalDateTime = localDateTime.plusDays(1);

        String result = newlocalDateTime.format(pattern);

        System.out.println(result);

    }

    public static void JDKMethod() throws ParseException {

        String s="2020年11月11日 00:00:00";

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

        Date date = sdf.parse(s);

        long time = date.getTime();

        time=time+(1000*60*60*24);

        Date newDate=new Date(time);

        String result = sdf.format(newDate);

        System.out.println(result);

    }

}

2.3 LocalDateTime获取方法 (应用)

方法说明

方法名	说明
public int getYear()	获取年
public int getMonthValue()	获取月份（1-12）
public int getDayOfMonth()	获取月份中的第几天（1-31）
public int getDayOfYear()	获取一年中的第几天（1-366）
public DayOfWeek getDayOfWeek()	获取星期
public int getMinute()	获取分钟
public int getHour()	获取小时

示例代码

package com.itheima.jdk8date;

import java.time.DayOfWeek;

import java.time.LocalDateTime;

import java.time.Month;

public class JDK8DateDemo3 {

    public static void main(String[] args) {

        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 11, 11, 20);

        //public int getYear()           获取年

        int year = localDateTime.getYear();

        System.out.println("年为" +year);

        //public int getMonthValue()     获取月份（1-12）

        int month = localDateTime.getMonthValue();

        System.out.println("月份为" + month);

        //       Month month1 = localDateTime.getMonth();

//        System.out.println(month1);

        //public int getDayOfMonth()     获取月份中的第几天（1-31）

        int day = localDateTime.getDayOfMonth();

        System.out.println("日期为" + day);

        //public int getDayOfYear()      获取一年中的第几天（1-366）

        int dayOfYear = localDateTime.getDayOfYear();

        System.out.println("这是一年中的第" + dayOfYear + "天");

        //public DayOfWeek getDayOfWeek()获取星期

        DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();

        System.out.println("星期为" + dayOfWeek);

        //public int getMinute()        获取分钟

        int minute = localDateTime.getMinute();

        System.out.println("分钟为" + minute);

        //public int getHour()           获取小时

        int hour = localDateTime.getHour();

        System.out.println("小时为" + hour);

    }

}

2.4 LocalDateTime转换方法 (应用)

方法说明

方法名说明

public LocalDate toLocalDate () 转换成为一个LocalDate对象

public LocalTime toLocalTime () 转换成为一个LocalTime对象
示例代码

方法名	说明
public LocalDate toLocalDate ()	转换成为一个LocalDate对象
public LocalTime toLocalTime ()	转换成为一个LocalTime对象

package com.itheima.jdk8date;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

public class JDK8DateDemo4 {

    public static void main(String[] args) {

        LocalDateTime localDateTime = LocalDateTime.of(2020, 12, 12, 8, 10, 12);

        //public LocalDate toLocalDate ()	转换成为一个LocalDate对象

        //public LocalTime toLocalTime ()	转换成为一个LocalTime对象

        //2020-12-12

        LocalDate localDate = localDateTime.toLocalDate();

        System.out.println(localDate);

        //08:10:12

        LocalTime localTime = localDateTime.toLocalTime();

        System.out.println(localTime);

    }

}

2.5 LocalDateTime格式化和解析 (应用)

方法说明

方法名	说明
public String format (指定格式)	把一个LocalDateTime格式化成为一个字符串
public LocalDateTime parse (准备解析的字符串, 解析格式)	把一个日期字符串解析成为一个LocalDateTime对象
public static DateTimeFormatter ofPattern(String pattern)	使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象

示例代码

package com.itheima.jdk8date;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

public class JDK8DateDemo5 {

    public static void main(String[] args) {

        method1();

        method2();

    }

    private static void method2() {

        //解析

        //public static LocalDateTime parse (准备解析的字符串, 解析格式) 把一个日期字符串解析成为一个LocalDateTime对象

        String s = "2020年11月12日 13:14:15";

        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        LocalDateTime parse = LocalDateTime.parse(s, pattern);

        System.out.println(parse);

    }

    //格式化

    private static void method1() {

        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 12, 13, 14, 15);

        System.out.println(localDateTime);

        //public String format (指定格式)   把一个LocalDateTime格式化成为一个字符串

        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        String s = localDateTime.format(pattern);

        System.out.println(s);

    }

}

2.6 LocalDateTime增加或者减少时间的方法 (应用)

方法说明

方法名	说明
public LocalDateTime plusYears (long years)	添加或者减去年
public LocalDateTime plusMonths(long months)	添加或者减去月
public LocalDateTime plusDays(long days)	添加或者减去日
public LocalDateTime plusHours(long hours)	添加或者减去时
public LocalDateTime plusMinutes(long minutes)	添加或者减去分
public LocalDateTime plusSeconds(long seconds)	添加或者减去秒
public LocalDateTime plusWeeks(long weeks)	添加或者减去周

示例代码

package com.itheima.jdk8date;

import java.time.LocalDateTime;

public class JDK8DateDemo6 {

    public static void main(String[] args) {

        //public LocalDateTime plusYears (long years)	添加或者减去年

        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);

        LocalDateTime newlocalDateTime = localDateTime.plusYears(1);

        int year = newlocalDateTime.getYear();

        System.out.println(year);

    }

}

方法会返回一个新的LocalDateTime对象，返回值就是修改后的结果。

参数为正，就是往后加

参数为负，就是往前减

2.7 LocalDateTime减少或者增加时间的方法 (应用)

方法说明

方法名	说明
public LocalDateTime minusYears (long years)	减去或者添加年
public LocalDateTime minusMonths(long months)	减去或者添加月
public LocalDateTime minusDays(long days)	减去或者添加日
public LocalDateTime minusHours(long hours)	减去或者添加时
public LocalDateTime minusMinutes(long minutes)	减去或者添加分
public LocalDateTime minusSeconds(long seconds)	减去或者添加秒
public LocalDateTime minusWeeks(long weeks)	减去或者添加周

示例代码

参数为正，就是往前减

参数为负，就是往后加

package com.itheima.jdk8date;

import java.time.LocalDateTime;

public class JDK8DateDemo7 {

    public static void main(String[] args) {

        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);

//        LocalDateTime newlocalDateTime = localDateTime.minusYears(1);

//        System.out.println(newlocalDateTime);

        LocalDateTime newlocalDateTime = localDateTime.minusYears(-1);

        System.out.println(newlocalDateTime);

    }

}

2.8 LocalDateTime修改方法 (应用)

方法说明

方法名	说明
public LocalDateTime withYear(int year)	直接修改年
public LocalDateTime withMonth(int month)	直接修改月
public LocalDateTime withDayOfMonth(int dayofmonth)	直接修改日期(一个月中的第几天)
public LocalDateTime withDayOfYear(int dayOfYear)	直接修改日期(一年中的第几天)
public LocalDateTime withHour(int hour)	直接修改小时
public LocalDateTime withMinute(int minute)	直接修改分钟
public LocalDateTime withSecond(int second)	直接修改秒

示例代码

package com.itheima.jdk8date;

import java.time.LocalDateTime;

public class JDK8DateDemo8 {

    public static void main(String[] args) {

        //public LocalDateTime withYear(int year)直接修改年

        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 11, 12, 13);

        //LocalDateTime newlocalDateTime = localDateTime.withYear(2022);

        //System.out.println(newlocalDateTime);

    }

}

2.9 Period (应用)

方法说明

方法名	说明
public static Period between(开始时间,结束时间)	计算两个“时间"的间隔
public int getYears()	获得这段时间的年数
public int getMonths()	获得此期间的总月数
public int getDays()	获得此期间的天数
public long toTotalMonths()	获取此期间的总月数

示例代码

package com.itheima.jdk8date;

import java.time.LocalDate;

import java.time.Period;

public class JDK8DateDemo9 {

    public static void main(String[] args) {

//        public static Period between(开始时间,结束时间)计算两个“时间"的间隔

        LocalDate localDate1 = LocalDate.of(2020, 1, 1);

        LocalDate localDate2 = LocalDate.of(2048, 12, 12);

        Period period = Period.between(localDate1, localDate2);

        System.out.println(period);

//        public int getYears()获得这段时间的年数

        System.out.println(period.getYears());//28

//        public int getMonths()获得此期间的总月数

        System.out.println(period.getMonths());//11

//        public int getDays()获得此期间的天数

        System.out.println(period.getDays());//11

//        public long toTotalMonths()获取此期间的总月数

        System.out.println(period.toTotalMonths());//347

    }

}

2.10 Duration (应用)

方法说明

方法名	说明
public static Durationbetween(开始时间,结束时间)	计算两个“时间"的间隔
public long toSeconds()	获得此时间间隔的秒
public int toMillis()	获得此时间间隔的毫秒
public int toNanos()	获得此时间间隔的纳秒

示例代码

package com.itheima.jdk8date;

import java.time.Duration;

import java.time.LocalDate;

import java.time.LocalDateTime;

public class JDK8DateDemo10 {

    public static void main(String[] args) {

        //public static Durationbetween(开始时间,结束时间)计算两个“时间"的间隔

        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 1, 1, 13, 14, 15);

        LocalDateTime localDateTime2 = LocalDateTime.of(2020, 1, 2, 11, 12, 13);

        Duration duration = Duration.between(localDateTime1, localDateTime2);

        System.out.println(duration);

        // public long toSeconds()获得此时间间隔的秒

        System.out.println(duration.toSeconds());//79078

        // public int toMillis()获得此时间间隔的毫秒

        System.out.println(duration.toMillis());//79078000

        // public int toNanos()获得此时间间隔的纳秒

        System.out.println(duration.toNanos());//79078000000000

    }

}

JDK8实践小结

LocalDate　　表示日期（年月日）

LocalTime　　表示时间（时分秒）

LocalDateTime　　表示时间+日期（年月日时分秒）----》toLocalDate（）可转为LocalDate类型或者toLocalTime（）可转为LocalTime类类型　

创建事件对象（now，of） now 获取当前系统时间 of获取指定时间

获取时间对象中的年，月，日，时，分，秒

格式化（format）

解析（parse）

增加或者减少时间的方法（plus开头，minus开头）

修改时间的方法with开头

计算时间间隔的类

Period

Duration

------------恢复内容结束------------

19 常用API的更多相关文章

Java map 详解 - 用法、遍历、排序、常用API等
尊重原创: http://www.cnblogs.com/lzq198754/p/5780165.html 概要: java.util 中的集合类包含 Java 中某些最常用的类.最常用的集合类是 L ...
java常用API的总结(1)
本篇是对于这一段时间以来接触到的常用api的一些总结,便于以后的查阅.... 一.正则表达式对于正则表达式,我的感觉就是当我们在做某些题的时候正则表达式会省去我们很多的时间,并且正则表达式的使用格式 ...
jedis常用API
一.Redis Client介绍 1.1.简介 Jedis Client是Redis官网推荐的一个面向java客户端,库文件实现了对各类API进行封装调用. Jedis源码工程地址:https://g ...
人工智能常用 API
人工智能常用 API 转载 2016年07月13日 19:17:27 2047 机器学习与预测 1.AlchemyAPI 在把数据由非结构化向结构化的转化中运用得较多.用于社交媒体监控.商业智能. ...
Robotframework-Appium 之常用API（一）
上一遍隨筆(https://www.cnblogs.com/cnkemi/p/9639809.html)用Python + Robotframework + Appium對Android app小試牛 ...
16常用API
常用API 今日内容介绍 u 正则表达式 u Date u DateFormat u Calendar 第1章正则表达式 1.1 正则表达式的概念正则表达式(英语:Regular Expressi ...
django QuerySet 的常用API
为了加深对queryset对象api的了解,我们建立了以下示例模型: from django.db import models class Author(models.Model): "&q ...
JAVA基础学习-集合三-Map、HashMap,TreeMap与常用API
森林森一份耕耘,一份收获博客园首页新随笔联系管理订阅随笔- 397 文章- 0 评论- 78 JAVA基础学习day16--集合三-Map.HashMap,TreeMap与常用A ...
常用API（正则表达式、Date、DateFormat、Calendar）
常用API 今日内容介绍 u 正则表达式 u Date u DateFormat u Calendar 第1章正则表达式 1.1 正则表达式的概念正则表达式(英语:Regular Expressi ...

随机推荐

Android Studio 之在活动中使用 Toast
•简介 Toast 是 Android 系统提供的一种非常好的提醒方式: 在程序中可以使用它将一些短小的信息通知给用户: 这些信息会在一段时间内自动消失,并且不会占用任何屏幕空间 •Toast.mak ...
计算机体系结构——CH4 输入输出系统
计算机体系结构--CH4 输入输出系统右键点击查看图像,查看清晰图像 X-mind 计算机体系结构--CH4 输入输出系统输入输出原理特点实时性与设备无关性异步性输入输出系统的组织方式 ...
Golang 基于Prometheus Node_Exporter 开发自定义脚本监控
Golang 基于Prometheus Node_Exporter 开发自定义脚本监控公司是今年决定将一些传统应用从虚拟机上迁移到Kubernetes上的,项目多而乱,所以迁移工作进展缓慢,为了建立 ...
[Fundamental of Power Electronics]-PART II-7. 交流等效电路建模-7.5 状态空间平均 7.6 本章小结
7.5 状态空间平均现有文献中已经出现了很多变换器交流建模的方法,其中包括电流注入法,电路平均和状态空间平均法.尽管某种特定方法的支持者可能更愿意使用该方法去建模,但所有方法的最终结果都是等效的.并 ...
【软件推荐】使用Cmder替换Windows自带的控制台
安装地址进入cmder官网,下载相应版本. 如果本地已经安装了git,可以选择mini版本. 将 λ 替换为 $ 当前cmder默认的提示符是λ,看上去总是有点不习惯. 打开cmder目录下的ven ...
Dynamics CRM使用JS隐藏自定义按钮
在我们平时客制化开发的时候会经常遇到要制作自定义按钮的情况,而这个自定义按钮的功能又经常会有一些隐藏逻辑需要实现,所以每次通过获取控件查找这个按钮再隐藏比较麻烦,而且偶尔会出现代码没起作用的效果.下面 ...
MySQL实战45讲,丁奇带你搞懂
之前,你大概都是通过搜索别人的经验来解决问题.如果能够理解MySQL的工作原理,那么在遇到问题的时候,是不是就能更快地直戳问题的本质? 以实战中的常见问题为切入点,带你剖析现象背后的本质原因.为你串起 ...
ElasticSearch-02-elasticsearch.yaml
# ======================== Elasticsearch Configuration ========================= # # NOTE: Elasticse ...
Digit Counting UVA - 1225
Trung is bored with his mathematics homeworks. He takes a piece of chalk and starts writing a sequ ...
k8s新手必看
转载自https://juejin.im/post/6844903840139968520 Kubernetes零基础快速入门!初学者必看! 起源 Kubernetes 源自于 google 内部的服 ...

19 常用API

1.2 如何使用API帮助文档【应用】

2.常用API

2.1 Math（应用）

2.2 System（应用）

2.3 Object类的toString方法（应用）

2.4 Object类的equals方法（应用）

2.5 Objects (应用)

2.6 BigDecimal (应用)

3.包装类

3.1 基本类型包装类（记忆）

3.2 Integer类（应用）

3.3 自动拆箱和自动装箱（理解）

3.4 int和String类型的相互转换（记忆）

3.5 字符串数据排序案例（应用）

5.数组的高级操作

5.1 二分查找 (理解)

5.2 冒泡排序 (理解)

4.递归

4.1 递归【应用】

4.2 递归求阶乘【应用】

5.3 快速排序 (理解)

5.4 Arrays (应用)

4.Optional

4.1获取对象(应用)

4.2常用方法(应用)

4.3处理空指针的方法(应用)

1.时间日期类

1.1 Date类（应用）

1.2 Date类常用方法（应用）

1.3 SimpleDateFormat类（应用）

1.4 时间日期类练习 (应用)

2.JDK8时间日期类

2.1 JDK8新增日期类 (理解)

2.2 LocalDateTime创建方法 (应用)

2.3 LocalDateTime获取方法 (应用)

2.4 LocalDateTime转换方法 (应用)

2.5 LocalDateTime格式化和解析 (应用)

2.6 LocalDateTime增加或者减少时间的方法 (应用)

2.7 LocalDateTime减少或者增加时间的方法 (应用)

2.8 LocalDateTime修改方法 (应用)

2.9 Period (应用)

2.10 Duration (应用)

19 常用API的更多相关文章

随机推荐

热门专题