JSON解析、JAVA常用的工具类、JAVA集合框架、JAVA泛型、枚举
JSON
简介
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C、C++、C#、Java、JavaScript、Perl、Python等）。这些特性使JSON成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成(网络传输速率)。
JSON 语法规则
JSON 语法是 JavaScript 对象表示语法的子集。
1. 数据在名称/值对中
2. 数据由逗号分隔
3. 花括号保存对象
4. 方括号保存数组
与XML比较
XML和JSON都使用结构化方法来标记数据，下面来做一个简单的比较。
用XML表示中国部分省市数据如下：
<country>
<name>中国name>
<province>
<name>黑龙江name>
<cities>
<city>哈尔滨city>
<city>大庆city>
cities>
province>
<province>
<name>广东name>
<cities>
<city>广州city>
<city>深圳city>
<city>珠海city>
cities>
province>
<province>
<name>台湾name>
<cities>
<city>台北city>
<city>高雄city>
cities>
province>
<province>
<name>新疆name>
<cities>
<city>乌鲁木齐city>
cities>
province>
country>
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
用JSON表示如下：
{
"name": "中国",
"province": [{
"name": "黑龙江",
"cities": {
"city": ["哈尔滨", "大庆"]
}
}, {
"name": "广东",
"cities": {
"city": ["广州", "深圳", "珠海"]
}
}, {
"name": "台湾",
"cities": {
"city": ["台北", "高雄"]
}
}, {
"name": "新疆",
"cities": {
"city": ["乌鲁木齐"]
}
}]
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
编码的可读性，xml有明显的优势，毕竟人类的语言更贴近这样的说明结构。json读起来更像一个数据块，读起来就比较费解了。不过，我们读起来费解的语言，恰恰是适合机器阅读，所以通过json的索引.province[0].name就能够读取“黑龙江”这个值。
编码的手写难度来说，xml还是舒服一些，好读当然就好写。不过写出来的字符JSON就明显少很多。去掉空白制表以及换行的话，JSON就是密密麻麻的有用数据，而xml却包含很多重复的标记字符。
代码示例
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
public class JsonTest {
public static void main(String[] args) {
String s=creatJson();
if(s!=null){ //解析JSON文本
JSONObject clazz=JSONObject.fromObject(s);
System.out.println("班级："+clazz.getString("班级"));
System.out.println("班级人数："+clazz.getString("班级人数"));
JSONArray array=clazz.getJSONArray("学生");
for (int i = 0; i < array.size(); i++) {
JSONObject obj =array.getJSONObject(i);
System.out.print("学生姓名："+obj.getString("姓名")+"\t");
System.out.println("学生年龄："+obj.getString("年龄"));
}
}
}
private static String creatJson() {//生成JSON文本格式
JSONObject obj1 = new JSONObject();
obj1.put("姓名", "张三");
obj1.put("年龄", "18");
JSONObject obj2 = new JSONObject();
obj2.put("姓名", "李四");
obj2.put("年龄", "19");
JSONObject obj3 = new JSONObject();
obj3.put("姓名", "王五");
obj3.put("年龄", "20");
JSONArray array = new JSONArray();
array.add(obj1);
array.add(obj2);
array.add(obj3);
JSONObject clazz = new JSONObject();
clazz.put("班级", "2012163");
clazz.put("班级人数", "27");
clazz.put("学生", array);
System.out.println(clazz.toString());
return clazz.toString();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
运行结果：
另一种生成JSON文本的方法
//创建一个Student类
public class Student {
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public int getage() {
return age;
}
public void setage(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
创建JsonTest类
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
public class JsonTest {
public static void main(String[] args) {
Student zhangsan = new Student("张三", 12);
Student lisi = new Student("李四", 12);
Student wangwu = new Student("王五", 12);
Student zhaoliu = new Student("赵六", 12);
JSONObject obj= new JSONObject();
JSONArray array = new JSONArray();
array.add(zhangsan);
array.add(lisi);
array.add(wangwu);
array.add(zhaoliu);
obj.put("学生", array);
System.out.println(obj.toString());
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
运行结果：
Math类
简介
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
字段摘要
- static final double E （常量）
比任何其他值都更接近 e（即自然对数的底数）的 double 值。 - static final double PI （常量）
比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。
方法摘要
- public static double sqrt(double a)返回正确舍入的 double 值的正平方根。
- 向上取整
public static double ceil(double a)返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。 - 向下取整
public static double floor(double a)返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。 - 数学上的四舍五入
public static int round(float a)返回最接近参数的 int。结果将舍入为整数：加上 1/2，对结果调用 floor 并将所得结果强制转换为 int 类型。换句话说，结果等于以下表达式的值： (int)Math.floor(a + 0.5f)。 - public static double random()返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。
- public static int max(int a,int b)返回两个 int 值中较大的一个。
- public static int min(int a,int b)返回两个 int 值中较小的一个。
Date类
构造方法摘要
Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
方法摘要
public long getTime()返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
Calendar类
它是一个抽象类
字段
- public static final int YEAR指示年的 get 和 set 的字段数字。
- public static final int MONTH指示月份的 get 和 set 的字段数字。
注意：第一个月份为0 - public static final int DATEget 和 set 的字段数字，指示一个月中的某天。
方法摘要
- public static Calendar getInstance()使用默认时区和语言环境获得一个日历。返回的 Calendar 基于当前时间，使用了默认时区和默认语言环境。
返回：一个 Calendar。 - public final Date getTime()返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象。
返回：表示时间值的 Date。 - public long getTimeInMillis()返回此 Calendar 的时间值，以毫秒为单位。
返回：当前时间，以从历元至现在所经过的 UTC 毫秒数形式。 - public abstract void add(int field,int amount)根据日历的规则，为给定的日历字段添加或减去指定的时间量。
代码示例
import java.util.Calendar;
import java.util.Date;
public class ShiJian {
public static void main(String[] args) {
Date date = new Date();
System.out.println(date);
System.out.println(date.getTime());//返回格林尼治时间之后的毫秒数
Calendar cal= Calendar.getInstance();
System.out.println(cal.getTime());
System.out.println(cal.getTimeInMillis());//返回格林尼治时间之后的毫秒数
System.out.println(cal.get(Calendar.YEAR)+"年"+(cal.get(Calendar.MONTH)+1)+"月"+cal.get(Calendar.DATE)+"日");
cal.add(Calendar.DATE, 50);//往后加50天的时间
System.out.println(cal.get(Calendar.YEAR)+"年"+(cal.get(Calendar.MONTH)+1)+"月"+cal.get(Calendar.DATE)+"日");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
运行结果：
SimpleDateFormat类
简介
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
构造方法
SimpleDateFormat()
用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
方法摘要
- public StringBuffer format(Date date,StringBuffertoAppendTo,FieldPosition pos)
将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。
返回：格式化的日期-时间字符串。 - public Date parse(String text,ParsePosition pos)解析字符串的文本，生成 Date。
返回：从字符串进行解析的 Date。如果发生错误，则返回 null。
代码示例
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Time {
public static void main(String[] args) {
Date date = new Date();
SimpleDateFormat format = new SimpleDateFormat("yyyy/MM/dd kk:mm:ss");
System.out.println(format.format(date));//按所要格式输出当前时间
String s = "2015/07/24 11:40:20";
try {
Date date1 = format.parse(s);//按格式解析一个时间字符串
System.out.println(date1.getDate());
} catch (ParseException e) {
e.printStackTrace();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
运行结果：
集合
分类
ArrayList
简介
ArrayList里边的元素不唯一，有序。
内存空间连续。
元素遍历快，增删慢。
方法摘要
- public int size()返回此列表中的元素数。
- public boolean isEmpty()如果此列表中没有元素，则返回 true。
- public boolean contains(Object o)如果此列表中包含指定的元素，则返回 true 。
- public int indexOf(Object o)返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
- public int lastIndexOf(Object o)返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
- public E get(int index)返回此列表中指定位置上的元素。
- public E set(int index,E element)用指定的元素替代此列表中指定位置上的元素。
- public void add(int index,E element)将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。
- public E remove(int index)移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。
Collections类
简介
java.util.Collections
方法摘要
1.public static 根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。
2.public static 根据指定比较器产生的顺序对指定列表进行排序。
Comparator接口的方法：public int compare(T o1,T o2)比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
代码示例
创建一个Student 类
public class Student {
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public int getage() {
return age;
}
public void setage(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
编写一个比较的类
import java.util.Comparator;
public class paixu implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
return s1.getage() - s2.getage();//按年龄大小排序
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
创建JiheTset类
mport java.util.ArrayList;
import java.util.Collections;
public class JiheTest { //ArrayList
public static void main(String[] args) {
ArrayList list = new ArrayList();
Student zhangsan= new Student("张三", 11);
Student lisi= new Student("李四", 12);
Student wangwu= new Student("王五", 13);
list.add(zhangsan);
list.add(lisi);
list.add(wangwu);
list.add(1, wangwu);
list.get(3).setName("我换了个名字");
System.out.println(list.size());
Collections.sort(list, new paixu());//排序
for(Student s:list){ //foreach语句
System.out.println(s.getName());
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
运行结果：
HashSet类
简介
元素唯一，无序。
此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。
方法摘要
- public Iterator iterator()返回对此 set 中元素进行迭代的迭代器。返回元素的顺序并不是特定的。
返回：对此 set 中元素进行迭代的 Iterator - public int size()返回此 set 中的元素的数量（set 的容量）。
- public boolean isEmpty()如果此 set 不包含任何元素，则返回 true。
- public boolean contains(Object o)如果此 set 包含指定元素，则返回 true。
- public boolean add(E e)如果此 set 中尚未包含指定元素，则添加指定元素。
- public boolean remove(Object o)如果指定元素存在于此 set 中，则将其移除。
- public void clear()从此 set 中移除所有元素。此调用返回后，该 set 将为空。
代码示例
import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
//随机生成10个随机数，放入一个HashSet中
public class Demo { //HashSet
public static void main(String[] args) {
HashSet set = new HashSet();
Random random = new Random();
while (set.size() < 10) {
int i = random.nextInt(90) + 10;
set.add(i);
}
Iterator it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
System.out.println(set.size());
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
HashMap类
简介
存在一个K到V的一一映射，且K值不允许重复。
K - 此映射所维护的键的类型，V - 所映射值的类型
基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
方法摘要
- public int size()返回此映射中的键-值映射关系数。
- public boolean isEmpty()如果此映射不包含键-值映射关系，则返回 true。
- public V get(Object key)返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
- public boolean containsKey(Object key)如果此映射包含对于指定键的映射关系，则返回 true。
- public V put(K key,V value)在此映射中关联指定值与指定键。如果该映射以前包含了一个该键的映射关系，则旧值被替换。
- public V remove(Object key)从此映射中移除指定键的映射关系（如果存在）。
- public Set keySet()返回此映射中所包含的键的 Set 视图。
- public Set entrySet()返回此映射所包含的映射关系的 Set 视图。
代码示例
创建一个Student类
public class Student {
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public int getage() {
return age;
}
public void setage(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
创建Test类
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class Test {
public static void main(String[] args) {
HashMap map = new HashMap<>();
Student zhangsan = new Student("张三", 18);
Student lisi = new Student("李四", 19);
Student wangwu = new Student("王五", 20);
map.put(201216301, zhangsan);
map.put(201216302, lisi);
map.put(201216303, wangwu);
Set keys = map.keySet();
Iterator it = keys.iterator();
while (it.hasNext()) {
Integer i = it.next();
System.out.println(i + "----" + map.get(i).getName());
}
//另一种写法
for (Integer key : map.keySet()) {
System.out.println(key + "----" + (String) map.get(key).getName());
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
运行结果：
泛型
泛型集合
ArrayList list = new ArrayList();
- 1
<>中写的数据类型必须是封装类和引用数据类型
HashMap map = new HashMap();
- 1
泛型类
public class 类名<T>{
private T 变量名1;
private T 变量名1;
}
- 1
- 2
- 3
- 4
泛型方法
泛型方法的语法
[访问权限修饰符] [static] [final] <类型参数列表> 返回值类型 方法名([形式参数列表])
public static Pair minmax(T[] a) // 是指 类型参数列表
- 1
【方法中传入或返回的泛型类型由调用方法时所设置的参数类型所决定。】可用extends 和 super 关键字分别来指定上限和下限类型。
Pair 是返回值。minmax 方法名，T[] a 形式参数列表
代码示例
创建Pair泛型类
public class Pair<T> {
private T first;
private T second;
public Pair(){
first=null;
second=null;
}
public Pair(T first,T second){
this.first=first;
this.second=second;
}
public T getFirst() {
return first;
}
public void setFirst(T first) {
this.first = first;
}
public T getSecond() {
return second;
}
public void setSecond(T second) {
this.second = second;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
创建ArrayAlg类
public class ArrayAlg {
public static > Pair minmax(T[] a) {
if (a == null || a.length == 0) {
return null;
}
T min = a[0];
T max = a[0];
for (int i = 0; i < a.length; i++) {
if (min.compareTo(a[i]) > 0) {
min = a[i];
}
if (max.compareTo(a[i]) < 0) {
max = a[i];
}
}
return new Pair(min,max);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
创建Test类
public class Test {
public static void main(String[] args) {
Integer[]a={1,2,3,4};
Pair pair = ArrayAlg.minmax(a);
System.out.println("最小值为："+pair.getFirst());
System.out.println("最大值为："+pair.getSecond());
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
运行结果：
枚举
用法一：常量
在JDK1.5之前，我们定义常量都是：publicstaticfianl….。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。
public enum Color {
RED, GREEN, BLANK, YELLOW
}
- 1
- 2
- 3
用法二：switch
JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。
enum Signal {
GREEN, YELLOW, RED
}
public class TrafficLight {
Signal color = Signal.RED;
public void change() {
switch (color) {
case RED:
color = Signal.GREEN;
break;
case YELLOW:
color = Signal.RED;
break;
case GREEN:
color = Signal.YELLOW;
break;
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
用法三：向枚举中添加新方法
如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且Java要求必须先定义enum实例。
public enum Color {
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// 普通方法
public static String getName(int index) {
for (Color c : Color.values()) {
if (c.getIndex() == index) {
return c.name;
}
}
return null;
}
// get set 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
用法四：覆盖枚举的方法
下面给出一个toString()方法覆盖的例子。
public enum Color {
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
//覆盖方法
@Override
public String toString() {
return this.index+"_"+this.name;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
用法五：实现接口
所有的枚举都继承自java.lang.Enum类。由于Java不支持多继承，所以枚举对象不能再继承其他类。
public interface Behaviour {
void print();
String getInfo();
}
public enum Color implements Behaviour{
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
//接口方法
@Override
public String getInfo() {
return this.name;
}
//接口方法
@Override
public void print() {
System.out.println(this.index+":"+this.name);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
用法六：使用接口组织枚举
public interface Food {
enum Coffee implements Food{
BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
}
enum Dessert implements Food{
FRUIT, CAKE, GELATO
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
用法七：关于枚举集合的使用
java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。
代码示例
public enum Color {//枚举
RED,ORANGE,YELLOW,GREEN,BULE,PURPLE
}
- 1
- 2
- 3
创建Test类
public class Test {
public static void main(String[] args) {
Color color = Color.RED;
switch (color) {
case RED:
System.out.println("这是红色");
break;
case ORANGE:
System.out.println("这是橙色");
break;
case YELLOW:
System.out.println("这是黄色");
break;
default:
break;
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
运行结果：