这源码分析的我快怀疑自己的智商了，能先跳过这部分吗

请问老师，做个项目的时候，是不是对着敲就好了

老师，请问这里为什么要判断fil！=null,才关闭IO流啊

如图，感谢蔚老师！

public class Test1 {
	public static void main(String[] args) {
		//ExecutorService pool = Executors.newSingleThreadExecutor();
		ExecutorService pool = Executors.newFixedThreadPool(10);
		//ExecutorService pool = Executors.newCachedThreadPool();
		
		for (int i = 0; i < 20; i++) {
			final int n = i;
			
			Runnable command = new Runnable() {
				@Override
				public void run() {
					System.out.println("开始执行: " + n);
					
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					System.out.println("结束执行: " + n);
				}
			};
			pool.execute(command);
		}
		pool.shutdown();
	}
}

老师, 请问一下, 在本节课的示例Test1中, 为什么在代码"final int n = i;", 要使用final呢? 不加final, 直接复制 int n = i; 应该也可以达到同样的效果吧?

环境：jdk1.8

服务端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
 
/**
 * 接受客户端消息的线程类
 */
class ChatReceive extends Thread{
    private Socket socket;
    public ChatReceive(Socket socket){
        this.socket=socket;
    }
    @Override
    public void run() {
        this.receiveMsg();
    }
    /**
     * 实现接收客户端发送的消息
     */
    private void receiveMsg(){
        BufferedReader br = null;
        try {
            br=new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
                String msg=br.readLine();
                synchronized ("abc"){
                    //把读取到的数据写入公共数据区
                ChatRoom.buf="["+this.socket.getInetAddress()+"] "+msg;
                    //唤醒发送消息的线程对象
                    "abc".notifyAll();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (br != null) {
                try {
                    br.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if (this.socket != null) {
                try {
                    this.socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
/**
 * 向客户端发送消息的线程类
 */
class ChatSend extends Thread{
    private Socket socket;
    public ChatSend(Socket socket){
        this.socket=socket;
    }
 
    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 将公共数据区的消息发送给客户端
     */
    private void sendMsg(){
        PrintWriter pw = null;
        try {
            pw=new PrintWriter(this.socket.getOutputStream());
            while (true){
                synchronized ("abc"){
                    //让发送消息的线程处于等待状态
                    "abc".wait();
                    //将公共数据区中的消息发送给客户端
                    pw.println(ChatRoom.buf);
                    pw.flush();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (pw != null) {
                pw.close();
            }
            if (this.socket != null) {
                try {
                    this.socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class ChatRoom {
    //定义公共数据区
    public static String buf;
    public static void main(String[] args) {
        System.out.println("Chat Server Version 1.0");
        System.out.println("Listen at 8888.....");
        ServerSocket serverSocket =null;
        try {
            serverSocket =new ServerSocket(8888);
            while (true){
                Socket socket=serverSocket.accept();
                System.out.println(socket.getInetAddress()+"加入聊天室");
                new ChatReceive(socket).start();
                new ChatSend(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
 
/**
 * 用于发送消息的线程类
 */
class SendMsg extends  Thread {
    private Socket socket;
    private  Scanner scanner;
    public SendMsg(Socket socket,Scanner scanner) {
        this.socket = socket;
        this.scanner=scanner;
    }
 
    @Override
    public void run() {
        this.sendMsg();
    }
 
    /**
     *发送消息
     */
    private void sendMsg() {
        PrintWriter pr = null;
        try {
            //创建向对方输出消息的流对象
            pr = new PrintWriter(this.socket.getOutputStream());
            while (true) {
                String str = scanner.nextLine();
                pr.println(str);
                pr.flush();
 
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (pr != null) {
                pr.close();
            }
            if (scanner != null) {
                scanner.close();
            }
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
 
/**
 * 用于接收消息的线程类
 */
class ReceiveMsg extends  Thread{
    private Socket socket;
 
    public ReceiveMsg(Socket socket) {
        this.socket = socket;
 
    }
    /**
     * 用于接收对方消息的方法
     */
    private   void ReceiveMsg (){
        BufferedReader br = null;
        try {
            //创建用于接收对方发送消息的流对象
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while (true){
                String str = br.readLine();
                System.out.println("用户"+str);
 
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
 
            }try {
                if(socket!=null){
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    @Override
    public void run() {
        this.ReceiveMsg();
    }
}
 
public class ChatClients {
    public static void main(String[] args) {
        System.out.println("请建立服务器或客户端");
        System.out.println("请输入：server,<port> 或者：<ip>,<port>");
        Scanner scanner = null;
        Socket socket = null;
        ServerSocket serverSocket = null;
        try{
 
            scanner = new Scanner(System.in);
            String scan = scanner.nextLine();
            String[] arr = scan.split(",");
            if("server".equals(arr[0])){
 
                serverSocket = new ServerSocket(Integer.parseInt(arr[1]));
                System.out.println("服务器监听中");
                socket = serverSocket.accept();
                System.out.println("接收成功");
 
            }else{
                socket = new Socket(arr[0],Integer.parseInt(arr[1]));
                System.out.println("连接成功");
            }
            new SendMsg(socket,scanner).start();
            new ReceiveMsg(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }
 
    }
}

客户端和服务器连接上以后，把客户端关闭就报这个错误，咋处理？

老师,为什么要分开写d1.flag=true和d2.flag=false

老师好，请看一下：

客户端和服务器端处理异常使用了try-catch, 先启动的服务器端，然后是客户端，运行结果显示服务器端收到和客户端一样的信息。

客户端代码：

package cn.sxt.net;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

public class TestSocket {
	public static void main(String[] args) {
		// 1)创建Socket对象，指定要连接服务器的IP地址和监听的端口号
		Socket client = null;
		// 2.获取输出流
		DataOutputStream dos = null;
		// 3.获取输入流
		DataInputStream dis = null;
		try {			
			client = new Socket("localhost", 9999);
			dos = new DataOutputStream(client.getOutputStream());
			dos.writeUTF("helloworld");
			dis = new DataInputStream(client.getInputStream());
			System.out.println(dis.readUTF());
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 4.关闭流
			if (dis != null) {
				try {
					dis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (dos != null) {
				try {
					dos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (client!=null) {
				try {
					client.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

服务器端代码：

package cn.sxt.net;

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

public class TestServerSocket {
	public static void main(String[] args) {
		System.out.println("服务器端启动——————————————");
		// 1.创建serverSocket对象
		ServerSocket server = null;
		// 2.监听客户端的连接
		Socket client = null;
		// 3，获取输入流
		DataInputStream dis = null;
		// 4.获取输出流
		DataOutputStream dos = null;
		try {	
			server = new ServerSocket(9999);
			client = server.accept();
			dis = new DataInputStream(client.getInputStream());
			System.out.println(dis.readUTF());
			dos = new DataOutputStream(client.getOutputStream());
			dos.writeUTF("收到了");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 5释放资源
			if (dos != null) {
				try {
					dos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (dis != null) {
				try {
					dis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (client != null) {
				try {
					client.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

运行结果截图：

请教老师个问题， 针对多线程安全的问题， 通过使用 synchronized 来解决。 我在测试时发现， 如果 synchronized 在 while 块里面， 那么三个线程会正常的争抢。 如果把 synchronized 移到 while 的外面， 那么每次运行，都只会出现一个线程的打印信息，其它两个线程不会参与争抢。 代码如下：

为什么会显示null？

复制出来的图片文件是空的可能是什么问题呢？
前面几个实验复制都成功了

下面文件路径我有小小遮下

package com.bjsxt;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileStreamBuffer3Demo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos  = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream("/Users/.../Documents/...jpg");
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream("/Users/.../Documents/...jpg");
            bos = new BufferedOutputStream(fos);
            int temp = 0;
            while((temp = bis.read()) != -1){
                bos.write(temp);
            }
            bos.flush();

        }catch (Exception e ){
            e.printStackTrace();
        }finally {
            try {

            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

老师，如果是一个二维Object数组，怎么把他转为对象数组或对象集合呢。

package com.bjsxt.test.container;

import org.junit.Test;

import java.util.ArrayList;

import java.util.Arrays;
import java.util.List;

public class TestArrayList {

    @Test
    public void test() {
        Object[][] objects = new Object[2][];
        Object [] object1 = new Object[3];
        object1[0] = 001;
        object1[1] = "张三";
        object1[2] =15;

        Object [] object2 = new Object[3];
        object2[0] = 002;
        object2[1] = "张一";
        object2[2] =18;
        objects[0] = object1;
        objects[1] = object2;

        List<Object[]> list = Arrays.asList(objects);  
    
        People[] peoples = list.toArray(new People[list.size()]);  //报错了java.lang.ArrayStoreException
    }
}

class People{
    public Integer id;
    public String name;
    public Integer age;
}

这种情况只能循环List<Object[]> list 然后把每一个Object[ ]的值取出来赋给People 存起来吗

throws一直向上抛出，最后这个异常是怎么处理的，异常不是需要我们程序员进行捕获和解决吗？一直抛出去还是没有处理掉这个异常啊

com.xykjjava.io.BufferedOutputStreamjava.io.DataOutputStreamjava.io.FileOutputStreamDataOutputDemo {
    (String[] args) {
        DataOutputStream dos = {
            dos = DataOutputStream(BufferedOutputStream(FileOutputStream()))dos.writeChar()dos.write()dos.writeDouble(Math.())dos.writeBoolean()dos.writeUTF()dos.flush()}(Exception e){
            e.printStackTrace()}{
            {
                (dos != ){
                    dos.close()}
            }(Exception e){
                e.printStackTrace()}
        }
    }
}

com.xykjjava.io.BufferedInputStreamjava.io.DataInputStreamjava.io.FileInputStreamDataInputDemo {
    (String[] args) {
        DataInputStream dis = {
            dis = DataInputStream(BufferedInputStream(FileInputStream()))System..println(+dis.readChar())System..println(+dis.readInt())System..println(+dis.readDouble())System..println(+dis.readBoolean())System..println(+dis.readUTF())}(Exception e){
            e.printStackTrace()}{
                {
                    (dis != ){
                        dis.close()}
                }(Exception e){
                    e.printStackTrace()}
        }
    }
}

老师，我是按着顺序读取的，怎么还会报错！

老师，我调试了很长时间都是空指针异常，您能帮我看一下吗，谢谢~