java客户端解析ACI协议

常用API

文章目录

• 常用API

• API
• Object 类

• Object类型的概述
• HashCode方法
• getClass 方法
• toString 方法
• equals 方法
• ==和equals方法的区别

• Scanner类
• String 类

• 概述
• 常量池
• String类型的构造方法
• New和不New的区别
• String类型的判断功能
• String类型的获取功能
• String类型的转换功能
• String类型的其他方法

• Math 类(静态)

• 两个常量
• 常用方法

• System 类(静态)
• StringBuilder

• 概述
• String和StringBuilder的区别
• String和StringBuilder拼接字符串的区别#
• String和StringBuilder的相互转换#
• 构造方法
• 添加功能
• 删除功能
• 替换和反转功能
• StringBuffer和StringBuilder的区别
• String和StringBuilder作为方法的参数

• 基本类型的包装类

• 概述
• Integer类型
• Integer的构造方法
• Integer类型的成员方法
• Integer类型的常量
• 自动拆箱和自动装箱（jdk1.5）

• 正则表达式(Regular Expression)

• 概述
• 正则表达式的例子
• 正则表达式的字符类
• 预定义的字符类
• 数量词
• 字符串中和正则表达式有关的三个方法

API

API(Application Programming Interface)，应用程序编程接口。

Java API是一本程序员的字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。

Object 类

Object类型的概述

1. Object 类是所有类型的顶层父类，所有类型的直接或者间接的父类；所有的类型中(包括数组)都含有Object类中的所有方法。
2. 随意定义的一个类型，不手动显示定义其父类，那么这个类的父类就是Object类
3. Object类的构造方法：Object()

1. 可以自己创建对象
2. 让子类访问，所有子类都会直接或间接的访问到这个顶层父类的构造方法
3. Object类在执行构造方法时，不去访问自己的父类，因为没有父类了

HashCode方法

1. 根据对象的情况，生成的一个整数，就是哈希码值。生成数字的方法就是hashCode方法
2. 哈希码：java语言中，Object对象有个特殊的方法：hashcode()，hashcode()表示的是JVM虚拟机为这个Object对象分配的一个int类型的数值，JVM会使用对象的hashcode值来提高对HashSet、HashMap、Hashtable哈希表存取对象的使用效率。
3. 生成数字的原则：

• 同一个对象多次调用hashcode方法，必须返回相同的整数（程序多次运行不要求哈希码值保持一致）。
• 使用equals方法判断相同的两个对象，必须返回相同的整数（equals方法是用于决定两个对象是否相同的方法）。
• 使用equals方法判断不相同的两个对象，尽量返回不相同的整数（不做强制要求）。
• Object类型的hashCode，确实会根据不同的对象生成不同的整数。

4. 官方定义的关键点：

1. hashCode是用来在散列存储结构中确定对象的存储地址的，减少对equals(java.lang.Object) 方法的调用，提高查找效率；
2. 如果两个对象相同，就是equals(java.lang.Object) 方法的返回值为true，那么这两个对象的hashCode一定要相同；
3. 两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定equals(java.lang.Object) 方法的返回值为true。
4. 如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；
   补充：
   hashCode值有时还会被用于计算底层存储位置的索引，如HashSet、HashMap的存储机制。

getClass 方法

• 返回当前对象的运行时类。
• 运行时类：真正创建对象所使用的那个类型。
• 返回值：class类型对象，就是加载到方法区的那个字节码文件。

toString 方法

1. 返回当前对象的字符串表示。Object类型中，这个方法的实现：全类名 + @ + 哈希码值的十六进制表示。简称这个内容为：对象的地址值。
2. 对象返回这样一个地址值的字符串，没有什么意义，因此对于子类而言，需要重写父类的这个方法
3. 重写的原则：返回该对象中的所有成员变量的值(对象的属性)
4. 最终操作：不需要手动重写，可以直接使用快捷键生成：
   eclipse： Alt+shift+s s
   idea: Alt+Ins
5. 使用打印语句打印一个对象，其实打印的就是这个对象的toString方法的返回值

equals 方法

1. 用于比较两个对象是否相等的方法，比较的就是”调用者“和”参数这两个对象
   boolean equals(Object obj)
2. 在object类型中，比较的是两个对象的地址值是否相同。
3. 实际生活中，比较两个对象的内存地址，没有声明意义。因此在自定义的子类中都要重写这个方法。
4. 重写规则：
   一般比较两个对象中的所有属性，是否全部相同
5. 操作：
   不需要手动自己重写equals方法，可以直接使用快捷键:
   eclipse： Alt+shift+s h
   idea: Alt+Ins
6. 性质：

• 自反性：自己和自己相等。
• 对称性：A和B相等，那么B就和A相等。A.equals(B)为true，那么B.equals(A)也为true。
• 传递性：A.equals(B)为true，并且B.equals©为true，那么A.equals©也为true。
• 一致性：A多次调用equals方法用于和B对象比较，应该返回相同的判断结果。
• 在Object类型中，比较的是两个引用是否指向了同一个对象。如果是，才返回true。相当于是在比较两个对象的地址值是否相同。

==和equals方法的区别

1. 相同点：
   ==和equals都是用于比较数据是否相等的方式
2. 不同点：

1. 比较内容的不同：

• ==可以比较任意数据类型，既可以标记基本数据类型，也可以比较引用数据类型
• equals方法只能比较引用数据类型【不能比较基本数据类型】

2. 比较的规则不同：

• ==在比较基本类型的时候，比较的是数据的值；比较引用类型时候，比较的是地址值
• equals方法在重写之前，比较的是两个对象的地址值；在重写之后，比较的是属性值

Scanner类

概述：

1. 一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器
   理解：是一个可以解析和基本数据类型和字符串的文本扫描器
2. 构造方法：

• Scanner(File file): 扫描指定文件
• Scanner(String path): 扫描指定路径
• Scanner(InputStream is): 扫描指定输入流
  Scanner(System.in)就是一个输入流，标准输入流，默认关联到键盘。

3. 扫描器可以解析基本数据类型和字符串

成员方法：

1. 录入基本数据类型：

• nextByte(): 获取一个byte类型
• nextShort(): 获取一个short类型
• nextInt():
• nextLong():
• nextFloat():
• nextDouble():
• nextBoolean():

注意事项：

1. 没有nextChar这个方法，一般都是直接录入字符串
2. 键盘录入的数据，不是java代码，所以float类型的常量不需要加f
3. 一次想录入多个数据，可以使用空格进行分隔

1. 录入字符串类型：

1. next(): 录入不含空格的字符串，碰到空格自动结束
   录入的字符串的时候不要包含空格
2. nextLine(): 录入整行的字符串，碰到回车自动结束
   同一个对象二次调用会发生不能录入的现象

String 类

概述

1. String 就是字符串类型，属于java.lang包，不需要导包
2. 所有的字符串常量都属于String类型的对象
3. 字符串字面值属于常量，存储在方法区的常量池中
4. String类型是一个常量，在创造后就无法更改（是一个不可变的字符序列）
5. 不可变的原因是因为String只提供了构造方法，没有提供set方法，因此只能在创建对象的时候初始化成员变量，将来对象创建完成之后，无法提供方法来修改。

常量池

任何好的编程语言的关键目标之一是高效的使用内存。随着应用程序的增长，String字面值占用大量的内存非常常见。对程序而言，全部String字面值中往往有大量的冗余，为了使Java更高效地使用内存，JVM留出一块特殊的内存区域，称为“String常量池”。当编译器遇到String字面值时，它检查该池内是否已经存在相同的String字面值。如果找到，则将新的字面值的引用指向现有的String，而不创建任何新的String字面值对象。

String类型的构造方法

1. String(): 创建一个空字符串
2. String(String original): 创建参数字符串的一个副本（参数字符串是在常量池中，构造方法创建的字符串在堆内存中）
3. String(byte[] arr): 将一个字节数组转换成一个字符串
4. String(byte[] arr, int offset, int length): 将字节数组的一部分转换成字符串
5. String(char[] arr): 将字符串组转换成字符串
   既不是编码，也不是解码，只不过是把字符串成了串
6. String(char[] arr, int offset, int length): 将字符数组的一部分转成字符串

New和不New的区别

String实质是字符数组，两个特点：1、该类不可被继承；2、不可变性(immutable)。

e.g.

String s1 = new String(“myString”);

String s1 = “myString”;

1. 第一种方式通过关键字new定义过程：

1. 在程序编译期，编译程序先去字符串常量池检查，是否存在“myString”,如果不存在，则在常量池中开辟一个内存空间存放“myString”；如果存在的话，则不用重新开辟空间，保证常量池中只有一个“myString”常量，节省内存空间。
2. 然后在内存堆中开辟一块空间存放new出来的String实例，在栈中开辟一块空间，命名为“s1”，存放的值为堆中String实例的内存地址，这个过程就是将引用s1指向new出来的String实例。
3. 你会发现String s1 = new String(“myString”); 这一句代码实际上可能创建了2个对象, 一个是String对象,存放在堆中, 一个是字符串常量对象,存放在串池中。

2. 第二种方式直接定义过程：
   在程序编译期，编译程序先去字符串常量池检查，是否存在“myString”，如果不存在，则在常量池中开辟一个内存空间存放“myString”；如果存在的话，则不用重新开辟空间。然后在栈中开辟一块空间，命名为“s1”，存放的值为常量池中“myString”的内存地址（相当于指向常量池中的“myString”）。

String类型的判断功能

1. equals(Object obj): 判断调用者和参数对象描述的字符串内容是否相同
2. equalsIgnoreCase(String otherStr): 忽略大小写判断两个字符串内容是否相同
3. contains(String str): 判断调用者是否包含str这个子窜
4. startsWith(String prefix): 判断调用者是否以prefix开头
5. endsWith(String suffix): 判断调用者是否以suffix结尾
6. isEmpty(): 判断调用者是否是空串
   String类型的判断功能返回的是boolean值

String类型的获取功能

1. length(): 获取字符串字符的个数
2. charAt(int index): 返回调用者字符串中索引为index的字符（和length方法结合后可以遍历字符串）
3. substring(int beginIndex): 获取一个字符串，内容是从当前字符串的beginIndex索引开始
4. substring(int beginIndex, int endIndex): 获取一个指定索引范围的子串
   注意事项：

1. 包含头不包含尾，返回的结果中，不包含endIndex索引指向的字符；
2. 所有的方法都无法修改字符串对象本身，一般都是返回一个新的字符串对象。

5. indexOf家族: (如果没找到返回-1)

• indexOf(int ch): 返回ch字符在当前调用者字符串中第一个出现的索引
• indexOf(int ch, int fromIndex): 从fromIndex索引开始寻找，找到ch字符在当前字符串中第一次出现的索引

6. lastIndex家族: (如果没找到返回-1)

• lastIndexOf(int ch): 返回ch字符在当前调用者字符串中最后一个出现的索引
• lastIndexOf(int ch, int fromIndex): 从fromIndex索引开始方向寻找，找到ch字符在当前字符串中最后一次出现的索引

String类型的转换功能

1. byte[]getBytes(): 将当前字符串，转成字节数组
2. char[]toCharArray(): 将当前字符串，转成字符数组
3. toUpperCase(): 将当前字符串，转成全大写形式
4. toLowerCase(): 将当前字符串，转成全小写形式
5. concat(String str): 将当前调用者和参数str进行拼接，返回拼接后的长字符串（不常用，因为更多使用的是运算符+）
6. valueOf家族：可以将任意数据类型的数据，转换成字符串。

String类型的其他方法

1. repace(String oldStr, String newStr): 将调用者中的老串替换成新串
2. trim(): 去掉字符串左右两边的空格、制表符
3. split():字符串拆分。

Math 类(静态)

两个常量

• E: 自然对数的底数，2.718
• PI: 圆周率

常用方法

• abc(数字类型)，绝对值
• cbrt(double d)，开立方根
• sqrt(double d)，正平方根
• ceil(double d)，向上取整
• floor(double d)，向下取整
• max(int a, int b)，最大值
• min(int a, int b)，最小值
• pow(int a, int b)，次幂
• random()，[0,1)的随机数
• round(double d)，四舍五入取整

System 类(静态)

1. 用于描述系统资源的类型，该类不用创建对象，直接使用静态变量和静态方法即可
2. 常用字段：

• System.in: 标准输入流，默认关联到键盘上
• System.out: 标准输出流，默认关联到控制台上
• System.err: 标准错误输出流，默认关联到控制台上，用于打印错误信息，在eclipse中使用该流打印的内容是红色的

3. 常用方法：

1. gc(): 强制垃圾回收器回收内存中的垃圾
2. currentTimeMillis(): 获取当前系统时间精确到毫秒 (1s = 1000ms)
   应用：

• 可以勇敢某些手段，将数字转换成时间对象、指定格式的字符串
• 可以通过计算两次的差值来获取某段代码的运行时间

StringBuilder

概述

1. StringBuilder是一个可变的字符序列，因为在类中提供了修改私有成员变量的方法。
   常用的方法是append和insert，就是在StringBuilder对象本身上，进行修改操作。
2. StringBuilder底层和String类型一样，也是维护了一个字符数组，数组是私有的，外界无法直接访问，因此在StringBuilder或者String中对数组进行操作的公有方法的封装。

String和StringBuilder的区别

• 相同点：都是用于描述字符串。
• 不同点：

1. String是不可变的字符序列，没有提供修改私有成员的方法；StringBuilder是可变的字符序列，因为提供了修改成员变量的方法。
2. String长度本身也不可以变化，StringBuilder长度可以变化，可以认为StringBuilder就像一个可以伸缩的容器，用于存储字符。

String和StringBuilder拼接字符串的区别#

• 使用String类型拼接字符串：时间和空间上都非常浪费。

1. 创建一个StringBuilder的存储空间，大小为第一个字符串的长度+16（第一个对象）。
2. 将第一个字符串添加到缓冲区中。
3. 将第二个字符串添加到缓冲区中。
4. 将缓冲区对象转成字符串对象（创建了一个新的字符串对象）（第二个对象）。
5. 返回该字符串对象。

• 使用StringBuilder拼接字符串：时间和空间上都非常节省，无论循环多少次，都只创建两个对象。

1. 创建一个新的StringBuilder的存储空间。
2. 在StringBuilder的基础上进行添加，不创建新的字符串。
3. 循环完成后，将StringBuilder转成String。

String和StringBuilder的相互转换#

• String转成StringBuilder

1. StringBuilder的构造方法。
2. append方法。

• StringBuilder转成String类型

1. toString的方法。
2. 使用String的构造方法。

构造方法

1. 构造方法作用：创建当前对象、将其他类型的数据，转换成当前类型
2. StringBuilder的构造方法：

1. StringBuilder()：创建一个生成器，初始容量为16个字符。
2. StringBuilder(int capacity)：创建一个生成器，初始容量为capacity大小。
3. StringBuilder(String str)：创建一个生成器，初始值就是str这些字符，初始大小是str+16。

3. 获取容积的方法：

1. capacity()：获取当前生成器的容器大小。
2. length()：获取当前生成器中的字符个数。
   (如果length超过capacity,capacity = (capacity+1)*2)

添加功能

1. append(任意类型)：可以将任意数据类型，转成字符，添加到生成器中。

2. insert(int index, 任意数据类型)：可以将任意数据类型，添加到指定的位置。
   注意事项：

1. index的范围是0~当前缓冲区的大小；
2. 插入数据之后，数据本身的索引就是参数中指定的index。

删除功能

1. deleteCharAt(int index) ：删除指定索引的字符。
    2. delete(int start, int end)：删除指定范围的字符，被删除的部分包含头不包含尾。

替换和反转功能

1. replace(int start, int end ,String str)：
   将字符串缓冲区中的从start开始到end-1这部分内容，替换成str。
2. reverse()：
   将原有字符序列进行反转。

StringBuffer和StringBuilder的区别

• 相同点：都是字符串的缓冲区，都是字符串的生成器，都是可变的字符序列。
• 不同点：

1. 出现版本不同：

• StringBuffer在jdk1.0出现的。
• StringBuilder在jdk1.5出现的。

2. 线程安全性不同：

• StringBuffer是线程安全的，在多线程环境下仍然保证数据安全。
• StringBuilder是线程不安全，在多线程环境下无法保证数据安全。

3. 效率不同：

• StringBuffer效率低。
• StringBuilder效率高。

String和StringBuilder作为方法的参数

1. String作为方法的参数进行传递，无法修改原值。在被调用的方法中，修改引用指向的对象，和主方法中的引用无关。
2. StringBuilder作为方法的参数进行传递，如果在被调用的方法中，修改的是StringBuilder的引用，那么不会改变原有对象中的数据。
3. StringBuilder作为方法的参数进行传递，如果在被调用的方法中，通过该引用修改了对象的数据，那么原值就会发生改变。

基本类型的包装类

概述

1. 基本的数据类型有八种，都是非常简单的数据
2. 在这些类型中，只能表示简单的数据，不能包含一些操作数据的方法，没有办法存储描述这些数据的内容。 需要准备一个引用数据类型，能将基本数据类型进行包装，提供一些操作基本数据类型的方法，定义一些描述数据的类型。
3. 基本数据类型的包装类：

• byte Byte
• short Short
• int Integer
• long Long
• float Float
• double Double
• boolean Boolean
• char Character

Integer类型

1. 各种包装类类型方法，特点基本相同，只要学习一个Integer类型，其他的能够触类旁通。
2. Integer类型对象中，底层就是维护了一个私有的成员变量，是一个int类型的字段，用于表示Integer对象要表示的数字
3. 提供了在int，Integer，String类型之间的相互转换的方法，进制上转换的方法
4. 提供了一些常量

Integer的构造方法

1. Integer(int i)：将一个基本数据类型的的int数，转换成Integer类型的对象
   把i这个int类型的变量，赋值给Integer对象中维护的私有的成员变量value
2. Integer(String num)：将一个字符串类型的数字，转换成Integer类型的对象
   转换的作用
   String --》 Integer前提String类型的对象必须是数字类型的。

Integer类型的成员方法

1. xxxValue()方法：可以将Integer类型的对象，转成其他基本数据类型的数据:
   例如：intValue(),byteValue(),floatValue()…
2. 常用的静态方法:

• parseInt（String str）:将str以十进制的方式解读为一个int数
• parseInt(String s, int radix)将str按照指定的radix进制解析为一个int数字（十进制）
• toBinaryString(int i) 将十进制的i通过二进制进行表示 10进制–》2进制
• toOctalString(int i) 将十进制的i通过 八进制进行表示 10进制–》8进制
• toHexString(int i) 将十进制的i通过 十六进制进行表示 10进制–》16进制
• toString(int i, int radix) ：将任意一个十进制的数字，转成任意进制的字符串表示
• valueOf(String s, int radix)将str以指定的radix进制进行解析，封装一个Integer

Integer类型的常量

1. MAX_VALUE: int类型的最大值
2. MIN_VALUE: int类型的最小值
3. SIZE: int类型在内存中的位数
4. TYPE: int类型在方法区的字节码对象，int.class

自动拆箱和自动装箱（jdk1.5）

1. 装箱和拆箱

• 装箱：将基本的数据类型，封装成包装类类型的对象，这个过程就是装箱使用构造方法或Integer.valueOf()即可
• 拆箱：将包装类类型对象转成基本的数据类型，这个过程就是拆箱，使用intValue()即可

2. 自动装箱和自动拆箱

• 自动装箱：可以直接使用基本的数据类型，给引用的数据类型进行赋值
• 自动拆箱：可以直接使用包装类对象，给基本数据类型赋值；或者是包装类类型对象直接参与算数运算

正则表达式(Regular Expression)

概述

1. 概述： 本质上就是一个字符串
2. 作用：不仅表示的是一个字符串，还可以表示一类字符串，表示一类字符串的规则或者格式。
3. 好处：可以使用特别简单的代码，表示非常复杂的规则
4. 坏处：写出正则的表达式的正确率不高

正则表达式的例子

需要：

• 键盘录入一个字符串，判断是否是一个合法的qq号码

合法qq号码的条件：

• 必须是5 - 12位
• 必须全都是数字
• 0不能开头

import java.util.Scanner;

public class RegularExpression {
	public static void main(String[] args) {
		// String re = "[^0\\D]\\d{5,11}";
		String re = "[1-9][0-9]{5,11}";
		System.out.println("请输入qq号: ");
		Scanner sc = new Scanner(System.in);
		String ip = sc.next();
		sc.close();
		if (ip.matches(re)) {
			System.out.println("qq号合法");
		} else {
			System.out.println("qq号不合法");
		}
	}
}

正则表达式的字符类

1. 普通的字符串就是正则表达式，但是只能表示自己本身，无法匹配一类字符串的
2. 判断某个字符串是否和某个正则表达式匹配，使用String类型的matches()
3. 字符类型：表示单个字符，使用的符号是[]
   说明：只要使用了中括号，那么无论里面写了多少内容，都表示的单个字符
4. 方括号的表达式:

[abc]: a或者b或者c中的一个
[^abc]: 除了a，b，c中的任意一个字符 
[a-zA-Z]: 就是a到z或者A到Z中的任意一个字符

预定义的字符类

1. 有一些字符类型经常使用，所以就提前在正则表达式中进行定义，称为预定义字符类
2. 罗列：

.    表示的任意单个字符，\.表示的是一个确定的.字符串 
\d   表示数字字符 
\D   表示非数字字符 
\s   表示空格字符 
\S   表示的非空格字符 
\w   [a-zA-Z0-9_] 
\W	 表示除了\w以外的所有字符

数量词

1. 无论是字符类型还是预定义字符类型都只能表示的是单个的字符，无法表示0个字符，也无法表示多个字符 需要使用一个数量词来修饰字符的个数
2. 在使用数量词的时候，数量词修饰的内容一定是要紧挨着，只会修饰在该数量次前面紧挨着的字符
3. 分类： 模糊的数量词 精确的数量词
4. 模糊的数量词

• x？ 表示x这个字符，出现0次或者1次
• x+ 表示的x这个字符，出现1次或者多次
• x* 表示的x这个字符，出现0次，1次或者多次

5. 精确的数量词

• x{n} 表示的是x这个字符，恰好出现n次
• x{n,} 表示的是x这个字符，至少出现n次
• x{n，m} 表示的是x这个字符，至少出现n次，至多出现m次

字符串中和正则表达式有关的三个方法

1. boolean matches(String regex): 判断当前字符串是否和参数正则表达式匹配
2. String[] split(String str): 使用指定的正则表达式切割当前字符串
3. String replaceAll(String regex,String replacement): 将调用者字符串中的所有匹配regex正则子串，全部替换成replacement新串