JAVA常用类库_SXL

---

引言

做个俗人，贪财好色，一身正气。

---

一、 泛型

泛型：指的是把类、接口或者方法等原本具有的具体类型进行参数化，然后在使用或者调用过程中传入各样参数。

使用泛型可以提高代码的复用率，而且泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）。值得注意的是泛型只是在编译阶段中有效，在编译之后程序会采取去泛型化的措施，运行过程中，泛型信息是不存在的。

补充：在没有泛型的情况的下，通过对类型 Object 的引用来实现参数的任意化，任意化带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译期可能不提示错误，在运行期会出现异常，这本身就是一个安全隐患。

那么泛型的好处就是在编译的时候能够检查类型安全，并且所有的强制转换都是自动和隐式的。

1.1 泛型类

public class Generics {

    public static void main(String[] args) {
    	// 由于Java中的泛型是通过编译时的类型擦除来完成的，当泛型被类型擦除后都变成Object类型。
    	// 因此Object类型不能指代像int，double这样的基本类型只能指代Integer，Double这样的引用类型。
    	// 此处参数类型为String
        ClassName<String> cs = new ClassName<>();
        cs.setData("String");
        // 此处参数类型为Integer
        ClassName<Integer> ci = new ClassName<>();
        ci.setData(123);
        // 此处参数类型为Integer
        ClassName<Integer> ci = new ClassName<>();
        ci.setData(123);
        // 此处参数类型为一个对象
        ClassName<Generics> cd = new ClassName<>();
        cd.setData(new Generics());
    }

}

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

1.2 泛型接口

// 实现接口时，可以选择指定泛型类型，也可以选择不指定，如下：
public interface GenericsInterface<T> {
    T getData();
}

// 指定类型：此处为String类型
class Interface1 implements GenericsInterface<String> {
    private String text;
    @Override
    public String getData() {
        return text;
    }
}

// 不指定类型：任意形式参数
class Interface2<T> implements GenericsInterface<T> {
    private T data;
    @Override
    public T getData() {
        return data;
    }
}

1.3 泛型方法

泛型方法：private static T 方法名(T a, T b) {}

public class GenericsClass {

    public static void main(String[] args) {
        genericsMethod("String"); 
        genericsMethod(123);
        genericsMethod(new GenericsClass());
		// 输出值分别为为 String 123 GenericsClass@47089e5f
    }

    public static <A> void genericsMethod(A a) {
        System.out.println(a);
    }

}

1.4 泛型限定

类型通配符是使用？代替方法具体的类型实参。
泛型不管是继承也好还是实现也罢，均用extend。
类型参数列表中存在多个类型参数上限，用逗号分开。

• <? extends Parent> 指定了泛型类型的上界。
• <? super Child> 指定了泛型类型的下界。
• <?> 指定了没有限制的泛型类型。

public class GenericsDemo {

    public static void main(String[] args) {
        Plate<? extends Fruit> pF = new Plate<Apple>();
        Plate<? super Apple> pS = new Plate<Fruit>();
    }

}

// 水果接口
interface Fruit {}
// 苹果类
class Apple implements Fruit {}
// 盘子
class Plate<T> {
    T data;
}

1.5 泛型通配

常用的通配符 ：T，E，K，V，？

• ？表示不确定的 java 类型
• T (type) 表示具体的一个java类型
• K V (key value) 分别代表java键值中的Key Value
• E (element) 代表Element

---

二、Objects类

		// 此例子输出13 参数a与b放置比较的值，相同返回0， 参数c自定义逻辑返回。
        Objects.compare(6, 7, (o1, o2) -> o1 + o2);


        // true 具有非空的相等判断
        Objects.equals("123", "123");

        // false 基本使用在Object[]数组比较是否相等
        String[] arr1 = {"1", "2", "3"};
        Integer[] arr2 = {1, 2, 3};
        Objects.deepEquals(arr1, arr2);

        // 为一系列输入值生成哈希码。 生成哈希码，所有输入值都放在一个数组中，并通过调用Arrays.hashCode(Object[])对该数组进行哈希处理 。
        // 提供单个对象引用时，返回的值不等于该对象引用的哈希码。 可以通过调用hashCode(Object)来计算此值
        Objects.hash(arr1);
        Objects.hashCode(arr1);

        // isNull: null 为true 否则 false nonNull相反
        Objects.isNull(arr1);
        Objects.nonNull(arr1);

        // 输出123 为null 返回第二个参数
        System.out.println(Objects.toString(null, "123"));

        // 为空抛出异常 第二个参数可以自定义异常接口
        Objects.requireNonNull(null, "空");
        // 非null，则返回第一个参数，否则返回非 null第二个参数 requireNonNull
        Objects.requireNonNullElse(null, "====");
        // 非null，则返回第一个参数，否则返回非 null值 supplier.get()
        Objects.requireNonNullElseGet(null, null);

---

三、System类

		// 数组拷贝 srcPos从源数组下标开始 destPos从目标数组下标开始 length拷贝长度
        // 输出 [2, 3, 3]
        int[] arr = {1, 2, 3};
        System.arraycopy(arr, 1, arr, 0, 2);

        // 返回当前系统环境的不可修改的字符串映射视图。
        System.out.println(System.getenv());
        // 键指值 返回相应的系统环境映射
        System.out.println(System.getenv("HOMEPATH"));

        // 重新分配“标准”输入流、 输出流、 错误输出流。
        // System.setIn(null);
        // System.setOut(null);
        // System.setErr(null);

        // 获取所有系统属性
        System.out.println(System.getProperties());
        // 键指值 获取相应系统属性
        System.out.println(System.getProperty("java.class.path"));
        // 设置系统属性
        // System.setProperties(null);
        // System.setProperty(null, null);

        // 如果已经为当前应用程序建立了安全管理器，则返回该安全管理器; 否则，返回null。
        System.out.println(System.getSecurityManager());
        // 设置安全管理器
        // System.setSecurityManager(null);

        // 当前时间 毫秒单位
        System.out.println(System.currentTimeMillis());

        // 运行Java虚拟机的高分辨率时间源的当前值，以纳秒为单位 用于测量经过的值
        System.out.println(System.nanoTime());

        // 运行垃圾收集器 Java虚拟机已尽最大努力从所有丢弃的对象中回收空间
        System.gc();

---

四、Math类

在做算法相关功能时，第一时间想到这个类

		// 绝对值 值为1
        System.out.println(Math.abs(-1));

        // 返回较大值 2
        System.out.println(Math.max(1, 2));
        // 返回较小值 1
        System.out.println(Math.min(1, 2));

        // 返回值等于数学整数最接近的 double值 3.0
        System.out.println(Math.rint(2.9));

        // 四舍五入
        System.out.println(Math.round(2.9));

        // 返回带有正号的double值，大于或等于 0.0且小于 1.0 。
        System.out.println(Math.random());

        // 返回参数的总和 值为4
        System.out.println(Math.addExact(1, 3));
        // 返回参数的差 值为-2 第一参数减去第二个参数
        System.out.println(Math.subtractExact(1, 3));
        // 返回参数的乘积 值为3
        System.out.println(Math.multiplyExact(1, 3));
        // 返回参数确切的乘积 值为3
        System.out.println(Math.multiplyFull(3, 3));
        // 返回参数-1 值为8
        System.out.println(Math.decrementExact(9));
        // 返回参数+1 值为10
        System.out.println(Math.incrementExact(9));

        // 返回小于或等于参数且等于数学整数的最大值（最接近正无穷大）double  值2
        System.out.println(Math.floor(2.3));
        // 返回大于或等于参数且等于数学整数的最小值（最接近负无穷大）double 值为-2
        System.out.println(Math.ceil(-2.8));

        // 返回三个参数的融合乘法加法; 也就是说，返回与第三个参数相加的前两个参数的精确乘积，然后舍入一次到最接近的double
        // 值为14
        System.out.println(Math.fma(3, 3, 5));

---

五、Arrays类

		Integer[] arr = {1, 2, 3};
        Integer[] arr1 = {1, 2, 3, 4, 5};
        Integer[] arr2 = {1, 2, 3, 4, 5};
        String[] arr3 = new String[6];
        Integer[] arr4 = {1, 4, 3, 2, 2};

        // 数组字符串形式显示 返回：[1, 2, 3]
        System.out.println(Arrays.toString(arr));

        // 数组转化集合 返回由指定数组支持的固定大小的列表
        List<Integer> list = Arrays.asList(arr);

        // 使用二进制搜索算法搜索值 返回1 重构方法很多
        Arrays.binarySearch(arr, 2);

        // 数组比较 相同0 不同前参数减去后参数 此处返回值-2
        Arrays.compare(arr, arr1);

        // copy数组 设置长度
        Arrays.copyOf(arr, 1);

        // copy数组 设置范围
        Arrays.copyOfRange(arr, 1, 2);

        // 数组是否相等
        System.out.println(Arrays.deepEquals(arr1, arr2));
        System.out.println(Arrays.equals(arr1, arr2));

        // 填充数组 此处值为[arr3, arr3, arr3, arr3, arr3, arr3]
        Arrays.fill(arr3, "arr3");
        System.out.println(Arrays.toString(arr3));

        // 返回俩个之间不匹配索引 返回值为3
        System.out.println(Arrays.mismatch(arr, arr2));

        // 排序
        Arrays.sort(arr4);
        System.out.println(Arrays.toString(arr4));

---

六、BigDecimal类

6.1常用构造函数

new BigDecimal(int/double/long/String)

BigDecimal a =new BigDecimal(0.1);
// 输出0.1000000000000000055511151231257827021181583404541015625
BigDecimal b =new BigDecimal(“0.1”);
// 输出 0.1

String的构造方法是定死的，使用double的构造方法数据会出现如上所示误差

6.1常用BigDecimal方法

// 相等0 小于-1 大于1
compareTo(bigdemical val)

// BigDecimal对象中的值相加，返回BigDecimal对象
add(BigDecimal val)

// BigDecimal对象中的值相减，返回BigDecimal对象
subtract(BigDecimal val)

// BigDecimal对象中的值相乘，返回BigDecimal对象
multiply(BigDecimal val)

// BigDecimal对象中的值相除，返回BigDecimal对象
divide(BigDecimal val)

// 将BigDecimal对象中的值转换成字符串
toString()

// 将BigDecimal对象中的值转换成双精度数
doubleValue()

// 将BigDecimal对象中的值转换成单精度数
floatValue()

// 将BigDecimal对象中的值转换成长整数
longValue()

// 将BigDecimal对象中的值转换成整数
intValue()

涉及精确计算，建议用BigDeciaml。

---

七、日期和时间

7.1 Date类

		// 当前时间
        Date date = new Date();

        // 当前时间毫秒 - 一天的毫秒
        long time = date.getTime() - (24 * 60 * 60 * 1000);
        // 不建议使用这种方式对天数进行运算
        Date yesterday = new Date(time);

        // 时间格式化
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 转为时间字符串
        System.out.println(sdf.format(yesterday));
        // 时间字符串转化date
        System.out.println(sdf.parse("2021-12-11 12:12:12"));

7.3 Calender类

		// Calender里面有个fields的int类型数组，通过对应数组下标获取年月日
        Calendar cl = Calendar.getInstance();

        // 当前年
        cl.get(Calendar.YEAR);
        // 月 -1
        cl.get(Calendar.MONTH);
        // 日
        cl.get(Calendar.DAY_OF_MONTH);

        // 设置年月日 第一个参数年月日对应常量 第二个参数具体时间
        cl.add(Calendar.YEAR, 1);

        // getTime 方法输出Sat Apr 23 22:11:36 CST 2022
        System.out.println(cl.getTime());

        // 获取最大值 此处获取当前月的最大天数
        cl.getActualMaximum(Calendar.DAY_OF_MONTH);
        // 获取最小值 此处获取当前月的最小值
        cl.getActualMinimum(Calendar.MONTH);

---

八、String类

8.1 String类的介绍和常用方法

字符串的值是不可变的，值在创建后是无法更改的。
俩个字符串内容完全相同，指向同一个地址（字符串常量池）。
CharSequence是String的父类。

		String str = "abc";
        String str1 = "abc13";
        String str2 = " ";
        String str3 = "abc.abc.abc.abc";
        String str4 = "     abc abc abc ";
        char[] c = {1, 2};

        // 字符串截取
        System.out.println(str.substring(0,1));

        // 字符串内字符进行大小写转换
        str.toLowerCase();
        str.toUpperCase();

        // 字符串赋值字符数组
        str.getChars(0, 2, c, 0);
        // 字符数组
        str.toCharArray();
        // 分割字符串为数组 第二个参数是返回的数组长度 返回值 [abc, abc.abc.abc]
        System.out.println(Arrays.toString(str3.split("\\.", 2)));
        // 字符串转化字节数组
        byte[] strBytes = str.getBytes();

        // strip去除俩段空操作 stripLeading去除前段空 stripTrailing去除后段空
        System.out.println(str4.strip());
        System.out.println(str4.stripLeading());
        System.out.println(str4.stripTrailing());
        System.out.println(str4.trim());

        // 替换 返回值 "qbc.qbc.qbc.qbc"
        System.out.println(str3.replace("a", "q"));
        // 第一个参数表达式查找参数 第二个参数替换 返回值 "abc abc abc abc"
        System.out.println(str3.replaceAll("\\.", " "));
        // 对一个找到的参数生效 返回值 "abc abc.abc.abc"
        System.out.println(str3.replaceFirst("\\.", " "));

        // 重复几次字符串 返回值为"abcabc"
        System.out.println(str.repeat(2));

        // 正则匹配， 参数为正则规则
        str.matches("");

        // 返回从此字符串中提取的行的流，由行终止符分隔。
        str.lines();

        // 返回值2 第二个参数是从指定索引往前搜索 length() 字符串长度包括空格
        System.out.println(str.lastIndexOf("b", str.length()));

        // 返回值：1<>2<>3
        String.join("<>", "1", "2", "3");

        // isBlank有空格就返回true isEmpty的长度也要为0才返回true
        System.out.println(str2.isBlank());
        System.out.println(str2.isEmpty());

        // 返回字符第一次出现的字符串中的索引
        // 98对应的char码值是b 第二个参数是指从第几个开始
        System.out.println(str.indexOf("a"));
        System.out.println(str1.indexOf(98));
        System.out.println(str1.indexOf(98, 1));

        // 返回指定索引的char值 返回值c
        System.out.println(str.charAt(2));

        // 判断是否以指定后缀结尾 返回值false c则为true
        System.out.println(str.endsWith("b"));
        // 从指定索引开始判断是否以指定前缀结尾 此处返回值true
        System.out.println(str.startsWith("b", 1));

        // 字符串是否包含char值 返回值true
        System.out.println(str.contains("b"));

        // 字符串比较 相等true 否则false ignoreCase忽略大小写
        System.out.println(str.equals(str));
        System.out.println(str.equalsIgnoreCase(str));

        // 字符串相互连接（只能连接字符串，建议相加用+） 返回值为abcabc13
        System.out.println(str.concat(str1));

        // 字符串等于此字符串，则值0;
        // 如果此字符串按字典顺序小于字符串参数，则小于0;
        // 如果此字符串按字典顺序大于字符串参数，则值大于0
        System.out.println(str.compareTo(str1));
        // 忽略大小写的比较
        System.out.println(str.compareToIgnoreCase(str1));

8.2 StringBuffer 和 StringBuilder

这俩个类主要用于解决字符串拼接问题。
StringBuilder效率较高，StringBuffer线程安全实现。

方法实现：

		StringBuilder sb = new StringBuilder();
        sb.append("1");
        sb.append("2");
        sb.append("3");
        sb.append("4");
        System.out.println(sb);

---

总结

人生无限，缓缓起航，修正改错，在满足完成任务的条件下，追求完善，全身而退。