Java核心常用类库

一、泛型

1. 概念：
   泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定 义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
2. 定义泛型所使用的字母有一些是特定的，比如E是element元素的意思，用来表示容积，后续会学习其他的特定字母。
3. 应用：泛型接口（实现接口时，可以选择指定泛型类型，也可以选择不指定）、泛型类（使用情况最多）、泛型方法
4. 作用：
   1、 提高代码复用率 2、 泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

5. // 右侧尖括号内正常情况下也应该写上String类型，但是在jdk1.7版本之后，可以省略
   Person<String> p = new Person<String>();
   

   • 1
   • 2
6. 可以同时指定多个泛型，
7. 注意：
   在编译之后程序会采取去泛型化的措施。
   也就是说Java中的泛型，只在编译阶段有效。 在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加 类型检查和类型转换的方法。
   也就是说，泛型信息不会进入到运行时阶段。
8. 类型受限：
   在使用泛型时， 可以指定泛型的限定区域。例如： 必须是某某类的子类或 某某接口的实现类，格式： <T extends 类或接口1 & 接口2>
9. 通配符？：
   1 <? extends Parent> 指定了泛型类型的上届
   2 <? super Child> 指定了泛型类型的下届
   3 <?> 指定了没有限制的泛型类型

二、java.util.objects

• equals:相对于普通对象的equals方法，能够对某一比较对象为null的情况进行比较
• isNull:判断对象是否为空 nonNull:判断对象是否不为空
• requireNonNull:如果是空直接抛异常,为了限制传过来的对象必须不为空，可以选择不处理直接抛异常

三、java.lang.Math

• abs: 求绝对值（double、float、int、long）
• min: 比较两个数的最小值（double、float、int、long）
• max: 比较两个数的最大值（double、float、int、long）
• round:（double、float）
• floor: 返回小于等于参数的最大整数,如果参数值已经等于整数，则结果与参数相同。如果参数为NaN或无穷大或正零或负零，则结果与参数相同。
• ceil: 返回大于等于参数的最小整数,如果参数值已经等于整数，则结果与参数相同。如果参数为NaN或无穷大或正零或负零，则结果与参数相同。
  如果参数值小于零但大于-1.0，则结果为负零。

public class Demo {
    public static void main(String[] args) {
        System.out.println(Math.abs(-100));
        System.out.println(Math.min(100,200));
        System.out.println(Math.max(100,200));
        // 四舍五入
        System.out.println(Math.round(100.5));
        System.out.println(Math.round(-100.5));
        // 返回小于等于参数的最大整数
        System.out.println(Math.floor(3.5));
        System.out.println(Math.floor(-3.5));
        // 返回大于等于参数的最小整数
        System.out.println(Math.ceil(3.5));
        System.out.println(Math.ceil(-3.5));
    }
}
// 输出结果为
// 100 100 200 101 -100 3.0 -4.0 4.0 -3.0

四、java.util.Arrays

• toString(): 用于输出数组的内容，输出格式[8, 1, 2, 3, 4, 5, 6, 7]
• sort()： 排序
• binarySearch: 二分查找(byte、char、double、float、int、long)
  binarySearch(long[] a, int fromIndex, int toIndex, long key)
  可以指定排序范围
  返回索引值
• copyOf(array,newlength): 用来给数组扩容，方法返回值为原扩容后的新数组

import java.util.Arrays;
public class Demo {
    public static void main(String[] args) {
        int[] arr = {8,1,2,3,4,5,6,7};
        System.out.println(arr);
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.binarySearch(arr,6));
        System.out.println(arr.length);
        arr = Arrays.copyOf(arr,15);
        System.out.println(arr.length);

        for(int i = 0 ;i < arr.length;i++){
            System.out.print(arr[i]+",");
        }
    }
}

五、java.math.BigDecimal

1. 概念：
   通过在控制台运行0.1+0.2，会发现float和double的运算误差，由于float类型和double类型在运算时可能会有误差，为了实现精确运算需要借助类加以描述
2. 常用构造方法
   public BigDecimal(String val){}
3. 常用方法

package java_math_BigDecimal;

import java.math.BigDecimal;

/**
 * 使用BigDecimal只需要new出来
 */
public class Demo {
    public static void main(String[] args) {
        System.out.println(0.1+0.2);
        BigDecimal b1 = new BigDecimal("0.1");
        BigDecimal b2 = new BigDecimal("0.2");
        // 下述所有的运算方法，不会影响参与运算的数据本身，运算的结果会被封装为一个新的BigDecimal对象，这个对象会通过return返回出去。
        // 1.public BigDecimal add(BigDecimal augend);加法运算。
        // 2.public BigDecimal subtract(BigDecimal augend);减法运算
        // 3.public BigDecimal multiply(BigDecimal augend);乘法运算。
        // 4.public BigDecimal divide(BigDecimal augend);除法运算。
        BigDecimal b3 = b1.add(b2);// 并不是将b2加到了b1上面，而是通过方法将结果返回了
        int b4 = b3.intValue();
        // BigDecimal的对象有很多value对象，可以通过这些方法转换值的类型
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
    }
}

六、java.util.Date

1. Date类表示 特定的时刻，精度为毫秒。
2. 大多数方法已过时，从JDK 1.1开始， Calendar类应该用于在日期和时间字段之间进行转换，而DateFormat类应该用于格式化和解析日期字符串。 不推荐使用Date中的相应方法。
3. long getTime() 返回自此Date对象表示的1970年1月1日东八区的早上八点以来的毫秒数。
4. Date() 分配 Date对象并对其进行初始化，使其表示分配时间，测量 Date到毫秒。 （表示此时此刻的时间）

package java_util_Date;

import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        // 创建一个当前时间的Date
        Date date = new Date();
        // 通过源码可以知道，println打印的是toString
        // date已经重写了toString方法
        System.out.println(date.toString());

        // 获取当前的毫秒数
        System.out.println(date.getTime());
        // 往前推24小时
        long time = date.getTime()-(24*60*60*1000);
        Date date1 = new Date(time);
        System.out.println(date);
        System.out.println(date1);

    }
}

七、java.text.DateFormat

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * DateFormat这个类就是用来修改Date这个类输出的日期格式的
 */
public class Demo {
    public static void main(String[] args) {
        // DateFormat是一个抽象的类，没有办法直接使用，需要使用他的子类
        /**
         * y : 年
         * M : 月
         * d : 日
         * H : 小时
         * m : 分
         * s : 秒
         * 2020年12月12日 12:12 50
         */
        // format方法：将Date转换为指定类型的字符串
        SimpleDateFormat format0 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm ss");
        // 格式化为一个字符串
        String text = format0.format(new Date());
        System.out.println(text);
        // parse:将一段日期字符串转换为Date对象
        /* parse()无参，将特定的字符串转换成Date类
         * 使用无参的parse()时，要解析的String表示一定是按照“年-月-日(一定有一个空格)上午 /下午小时:分钟”
         * 如：2011-11-21 上午23:12      11-10-2 下午01:34
         * 转换成的Date类也是系统的格式，可读性很差
         * 如果在SimpleDateFormat()定义了格式，那么转换的字符串格式要和定义的相同
         * */
        Date date = new Date();
        try {
            date = format0.parse("2021-12-12 12:12 12");
        } catch (ParseException e) {
//            e.printStackTrace();
        }
		
		// 
		Date date3 = new Date();
        long m = date3.getTime();
        System.out.println(m);
        // 计算活了多少年
        Calendar calendar = Calendar.getInstance();
        calendar.set(1998,5,8);
        long time = calendar.getTimeInMillis();
        System.out.println((m - time) / 1000 / 60 / 60 / 24 / 365);
		
		Date date = null;
        String s = "2012-01-29 上午12:03";
        SimpleDateFormat sdf = new SimpleDateFormat();
        try {
            date = sdf.parse(s);
        } catch (ParseException e) {
        }
        System.out.println("------系统默认无参数Date的parse------");
        // 输出null
        System.out.println("      " + date);
		
        /*使用自定义格式SimpleDateFormat(String pattern)利用parse()将字符串转换成Date类
         * Date类也是系统的格式，可读性很差*/
        Date date1 = null;
        String s1 = "2012-01-29-22-26-23";
        String pattern = "yyyy-MM-dd-HH-mm-ss";
        SimpleDateFormat sdf1 = new SimpleDateFormat(pattern);
        try {
            date1 = sdf1.parse(s1);
        } catch (ParseException e) {
        }
        System.out.println("------自定义格式Date的parse------");
        // 输出Sun Jan 29 22:26:23 CST 2012
        System.out.println("      " + date1);
    }
}

八、java.util.Calendar

import java.util.Calendar;
/**
 * Calendar是一个抽象类，需要通过Calendar.getInstance()获取Calendar类的对象
 * getTime:获取日历时间表示的Date对象
 * getActualMaximum:获取某字段的最大值
 * set()设置当前时间的年、月、日
 * add():可以增加特定时间
 * long getTimeInMillis()：以毫秒为单位返回此Calendar的时间值
 */
public class Demo {
    public static void main(String[] args) {
        // 通过Calendar.getInstance()获取Calendar类的对象
        Calendar c1 = Calendar.getInstance();
        // 不知道什么原因，我这里需要清除一下当前时间的一些设置才能正确运行
        c1.clear();
        c1.set(Calendar.MONTH,1);
        // 可以通过这种方式获取一月有多少天、一年有多少周等等
        int m = c1.getActualMaximum(Calendar.DATE);
        int n = c1.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println(m);
        System.out.println(n);
        c1.set(Calendar.YEAR,2021);
        c1.add(Calendar.YEAR,1);
        int year = c1.get(Calendar.YEAR);
        int day = c1.get(Calendar.DAY_OF_WEEK);
        System.out.println(year);
        System.out.println(day);
    }
}

九、java.lang.System

package java_lang_System;

import java.util.Arrays;

/**
 * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
 * 将指定源数组中的数组从指定位置开始复制到目标数组的指定位置。
 * 原数组 原数组起始位置 目标数组 目标数组起始位置 要赋值的长度
 * currentTimeMillis() 以毫秒为单位返回当前时间。
 * exit(int status) 终止当前运行的Java虚拟机。0:正常退出，其他：非正常退出
 * gc() 运行垃圾收集器。
 */
public class Demo {
    public static void main(String[] args) {
        int[] array1 = {6,7,8,9,0};
        int[] array2 = {1,2,3,4,5};
        // 注意这不是动态扩容，需要注意，不要超出数组下标
        System.arraycopy(array1,1,array2,0,3);
        // 输出：[7, 8, 9, 4, 5]
        System.out.println(Arrays.toString(array2));
        // 输出：1609466880620
        System.out.println(System.currentTimeMillis());
        System.gc();
        System.exit(0);
    }
}

十、String

// 通过new产生的对象，不管内容是否相同，也是两个对象
// s1和s2因为内容相同，引用的是同一块内存地址
String s1 = "123123";
String s2 = "123123";
String s3 = new String("123123");

字符串常量池

方法区，又称永久代，常称为PermGen,位于非堆空间，又称非堆区
方法区是被所有线程共享。
	所有字段和方法字节码以及一些特殊方法如构造方法，接口代码也在此定义。
	简单说，所有定义的方法的信息都保存在该区域，此区属于共享区间
	这些区域存储的是：静态变量+常量+类信息（构造方法/接口定义）+运行时常量池

但是，实例变量存在堆内存中，和方法区无关。

以上，只是逻辑的定义，在HotSpot中，方法区仅仅只是逻辑上的独立，实
际上还是包含在Java堆中，也就是说，方法区在物理上属于Java堆区中的
一部分，而永久区就是方法区的实现。

2.堆
一个JVM实例只存在一个堆内存中，堆内存的大小是可以调节的。类加载器
读取了类文件后，需要把类、方法、常变量放到堆内存中，保留所有引用
类型的真实信息，以方便执行器执行

堆 在逻辑上分为三部分
新生代，常称为YoungGen
老年代，常称为oldGen
永久代，常称为PermGen
2.1 新生区
位于堆空间，又分为Eder区和Survior(幸存区)
Eder:新创建的对象
Survior:经过垃圾回收，但是垃圾回收次数小于15次的对象
2.2 老年代
位于堆空间，垃圾回收次数大于15次，依然存活的对象
2.3 永久区
位于非堆空间
永久区是一个常驻内存区域，用于存放JDK自身所携带的Class,Interface的
元数组，也就是说它存储的是运行环境必须的类信息，被装载进此区域的
数据是不会被垃圾回收器回收掉的，关闭JVM才会释放此区域所占用的内存

• charAt(int index):返回索引index处的字符
• toCharArray():将字符串转换为新的字符数组
• String substring(int beginIndex):返回从开始索引值下标到字符串结尾
• String substring(int beginIndex，int endIndex):左闭右开，返回从开始到endIndex-1的子字符串
• int lastIndexOf(int ch):ch是Unicode编码，返回指定字符串最后一次出现的字符串中的索引
• public int lastIndexOf​(int ch, int fromIndex)：返回指定字符最后一次出现的字符串中的索引，从指定的索引开始向后搜索。
• public int lastIndexOf​(String str)：返回指定子字符串最后一次出现的字符串中的索引。 最后一次出现空字符串“”被认为发生在索引值this.length() 。
• public int lastIndexOf​(String str, int fromIndex)：返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。

转自:https://blog.csdn.net/qq_38679239/article/details/111991601?utm_medium=distribute.pc_category.none-task-blog-hot-9.nonecase&depth_1-utm_source=distribute.pc_category.none-task-blog-hot-9.nonecase