3.1 核心类库-常用类库

11

---

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、常用类库

1.泛类

1.1 泛类型的使用

泛型：参数化模型（不确定，后续使用时指定类型）

1.2泛型的接口

1.3泛型方法

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

编译之后程序会采取去泛型化措施（泛型只在编译阶段有效）
运行时对传入的对象进行相应类型的生成，即对象进入和离开方法的边界处添加类型检查和类型转换的方法（泛型不进入运行阶段）

1.4泛型的限定和通配符

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

<T extends 类或接口1 & 接口2>

上界限定

指定了泛型类型的上届（限定了父类）
< ? extends Parent>

下界限定

指定了泛型类型的下届（限定了子类）

<? super Child>

1.5 泛型的作用

• 提高代码的复用率
• 类型在使用时绑定，无序强制类型转换

无限制：

• 指定了没有限制的泛型类型
• 区别于Object

2. Objects

2.1 Objects方法

2.2 Objects基本常用方法

equals(Object a, Object b)源码：
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}

isNull(Object obj)源码：
public static boolean isNull(Object obj) {
return obj == null;
}

nonNull(Object obj)源码：
public static boolean nonNull(Object obj) {
return obj != null;
}

requireNonNull(T obj)源码：
public static T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
}

2.3Objects源码

package java.util;

import jdk.internal.util.Preconditions;
import jdk.internal.vm.annotation.ForceInline;

import java.util.function.Supplier;


public final class Objects {
    private Objects() {
        throw new AssertionError("No java.util.Objects instances for you!");
    }


    public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }


    public static boolean deepEquals(Object a, Object b) {
        if (a == b)
            return true;
        else if (a == null || b == null)
            return false;
        else
            return Arrays.deepEquals0(a, b);
    }


    public static int hashCode(Object o) {
        return o != null ? o.hashCode() : 0;
    }

    public static int hash(Object... values) {
        return Arrays.hashCode(values);
    }

    
    public static String toString(Object o) {
        return String.valueOf(o);
    }

    
    public static String toString(Object o, String nullDefault) {
        return (o != null) ? o.toString() : nullDefault;
    }

   
    public static <T> int compare(T a, T b, Comparator<? super T> c) {
        return (a == b) ? 0 :  c.compare(a, b);
    }

    
    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

    
    public static <T> T requireNonNull(T obj, String message) {
        if (obj == null)
            throw new NullPointerException(message);
        return obj;
    }

   
    public static boolean isNull(Object obj) {
        return obj == null;
    }

    
    public static boolean nonNull(Object obj) {
        return obj != null;
    }

    public static <T> T requireNonNullElse(T obj, T defaultObj) {
        return (obj != null) ? obj : requireNonNull(defaultObj, "defaultObj");
    }

   
    public static <T> T requireNonNullElseGet(T obj, Supplier<? extends T> supplier) {
        return (obj != null) ? obj
                : requireNonNull(requireNonNull(supplier, "supplier").get(), "supplier.get()");
    }

    
    public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) {
        if (obj == null)
            throw new NullPointerException(messageSupplier == null ?
                                           null : messageSupplier.get());
        return obj;
    }

   
    @ForceInline
    public static
    int checkIndex(int index, int length) {
        return Preconditions.checkIndex(index, length, null);
    }

   
    public static int checkFromToIndex(int fromIndex, int toIndex, int length) {
        return Preconditions.checkFromToIndex(fromIndex, toIndex, length, null);
    }

   
    public static int checkFromIndexSize(int fromIndex, int size, int length) {
        return Preconditions.checkFromIndexSize(fromIndex, size, length, null);
    }

}

3. Object

3.1 Object和Objects的区别

public Object()

Object类是基类，是所有类的父类（基类）
如果一个类没有明确的继承某一个具体的类，则将默认继承Object类

例如我们定义一个类：
public class Person{
}
其实它被使用时 是这样的：
public class Person extends Object{
}

object的多态：使用Object可以接收任意的引用数据类型：

public static void main(String[] args){
	String text = "123";
	say(text);
	int a = 10;
	say(a);
	say("123");
}
public static void say(Object o){//多态的体现
	System.out.println(o);
}

3.2 Object方法

equals(Object obj)源码：
public boolean equals(Object obj) {
return (this == obj);
}

equals方法在非null对象引用上实现等价关系

等于
对于任何非空引用值x和y，当且仅当x和y引用同一对象（ x == y具有值true ）时，此方法返回true

==比的是内存地址
请注意，通常需要在重写此方法时覆盖hashCode方法，以便维护hashCode方法的常规协定，该方法声明相等对象必须具有相等的哈希代码。

public static void main(String[] args) {
        Person p = new Person(1234,"张三");
        Person e = new Person(2345,"李四");
        System.out.println("p:"+p.hashCode());//p:1239731077
        System.out.println("e:"+e.hashCode());//e:357863579
        System.out.println(p.equals(e));//false
        e=p;//此时指向相同的内存地址
        System.out.println("e:"+e.hashCode());//e:1239731077
        System.out.println(p.equals(e));//true
}
===============================================================
输出结果：
p:1239731077
e:357863579
false
e:1239731077
true

equals方法重写时的五个特性：

• 自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true 。

• 对称性 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)返回true 。

• 传递性 ：对于任何非空引用值x ,y和z ，如果x.equals(y)回报true并且y.equals(z)返回true，x.equals(z)应该返回true 。

• 一致性 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前提是未修改对象上的equals比较中使用的信息。

• 非空性 ：对于任何非空的参考值x ， x.equals(null)应该返回false 。

toString()源码
public String toString() {
return getClass().getName() + “@” + Integer.toHexString(hashCode());
}

默认为字符串，通常返回一个“文本表示”此对象的字符串，返回对象的内存地址（对象实例的类名称@对象的哈希码的无符号十六进制，即：getClass().getName() + ‘@’ + Integer.toHexString(hashCode())）

public static void main(String[] args) {
        Person p = new Person(1234,"张三");
        Person e = new Person(2345,"李四");
        System.out.println("e.getClass()："+e.getClass());
        System.out.println("e.hashCode()："+e.hashCode());
        System.out.println("e.toString()："+e.toString());
}
==============================================
输出结果：
e.getClass():class com.company.demo.Person
e.hashCode():114132791
e.toString():com.company.demo.Person@6cd8737

3.3 Object源码

package java.lang;

import jdk.internal.HotSpotIntrinsicCandidate;

public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }

    @HotSpotIntrinsicCandidate
    public Object() {}

    @HotSpotIntrinsicCandidate
    public final native Class<?> getClass();

    @HotSpotIntrinsicCandidate
    public native int hashCode();

    public boolean equals(Object obj) {
        return (this == obj);
    }

    @HotSpotIntrinsicCandidate
    protected native Object clone() throws CloneNotSupportedException;

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    @HotSpotIntrinsicCandidate
    public final native void notify();

    @HotSpotIntrinsicCandidate
    public final native void notifyAll();

    public final void wait() throws InterruptedException {
        wait(0L);
    }

    public final native void wait(long timeoutMillis) throws InterruptedException;


    public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("timeoutMillis value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeoutMillis++;
        }

        wait(timeoutMillis);
    }


    protected void finalize() throws Throwable { }
}

4.Math

类Math包含用于执行基本数字运算的方法，例如基本指数，对数，平方根和三角函数

4.1 Math常用方法

部分方法源码

	public static long round(double a) {
        long longBits = Double.doubleToRawLongBits(a);
        long biasedExp = (longBits & DoubleConsts.EXP_BIT_MASK)
                >> (DoubleConsts.SIGNIFICAND_WIDTH - 1);
        long shift = (DoubleConsts.SIGNIFICAND_WIDTH - 2
                + DoubleConsts.EXP_BIAS) - biasedExp;
        if ((shift & -64) == 0) { // shift >= 0 && shift < 64
            // a is a finite number such that pow(2,-64) <= ulp(a) < 1
            long r = ((longBits & DoubleConsts.SIGNIF_BIT_MASK)
                    | (DoubleConsts.SIGNIF_BIT_MASK + 1));
            if (longBits < 0) {
                r = -r;
            }
            // In the comments below each Java expression evaluates to the value
            // the corresponding mathematical expression:
            // (r) evaluates to a / ulp(a)
            // (r >> shift) evaluates to floor(a * 2)
            // ((r >> shift) + 1) evaluates to floor((a + 1/2) * 2)
            // (((r >> shift) + 1) >> 1) evaluates to floor(a + 1/2)
            return ((r >> shift) + 1) >> 1;
        } else {
            // a is either
            // - a finite number with abs(a) < exp(2,DoubleConsts.SIGNIFICAND_WIDTH-64) < 1/2
            // - a finite number with ulp(a) >= 1 and hence a is a mathematical integer
            // - an infinity or NaN
            return (long) a;
        }
    }


    public static int max(int a, int b) {
        return (a >= b) ? a : b;
    }
		
		
	 public static int min(int a, int b) {
        return (a <= b) ? a : b;
    }


    public static int abs(int a) {
        return (a < 0) ? -a : a;
    }

具体实现

public class Test {
    public static void main(String[] args) {
        System.out.println("≥3.2的最小整数为："+Math.ceil(3.2));//output:4
        System.out.println("≤3.2的最大整数为："+Math.floor(3.2));//output:3
        System.out.println("3.2四舍五入为："+Math.round(3.2));//output:3
        System.out.println("-1,5中较大的数为："+Math.max(-1,5));//output:5
        System.out.println("-1,5中较小的数为："+Math.min(-1,5));//output:-1
        System.out.println("随机产生[0,5)范围的数"+Math.random()*5);//output:[0,5)中任意的随机数
        System.out.println("25的平方根为："+Math.sqrt(25));//output:5
        System.out.println("-9的绝对值为："+Math.abs(-9));//output:9
        System.out.println("2^3的值为："+Math.pow(2,3));//output:8
        System.out.println("以e为基数的对数为："+Math.log(10));
        System.out.println("以10为基数的对数为："+Math.log10(100));//output:2
    }
}

4.2 算数运算

4.3 三角函数

4.4 其他函数

5.Arrays

类Arrays包含用于操作数组的各种方法（例如排序和搜索）

5.1 toString

举例

       int[] a1 = {1,2,3,4,5};
       System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]

源代码

	public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

5.2 Sort

排序（默认升序）

指定区间进行排序

       int[] a1 = {9,1,3,7,2,5};
       System.out.println(Arrays.toString(a1));//[9, 1, 3, 7, 2, 5]
       Arrays.sort(a1,0,3);//[0,3),对9,1,3进行排序
       System.out.println(Arrays.toString(a1));//[0[1, 3, 9, 7, 2, 5]

源码

    public static void sort(int[] a, int fromIndex, int toIndex) {
        rangeCheck(a.length, fromIndex, toIndex);
        DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
    }

对整个数组进行排序

       int[] a1 = {0,7,8,2,4,1};
       System.out.println(Arrays.toString(a1));//[0, 7, 8, 2, 4, 1]
       Arrays.sort(a1);
       System.out.println(Arrays.toString(a1));//[0, 1, 2, 4, 7, 8]

源码

    public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
    }
    

其他

5.3 copyOf

复制（常用于数组扩容）

举例

       int[] a = {1,2,3};
       System.out.println(a.length);//output：3
       a = Arrays.copyOf(a,15);
       System.out.println(a.length);//output：15

源码

  public static int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
        return copy;
    }

其他

八.XML与JSON

1.XML

1.1 XML的基本介绍

• XML可拓展标记语言
  XML:可扩展标记语言（eXtensible Markup Language）

• 通常指字符串，而不是文件
  .XML文件
  .XML文件是保存XML数据的一种方式

• XML数据也可以以其他的方式存在（如在内存中构建XML数据）

不要将XML语言狭隘的理解成XML文件

特性

• 具有平台无关性，是一门独立的标记语言（不依赖，单独存在也是有意义的）
• 系统平台无关性：XML文件不论是在windows系统还是苹果系统打开，都是一样的
• 语言平台无关性：不论由java还是python还是其他语言进行解析，看到的效果特性都是一样的，因此可以跨语言
• 具有自我描述性（自己描述自己）

作用

• 网络数据传输（一般用JSON）
  （有层次、很清晰地区分一段数据里的内容）
• 数据存储（基本不用）
  （重要数据实现互通，方便程序读取）
• 配置文件（用的最多）

语法

• 1、 文档声明
  必须放在第一行

<?xml version="1.0" encoding="UTF-8"?>

• 版本：1.0
  编码：UTF-8

• 2、 描述内容（关键部分）
  XML : 可扩展标记语言（eXtensible Markup Language）

• 描述的内容，即标记 ( 元素 / 标签 / 节点) ，标记之间允许重名

• 元素：描述包含关系
  标签：语法
  节点：加载的时候通常以节点方式展开
  XML文档，由一个个的标记组成

• 开始标记(开放标记): <标记名称>
  结束标记(闭合标记): </标记名称>

• 标记名称：（自定义名称，必须遵循以下命名规则）
  1.可以含字母、数字以及其他的字符
  2.不能以数字或者标点符号开始
  3.不能以字符 “xml”（或者 XML、Xml）开始
  4.不能包含空格，不能包含冒号（:）
  5.区分大小写
  标记内容:
  开始标记与结束标记之间
  例如，通过标记，描述一个name： MIKE

• 3、 标记嵌套
  标记可以嵌套，但是不允许交叉

可以嵌套：

<person>
	<name>张三</name>
	<age>18</age>
</person>

不允许交叉（name和age）：

<person>
	<name>张三<age></name>
	18</age>
</person>

• 4、 属性

标记除了开始和结束 , 还有属性

标记中的属性，在标记开始时 描述，由属性名和属性值组成

• 格式：
  在开始标记中, 描述属性
  可以包含0-n个属性, 每一个属性是一个键值对
  属性名不允许重复 ，键与值之间使用等号连接，多个属性之间使用空格分割（换行or空白字符都可以）
  属性值必须被引号引住

代码示例：

<persons>
	<person id="10001" groupid="1">        <!--标记属性，在标记开始时描述-->
		<name>李四</name>
		<age>18</age>
	</person>
	<person id="10002" groupid="1">
		<name>李四</name>
		<age>20</age>
	</person>
</persons>

• 5、 注释
  注释不能写在文档声明前
  注释间不能嵌套
  格式：
  注释开始: <!–
  注释结束: -->

• 6、 根标记

标记与标记嵌套过程中最外层的部分叫做根，必须有且只能有一个根标记

names位于最外层，这段代码中有且仅有names一个根标记：

<names>
	<name>张三</name>
	<name>李四</name>
</names>

两个name都在最外层，无法区别哪个是根：

<name>李四</name>
<name>麻子</name>

• 7、 层级称呼

• 层级称呼：子标记（后代标记的一种）、父标记、兄弟标记、后代标记、祖先标记

• 子标记（后代标记的一种）：上下相邻的被包含部分
  父标记：上下相邻的外层部分
  兄弟标记：同级
  后代标记：被包含部分
  祖先标记：外层部分
  例如:
  name是person的子标记，也是person的后代标记
  person是name的父标记，也是name的祖先标记

• name是persons的后代标记
  persons是name的祖先标记
  name与length护互为兄弟标记

对应代码如下：

<persons>
	<person>				
		<name>李四</name>
		<length>180cm</length>
	</person>
	<person>
		<name>李四</name>
		<length>170cm</length>
	</person>
</persons>

解析
引入jar文件
dom4j.jar

创建一个指向XML文件的输入流
FileInputStream fis = new FileInputStream(“xml文件的地址”);

创建一个XML读取工具对象
SAXReader sr = new SAXReader();

使用读取工具对象, 读取XML文档的输入流 , 并得到文档对象
Document doc = sr.read(fis);

通过文档对象, 获取XML文档中的根元素对象
Element root = doc.getRootElement();

1.2 XML解析

XML解析

2.JSON解析

JSON解析