09-常用类库（核心类库）

王宇辉

已于 2022-02-26 09:28:00 修改

阅读量2.3k

点赞数 1

分类专栏： java知识体系文章标签： java 蓝桥杯 android

于 2021-12-14 07:58:36 首次发布

本文链接：https://blog.csdn.net/weixin_42688085/article/details/121917002

版权

本文详细介绍了Java中的泛型概念及其在类、接口、方法中的使用，阐述了泛型带来的好处和通配符的应用。此外，还探讨了Java常用的类库，包括Math、Arrays、BigDecimal、Date、DateFormat、Calendar、System和String类，讲解了它们的基本用法和重要方法，是Java学习者的重要参考资料。

摘要由CSDN通过智能技术生成

感谢你的路过，希望学生的笔记能给你一点微不足道的参考（2/100）
Java基础思维导图，完整Java体系的链接
在这里插入图片描述

目录标题

一，泛型

1.1什么是泛型？

    参数化类型，将类型由原来的具体的类型参数化，此时类型定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。可以在类或方法中预支地使用未知的类型。
    编个例子：
        定义时-定义泛型–类似形参-把他定义为动物
        使用/调用时-传入具体类型-类似实参，像是猫啊，狗啊。泛型可以代表具体类型，具体类型不可以代表泛型。

1.2使用泛型的好处有哪些？

    * 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
    * 避免了类型强转的麻烦。
        注意：泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型

1.3泛型在类中的使用？（person,demo01）

    *定义一个泛型类：
        public class ClassName{
        private T data;
        public T getData() {
        return data;
        }
        public void setData(T data) {
        this.data = data;
        }
        }
代码：

package com.wyh.FanXing;

/**
 * @Deacription 泛型类
 * 泛型在类中的定义
 * @Author 王宇辉
 * @Date 2021/8/29 18:08
 **/
public class Person<T> {
   
    private String name;
    private int age;
    private T data; // 这个就是泛型

    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 T getData() {
   
        return data;
    }

    public void setData(T data) {
   
        this.data = data;
    }

    @Override
    public String toString() {
   
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", data=" + data +
                '}';
    }
}

package com.wyh.FanXing;

/**
 * @Deacription 泛型在类中的使用（用person类）及
 * @Author 王宇辉
 * @Date 2021/8/29 18:13
 **/
public class Demo01_LeiZhongShiYong {
   
    public static void main(String[] args) {
   
       Person<String> p = new Person<>();
       p.setData("王宇辉");
       System.out.println(p);
    }
}

1.4泛型在接口中的使用？

    定义格式：修饰符 interface接口名<代表泛型的变量> { }
    使用格式：
        1、定义类时确定泛型的类型
        2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型
    使用方法
        第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
        第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型
代码：

package com.wyh.FanXing.JieKo;
/*
    定义含有泛型的接口
 */
public interface GenericInterface<I> {
   
    public abstract void method(I i);
}

package com.wyh.FanXing.JieKo;
/*
    含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
    public interface Iterator<E> {
        E next();
    }
    Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默认就是String
    public final class Scanner implements Iterator<String>{
        public String next() {}
    }
 */
public class GenericInterfaceImpl1 implements GenericInterface<String>{
   
    @Override
    public void method(String s) {
   
        System.out.println(s);
    }
}

package com.wyh.FanXing.JieKo;
/*
    含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
    就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型
    public interface List<E>{
        boolean add(E e);
        E get(int index);
    }
    public class ArrayList<E> implements List<E>{
        public boolean add(E e) {}
        public E get(int index) {}
    }
 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
   
    @Override
    public void method(I i) {
   
        System.out.println(i);
    }
}

package com.wyh.FanXing.JieKo;
/*
    测试含有泛型的接口
 */
public class Demo02_Interface {
   
    public static void main(String[] args) {
   

        //创建GenericInterfaceImpl1对象
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method("字符串");

        //创建GenericInterfaceImpl2对象
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method(10);

        GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
        gi3.method(8.8);
    }
}

1.5泛型在方法中的使用？

定义格式：修饰符 <代表泛型的变量> 返回值类型方法名(参数){ }
使用格式：调用方法时，确定泛型的类型
代码：

package com.wyh.FanXing.FangFa;
/*
    定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间

    格式:
        修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
            方法体;
        }

    含有泛型的方法,在调用方法的时候确定泛型的数据类型
    传递什么类型的参数,泛型就是什么类型
 */
public class GenericMethod {
   
    //定义一个含有泛型的方法
    public <M> void method01(M m){
   
        System.out.println(m);
    }

    //定义一个含有泛型的静态方法
    public static <S> void method02(S s){
   
        System.out.println(s);
    }
}

package com.wyh.FanXing.FangFa;
/*
    测试含有泛型的方法
 */
public class Demo03_Method {
   
    public static void main(String[] args) {
   
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();

        /*
            调用含有泛型的方法method01
            传递什么类型,泛型就是什么类型
         */
        gm.method01(10);
        gm.method01("abc");
        gm.method01(8.8);
        gm.method01(true);

        gm.method02("静态方法,不建议创建对象使用");

        //静态方法,通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(1);
    }
}

1.6泛型通配符

通配符基本使用：
泛型的通配符:**不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。**此时只能接受数据,不能往该集合中存储数据。
代码：

package com.wyh.FanXing.TongPeiFu;
import java.util.ArrayList;
import java.util.Iterator;
/*
    泛型的通配符:
        ?:代表任意的数据类型
    使用方式:
        不能创建对象使用
        只能作为方法的参数使用
 */
public class Demo04_TongPeiFu {
   
    public static void main(String[] args) {
   
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("b");

        printArray(list01);
        printArray(list02);

        //ArrayList<?> list03 = new ArrayList<?>();
    }

    /*
        定义一个方法,能遍历所有类型的ArrayList集合
        这时候我们不知道ArrayList集合使用什么数据类型,可以泛型的通配符?来接收数据类型
        注意:
            泛型没有继承概念的
     */
    public static void printArray(ArrayList<?> list){
   
        //使用迭代器遍历集合
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
   
            //it.next()方法,取出的元素是Object,可以接收任意的数据类型
            Object o = it.next();
            System.out.println(o);
        }
    }
}

    通配符高级使用----受限泛型
        之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
    泛型的上限
        格式：类型名称 <? extends 类 > 对象名称
        意义：只能接收该类型及其子类
    泛型的下限
        格式：类型名称 <? super 类 > 对象名称
        意义：只能接收该类型及其父类型
代码：

package com.wyh.FanXing.TongPeiFu;
import java.util.ArrayList;
import java.util.Collection;

/*
    泛型的上限限定: ? extends E  代表使用的泛型只能是E类型的子类/本身
    泛型的下限限定: ? super E    代表使用的泛型只能是E类型的父类/本身
 */
public class Demo05_XianDin {
   
    public static void main(String[] args) {
   
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();

        getElement1(list1);
        //getElement1(list2);//报错
        getElement1(list3);
        //getElement1(list4);//报错

        //getElement2(list1);//报错
        //getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);

        /*
            类与类之间的继承关系
            Integer extends Number extends Object
            String extends Object
         */

    }
    // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){
   }
    // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){
   }
}

二，常用库

2.1math

   Math类是什么？
      java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。
   基本运算的方法有哪些？
      public static double abs(double a) ：返回 double 值的绝对值
      public static double ceil(double a) ：返回大于等于参数的最小的整数
      public static double floor(double a) ：返回小于等于参数最大的整数
      public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
代码：

package com.wyh.Math;
/*
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

public static double abs(double num)：获取绝对值。有多种重载。
public static double ceil(double num)：向上取整。
public static double floor(double num)：向下取整。
public static long round(double num)：四舍五入。

Math.PI代表近似的圆周率常量（double）。
 */
public class Demo06_Math {
   
    public static void main(String[] args) {
   
        // 获取绝对值
        System.out.println(Math.abs(3.14)); // 3.14
        System.out.println(Math.abs(0)); // 0
        System.out.println(Math.abs(-2.5)); // 2.5
        System.out.println("================");

        // 向上取整
        System.out.println(Math.ceil(3.9)); // 4.0
        System.out.println(Math.ceil(3.1)); // 4.0
        System.out.println(Math.