老师，这里使用BufferedInputStream和BufferedOutputStream定义的处理流，是不是与自定义byte[]数组缓冲区然后read(byte[] b)并不一样？

我的理解：

1）处理流仍然是一个字节一个字节从数据源中读取数据，只是将这些字节缓存在处理流定义的字节数组中，之后等满了以后（达到8192个字节）再读入到程序中；

2）而自定义的缓冲区是一次直接从数据源中读取多个字节（比如定义的1024个字节数组）到程序中。

处理小文件的时候，自定义的会不会效率更高一下？

处理大文件的时候使用那个更好一些？

两个结合在一块使用适用吗？（比如第二段代码中的适用）

第一段代码：

package cn.ljp;

import java.io.*;

public class TestBufferedInputStream02 {
    public static void main(String[] args) {
        // 1) 定义字节流和处理流
        InputStream fis = null;
        InputStream fib = null;
        OutputStream fos = null;
        OutputStream fob = null;
        try{
            fis = new FileInputStream("f:/a.png");
            fib = new BufferedInputStream(fis);
            fos = new FileOutputStream("f:/aa.png");
            fob = new BufferedOutputStream(fos);
            int emp = 0;
            long start = System.currentTimeMillis();
            while((emp = fib.read()) != -1){
                System.out.println(emp);
                fob.write(emp);
            }
            fob.flush();
            long stop = System.currentTimeMillis();
            System.out.println("花费时间" + (stop - start) + "毫秒");
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(fib != null)
                    fib.close();
                if(fis != null)
                    fis.close();
                if(fob != null)
                    fob.close();
                if(fos != null)
                    fos.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

第二段代码：

package cn.ljp;

import java.io.*;

public class TestBufferedInputStream {
    public static void main(String[] args) {
        // 1) 定义字节流和处理流
        InputStream fis = null;
        InputStream fib = null;
        OutputStream fos = null;
        OutputStream fob = null;
        try{
            fis = new FileInputStream("f:/a.png");
            fib = new BufferedInputStream(fis);
            fos = new FileOutputStream("f:/aa.png");
            fob = new BufferedOutputStream(fos);
            byte[] buff = new byte[1204];
            int emp = 0;
            long start = System.currentTimeMillis();
            while((emp = fib.read(buff)) != -1){
                System.out.println(emp);
                fob.write(buff,0,emp);
            }
            fob.flush();
            long stop = System.currentTimeMillis();
            System.out.println("花费时间" + (stop - start) + "毫秒");
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(fib != null)
                    fib.close();
                if(fis != null)
                    fis.close();
                if(fob != null)
                    fob.close();
                if(fos != null)
                    fos.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }

    }
}

老师，请问一下为什么不写关闭语句时字符将不能输出到目标文件中。

package com.bjsxt;

import java.io.*;

public class LineNumberDemo3 {
    public static void main(String[] args) {
        BufferedReader br=null;
        PrintWriter pw=null;
        try {
            br=new BufferedReader(new InputStreamReader(new FileInputStream("d:/sxt.txt")));
            pw=new PrintWriter("d:/sxt4.txt");
            String temp="";
            int i=1;
            while((temp=br.readLine())!=null){
                pw.println(i+""+temp);
                i++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

为什么这样不行？

数字后面加了个L，是代表毫秒单位吗

老师能帮我看看我这样理解对吗？ 谢谢老师了

因为创建了ThreadLocal这样一个容器并赋上了初始值，那么每当一个线程调用这个容器的set方法时就会在当前线程对象里面重新创建一个ThreadLocalMap对象，这个ThreadLocalMap对象里的key是一个新的ThreadLocal容器，所以value就可以再次以初始值开始了，这样就可以实现数据的隔离效果让每个线程操作自己的变量。

老师，我按照视频要求，全部都敲了，但是，结果出不来怎么回事？

请问File.separator中的separator什么意思？

有什么作用？

怎么通过instance of判断它的类型

还是不对，麻烦了。老师。我所有的文件都不对，都是这个的错误。我也不知道什么错

不明白第31行代码为什么先要把日期设置成1号

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

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

这个是什么原因导致。

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));

    }
}

我知道接口是一个更抽象的抽象类。我是想说如果往多态的三个必要条件上面靠的话，是不是只要有类似于extends这样的类之间的关系存在都可以符合，而不是必须要有extends关键字。换句话说，就是是不是继承是一个概念，而extends是最接近他的解释，但不是继承=extends。只要符合继承概念，类与类之间关系的都可以看作符合多态的必要条件之一即继承，即会发生多态性。

这是百度百科上面对于继承的解释

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于java.lang.Object，当一个类没

有继承的两个关键字，则默认继承object（这个类在 java.lang包中，所以不需要 import）祖先类。

是不是可以理解为继承是一个概念，而实现继承概念的方法有implemets和extends。而不是我们经常说的，extends叫做继承。

客户端：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;


public class Client  {
    public static void main(String[] args) {
        //1.创建Socket对象
        Socket client = null;
        DataOutputStream dos =null;
        DataInputStream dis=null;
        try {
            client = new Socket("localhost",8888);
            //2.发送请求，获取输出流>请求
             dos =new DataOutputStream(client.getOutputStream());
            dos.writeUTF("我是客户端:服务器你好!");
            //3.响应请求，获取输入流>响应
             dis= new DataInputStream(client.getInputStream());
            System.out.println(dis.readUTF());
        } catch (IOException e) {
            e.printStackTrace();
        }
        //4.关闭流
        finally {
            IOClose.closeAll(dis,dos,client);
        }
    }
}

服务端：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;


public class Server {
    public static void main(String[] args) {
        //创建ServerSocket对象
        ServerSocket server = null;
        //监听是否有客户端发送请求
        Socket client =null;
        //获取socke对象
        //获取输入流>得到客户端的请求
        DataInputStream dis = null;
        //获取输出流>给客户端发送消息
        DataOutputStream dos =null;
        try {
            server = new ServerSocket(8888);
             client =server.accept();
             dis=new DataInputStream(client.getInputStream());
            System.out.println(dis.readUTF());
             dos = new DataOutputStream(client.getOutputStream());
            dos.writeUTF("客户端您好：我是服务器，我收到了你的信息");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭流
            IOClose.closeAll(dos,dis,client,server);
        }
    }
}

服务端运行结果：

客户端运行结果：

老师我的代码安装视频中敲的，为什么控制台没有收到任何输出啊

老师，我有个问题想问一下，就是视频上面讲的，服务端在接收客户端发送的信息的时候，为什么读取信息的操作不能放到sy锁结构里面，你的解释是读取信息不需要同步，但是我把读取信息的代码放到sy块里面的时候，客户端发送消息的时候，服务端发送消息的线程为什么不启动，这是什么原因呢