绝对路径是换了，但是又显示这样的错误

文件名应该没错啊

<?xml version="1.0" encoding="UTF-8"?>
<books xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:niNamespaceSchemaLocation="{book.xsd}">
    <book id ="1001">
        <name>java开发实战</name>
        <author>张小三</author>
        <price>98.5</price>>
    </book>>
</books>

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="books">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="book" maxOccurs="unbounded">
                    <xs:complexType>
                        <xs:sequence>
                        <xs:element name="name" type="xs:string"></xs:element>
                        <xs:element name="author" type="xs:string"></xs:element>
                        <xs:element name="price" type="xs:double"></xs:element>
                        </xs:sequence>
                        <xs:attribute name="id" type="xs:positiveInteger" use="required"></xs:attribute>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

package com.Jin.XML;

import org.xml.sax.SAXException;

import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws SAXException {
        //(1)创建SchemaFactory工厂
        SchemaFactory sch = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
        //(2)建立验证文件对象
        File schemaFile = new File("book.xsd");
        //(3)利用SchemaFactory工厂对象，接收验证的文件对象，生成Schema对象
        Schema schema = sch.newSchema(schemaFile);
        //(4)产生对此schema的验证器
        Validator validator = schema.newValidator();
        //(5)要验证的数据（准备数据源）
        Source source = new StreamSource("book.xml");
        //(6)开始验证
        try{
            validator.validate(source);
            System.out.println("成功");
        }catch (IOException e) {
            e.printStackTrace();
            System.out.println("失败");
        }

    }
}

显示找不到文件

我看了之前过相同问题的，老师你回复idea要用绝对路径，我找了很久也不知道怎么弄，能说的仔细点吗

多线程问题：以下代码通过run方法和start方法输出的结果都是一样，这个有和区别？调用run方法是单线程，调用start是多线程吗？

public class MyThread extends Thread{
    public void run(){
        //线程体
        System.out.println("My Thread------------------");
    }
}

public class TestMyThread {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.run();
        myThread.start();
        System.out.println("---------Main");
    }
}

老师有个空指针求看

视频末尾的hashset对象迭代遍历的时候，为什么不是123，345，456 这个顺序输出。而是456，345，123这样的顺序输出？

关于文件读取设定中转站，老师大小都是设定1024，这个大小对于读取大文件或者较多文件时，是否足够用，若设定更大的空间，是否可用提高效率

byte[] buf=new byte[1024];

package com.Jin.server;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Test {
    public static void main(String[] args) throws IOException {
        System.out.println("__________服务器已启动______________");
        //(1)创建ServerSocket对象
        ServerSocket server = new ServerSocket(9999);
        //(2)监听是否有客户端来请求连接
        Socket client = server.accept();
        //(3)获取输入流
        InputStream is = client.getInputStream();
        System.out.println((char)is.read());
        //(4)获取输出流
        //“收到了”
        OutputStream os = client.getOutputStream();
        os.write("收到了！".getBytes());
        //(5)关闭流，关闭Socket
        if (os!=null){
            os.close();
        }
        if (is!=null){
            is.close();
        }
        if (client!=null){
            client.close();
        }
    }
}



package com.Jin.client;

import com.sun.org.apache.xpath.internal.operations.String;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class Test {
    public static void main(String[] args) throws IOException {
        //(1)创建Socket对象
        Socket client = new Socket("192.168.0.101",9999);
        //(2)获取输出流
        OutputStream os = client.getOutputStream();
        os.write('a');
        //(3)获取输入流
        InputStream is = client.getInputStream();
        byte [] buf = new byte[1024];//中转站
        int len = 0;//读到字节的个数
        while ((len=is.read(buf))!=-1){
            System.out.println(new String(buf,0,len));
        }
        //(4)关闭流
        if (is!=null){
            is.close();
        }
        if (os!=null){
            os.close();
        }
        if (client!=null){
            client.close();
        }

    }

}

启动不了，显示错误

缓冲字节流和缓冲字符流问题

老师，我在测试缓冲字节流_缓冲字符流时，发现缓冲字节流可以读取复制文本、视频、图片等文件，复制的文件大小一致可以正常打开。缓冲字符流复制视频和图片后，文档变大了，而且无法打开，复制文档后，打开出现乱码情况。

这个是什么原因导致。

import java.io.*;

public class TestCopy2 {
    public static void main(String[] args) {
        BufferedReader br= null;
        BufferedWriter bw= null;
        long start= 0;
        try {
            br = new BufferedReader(new FileReader("G:\\1.txt"));
            bw = new BufferedWriter(new FileWriter("F:\\1.txt"));
            start = System.currentTimeMillis();
            String line=null;
            while((line=br.readLine())!=null) {
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        long end=System.currentTimeMillis();
        System.out.println("耗时:"+(end-start));

    }
}

try catch 和抛出异常的疑问：

以下2段代码，都能往磁盘写文件，在处理异常时，用try catch和抛出异常都能正常写文件，2者在用法上有什么规则或者要求吗？抛出异常感觉代码会更简洁，

import java.io.FileWriter;
import java.io.IOException;
public class TestFileWrite2 {
    public static void main(String[] args) throws IOException {
        FileWriter writer=new FileWriter("G:\\test5.txt");
        writer.write("hello,python");
        if(writer!=null) {
            writer.close();
        }
    }
}

-------------------

import java.io.IOException;
public class TestFileWriter {
    public static void main(String[] args) {
        //创建对象
        FileWriter writer=null;
        try {
            writer=new FileWriter("G:\\test2.txt");
            //写数据
            writer.write("hello,java");//写到的是缓冲区，不关闭不会写到文件里
            // writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //
            try {
                if(writer!=null)
                writer.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

老师，下面提问里许多人说什么反编译，我看视频里没提呀，他们说的是以前的视频的内容吗

老师，为什么我运行后没有结果，代码和老师的源码全部对照过，路径换过绝对路径和内容根的路径结果也一样。JDK也是今天重新配置的1.8版本，用的IDEA2020.1.2。

我的源码文件

FileInputStream fis=new FileInputStream(new File("G:\\test.txt"));
FileInputStream fis=new FileInputStream("G:\\test.txt");

老师，这两种方式有何区别

调用同步方法时，不加this关键字也可以正常运行，加和不加有什么区别吗？

try

语句1

语句2

...

老师，语句1有异常，会抛出处理，处理完了直接越过语句2了，但如果语句2也有是异常怎么办，不用管了吗

麻烦老师给我发下第二阶段的WORD课件，在网页上看太不方便了