4---常用API(Date,Calendar等)+包装类+自定义泛型+collection接口

最新推荐文章于 2024-03-22 00:01:24 发布

Chosen_ONE026

最新推荐文章于 2024-03-22 00:01:24 发布

阅读量156

点赞数

本文链接：https://blog.csdn.net/weixin_45391505/article/details/96288921

版权

1、Date类

1、概念：

java.util.Date 类表示特定的瞬间，精确到毫秒

2、Date类构造方法:

（1）public Date()创建一个Date对象并初始化，初始化的时间为执行这个代码的时间(当前时间，精确到毫秒)
（2）public Date(long date) 创建一个Date对象并初始化,以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT，unix系统初次定义）以来的指定毫秒数。

Ps：GMT是世界协调时间（格林尼治时间）

3、Date类普通方法

（1）public long getTime() 返回自1970年1月1日以来，由 Date对象表示的00:00:00 GMT的毫秒数。
（2）public void setTime(long time) 修改Date对象的时间,设置为1970年1月1日00:00:00 的基础上加上参数指定毫秒数

public class Demo01 {
    public static void main(String[] args) {
        // Date() 创建一个Date对象时间为执行这个代码的时间
        Date now = new Date();
        System.out.println("now = " + now); // Tue Jul 16 09:22:24 CST 2019

        // Date(long date) 创建一个Date对象,时间为1970年1月1日00:00:00 的基础上加上参数指定毫秒数
        Date d2 = new Date(1000);
        System.out.println("d2 = " + d2); // d2 = Thu Jan 01 08:00:01 CST 1970

        // long getTime() 返回 Date对象表示的时间与1970年的起始时间的 毫秒值
        long time = now.getTime();
        System.out.println("time = " + time); // time = 1563240492757

        // void setTime(long time) 【修改】Date对象的时间,设置为1970年1月1日00:00:00 的基础上加上参数指定毫秒数
                                    //区别于Date(long date)构造方法，
        now.setTime(2000);
        System.out.println("now = " + now);
    }
}

2、DateFormat

1、该类的作用（有了Date类，为什么还要DateFormat类？）

Date主要表示1970年到某个时间的毫秒值,如果输出给用户看,用户是看不太懂的；同时这种特定格式的事件表示："Thu Oct 25 21:41:33 CST 2018"人们也不习惯。用户实际上比较喜欢类似"2018年10月25日 21时41分33秒"这样的格式。

DateFormat类的作用：

1、将Date类型的日期【格式化】为文本类的易看得懂得时间字符串日期。

2、将文本类的易看得懂得时间字符串日期【解析】为Date类型的日期

字段摘要：

年：y；月：M；日：d；时：H；分：m；秒：s；

public class Demo02 {
    public static void main(String[] args) throws ParseException {
        // 需求:将 当前时间的Date对象 转成 "2018年9月15日 19时18分19秒"
        // 格式化:将日期转成文本

        // 1.创建当前时间的Date对象
        Date now = new Date();
        // 2.创建SimpleDateFormat对象

        //SimpleDateFormat默认格式
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        String str1 = sdf1.format(now);
        System.out.println(str1);//2019/7/16 下午6:43

        //自定义SimpleDateFormat格式
        // 2.1明确目标格式: "2018年9月15日 19时18分19秒"
        // 2.2 指定时间的格式
        //      不会变化的东西不管
        //      会变化的东西使用特殊的字母来代替 "yyyy年MM月dd日 HH时mm分ss秒"


        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        // 3.调用格式化的方法将日期转成文本: String format(Date date) 将日期格式化成时间字符串。
        String str2 = sdf2.format(now);
        System.out.println("str = " + str2); // str = 2019/7/16 上午9:41
        // str = 2019年07月16日 09时48分33秒

        System.out.println("---------------");
        // 6.需求:将字符串 "2007-12-26 10:13:31" 转成 Date对象
        // 解析:将文本转成日期
        // 1.定义一个时间字符串
        String time = "2007-12-26 10:13:31";
        // 2.创建SimpleDateFormat对象
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 3.调用解析的方法将文本转成日期: Date parse(String source)
        Date date = sdf3.parse(time); // 未处理的异常: alt + 回车 -> 选择第一项
        System.out.println("date = " + date);
    }
}

3、calendar类

1、该类的作用（有了Date类，为什么还要calendar类？）

Date主要是表示1970的毫秒值,Date类对单独获取年,月,日,时,分,秒,昨天,明天,上个星期,加上或减去一些时间不好处理；

主要作用：获取时间和修改时间，其比Date类在该功能上更方便

2、如何创建Calendar对象

（Calendar是一个抽象类，不能直接创建对象；通过静态方法Calendar getInstance();来获得Calendar对象）

格式：Calendar rightNow = Calendar.getInstance();

3、Calendar类常用方法

int get(int field) 返回给定日历字段的值。
void set(int field, int value) 将给定的日历字段设置为给定的值。
void add(int field, int amount) 根据日历的规则，在Calendar表示的时间基础上增减或减去指定的时间

4、Calendar注意事项

（1）MONTH是从0开始:6表示7月

（2）日历字段（field）查阅api文档

public class Demo03 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        System.out.println("calendar = " + calendar);

        // int get(int field) 返回给定日历字段的值。
        int year = calendar.get(Calendar.YEAR);
        System.out.println("year = " + year);//快捷键：soutv
        int month = calendar.get(Calendar.MONTH);
        System.out.println("month = " + month);//快捷键：soutv
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("day = " + day);//快捷键：soutv
        int hour = calendar.get(Calendar.HOUR);
        System.out.println("hour = " + hour);//快捷键：soutv
        int minute = calendar.get(Calendar.MINUTE);
        System.out.println("minute = " + minute);//快捷键：soutv
        int second = calendar.get(Calendar.SECOND);
        System.out.println("second = " + second);//快捷键：soutv

        // void set(int field, int value) 将给定的日历字段设置为给定的值。
        // int field: 时间单位
        // int value: 新的值
        // calendar.set(Calendar.YEAR, 2088);
        // calendar.set(Calendar.MONTH, 1);
        // System.out.println("修改后的calendar = " + calendar);
        calendar.set(2011, 7, 8);
        System.out.println("set calendar = " + calendar);

        // void add(int field, int amount) 根据日历的规则，在Calendar表示的时间基础上增减或减去指定的时间
        // int field: 时间单位
        // int amount: 添加或减去的时间, 正数表示添加,负数表示减去
        // calendar.add(Calendar.YEAR, -10);
        calendar.add(Calendar.DAY_OF_MONTH, 1000);
        System.out.println("calendar = " + calendar);

关于日期类地练习：

/*
需求:计算你出生了多少天?

分析:
    活着的时间的毫秒值 = 现在的日期毫秒值 - 出生的日期毫秒值
    活着的时间的毫秒值转成天

实现步骤:
    1.创建当前时间的Date对象.
    2.定义一个出生日期的字符串"1999-09-09"
    3.出生日期的字符串转成Date对象
    4.活着的时间的毫秒值 = 现在的日期毫秒值 - 出生的日期毫秒值
    5.活着的时间的毫秒值转成天
 */
public class Demo04 {
    public static void main(String[] args) throws ParseException {
        // 1.创建当前时间的Date对象.
        Date now = new Date();
        // 2.定义一个出生日期的字符串"1999-09-09"
        String birthdayStr = "1996年04月23日";
        // 3.出生日期的字符串转成Date对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse(birthdayStr);
        // 4.活着的时间的毫秒值 = 现在的日期毫秒值 - 出生的日期毫秒值
        long liveTime = now.getTime() - date.getTime();

        // 5.活着的时间的毫秒值转成天
        long day = liveTime / 1000 / 60 / 60 / 24;
        System.out.println("活了 " + day + "天");
    }
}

4、System类

1、概况：

System类没有看到构造方法,【不能够创建对象】,他里面的【方法全部是由static修饰】的（急要通过类名调用）

2、System类普通方法:

（1）static void exit(int status) 终止当前运行的Java虚拟机。（参数一般是0）
（2）static long currentTimeMillis() 返回当前时间（以毫秒为单位）。
（3）static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将指定源数组中的数组从指定位置复制到目标数组的指定位置。

注解：

Object src: 源数组(被复制的数组)
int srcPos: 从源素组的哪个位置开始复制
Object dest: 目标数组
int destPos: 复制的元素放在目标数组的哪个位置开始
int length: 复制元素的个数

5、BigDecimal类

1、概述：

在 java.math包中，一般解决数学类问题

2、构造方法:

BigDecimal(String val)

3、普通方法:

BigDecimal add(BigDecimal augend) 添加
BigDecimal subtract(BigDecimal subtrahend) 减法
BigDecimal multiply(BigDecimal multiplicand) 乘法
BigDecimal divide(BigDecimal divisor) 除法

4、BigDecimal类地作用：

用于数学计算，且计算结果不会丢失数据，精度有保障。

public class Demo06 {
    public static void main(String[] args) {
        // 小数在计算机里面不是精确的数据,是近似值.有误差
        // double d = 0.82 + 0.08; // 0.9
        // System.out.println("d = " + d); // d = 0.8999999999999999   

        // 创建BigDecimal
        BigDecimal b1 = new BigDecimal("0.82");//参数是字符串类型
        BigDecimal b2 = new BigDecimal("0.08");//参数是字符串类型

        // BigDecimal add(BigDecimal augend) 添加
        System.out.println(b1.add(b2));
        // BigDecimal subtract(BigDecimal subtrahend) 减法
        System.out.println(b1.subtract(b2));
        // BigDecimal multiply(BigDecimal multiplicand) 乘法
        System.out.println(b1.multiply(b2));
        // BigDecimal divide(BigDecimal divisor) 除法
        System.out.println(b1.divide(b2));

6、包装类

1、概述

我们之前学过基本数据类型有8种.基本数据类型效率高,但是功能极其有限,只能做加减乘除运算.
为了对基本数据类型进行更多的操作,Java为每种基本数据类型提供了对应的类(包装类)

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

规律:首字母大写,特殊的两个: int -> Integer, char -> Character

2、包装类地作用：

包装类中会提供很多方法给我们使用

3、包装类应用：

1.我们知道，将int类型转换为String很简单：
5 -> “5”
添加 ""即可
String s1 = 5 + “”;

那么如何如何将String转换成int类型?

	 解决：`int x = Integer.parseInt("55");`

public class Demo071 {
    public static void main(String[] args) {
        // 数字的5 -> 字符串的"5"
        String s1 = 5 + ""; // "5"

        // 字符串的"5" -> 数字的5
        // int x = Integer.parseInt("5hehe"); // 注意:必须保证字符串中能转成数字，否则报错，出现：ClassCastException错误
        int x = Integer.parseInt("5"); // 数字5
        System.out.println(x + 1);//6

        // "3.14" -> double 3.14
        double dd = Double.parseDouble("3.14");
        System.out.println("dd = " + dd);
    }
}

4、自动装箱和自动拆箱

（1）自动装箱：将基本数据类型自动转成包装类

例：Integer i3 = 7;

（2）自动拆箱：将包装类自动转成基本数据类型

例：

Integer i3 = 10;
int i5 = i3;

（3）自动装箱和自动拆箱的好处：

方便,代码简单

public class Demo072 {
    public static void main(String[] args) {
        
        // int -> Integer

        // 途径一：通过构造方法 Integer(int value)
        Integer i1 = new Integer(5);
        System.out.println("i1 = " + i1);//5

        // 途径二：通过静态的成员方法 static Integer valueOf(int i)
        Integer i2 = Integer.valueOf(6);//6
        System.out.println("i2 = " + i2);

        // 途径三：自动装箱: 将基本数据类型转成了包装类（简单方便）
        Integer i3 = 7;

        // Integer -> int
        
        // 途径一：通过成员方法 int intValue() : 返回Integer对象的int值
        int i4 = i3.intValue();

        // 途径二：自动拆箱: 将包装类自动转成基本数据类型（简单方便）
        int i5 = i3;
    }
}

5、自动装箱、自动拆箱原理（见代码）

public static void main(String[] args) {

    //原理通过反编译器查看

    Integer i1 = 10; // 自动装箱的原理: 调用了Integer类的方法：Integer.valueOf(10);

    int i2 = i1; // 自动拆箱的原理: 调用了Integer类的方法：i1.intValue();

    Integer i3 = 5; // Integer i3 = Integer.valueOf(5);
    i3 += 2;
    //分析要点：按照表达式的运算顺序（优先级）进行分析
    // i3 = i3 + 2;
    // i3 + 2; => i3.intValue() + 2 => int
    // i3 = Integet.valueOf(i3.intValue() + 2);
    System.out.println(i3);
    // System.out.println("i3 = " + i3);
}

7、泛型

1、概述：

泛型，表示为,可以理解为是一种参数化的类型，即其类型像变量一样可以变化。

2、泛型的作用

典型使用泛型的类：ArrayList集合

ArrayList list = new ArrayList<>();

若ArrayList集合不使用泛型，则集合内元素默认是Object类型，即可以存入任何数据。但是取出数据时会导致强制类型转换失败.运行时会失败（见下面代码示例）

/*
不使用泛型.可以存入任何数据,集合内元素默认是Object类型，故取出数据时会导致强制类型转换失败.

除了需要强转之外，还有可能会有如下情况导致运行时会报一下错误：
ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String （iny不能被强转为String）

*/
       ArrayList list = new ArrayList();
        list.add("凤姐");
        list.add("如花");
        list.add("石榴姐");
        list.add("芙蓉姐姐");
        list.add(123);

        // 遍历取出数据
        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i);//将Object类型强转为String类型
            System.out.println(name + ",长度" + name.length());
        }

若ArrayList集合使用泛型，不合格的数据无法添加.不需要强转,避免强制类型转换带来的失败问题

// 使用泛型,不合格的数据无法添加.不需要强转,避免强制类型转换带来的失败问题
ArrayList<String> list = new ArrayList<>();
list.add("凤姐");
list.add("如花");
list.add("石榴姐");
list.add("芙蓉姐姐");
// list.add(123);//报错，无法编译（不会向之前的运行报错，而是编译报错）
for (int i = 0; i < list.size(); i++) {
    String name = list.get(i);
    System.out.println(name + ",长度" + name.length());
}

3、泛型类

（1）概念：泛型定义在类上面的类

（2）定义格式：

class 类名<E> {
    private E xx;

    public setXx(E xx) {
        this.xx = xx;
    }
}

（3）使用步骤：

类名<指定类型> 变量名 = new 类名<>();

PS：和普通类相比在类名后面添加<指定类型>

4、泛型方法

（1）概念：泛型定义在方法上的方法

（2）泛型方法的好处：可以传入任何的类型

（3）定义格式：

修饰符 <E> 返回值类型 方法名(E 变量名) {
}

PS：和普通方法的区别:
1.在返回值类型前面添加
2.参数的类型使用E

public class Demo10 {
    public static void main(String[] args) {
        show("abc");
        show(110);
        show(true);
        show(3.14);
    }

    public static <E> void show(E s) {
        // 注意:因为泛型方法可以传入任何类型,在方法里面E看作Object类型
        System.out.println(s);
    }
}

5、泛型接口

（1）概念：泛型放在接口上的接口

（2）泛型方法的好处：可以传入任何的类型

（3）定义格式：

interface 接口名<E> {
    public abstract 返回值类型 方法名(E 变量名);
}

（4）使用的两种方式：（见下面代码）

a.定义实现类时指定泛型, 创建对象时就不需要指定泛型
b.定义实现类时,接着使用泛型, 创建对象时,再进行指定泛型

接口

public interface Swimmable<E> {
    public abstract void swimming(E s);
}

Student实现类

//1.定义实现类时指定泛型
public class Student implements Swimmable<String> {
    @Override
    public void swimming(String s) {
        System.out.println(s);
    }
}

Teacher实现类

//1.定义实现类时指定泛型
public class Teacher<E> implements Swimmable<E> {
    @Override
    public void swimming(E s) {
        System.out.println(s);
    }
}

测试类

public class Demo11 {
    public static void main(String[] args) {
        // 1.定义实现类时指定泛型, 创建对象时就不需要指定泛型
        // 创建对象时就不需要指定泛型
        Student s = new Student();

        //  2.定义实现类时,接着使用泛型, 创建对象时,就需要指定泛型
        // 创建对象时,再指定泛型
        Teacher<String> t = new Teacher<>();
        t.swimming("漂亮啊");

        Teacher<Integer> t2 = new Teacher<>();
        t2.swimming(11);
    }
}

6、泛型通配符?

1、概念：泛型通配符就是一个“?“f符号，填在原本E所在的位置

2、作用：等号的左边若是泛型通配符，则等号的右边可以是任意类型的泛型（详细见下面代码）

public class Demo121 {
    public static void main(String[] args) {
        // 多态: 父类 变量名 = new 子类();
        ArrayList<Object> list1 = new ArrayList<Object>();
        // String是Object的子类,泛型不存在多态一说,泛型的的左右两边类型要是一样的
        //ArrayList<Object> list2 = new ArrayList<String>();//报错


        //以下写法都是对的，等号的左边若是泛型通配符，则等号的右边可以是任意类型的泛型
        //但是这种写法没有任何实际意义，让人看得很奇怪。
        // ArrayList<?> list2 = new ArrayList<String>();
        // ArrayList<?> list3 = new ArrayList<Integer>();
        // ArrayList<?> list4 = new ArrayList<Double>();

        //推荐写法
        ArrayList<String> list2 = new ArrayList<String>();
        ArrayList<Integer> list3 = new ArrayList<Integer>();
        ArrayList<Double> list4 = new ArrayList<Double>();

        printArray(list2);
        printArray(list3);
        printArray(list4);
    }

    // 泛型通配符最常见用法：泛型通配符?用在方法参数上
    // 遍历所有ArrayList集合里面的元素
    // printArray(list2);//左边     ArrayList<String> ll = new ArrayList<String>();//右边，参数传进成功
    // printArray(list3); //左边    ArrayList<String> ll = new ArrayList<Integer>();//右边，参数传进失败
    public static void printArray(ArrayList<?> ll) {
        for (int i = 0; i < ll.size(); i++) {
            Object o = ll.get(i);//取出集合元素时候，看作是Object类型
            System.out.println("o = " + o);
        }
    }
}

7、泛型限定：

1、概念：作为变量的类型，限定变量传进的泛型类型

2、两种限定：

继承关系： Object
|
Animal
/
Dog Cat

（1）向上限定：<? extends Animal>: 向上限定,表示右边的泛型可以是Animal及其子类

（2）向下限定：<? super Animal>: 向下限定,表示右边的泛型可以是Animal及其父类

public static void main(String[] args) {
    ArrayList<Object> list1 = new ArrayList<Object>();
    // Object o1 = new Object();
    list1.add(new Object());//匿名对象
    ArrayList<Animal> list2 = new ArrayList<Animal>();
    // Animal a1 = new Animal();
    list2.add(new Animal());//匿名对象
    ArrayList<Dog> list3 = new ArrayList<Dog>();
    list3.add(new Dog());//匿名对象
    ArrayList<Cat> list4 = new ArrayList<Cat>();
    list4.add(new Cat());//匿名对象

    // printArrayList(list1);//方法参数类型为Animal的向上限定，无法传进Animal的父类Dog类和cat类
    printArrayList(list2);
    printArrayList(list3);
    printArrayList(list4);

    printArrayList2(list1);
    printArrayList2(list2);
    // printArrayList2(list3);//方法参数类型为Animal的向下限定，无法传进Animal的子类Object类
    // printArrayList2(list4);
}



/*此处方法形参类型采用泛型限定的【意义】：
    定义一个方法,遍历ArrayList调用元素的eat方法,我们要注意.
    不是存储任何类型的ArrayList集合里面的元素都有eat
    Animal,Dog,Cat这些数据才有eat方法,我们要限定集合的泛型的类型需要是Animal或Animal的子类
 */
// printArrayList(list2);           ArrayList<? extends Animal> ll = new ArrayList<Animal>();
// printArrayList(list3);           ArrayList<? extends Animal> ll = new ArrayList<Dog>();
// printArrayList(list4);           ArrayList<? extends Animal> ll = new ArrayList<Cat>();

//方法参数类型为Animal的向上限定，无法传进Animal的父类Object类
public static void printArrayList(ArrayList<? extends Animal> ll) {

}

// printArrayList2(list1);          ArrayList<? super Animal> ll = new ArrayList<Object>();
// printArrayList2(list2);          ArrayList<? super Animal> ll = new ArrayList<Animal>();
public static void printArrayList2(ArrayList<? super Animal> ll) {

}

8、Collection类

1、概念：是集合的最顶层接口

2、集合层次：

在这里插入图片描述

3、Collection常用功能有哪些?

add: 添加数据
clear: 清空数据
remove: 删除数据
contains: 判断是否包含指定的数据
isEmpty: 判断集合是否为空
size: 获取集合元素的数量
toArray: 将集合转成数组

代码实现：

public static void main(String[] args) {
    // 我们学习Collection集合中的方法,编译看左边,我们使用的方法都是来自Collection接口
    // 多态
    // 接口            变量名 = new 实现类();
    Collection<String> coll = new ArrayList<>();
    // 1.boolean add(E e) 往集合中添加一个元素
    coll.add("王宝强");
    coll.add("谢霆锋");
    coll.add("贾乃亮");
    coll.add("陈羽凡");
    System.out.println(coll);
    // 2.void clear() 从此集合中删除所有元素
    // coll.clear();

    // 3.boolean contains(Object o) 判断集合中是否包含指定的元素
    System.out.println(coll.contains("贾乃亮")); // true
    System.out.println(coll.contains("杜海涛")); // false

    // 4.boolean isEmpty() 判断集合是否为空(没有元素),如果为空返回true
    System.out.println(coll.isEmpty());

    // 5.boolean remove(Object o) 删除集合中的指定元素,如果删除返回true
    System.out.println(coll.remove("王宝强")); // true
    System.out.println(coll.remove("大郎")); // false

    // 6.int size() 返回此集合中的元素数
    System.out.println(coll.size());
    System.out.println(coll);
    System.out.println("------");
    // 7.Object[] toArray() 将集合转成数组
    Object[] objects = coll.toArray();
    for (int i = 0; i < objects.length; i++) {
        Object obj = objects[i];
        System.out.println(obj);
    }
}

t o) 判断集合中是否包含指定的元素
System.out.println(coll.contains(“贾乃亮”)); // true
System.out.println(coll.contains(“杜海涛”)); // false

// 4.boolean isEmpty() 判断集合是否为空(没有元素),如果为空返回true
System.out.println(coll.isEmpty());

// 5.boolean remove(Object o) 删除集合中的指定元素,如果删除返回true
System.out.println(coll.remove("王宝强")); // true
System.out.println(coll.remove("大郎")); // false

// 6.int size() 返回此集合中的元素数
System.out.println(coll.size());
System.out.println(coll);
System.out.println("------");
// 7.Object[] toArray() 将集合转成数组
Object[] objects = coll.toArray();
for (int i = 0; i < objects.length; i++) {
    Object obj = objects[i];
    System.out.println(obj);
}

}