java常用类库 源码_Java核心常用类库

一、泛型

概念：

泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定 义成参数形式(可以称之为类型形参)，然后在使用/调用时传入具体的类型(类型实参)。

定义泛型所使用的字母有一些是特定的，比如E是element元素的意思，用来表示容积，后续会学习其他的特定字母。

应用：泛型接口(实现接口时，可以选择指定泛型类型，也可以选择不指定)、泛型类(使用情况最多)、泛型方法

作用：

1、 提高代码复用率 2、 泛型中的类型在使用时指定，不需要强制类型转换(类型安全，编译器会检查类型)

// 右侧尖括号内正常情况下也应该写上String类型，但是在jdk1.7版本之后，可以省略

Person p = new Person();

1

2

可以同时指定多个泛型，

注意：

在编译之后程序会采取去泛型化的措施。

也就是说Java中的泛型，只在编译阶段有效。 在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加 类型检查和类型转换的方法。

也就是说，泛型信息不会进入到运行时阶段。

类型受限：

在使用泛型时， 可以指定泛型的限定区域。例如： 必须是某某类的子类或 某某接口的实现类，格式：

通配符？：

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