反射

1 下列XML文档中，符合XML语法规范的是

A．

  1. <customer>
  2.      <address>123 MainStreet></Address>
  3. </customer>

B．

  1. <customer>
  2. <name>Joe’s XML Works</name>
  3. <address>New York
  4. </costomer>

C．

  1. <customer type=extemal>
  2. <name>Partners Unlimited</name>
  3. </customer>

D.

 
  1. <customer name="JohnDoe">
  2. <address>123 Main Street</address>
  3. <zip code="01837"/>
  4. </customer>

参考答案

本题正确答案为D。

AB选项，不符合XML语法规范。在XML中，元素要成对出现，而且大小写敏感。A选项元素address的结尾为</Address>，“A”字母要小写。B选项元素<address>没有结尾标记。

C选项，不符合XML语法规范。在XML中，属性必须被引号包围，不过单引号和双引号均可使用。

2 简述SAX和DOM解析方式的不同

参考答案

DOM：(Document Object Model, 即文档对象模型) 是 W3C 组织推荐的处理 XML 的一种方式。DOM解析器在解析XML文档时，会把文档中的所有元素，按照其出现的层次关系，解析成各个Node对象(节点)。

优点:把xml文件在内存中构造树形结构，可以遍历和修改节点

缺点：如果文件比较大，内存有压力，解析的时间会比较长

SAX（simple API for XML）是一种XML解析的替代方法。相比于DOM，SAX是一种速度更快，更有效的方法。它逐行扫描文档，一边扫描一边解析。而且相比于DOM，SAX可以在解析文档的任意时刻停止解析。

优点： 解析可以立即开始，速度快，没有内存压力

缺点： 不能对节点做修改

3 客户端以XML格式向服务器端发送数据V1

客户端以XML格式向服务器端发送数据，详细要求如下：

1）客户端读取EmpList.xml数据，将其发送到服务器端。

2）服务器接收到XML格式的数据后，进行解析，将解析到的数据输出到控制台。

参考答案

实现此案例需要按照如下步骤进行。

步骤一：导入dom4j对应的jar包

在当前工程下导入dom4j对应的jar包。

步骤二：创建服务器端Server类

首先，新建类Server；然后在该类的main方法中创建ServerSocket对象，监听客户端的连接以及网络输入流对象，代码如下所示：

 
  1. import java.io.InputStream;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  5. public class Server {
  6.     public static void main(String[] args) {
  7.         try {
  8.             //创建服务端Socket
  9.             ServerSocket server = new ServerSocket(8088);
  10.             System.out.println("等待客户端连接");
  11.             //监听客户端连接
  12.             Socket socket = server.accept();
  13.             System.out.println("客户端已经连接");
  14.             //获取输入流
  15.             InputStream in = socket.getInputStream();
  16.         } catch (Exception e) {
  17.             e.printStackTrace();
  18.         }
  19.     }
  20. }

步骤三：创建SAXReader类的对象，获取Document对象

首先，创建SAXReader类的对象来实现读取XML文档；然后，使用SAXReader类的read方法获取Document对象，代码如下所示：

 
  1. import java.io.InputStream;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4. import java.util.ArrayList;
  5. import java.util.List;
  7. import org.dom4j.Document;
  8. import org.dom4j.Element;
  9. import org.dom4j.io.SAXReader;
  11. public class Server {
  12.     public static void main(String[] args) {
  13.         try {
  14.             //创建服务端Socket
  15.             ServerSocket server = new ServerSocket(8088);
  16.             System.out.println("等待客户端连接");
  17.             //监听客户端连接
  18.             Socket socket = server.accept();
  19.             System.out.println("客户端已经连接");
  20.             //获取输入流
  21.             InputStream in = socket.getInputStream();
  22.             //创建SAXReader
  23.             SAXReader reader = new SAXReader();
  24.             System.out.println("开始解析客户端发送的xml");
  25. //读取指定文件
  26.             Document doc = reader.read(in);
  27.         } catch (Exception e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }

步骤四：获取根元素

使用Document对象的getRootElement方法获取EmpList.xml文档的根元素，代码如下所示：

 
  1. import java.io.InputStream;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4. import java.util.ArrayList;
  5. import java.util.List;
  7. import org.dom4j.Document;
  8. import org.dom4j.Element;
  9. import org.dom4j.io.SAXReader;
  11. public class Server {
  12.     public static void main(String[] args) {
  13.         try {
  14.             //创建服务端Socket
  15.             ServerSocket server = new ServerSocket(8088);
  16.             System.out.println("等待客户端连接");
  17.             //监听客户端连接
  18.             Socket socket = server.accept();
  19.             System.out.println("客户端已经连接");
  20.             //获取输入流
  21.             InputStream in = socket.getInputStream();
  22.             //创建SAXReader
  23.             SAXReader reader = new SAXReader();
  24.             System.out.println("开始解析客户端发送的xml");
  25.             //读取指定文件
  26.             Document doc = reader.read(in);
  27.             //获取跟节点list
  28.             Element root = doc.getRootElement();
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }

步骤五：获取<list>元素下的所有子元素

使用Element对象的elements方法获取<list>元素下的所有子元素，即所有的<emp>节点，代码如下所示：

 
  1. import java.io.InputStream;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4. import java.util.ArrayList;
  5. import java.util.List;
  7. import org.dom4j.Document;
  8. import org.dom4j.Element;
  9. import org.dom4j.io.SAXReader;
  11. public class Server {
  12.     public static void main(String[] args) {
  13.         try {
  14.             //创建服务端Socket
  15.             ServerSocket server = new ServerSocket(8088);
  16.             System.out.println("等待客户端连接");
  17.             //监听客户端连接
  18.             Socket socket = server.accept();
  19.             System.out.println("客户端已经连接");
  20.             //获取输入流
  21.             InputStream in = socket.getInputStream();
  22.             //创建SAXReader
  23.             SAXReader reader = new SAXReader();
  24.             System.out.println("开始解析客户端发送的xml");
  25.             //读取指定文件
  26.             Document doc = reader.read(in);
  27.             //获取跟节点list
  28.             Element root = doc.getRootElement();
  29.             //获取list下的所有子节点emp
  30.             List<Element> elements = root.elements();
  31.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  35. }

步骤六：封装Emp对象，存储到List集合中

1）创建存储的数据类型为Emp类型的List集合emps；

2）循环上一步中的elements集合，每循环一次获取一个emp元素。在循环中使用Element对象的attribute方法获取id属性对应的Attribute对象，再使用Attribute对象的getValue方法就可以获取到属性id对应的文本信息，即Emp对象的属性id的信息；

3）在循环中，使用Element对象的elementText方法获取节点<name>、<age>、<gender>以及<salary>对应的文本信息，即Emp对象的属性name、age、gender以及salary。

4）在循环中，将上述获取到的信息封装为Emp对象，存储到集合emps中。

代码如下所示：

 
  1. import java.io.InputStream;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4. import java.util.ArrayList;
  5. import java.util.List;
  7. import org.dom4j.Document;
  8. import org.dom4j.Element;
  9. import org.dom4j.io.SAXReader;
  11. public class Server {
  12.     public static void main(String[] args) {
  13.         try {
  14.             //创建服务端Socket
  15.             ServerSocket server = new ServerSocket(8088);
  16.             System.out.println("等待客户端连接");
  17.             //监听客户端连接
  18.             Socket socket = server.accept();
  19.             System.out.println("客户端已经连接");
  20.             //获取输入流
  21.             InputStream in = socket.getInputStream();
  22.             //创建SAXReader
  23.             SAXReader reader = new SAXReader();
  24.             System.out.println("开始解析客户端发送的xml");
  25.             //读取指定文件
  26.             Document doc = reader.read(in);
  27.             //获取跟节点list
  28.             Element root = doc.getRootElement();
  29.             //获取list下的所有子节点emp
  30.             List<Element> elements = root.elements();
  31.             //保存所有员工对象的集合
  32.             List<Emp> emps = new ArrayList<Emp>();
  33.             for(Element element : elements){            
  34.                 int id = Integer.parseInt(element.attribute("id").getValue());
  35.                 String name = element.elementText("name");
  36.                 int age = Integer.parseInt(element.elementText("age"));
  37.                 String gender = element.elementText("gender");
  38.                 double salary = Double.parseDouble(element.elementText("salary"));
  39.                 Emp emp = new Emp(id,name,age,gender,salary);
  40.                 emps.add(emp);
  41.             }
  42.             System.out.println("解析完毕");
  43.         } catch (Exception e) {
  44.             e.printStackTrace();
  45.         }
  46.     }
  47. }

步骤七：输出集合

将emps集合的信息输出到控制台并关闭Socket对象，代码如下所示：

 
  1. import java.io.InputStream;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4. import java.util.ArrayList;
  5. import java.util.List;
  7. import org.dom4j.Document;
  8. import org.dom4j.Element;
  9. import org.dom4j.io.SAXReader;
  11. public class Server {
  12.     public static void main(String[] args) {
  13.         try {
  14.             //创建服务端Socket
  15.             ServerSocket server = new ServerSocket(8088);
  16.             System.out.println("等待客户端连接");
  17.             //监听客户端连接
  18.             Socket socket = server.accept();
  19.             System.out.println("客户端已经连接");
  20.             //获取输入流
  21.             InputStream in = socket.getInputStream();
  22.             //创建SAXReader
  23.             SAXReader reader = new SAXReader();
  24.             System.out.println("开始解析客户端发送的xml");
  25.             //读取指定文件
  26.             Document doc = reader.read(in);
  27.             //获取跟节点list
  28.             Element root = doc.getRootElement();
  29.             //获取list下的所有子节点emp
  30.             List<Element> elements = root.elements();
  31.             //保存所有员工对象的集合
  32.             List<Emp> emps = new ArrayList<Emp>();
  33.             for(Element element : elements){            
  34.                 int id = Integer.parseInt(element.attribute("id").getValue());
  35.                 String name = element.elementText("name");
  36.                 int age = Integer.parseInt(element.elementText("age"));
  37.                 String gender = element.elementText("gender");
  38.                 double salary = Double.parseDouble(element.elementText("salary"));
  39.                 Emp emp = new Emp(id,name,age,gender,salary);
  40.                 emps.add(emp);
  41.             }
  42.             System.out.println("解析完毕");
  43.             System.out.println(emps);
  44.             server.close();
  45.         } catch (Exception e) {
  46.             e.printStackTrace();
  47.         }
  48.     }
  49. }

步骤八： 创建客户端Client类

新建类Client，在该类的main方法中，首先，创建Socket去连接服务器端；然后获取网络输出流，代码如下所示：

 
  1. import java.io.File;
  2. import java.io.OutputStream;
  3. import java.net.Socket;
  5. import org.dom4j.Document;
  6. import org.dom4j.io.SAXReader;
  7. import org.dom4j.io.XMLWriter;
  9. public class Client {
  10.     public static void main(String[] args) {
  11.         try {
  12.             //连接服务端
  13.             Socket socket = new Socket("127.0.0.1",8088);
  14.             //获取输出流
  15.             OutputStream out = socket.getOutputStream();
  16.         } catch (Exception e) {
  17.             e.printStackTrace();
  18.         }
  19.     }
  20. }

步骤九： 读取XML文档

创建SAXReader对象，来读取XML文档，并获取Document对象，代码如下所示：

  1. import java.io.File;
  2. import java.io.OutputStream;
  3. import java.net.Socket;
  5. import org.dom4j.Document;
  6. import org.dom4j.io.SAXReader;
  7. import org.dom4j.io.XMLWriter;
  9. public class Client {
  10.     public static void main(String[] args) {
  11.         try {
  12.             //连接服务端
  13.             Socket socket = new Socket("127.0.0.1",8088);
  14.             //获取输出流
  15.             OutputStream out = socket.getOutputStream();
  16.             //创建SAXReader
  17.             SAXReader reader = new SAXReader();
  18.             //读取指定文件
  19.             Document doc = reader.read(new File("EmpList.xml"));
  20.         } catch (Exception e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  24. }

步骤十：发送XML文件到服务器端

首先，创建XML输出流XMLWriter类的对象；然后，设置该XML输出流的字节输出流为网络输出流out；最后，将Document对象写出到服务器端并关闭Socket对象，代码如下所示：

 
  1. import java.io.File;
  2. import java.io.OutputStream;
  3. import java.net.Socket;
  5. import org.dom4j.Document;
  6. import org.dom4j.io.SAXReader;
  7. import org.dom4j.io.XMLWriter;
  9. public class Client {
  10.     public static void main(String[] args) {
  11.         try {
  12.             //连接服务端
  13.             Socket socket = new Socket("127.0.0.1",8088);
  14.             //获取输出流
  15.             OutputStream out = socket.getOutputStream();
  16.             //创建SAXReader
  17.             SAXReader reader = new SAXReader();
  18.             //读取指定文件
  19.             Document doc = reader.read(new File("EmpList.xml"));
  20.             //创建XML输出流
  21.             XMLWriter writer = new XMLWriter();
  22.             writer.setOutputStream(out);
  23.             writer.write(doc);
  24.             socket.close();
  25.         } catch (Exception e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  29. }

步骤十一: 测试

运行代码，首先启动服务器端，然后启动客户端，服务器端控制台输出结果如下所示：

 
  1. 等待客户端连接
  2. 客户端已经连接
  3. 开始解析客户端发送的xml
  4. 解析完毕
  5. [Emp [id=1,name=张三, age=34, gender=男, salary=3000.0], Emp [id=2,name=李四, age=21, gender=女, salary=4000.0], Emp [id=3,name=王五, age=46, gender=女, salary=6500.0], Emp [id=4,name=赵六, age=28, gender=男, salary=4400.0], Emp [id=5,name=钱七, age=53, gender=男, salary=12000.0]]

本案例中，Emp类的完整代码如下所示：

 
  1. /**
  2. * 描述xml文件中每一个员工信息
  3. */
  4. public class Emp {
  5.     private int id;
  6.     private String name;
  7.     private int age;
  8.     private String gender;
  9.     private double salary;
  11.     public Emp(int id,String name, int age, String gender, double salary) {
  12.         this.id = id;
  13.         this.name = name;
  14.         this.age = age;
  15.         this.gender = gender;
  16.         this.salary = salary;
  17.     }
  19.     public int getId() {
  20.         return id;
  21.     }
  23.     public void setId(int id) {
  24.         this.id = id;
  25.     }
  27.     public String getName() {
  28.         return name;
  29.     }
  31.     public void setName(String name) {
  32.         this.name = name;
  33.     }
  35.     public int getAge() {
  36.         return age;
  37.     }
  39.     public void setAge(int age) {
  40.         this.age = age;
  41.     }
  43.     public String getGender() {
  44.         return gender;
  45.     }
  47.     public void setGender(String gender) {
  48.         this.gender = gender;
  49.     }
  51.     public double getSalary() {
  52.         return salary;
  53.     }
  55.     public void setSalary(double salary) {
  56.         this.salary = salary;
  57.     }
  59.     @Override
  60.     public String toString() {
  61.         return "Emp [id=" + id + ",name=" + name + ", age=" + age + ", gender=" + gender
  62.                 + ", salary=" + salary + "]";
  63.     }
  64. }

Server类的完整代码如下所示：

  1. import java.io.InputStream;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4. import java.util.ArrayList;
  5. import java.util.List;
  7. import org.dom4j.Document;
  8. import org.dom4j.Element;
  9. import org.dom4j.io.SAXReader;
  11. public class Server {
  12.     public static void main(String[] args) {
  13.         try {
  14.             //创建服务端Socket
  15.             ServerSocket server = new ServerSocket(8088);
  16.             System.out.println("等待客户端连接");
  17.             //监听客户端连接
  18.             Socket socket = server.accept();
  19.             System.out.println("客户端已经连接");
  20.             //获取输入流
  21.             InputStream in = socket.getInputStream();
  22.             //创建SAXReader
  23.             SAXReader reader = new SAXReader();
  24.             System.out.println("开始解析客户端发送的xml");
  25.             //读取指定文件
  26.             Document doc = reader.read(in);
  27.             //获取跟节点list
  28.             Element root = doc.getRootElement();
  29.             //获取list下的所有子节点emp
  30.             List<Element> elements = root.elements();
  31.             //保存所有员工对象的集合
  32.             List<Emp> emps = new ArrayList<Emp>();
  33.             for(Element element : elements){            
  34.                 int id = Integer.parseInt(element.attribute("id").getValue());
  35.                 String name = element.elementText("name");
  36.                 int age = Integer.parseInt(element.elementText("age"));
  37.                 String gender = element.elementText("gender");
  38.                 double salary = Double.parseDouble(element.elementText("salary"));
  39.                 Emp emp = new Emp(id,name,age,gender,salary);
  40.                 emps.add(emp);
  41.             }
  42.             System.out.println("解析完毕");
  43.             System.out.println(emps);
  44.             server.close();
  45.         } catch (Exception e) {
  46.             e.printStackTrace();
  47.         }
  48.     }
  49. }

Client类的完整代码如下所示：

  1. import java.io.File;
  2. import java.io.OutputStream;
  3. import java.net.Socket;
  5. import org.dom4j.Document;
  6. import org.dom4j.io.SAXReader;
  7. import org.dom4j.io.XMLWriter;
  9. public class Client {
  10.     public static void main(String[] args) {
  11.         try {
  12.             //连接服务端
  13.             Socket socket = new Socket("127.0.0.1",8088);
  14.             //获取输出流
  15.             OutputStream out = socket.getOutputStream();
  16.             //创建SAXReader
  17.             SAXReader reader = new SAXReader();
  18.             //读取指定文件
  19.             Document doc = reader.read(new File("EmpList.xml"));
  20.             //创建XML输出流
  21.             XMLWriter writer = new XMLWriter();
  22.             writer.setOutputStream(out);
  23.             writer.write(doc);        
  24.             socket.close();
  25.         } catch (Exception e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  29. }

4 客户端以XML格式向服务器端发送数据V2(提高题，选做)

客户端以XML格式向服务器端发送数据，详细要求如下：

1）客户端读取EmpList.xml中的数据，将其发送到服务器端。

2）服务器接收到XML格式的数据后，将其输出到Emp_Server.xml文件中。

参考答案

在上一案例中，是将客户端发送来的EmpList.xml解析输出到控制台，本案例要求将客户端发送来的XML格式的数据输出到Emp_Server.xml文件中，即，我们只要将服务器端Server类解析输出到控制台的代码，改为将XML格式的数据输出到Emp_Server.xml文件即可。

实现此案例需要按照如下步骤进行。

步骤一：修改Server类

修改Server类，将解析输出到控制台的代码，改为将XML格式的数据输出到Emp_Server.xml文件，代码如下所示：

  1. import java.io.FileOutputStream;
  2. import java.io.InputStream;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  6. import org.dom4j.Document;
  7. import org.dom4j.io.SAXReader;
  8. import org.dom4j.io.XMLWriter;
  10. public class Server {
  11.     public static void main(String[] args) {
  12.         try {
  13.             //创建服务端Socket
  14.             ServerSocket server = new ServerSocket(8088);
  15.             System.out.println("等待客户端连接");
  16.             //监听客户端连接
  17.             Socket socket = server.accept();
  18.             System.out.println("客户端已经连接");
  19.             //获取输入流
  20.             InputStream in = socket.getInputStream();
  21.             //创建SAXReader
  22.             SAXReader reader = new SAXReader();
  23.             System.out.println("开始解析客户端发送的xml");
  24.             //读取用户发送过来的xml
  25.             Document doc = reader.read(in);
  26.             //写出XML
  27.             XMLWriter writer = new XMLWriter();
  28.             FileOutputStream fos = new FileOutputStream("Emp_Server.xml");
  29.             writer.setOutputStream(fos);
  30.             writer.write(doc);
  31.             writer.close();
  32.             server.close();
  33.         } catch (Exception e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37.     
  38. }

运行代码，首先启动服务器端，然后启动客户端，在你当前工程目录下会生成emp_server.xml文件。文件内容与EmpList.xml文件内容相同。

本案例中，Emp类的完整代码如下所示：

 
  1. /**
  2. * 描述xml文件中每一个员工信息
  3. */
  4. public class Emp {
  5.     private int id;
  6.     private String name;
  7.     private int age;
  8.     private String gender;
  9.     private double salary;
  11.     public Emp(int id,String name, int age, String gender, double salary) {
  12.         this.id = id;
  13.         this.name = name;
  14.         this.age = age;
  15.         this.gender = gender;
  16.         this.salary = salary;
  17.     }
  19.     public int getId() {
  20.         return id;
  21.     }
  23.     public void setId(int id) {
  24.         this.id = id;
  25.     }
  27.     public String getName() {
  28.         return name;
  29.     }
  31.     public void setName(String name) {
  32.         this.name = name;
  33.     }
  35.     public int getAge() {
  36.         return age;
  37.     }
  39.     public void setAge(int age) {
  40.         this.age = age;
  41.     }
  43.     public String getGender() {
  44.         return gender;
  45.     }
  47.     public void setGender(String gender) {
  48.         this.gender = gender;
  49.     }
  51.     public double getSalary() {
  52.         return salary;
  53.     }
  55.     public void setSalary(double salary) {
  56.         this.salary = salary;
  57.     }
  59.     @Override
  60.     public String toString() {
  61.         return "Emp [id=" + id + ",name=" + name + ", age=" + age + ", gender=" + gender + ", salary=" + salary + "]";
  62.     }
  63. }

Server类的完整代码如下所示：

 
  1. import java.io.FileOutputStream;
  2. import java.io.InputStream;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  6. import org.dom4j.Document;
  7. import org.dom4j.io.SAXReader;
  8. import org.dom4j.io.XMLWriter;
  10. public class Server {
  11.     public static void main(String[] args) {
  12.         try {
  13.             //创建服务端Socket
  14.             ServerSocket server = new ServerSocket(8088);
  15.             System.out.println("等待客户端连接");
  16.             //监听客户端连接
  17.             Socket socket = server.accept();
  18.             System.out.println("客户端已经连接");
  19.             //获取输入流
  20.             InputStream in = socket.getInputStream();
  21.             //创建SAXReader
  22.             SAXReader reader = new SAXReader();
  23.             System.out.println("开始解析客户端发送的xml");
  24.             //读取用户发送过来的xml
  25.             Document doc = reader.read(in);
  26.             //写出XML
  27.             XMLWriter writer = new XMLWriter();
  28.             FileOutputStream fos = new FileOutputStream("Emp_Server.xml");
  29.             writer.setOutputStream(fos);
  30.             writer.write(doc);
  31.             writer.close();
  32.             server.close();
  33.         } catch (Exception e) {
  34.             e.printStackTrace();
  35.         }
  36.     }    
  37. }
 

Client类的完整代码如下所示：

 
  1. import java.io.File;
  2. import java.io.OutputStream;
  3. import java.net.Socket;
  5. import org.dom4j.Document;
  6. import org.dom4j.io.SAXReader;
  7. import org.dom4j.io.XMLWriter;
  9. public class Client {
  10.     public static void main(String[] args) {
  11.         try {
  12.             //连接服务端
  13.             Socket socket = new Socket("127.0.0.1",8088);
  14.             //获取输出流
  15.             OutputStream out = socket.getOutputStream();
  16.             //创建SAXReader
  17.             SAXReader reader = new SAXReader();
  18.             //读取指定文件
  19.             Document doc = reader.read(new File("EmpList.xml"));
  20.             //创建XML输出流
  21.             XMLWriter writer = new XMLWriter();
  22.             writer.setOutputStream(out);
  23.             writer.write(doc);        
  24.             socket.close();
  25.         } catch (Exception e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  29. }
 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/xyk1987/p/8330975.html