Java核心常用类库

一、泛型

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

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

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

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

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

Date类表示特定的时刻，精度为毫秒。
大多数方法已过时，从JDK 1.1开始， Calendar类应该用于在日期和时间字段之间进行转换，而DateFormat类应该用于格式化和解析日期字符串。不推荐使用Date中的相应方法。
long getTime() 返回自此Date对象表示的1970年1月1日东八区的早上八点以来的毫秒数。
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

相关阅读:
SQL 将查询结果插入到另一张表中
 IntelliJ IDEA 的使用方法总结
 IntelliJ IDEA 常用快捷键使用说明
 从零打造在线网盘系统之Struts2框架配置全解析
 从零打造在线网盘系统之Struts2框架核心功能全解析
 从零打造在线网盘系统之Struts2框架起步
 从零打造在线网盘系统之Hibernate配置O/R映射
 从零打造在线网盘系统之Hibernate查询与更新技术
 从零打造在线网盘系统之Hibernate框架起步
 善用缓存提高你的Spring工程效率
原文地址：https://www.cnblogs.com/coder-ahao/p/14224054.html

最新文章
差分隐私
 拉普拉斯（Laplace）分布
 随机森林
 maven常用插件总结
 C#安全API
C#常用代码
 语义化版本
 Homebrew
Android系统目录结构
 Samba服务