JAVA核心技术（1）泛型、常用工具类、集合

public class Person<T> {
        private T data;
        private String name;

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }
        
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
        
    }

2、实现接口时，可以选择指定泛型类型，也可以选择不指定，如下：

指定类型：
    public class Interface1 implements IntercaceName<String> {
        private String text;

        @Override
        public String getData() {
            return text;
        }
    }

    不指定类型：在new对象的时候，再指定泛型类型

    public class Interface1<T> implements IntercaceName<T> {
        private T data;

        @Override
        public T getData() {
            return data;
        }
    }

3、泛型方法

private static <T> T 方法名(T a, T b) {}
public class Main {
    public static void main(String[] args) {
        Object a = say("111");
        System.out.println(a);
    }

    public static <T> T say(T a) {
        System.out.println(a);
        return a;
    }
}

4、泛型限制类型

public class Main {
    public static void main(String[] args) {
        Plate<Apple> p = new Plate<>();
        Apple apple = new Apple("一个苹果");
        p.say(apple);
    }

}
interface Fruit{}
class Apple implements Fruit{
    private String name;

    public Apple(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Plate<T extends Fruit> {
    void say(T t){
        System.out.println(t);
    }
}

5、泛型通配符

类型通配符是使用？代替方法具体的类型实参。

1 <? extends Parent> 指定了泛型类型的上届

2 <? super Child> 指定了泛型类型的下届

3 <?> 指定了没有限制的泛型类型

作用：

1、提高代码复用率

2、泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

注意：

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

二、Objects工具类

变量和类型	方法	描述
static int	checkFromIndexSize(int fromIndex, int size, int length)	检查是否在子范围从 fromIndex （包括）到 fromIndex + size （不包括）是范围界限内 0 （包括）到 length （不包括）。
static int	checkFromToIndex(int fromIndex, int toIndex, int length)	检查是否在子范围从 fromIndex （包括）到 toIndex （不包括）是范围界限内 0 （包括）到 length （不包括）。
static int	checkIndex(int index, int length)	检查 index是否在 0 （含）到 length （不包括）范围内。
static <T> int	compare(T a, T b, Comparator<? super T> c)	如果参数相同则返回0，否则返回 c.compare(a, b) 。
static boolean	deepEquals(Object a, Object b)	返回 true如果参数是深层相等，彼此 false其他。
static boolean	equals(Object a, Object b)	返回 true如果参数相等，彼此 false其他。
static int	hash(Object... values)	为一系列输入值生成哈希码。
static int	hashCode(Object o)	返回非的哈希码 null参数，0为 null的论点。
static boolean	isNull(Object obj)	返回 true如果提供的参考是 null ，否则返回 false 。
static boolean	nonNull(Object obj)	返回 true如果提供的参考是非 null否则返回 false 。
static <T> T	requireNonNull(T obj)	检查指定的对象引用是否不是 null 。
static <T> T	requireNonNull(T obj, String message)	检查指定的对象引用是否为null ，如果是，则抛出自定义的NullPointerException 。
static <T> T	requireNonNull(T obj, Supplier<String> messageSupplier)	检查指定的对象引用是否为null ，如果是，则抛出自定义的NullPointerException 。
static <T> T	requireNonNullElse(T obj, T defaultObj)	如果它是非 null ，则返回第一个参数，否则返回非 null第二个参数。
static <T> T	requireNonNullElseGet(T obj, Supplier<? extends T> supplier)	如果它是非 null ，则返回第一个参数，否则返回非 null值 supplier.get() 。
static String	toString(Object o)	返回调用的结果 toString对于非 null参数， "null"为 null的说法。
static String	toString(Object o, String nullDefault)	如果第一个参数不是 null ，则返回在第一个参数上调用 toString的结果，否则返回第二个参数。

三、Math工具类

变量和类型	方法	描述
static double	abs(double a)	返回 double值的绝对值。
static float	abs(float a)	返回 float值的绝对值。
static int	abs(int a)	返回 int值的绝对值。
static long	abs(long a)	返回 long值的绝对值。
static double	acos(double a)	返回值的反余弦值; 返回的角度在0.0到pi的范围内。
static int	addExact(int x, int y)	返回其参数的总和，如果结果溢出 int则抛出异常。
static long	addExact(long x, long y)	返回其参数的总和，如果结果溢出 long则抛出异常。
static double	asin(double a)	返回值的反正弦值; 返回的角度在-pi / 2到pi / 2的范围内。
static double	atan(double a)	返回值的反正切值; 返回的角度在-pi / 2到pi / 2的范围内。
static double	atan2(double y, double x)	返回从直角坐标（转换角度 theta x ， y ）为极坐标（R，θ-）。
static double	cbrt(double a)	返回 double值的多维数据集根。
static double	ceil(double a)	返回大于或等于参数且等于数学整数的最小值（最接近负无穷大） double 。
static double	copySign(double magnitude, double sign)	返回带有第二个浮点参数符号的第一个浮点参数。
static float	copySign(float magnitude, float sign)	返回带有第二个浮点参数符号的第一个浮点参数。
static double	cos(double a)	返回角度的三角余弦值。
static double	cosh(double x)	返回 double值的双曲余弦值。
static int	decrementExact(int a)	返回参数递减1，如果结果溢出 int则抛出异常。
static long	decrementExact(long a)	返回参数递减1，如果结果溢出 long则抛出异常。
static double	exp(double a)	返回Euler的数字 e ，其值 double值。
static double	expm1(double x)	返回 e x -1。
static double	floor(double a)	返回小于或等于参数且等于数学整数的最大值（最接近正无穷大） double 。
static int	floorDiv(int x, int y)	返回小于或等于代数商的最大值（最接近正无穷大） int 。
static long	floorDiv(long x, int y)	返回小于或等于代数商的最大值（最接近正无穷大） long 。
static long	floorDiv(long x, long y)	返回小于或等于代数商的最大值（最接近正无穷大） long 。
static int	floorMod(int x, int y)	返回 int参数的floor模数。
static int	floorMod(long x, int y)	返回 long和 int参数的floor数。
static long	floorMod(long x, long y)	返回 long参数的floor模数。
static double	fma(double a, double b, double c)	返回三个参数的融合乘法加法; 也就是说，返回与第三个参数相加的前两个参数的精确乘积，然后舍入一次到最接近的double 。
static float	fma(float a, float b, float c)	返回三个参数的融合乘法加法; 也就是说，返回与第三个参数相加的前两个参数的精确乘积，然后舍入一次到最接近的float 。
static int	getExponent(double d)	返回 double表示中使用的无偏指数。
static int	getExponent(float f)	返回 float表示中使用的无偏指数。
static double	hypot(double x, double y)	返回sqrt（ x 2 + y 2 ），没有中间溢出或下溢。
static double	IEEEremainder(double f1, double f2)	根据IEEE 754标准规定，计算两个参数的余数运算。
static int	incrementExact(int a)	返回以1递增的参数，如果结果溢出 int则抛出异常。
static long	incrementExact(long a)	返回以1递增的参数，如果结果溢出 long则抛出异常。
static double	log(double a)	返回 double值的自然对数（基数 e ）。
static double	log10(double a)	返回 double值的基数10对数。
static double	log1p(double x)	返回参数和的总和的自然对数。
static double	max(double a, double b)	返回两个 double值中较大的 double 。
static float	max(float a, float b)	返回两个 float值中较大的 float 。
static int	max(int a, int b)	返回两个 int值中较大的 int 。
static long	max(long a, long b)	返回两个 long值中较大的 long 。
static double	min(double a, double b)	返回两个 double值中较小的 double 。
static float	min(float a, float b)	返回两个 float值中较小的 float 。
static int	min(int a, int b)	返回两个 int值中较小的 int 。
static long	min(long a, long b)	返回两个 long值中较小的 long 。
static int	multiplyExact(int x, int y)	返回参数的乘积，如果结果溢出 int则抛出异常。
static long	multiplyExact(long x, int y)	返回参数的乘积，如果结果溢出 long则抛出异常。
static long	multiplyExact(long x, long y)	返回参数的乘积，如果结果溢出 long则抛出异常。
static long	multiplyFull(int x, int y)	返回参数的确切数学乘积。
static long	multiplyHigh(long x, long y)	返回 long作为两个64位因子的128位乘积的最高64位。
static int	negateExact(int a)	返回参数的否定，如果结果溢出 int则抛出异常。
static long	negateExact(long a)	返回参数的否定，如果结果溢出 long则抛出异常。
static double	nextAfter(double start, double direction)	返回第二个参数方向上第一个参数旁边的浮点数。
static float	nextAfter(float start, double direction)	返回第二个参数方向上第一个参数旁边的浮点数。
static double	nextDown(double d)	返回负无穷大方向上与 d相邻的浮点值。
static float	nextDown(float f)	返回负无穷大方向上与 f相邻的浮点值。
static double	nextUp(double d)	返回正无穷大方向上与 d相邻的浮点值。
static float	nextUp(float f)	返回正无穷大方向上与 f相邻的浮点值。
static double	pow(double a, double b)	返回第一个参数的值，该值是第二个参数的幂。
static double	random()	返回带有正号的 double值，大于或等于 0.0且小于 1.0 。
static double	rint(double a)	返回与 double值最接近的 double值，该值等于数学整数。
static long	round(double a)	返回与参数最接近的 long ，并将关系四舍五入为正无穷大。
static int	round(float a)	返回与参数最接近的 int ，并将关系四舍五入为正无穷大。
static double	scalb(double d, int scaleFactor)	返回 d ×2 scaleFactor舍入，就像通过单个正确舍入的浮点乘以双 scaleFactor值集的成员一样。
static float	scalb(float f, int scaleFactor)	返回 f ×2 scaleFactor舍入，就像通过单个正确舍入的浮点乘以浮点值集的成员一样。
static double	signum(double d)	返回参数的signum函数; 如果参数为零，则为零;如果参数大于零，则为1.0;如果参数小于零，则为-1.0。
static float	signum(float f)	返回参数的signum函数; 如果参数为零则为零，如果参数大于零则为1.0f，如果参数小于零则为-1.0f。
static double	sin(double a)	返回角度的三角正弦值。
static double	sinh(double x)	返回 double值的双曲正弦值。
static double	sqrt(double a)	返回 double值的正确舍入正平方根。
static int	subtractExact(int x, int y)	返回参数的差异，如果结果溢出 int则抛出异常。
static long	subtractExact(long x, long y)	返回参数的差异，如果结果溢出 long则抛出异常。
static double	tan(double a)	返回角度的三角正切。
static double	tanh(double x)	返回 double值的双曲正切值。
static double	toDegrees(double angrad)	将以弧度测量的角度转换为以度为单位测量的近似等效角度。
static int	toIntExact(long value)	返回long参数的值; 如果值溢出int则抛出异常。
static double	toRadians(double angdeg)	将以度为单位测量的角度转换为以弧度为单位测量的近似等效角度。
static double	ulp(double d)	返回参数的ulp大小。
static float	ulp(float f)	返回参数的ulp大小。

四、Arrays工具类

变量和类型	方法	描述
static <T> List<T>	asList(T... a)	返回由指定数组支持的固定大小的列表。
static int	binarySearch(byte[] a, byte key)	使用二进制搜索算法在指定的字节数组中搜索指定的值。
static int	binarySearch(byte[] a, int fromIndex, int toIndex, byte key)	使用二进制搜索算法搜索指定值的指定字节数组的范围。
static int	binarySearch(char[] a, char key)	使用二进制搜索算法在指定的字符数组中搜索指定的值。
static int	binarySearch(char[] a, int fromIndex, int toIndex, char key)	使用二进制搜索算法搜索指定值的指定数组的范围。
static int	binarySearch(double[] a, double key)	使用二进制搜索算法在指定的双精度数组中搜索指定的值。
static int	binarySearch(double[] a, int fromIndex, int toIndex, double key)	使用二进制搜索算法搜索指定值的指定数组的范围。
static int	binarySearch(float[] a, float key)	使用二进制搜索算法在指定的浮点数组中搜索指定的值。
static int	binarySearch(float[] a, int fromIndex, int toIndex, float key)	使用二进制搜索算法搜索指定值的指定浮点数范围。
static int	binarySearch(int[] a, int key)	使用二进制搜索算法在指定的int数组中搜索指定的值。
static int	binarySearch(int[] a, int fromIndex, int toIndex, int key)	使用二进制搜索算法搜索指定值的指定数组的范围。
static int	binarySearch(long[] a, int fromIndex, int toIndex, long key)	使用二进制搜索算法搜索指定值的指定数组的范围。
static int	binarySearch(long[] a, long key)	使用二进制搜索算法在指定的long数组中搜索指定的值。
static int	binarySearch(short[] a, int fromIndex, int toIndex, short key)	使用二进制搜索算法搜索指定值的指定数组的范围。
static int	binarySearch(short[] a, short key)	使用二进制搜索算法在指定的short数组中搜索指定的值。
static int	binarySearch(Object[] a, int fromIndex, int toIndex, Object key)	使用二进制搜索算法搜索指定对象的指定数组范围。
static int	binarySearch(Object[] a, Object key)	使用二进制搜索算法在指定的数组中搜索指定的对象。
static <T> int	binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)	使用二进制搜索算法搜索指定对象的指定数组范围。
static <T> int	binarySearch(T[] a, T key, Comparator<? super T> c)	使用二进制搜索算法在指定的数组中搜索指定的对象。
static int	compare(boolean[] a, boolean[] b)	boolean字典顺序比较两个 boolean阵列。
static int	compare(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 boolean阵列。
static int	compare(byte[] a, byte[] b)	byte字典顺序比较两个 byte阵列。
static int	compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 byte阵列。
static int	compare(char[] a, char[] b)	char字典顺序比较两个 char阵列。
static int	compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 char阵列。
static int	compare(double[] a, double[] b)	double字典顺序比较两个 double阵列。
static int	compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 double阵列。
static int	compare(float[] a, float[] b)	float字典顺序比较两个 float阵列。
static int	compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 float阵列。
static int	compare(int[] a, int[] b)	int字典顺序比较两个 int阵列。
static int	compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 int阵列。
static int	compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 long阵列。
static int	compare(long[] a, long[] b)	long字典顺序比较两个 long阵列。
static int	compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 short阵列。
static int	compare(short[] a, short[] b)	short字典顺序比较两个 short阵列。
static <T extends Comparable<? super T>> int	compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 Object阵列。
static <T> int	compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)	在指定范围内按字典顺序比较两个 Object阵列。
static <T extends Comparable<? super T>> int	compare(T[] a, T[] b)	按 Object顺序比较两个 Object阵列，在可比元素中。
static <T> int	compare(T[] a, T[] b, Comparator<? super T> cmp)	使用指定的比较器按字典顺序比较两个 Object阵列。
static int	compareUnsigned(byte[] a, byte[] b)	byte字典顺序比较两个 byte阵列，数字处理元素为无符号。
static int	compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 byte阵列，将元素数字处理为无符号。
static int	compareUnsigned(int[] a, int[] b)	int字典顺序比较两个 int阵列，数字处理元素为无符号。
static int	compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 int数组，将数字按数字处理为无符号。
static int	compareUnsigned(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 long阵列，将元素数字处理为无符号。
static int	compareUnsigned(long[] a, long[] b)	long字典顺序比较两个 long阵列，数字处理元素为无符号。
static int	compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	在指定范围内按字典顺序比较两个 short阵列，将元素数字处理为无符号。
static int	compareUnsigned(short[] a, short[] b)	short字典顺序比较两个 short阵列，数字处理元素为无符号。
static boolean[]	copyOf(boolean[] original, int newLength)	使用 false （如有必要）复制指定的数组，截断或填充，以使副本具有指定的长度。
static byte[]	copyOf(byte[] original, int newLength)	使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
static char[]	copyOf(char[] original, int newLength)	使用空字符复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
static double[]	copyOf(double[] original, int newLength)	使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
static float[]	copyOf(float[] original, int newLength)	使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
static int[]	copyOf(int[] original, int newLength)	使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
static long[]	copyOf(long[] original, int newLength)	使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
static short[]	copyOf(short[] original, int newLength)	使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
static <T> T[]	copyOf(T[] original, int newLength)	使用空值复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
static <T,U> T[]	copyOf(U[] original, int newLength, 类<? extends T[]> newType)	使用空值复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
static boolean[]	copyOfRange(boolean[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static byte[]	copyOfRange(byte[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static char[]	copyOfRange(char[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static double[]	copyOfRange(double[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static float[]	copyOfRange(float[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static int[]	copyOfRange(int[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static long[]	copyOfRange(long[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static short[]	copyOfRange(short[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static <T> T[]	copyOfRange(T[] original, int from, int to)	将指定数组的指定范围复制到新数组中。
static <T,U> T[]	copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType)	将指定数组的指定范围复制到新数组中。
static boolean	deepEquals(Object[] a1, Object[] a2)	如果两个指定的数组彼此深度相等，则返回 true 。
static int	deepHashCode(Object[] a)	返回基于指定数组的“深层内容”的哈希码。
static String	deepToString(Object[] a)	返回指定数组的“深层内容”的字符串表示形式。
static boolean	equals(boolean[] a, boolean[] a2)	如果两个指定的布尔数组彼此相等，则返回 true 。
static boolean	equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)	如果两个指定的布尔数组在指定范围内彼此相等，则返回true。
static boolean	equals(byte[] a, byte[] a2)	如果两个指定的字节数组彼此相等，则返回 true 。
static boolean	equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定字节数彼此相等，则返回true。
static boolean	equals(char[] a, char[] a2)	如果两个指定的字符数组彼此相等，则返回 true 。
static boolean	equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)	如果两个指定的chars数组在指定范围内彼此相等，则返回true。
static boolean	equals(double[] a, double[] a2)	如果两个指定的双精度数组彼此相等，则返回 true 。
static boolean	equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定的双精度数组彼此相等，则返回true。
static boolean	equals(float[] a, float[] a2)	如果两个指定的浮点数组彼此相等，则返回 true 。
static boolean	equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)	如果两个指定的浮点数组在指定范围内彼此相等，则返回true。
static boolean	equals(int[] a, int[] a2)	如果两个指定的int数组彼此相等，则返回 true 。
static boolean	equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定的int数组彼此相等，则返回true。
static boolean	equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)	如果指定范围内的两个指定long数组彼此相等，则返回true。
static boolean	equals(long[] a, long[] a2)	如果两个指定的long数组彼此相等，则返回 true 。
static boolean	equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	如果超过指定范围的两个指定的short数组彼此相等，则返回true。
static boolean	equals(short[] a, short[] a2)	如果两个指定的short数组彼此相等，则返回 true 。
static boolean	equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)	如果在指定范围内指定的两个Object数组彼此相等，则返回true。
static boolean	equals(Object[] a, Object[] a2)	如果两个指定的Objects数组彼此相等，则返回 true 。
static <T> boolean	equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)	如果在指定范围内指定的两个Object数组彼此相等，则返回true。
static <T> boolean	equals(T[] a, T[] a2, Comparator<? super T> cmp)	如果两个指定的Objects数组彼此相等，则返回 true 。
static void	fill(boolean[] a, boolean val)	将指定的布尔值分配给指定的布尔数组的每个元素。
static void	fill(boolean[] a, int fromIndex, int toIndex, boolean val)	将指定的布尔值分配给指定的布尔数组的指定范围的每个元素。
static void	fill(byte[] a, byte val)	将指定的字节值分配给指定字节数组的每个元素。
static void	fill(byte[] a, int fromIndex, int toIndex, byte val)	将指定的字节值分配给指定字节数组的指定范围的每个元素。
static void	fill(char[] a, char val)	将指定的char值分配给指定的chars数组的每个元素。
static void	fill(char[] a, int fromIndex, int toIndex, char val)	将指定的char值分配给指定的chars数组的指定范围的每个元素。
static void	fill(double[] a, double val)	将指定的double值分配给指定的double数组的每个元素。
static void	fill(double[] a, int fromIndex, int toIndex, double val)	将指定的double值分配给指定的double数组的指定范围的每个元素。
static void	fill(float[] a, float val)	将指定的float值分配给指定浮点数组的每个元素。
static void	fill(float[] a, int fromIndex, int toIndex, float val)	将指定的float值分配给指定浮点数组的指定范围的每个元素。
static void	fill(int[] a, int val)	将指定的int值分配给指定的int数组的每个元素。
static void	fill(int[] a, int fromIndex, int toIndex, int val)	将指定的int值分配给指定的int数组的指定范围的每个元素。
static void	fill(long[] a, int fromIndex, int toIndex, long val)	将指定的long值分配给指定long数组的指定范围的每个元素。
static void	fill(long[] a, long val)	将指定的long值分配给指定longs数组的每个元素。
static void	fill(short[] a, int fromIndex, int toIndex, short val)	将指定的short值分配给指定short类数组的指定范围的每个元素。
static void	fill(short[] a, short val)	为指定的short数组的每个元素指定指定的short值。
static void	fill(Object[] a, int fromIndex, int toIndex, Object val)	将指定的Object引用分配给指定Object对象的指定范围的每个元素。
static void	fill(Object[] a, Object val)	将指定的Object引用分配给指定的Objects数组的每个元素。
static int	hashCode(boolean[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(byte[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(char[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(double[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(float[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(int[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(long[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(short[] a)	根据指定数组的内容返回哈希码。
static int	hashCode(Object[] a)	根据指定数组的内容返回哈希码。
static int	mismatch(boolean[] a, boolean[] b)	查找并返回两个 boolean数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static int	mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 boolean数组之间第一个不匹配的相对索引，否则返回-1（如果未找到不匹配）。
static int	mismatch(byte[] a, byte[] b)	查找并返回两个 byte数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static int	mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 byte数组之间第一个不匹配的相对索引，否则返回-1（如果未找到不匹配）。
static int	mismatch(char[] a, char[] b)	查找并返回两个 char数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static int	mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 char数组之间第一个不匹配的相对索引，否则返回-1（如果未找到不匹配）。
static int	mismatch(double[] a, double[] b)	查找并返回两个 double数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static int	mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 double数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。
static int	mismatch(float[] a, float[] b)	查找并返回两个 float数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static int	mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 float数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。
static int	mismatch(int[] a, int[] b)	查找并返回两个 int数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static int	mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 int数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。
static int	mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 long数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。
static int	mismatch(long[] a, long[] b)	查找并返回两个 long数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static int	mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 short数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。
static int	mismatch(short[] a, short[] b)	查找并返回两个 short数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static int	mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)	查找并返回指定范围内两个 Object数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。
static int	mismatch(Object[] a, Object[] b)	查找并返回两个 Object数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static <T> int	mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)	查找并返回指定范围内两个 Object数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。
static <T> int	mismatch(T[] a, T[] b, Comparator<? super T> cmp)	查找并返回两个 Object数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。
static void	parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)	对于给定的数组子范围执行 parallelPrefix(double[], DoubleBinaryOperator) 。
static void	parallelPrefix(double[] array, DoubleBinaryOperator op)	使用提供的函数并行地累积给定数组的每个元素。
static void	parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)	对于给定的数组子范围执行 parallelPrefix(int[], IntBinaryOperator) 。
static void	parallelPrefix(int[] array, IntBinaryOperator op)	使用提供的函数并行地累积给定数组的每个元素。
static void	parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)	对于给定的数组子范围执行 parallelPrefix(long[], LongBinaryOperator) 。
static void	parallelPrefix(long[] array, LongBinaryOperator op)	使用提供的函数并行地累积给定数组的每个元素。
static <T> void	parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)	对于给定的数组子范围执行 parallelPrefix(Object[], BinaryOperator) 。
static <T> void	parallelPrefix(T[] array, BinaryOperator<T> op)	使用提供的函数并行地累积给定数组的每个元素。
static void	parallelSetAll(double[] array, IntToDoubleFunction generator)	使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素。
static void	parallelSetAll(int[] array, IntUnaryOperator generator)	使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素。
static void	parallelSetAll(long[] array, IntToLongFunction generator)	使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素。
static <T> void	parallelSetAll(T[] array, IntFunction<? extends T> generator)	使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素。
static void	parallelSort(byte[] a)	将指定的数组按升序排序。
static void	parallelSort(byte[] a, int fromIndex, int toIndex)	将指定的数组范围按数字升序排序。
static void	parallelSort(char[] a)	将指定的数组按升序排序。
static void	parallelSort(char[] a, int fromIndex, int toIndex)	将指定的数组范围按数字升序排序。
static void	parallelSort(double[] a)	将指定的数组按升序排序。
static void	parallelSort(double[] a, int fromIndex, int toIndex)	将指定的数组范围按数字升序排序。
static void	parallelSort(float[] a)	将指定的数组按升序排序。
static void	parallelSort(float[] a, int fromIndex, int toIndex)	将指定的数组范围按数字升序排序。
static void	parallelSort(int[] a)	将指定的数组按升序排序。
static void	parallelSort(int[] a, int fromIndex, int toIndex)	将指定的数组范围按数字升序排序。
static void	parallelSort(long[] a)	将指定的数组按升序排序。
static void	parallelSort(long[] a, int fromIndex, int toIndex)	将指定的数组范围按数字升序排序。
static void	parallelSort(short[] a)	将指定的数组按升序排序。
static void	parallelSort(short[] a, int fromIndex, int toIndex)	将指定的数组范围按数字升序排序。
static <T extends Comparable<? super T>> void	parallelSort(T[] a)	根据元素的natural ordering对指定的对象数组按升序排序。
static <T extends Comparable<? super T>> void	parallelSort(T[] a, int fromIndex, int toIndex)	根据元素的natural ordering ，将指定对象数组的指定范围按升序排序。
static <T> void	parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)	根据指定比较器引发的顺序对指定对象数组的指定范围进行排序。
static <T> void	parallelSort(T[] a, Comparator<? super T> cmp)	根据指定比较器引发的顺序对指定的对象数组进行排序。
static void	setAll(double[] array, IntToDoubleFunction generator)	使用提供的生成器函数设置指定数组的所有元素以计算每个元素。
static void	setAll(int[] array, IntUnaryOperator generator)	使用提供的生成器函数设置指定数组的所有元素以计算每个元素。
static void	setAll(long[] array, IntToLongFunction generator)	使用提供的生成器函数设置指定数组的所有元素以计算每个元素。
static <T> void	setAll(T[] array, IntFunction<? extends T> generator)	使用提供的生成器函数设置指定数组的所有元素以计算每个元素。
static void	sort(byte[] a)	将指定的数组按升序排序。
static void	sort(byte[] a, int fromIndex, int toIndex)	按升序对数组的指定范围进行排序。
static void	sort(char[] a)	将指定的数组按升序排序。
static void	sort(char[] a, int fromIndex, int toIndex)	按升序对数组的指定范围进行排序。
static void	sort(double[] a)	将指定的数组按升序排序。
static void	sort(double[] a, int fromIndex, int toIndex)	按升序对数组的指定范围进行排序。
static void	sort(float[] a)	将指定的数组按升序排序。
static void	sort(float[] a, int fromIndex, int toIndex)	按升序对数组的指定范围进行排序。
static void	sort(int[] a)	将指定的数组按升序排序。
static void	sort(int[] a, int fromIndex, int toIndex)	按升序对数组的指定范围进行排序。
static void	sort(long[] a)	将指定的数组按升序排序。
static void	sort(long[] a, int fromIndex, int toIndex)	按升序对数组的指定范围进行排序。
static void	sort(short[] a)	将指定的数组按升序排序。
static void	sort(short[] a, int fromIndex, int toIndex)	按升序对数组的指定范围进行排序。
static void	sort(Object[] a)	根据元素的natural ordering ，将指定的对象数组按升序排序。
static void	sort(Object[] a, int fromIndex, int toIndex)	根据元素的natural ordering ，将指定对象数组的指定范围按升序排序。
static <T> void	sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)	根据指定比较器引发的顺序对指定对象数组的指定范围进行排序。
static <T> void	sort(T[] a, Comparator<? super T> c)	根据指定比较器引发的顺序对指定的对象数组进行排序。
static Spliterator.OfDouble	spliterator(double[] array)	返回覆盖所有指定数组的Spliterator.OfDouble 。
static Spliterator.OfDouble	spliterator(double[] array, int startInclusive, int endExclusive)	返回覆盖指定数组的指定范围的Spliterator.OfDouble 。
static Spliterator.OfInt	spliterator(int[] array)	返回覆盖所有指定数组的Spliterator.OfInt 。
static Spliterator.OfInt	spliterator(int[] array, int startInclusive, int endExclusive)	返回覆盖指定数组的指定范围的Spliterator.OfInt 。
static Spliterator.OfLong	spliterator(long[] array)	返回覆盖所有指定数组的Spliterator.OfLong 。
static Spliterator.OfLong	spliterator(long[] array, int startInclusive, int endExclusive)	返回覆盖指定数组的指定范围的Spliterator.OfLong 。
static <T> Spliterator<T>	spliterator(T[] array)	返回覆盖所有指定数组的Spliterator 。
static <T> Spliterator<T>	spliterator(T[] array, int startInclusive, int endExclusive)	返回覆盖指定数组的指定范围的Spliterator 。
static DoubleStream	stream(double[] array)	返回以指定数组作为源的顺序DoubleStream 。
static DoubleStream	stream(double[] array, int startInclusive, int endExclusive)	返回指定数组的指定范围作为其源的顺序DoubleStream 。
static IntStream	stream(int[] array)	返回以指定数组作为源的顺序IntStream 。
static IntStream	stream(int[] array, int startInclusive, int endExclusive)	返回指定数组的指定范围作为其源的顺序IntStream 。
static LongStream	stream(long[] array)	返回以指定数组作为源的顺序LongStream 。
static LongStream	stream(long[] array, int startInclusive, int endExclusive)	返回指定数组的指定范围作为其源的顺序LongStream 。
static <T> Stream<T>	stream(T[] array)	返回以指定数组作为源的顺序Stream 。
static <T> Stream<T>	stream(T[] array, int startInclusive, int endExclusive)	返回指定数组的指定范围作为其源的顺序Stream 。
static String	toString(boolean[] a)	返回指定数组内容的字符串表示形式。
static String	toString(byte[] a)	返回指定数组内容的字符串表示形式。
static String	toString(char[] a)	返回指定数组内容的字符串表示形式。
static String	toString(double[] a)	返回指定数组内容的字符串表示形式。
static String	toString(float[] a)	返回指定数组内容的字符串表示形式。
static String	toString(int[] a)	返回指定数组内容的字符串表示形式。
static String	toString(long[] a)	返回指定数组内容的字符串表示形式。
static String	toString(short[] a)	返回指定数组内容的字符串表示形式。
static String	toString(Object[] a)	返回指定数组内容的字符串表示形式。

五、BigDecimal类

用double进行计算时，精确度不会很高，如果进行金额计算或需要高精度的计算时，就要用BigDecimal类进行运算，还可以有四舍五入的方法等。

六、日期工具类

在JDK 1.1之前， Date类还有两个附加功能。它允许将日期解释为年，月，日，小时，分钟和秒值。它还允许格式化和解析日期字符串。不幸的是，这些功能的API不适合国际化。从JDK 1.1开始， Calendar类(日历)应该用于在日期和时间字段之间进行转换，而DateFormat类应该用于格式化和解析日期字符串。不推荐使用Date中的相应方法。

Date

很多方法都过时了，具体看帮助文档

没过时的有，无参构造函数，获取当前时间，不过格式需要进行转换

gettime()方法，获取当前时间的毫秒数，从格林威治时间1970年1月1号0点开始计算的

Dateformat

抽象类，使用时实例化子类SimpleDateformat，获取当前系统日期

SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//format：将Date格式，转换为字符串
String dateStr = format.format(new Date());
System.out.println(dateStr);
//parse：将自己定义的格式的字符串，转换为，Date对象
Date date = format.parse("2022年06月16日 12:26:48");
long time1 = date.getTime();
System.out.println(new Date().getTime()-time1);
System.out.println((new Date().getTime()-time1)/1000/60/60/24);

Letter	Date or Time Component	Presentation	Examples
G	Era designator	Text	AD
y	Year	Year	1996; 96
Y	Week year	Year	2009; 09
M	Month in year (context sensitive)	Month	July; Jul; 07
L	Month in year (standalone form)	Month	July; Jul; 07
w	Week in year	Number	27
W	Week in month	Number	2
D	Day in year	Number	189
d	Day in month	Number	10
F	Day of week in month	Number	2
E	Day name in week	Text	Tuesday; Tue
u	Day number of week (1 = Monday, ..., 7 = Sunday)	Number	1
a	Am/pm marker	Text	PM
H	Hour in day (0-23)	Number	0
k	Hour in day (1-24)	Number	24
K	Hour in am/pm (0-11)	Number	0
h	Hour in am/pm (1-12)	Number	12
m	Minute in hour	Number	30
s	Second in minute	Number	55
S	Millisecond	Number	978
z	Time zone	General time zone	Pacific Standard Time; PST; GMT-08:00
Z	Time zone	RFC 822 time zone	-0800
X	Time zone	ISO 8601 time zone	-08; -0800; -08:00

Calendar

常用方法：set, get ,add ,gettime ,getActualMaximum

Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR, 2099);
int year = calendar.get(Calendar.YEAR);
//这里的月，会-1，所以要手动+1，原因在下面
int month = calendar.get(Calendar.MONTH)+1;
int day = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(year + "-" + month + "-" + day);
calendar.add(Calendar.YEAR, 1);
System.out.println(calendar.get(Calendar.YEAR) + "-" + month + "-" + day);
calendar.add(Calendar.MONTH, 10);
System.out.println(calendar.get(Calendar.YEAR) + "-" + calendar.get(Calendar.MONTH) + "-" + day);

Date date2 = calendar.getTime();
System.out.println(date2);
//获取某个月最大的天数,set月的时候，也要从0开始
calendar.set(Calendar.MONTH, 0);
int m = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
System.out.println(m);
System.out.println(calendar.get(Calendar.MONTH));

注意：

MONTH加1的原因：

public static final int MONTH 指示月份的 get 和 set 的字段数字。这是一个特定于日历的值。在格里高利历和罗马儒略历中一年中的第一个月是 JANUARY，它为 0；最后一个月取决于一年中的月份数。简单来说，因为这个值的初始值是0，因此我们要用它来表示正确的月份时就需要加1。

WEEK减1的原因：

public static final int DAY_OF_WEEK get 和 set 的字段数字，指示一个星期中的某天。该字段可取的值为 SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY 和 SATURDAY 观察代码，你会发现其实week是用来确定随后的字符串week1该如何截取的，我们知道DAY_OF_WEEK是获取当前日期是一周中的第几天，而一周从周日算起，因此当我们取得这个值之后，为了要正确的截取出随后的字符串week1中的那个中文字符，因此它需要减1来达到目的。你只要跟踪一下程序运行，观察变量的赋值就会理解它这样编写的用意了。

定义day时不用的原因：

public static final int DATE get 和 set 的字段数字，指示一个月中的某天。它与 DAY_OF_MONTH 是同义词。一个月中第一天的值为 1。根据定义我们可以知道，这个值取得后不需要做任何变更就是程序需要的值。

substring(week, week+1)：

public String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。根据定义，我们就知道这个方法的用途了。举例来说，假如今天是星期四，那么之前获得的week的值就是4，因为我们取到了DAY_OF_WEEK（这里是5）后又减了1，然后我们用这个变量week来帮助我们截取字符串week1,这里调用了substring(4,5),所以取到的字符就是“四，正是我们需要的字符。

七、System类

currentTimeMillis()获取当前时间毫秒数

gc()运行垃圾回收器

八、String

任何字符串都是String的实例

字符串创建完是不变的，进行拼接操作，实际上是创建一个新的字符串

两个非new出来的字符串如果内容完全相同，则采用同一块内存地址

String str = "abc";
相当于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);

字符串常量池，存在方法区里

方法区，又称为永久代，被所有线程共享，是可以被同时操作的内存区。现在被挪到堆里了

堆：

新生代：刚创建的对象，都存在新生代，GC进行非常快，连续经过15次垃圾回收，都没有被回收，就会放入老年代

老年代：GC进行慢，

永久代：不会被回收，类，方法，常量。JDK8以后永久代被删除，改为用元空间，元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制，可以通过参数调整大小

字符串加法拼接，会占用很多内存，能避免尽量避免。如果无法避免拼接，则用StringBuffer或者StringBuilder

StringBuilder线程不安全，StringBuffer线程安全，

九、集合

1、类集概述

普通数组元素是固定的，所以在 Java 中为了方便用户操作各个数据结构，所以引入了类集的概念，有时候就可以把类集称为 java 对数据结构的实现

Collection 接口是在整个 Java 类集中保存单值的最大操作父接口，里面每次操作的时候都只能保存一个对象的数据

Map接口是在整个 Java 类集中保存键值的最大操作父接口

2、二叉树和链表思路

1.链表：

链表 [Linked List]：链表是由一组不必相连（不必相连：可以连续也可以不连续）的内

存结构（节点），按特定的顺序链接在一起的抽象数据类型。

补充：

抽象数据类型（Abstract Data Type [ADT]）：表示数学中抽象出来的一些操作的集合。

内存结构：内存中的结构，如：struct、特殊内存块...等等之类；

数组和链表的区别和优缺点：

数组是一种连续存储线性结构，元素类型相同，大小相等

数组的优点：

存取速度快

数组的缺点：

事先必须知道数组的长度

插入删除元素很慢

空间通常是有限制的

需要大块连续的内存块

插入删除元素的效率很低

链表是离散存储线性结构

n 个节点离散分配，彼此通过指针相连，每个节点只有一个前驱节点，每个节点只有一

个后续节点，首节点没有前驱节点，尾节点没有后续节点。

链表优点：

空间没有限制

插入删除元素很快

链表缺点：

存取速度很慢

2.二叉树

3、常见的数据结构

1.栈Stack：

又称堆栈，栈（stack）是限定仅在表尾进行插入和删除操作的线性表。我们把允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈。栈又称为先进后出的线性表。

压栈：存元素。

弹栈：取元素。

特点：

先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹

压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后

才能弹出下面的子弹。

栈的入口、出口的都是栈的顶端位置。

2.队列Queue：

只允许在表的一端进行插入，而在另一端进行删除元素的线性表。队尾(rear)是允许插入的一端。队头(front)是

允许删除的一端。空队列是不含元素的空表

特点：先进先出

3.数组Array：

是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个

房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。

特点：

查找元素快：通过索引，可以快速访问指定位置的元素

增删元素慢

指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原

数组元素根据索引，复制到新数组对应索引的位置。

指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应

索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图

4.链表 linkedlist：

由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动

态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的

指针域。我们常说的链表结构有单向链表与双向链表，那么这里给大家介绍的是单向链表。

特点：

查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素

增删元素快：

增加元素：只需要修改连接下个元素的地址即可。

5.树Tree：

二叉树：binary tree ,是每个结点不超过2的有序树（tree）

红黑树：平衡二叉树

1. 节点可以是红色的或者黑色的

2. 根节点是黑色的

3. 叶子节点(特指空节点)是黑色的

4. 每个红色节点的子节点都是黑色的

5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同

红黑树的特点:

速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍

4、Collection接口

存储单值

list接口和set接口的父接口

5、List接口

允许重复

在 List 接口中有以上 10 个方法是对已有的 Collection 接口进行的扩充。

实现类有如下几个：

ArrayList（95%）：线程不安全，基于动态数组的实现

Vector（4%）：线程安全，基于动态数组的实现

LinkedList（1%）：链表

5.1、ArrayList

使用的是数组结构，增加删除慢，查找快。

最大长度为int的最大值

通过无参构造方法，创建的是长度为0的数组，只有第一次add增加的时候，才会设置为默认10的长度

add()方法，永远返回true，添加失败也返回true。每次扩容长度为，旧长度+旧长度二进制右移一位（旧长度除以2）=1.5倍，

5.2、Vector

线程安全的ArrayList

每次扩容增加一倍

有个指定每次扩容增量的构造方法

Vector(int initialCapacity, int capacityIncrement)

构造具有指定初始容量和容量增量的空向量。

5.3、LinkedList

使用的是双向链表结构，增删快，查找慢

可以当做栈使用，push方法压栈，pop方法弹栈。

也队列进行使用 addFirst,removeLast

6、Iterator、ListIterator 迭代器

Iterator:用来遍历Collection和Set下面的所有集合

java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改）。

场景：java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

ListIterator：只能用来遍历List接口下面的集合。

ArrayList<Integer> list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);

Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
    Integer next = iterator.next();
    System.out.println(next);
}
System.out.println("----------");
iterator = list.iterator();
if (iterator.hasNext()) {
    Integer next = iterator.next();
    iterator.remove();
}
while (iterator.hasNext()) {
    Integer next = iterator.next();
    System.out.println(next);
}

7、foreach 增强for循环

最早出现在C#语言中

内部用迭代器，进行遍历，可以遍历数组Array或者Collection下的集合

for (Integer i : list) {
    System.out.println(i);
}

for循环与增强for循环遍历，都不能直接改变集合的值

public class Main {
    public static void main(String[] args) {
        ArrayList<People> peopleList = new ArrayList<>();
        peopleList.add(new People("p1"));
        peopleList.add(new People("p2"));
        peopleList.add(new People("p3"));
        peopleList.add(new People("p4"));
        peopleList.add(new People("p5"));
        for (People p : peopleList) {
            p = new People("ppp1");
        }
        System.out.println(peopleList);
        /*
        输出[People{name='p1'}, People{name='p2'}, People{name='p3'}, People{name='p4'}, People{name='p5'}]
        值没有发生变化，因为list中，存放的其实是一堆内存地址。在循环中，People p是一个新的对象，只是它的指针，指向原本list中对应的对象的内存地址。
        做了p = new People("ppp1")操作后，只是把p的指针指向的内存地址，给进行了变化，并不是把list中原本存放的内存地址进行改变，所以输出的值，与原来相同
        */
        System.out.println("-----------");
        for (People p : peopleList) {
            p.name = "666";
        }
        System.out.println(peopleList);
        /*
        输出[People{name='666'}, People{name='666'}, People{name='666'}, People{name='666'}, People{name='666'}]
        值发生了变化，因为list中，存放的其实是一堆内存地址，在循环中，People p是一个新的对象，只是它的指针，指向原本list中对应的对象的内存地址。
        这时候进行p.name = "666"操作，就是把p指向的对象在内存中的值进行改变，相当于把list中存的内存地址对应的对象的值进行改变，
        而list中存放的内存地址，并没有发生变化，所以输出的值发生了变化
        */
    }
}
class People {
    String name;

    public People(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                '}';
    }
}

7、set集合

不包含重复元素，最多只能存一个null。

遍历或取数据时用toArray或者Iterator或者foreach

不要用set存会变的数据。

7.1HashSet

散列存放（哈希表），基于HashMap进行存储，没有存储顺序

LinkedHashSet：有存储顺序

7.2TreeSet和Comparable接口

用二叉树存放，基础TreeMap进行存储

此类的迭代器是快速失败的

数据是有序的，顺序不是存放时的顺序，是数据的顺序。

所以只要把数据，放进TreeSet，就会自动排序

如果要存放自己定义的对象，必须实现Comparable<>接口

static class People implements Comparable<People>{
    String name;

    public People(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    public int compareTo(People o) {
    //用this与o进行比较
    //返回：负数this小/0一样大/正数this大
    //返回0的话，就无法存入TreeSet
    return this.name.compareTo(o.name);
    }
}

8、Comparator

自行百度

9、Map

键值存储

键不可重复

用keySet方法获取key，然后结合get方法进行遍历key和value。如果只想遍历值，可以用values方法，获取value的Collection

put方法会返回旧值，如果没有旧值，就会返回null

remove方法会根据key删除元素，并返回删除的value

9.1、HashMap与哈希表

对象数组(哈希桶)+链表，链表长度大于等于8后，会转换成二叉树，如果长度减少到6，又会恢复为链表

默认长度16，下标0-15

默认散列因子0.75，如果桶使用到百分之75时，就会扩容，每次扩容容量*2，用于取余的数也*2

散列因子可以通过构造函数设定，设置值越小，占用空间越大，读取速度越快。设置值越大，占用空间越小，读取速度越慢。

如果HashMap的值确定很大，可以通过构造函数，把默认大小设置大些，效率会高

如果key要存入自定义的对象，该对象就要重写hashCode方法和equal方法，且在存放后，如果key的类的内容发生改变，意味着hashCode发生了改变，则再用该key，就找不到value了

9.2、HashMap/HashTable/ConcurrentHashMap区别

TreeMap：不保证存储顺序，自动根据Comparable进行排序

LinkedHashMap：数据存储有序，又拥有高性能

10、JDK9集合新特性

of方法，创建固定长度的，且不可修改的集合

public static void main(String[] args) {
    List<String> list = List.of("1", "2", "3", "4");
    System.out.println(list);
    Set<String> set = Set.of("1", "2", "3", "4", "5");
    System.out.println(set);
    Map<Integer, String> map = Map.of(1, "1", 2, "2", 3, "3");
    System.out.println(map);
}