package cn.jscn.tz;


import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Scanner;


public class test {
	public static void main(String[] args) throws ParseException {
		System.out.println("请输入一个日期：yyyy-MM-dd");
		Scanner input =new Scanner(System.in);
		String str=input.next();
		DateFormat df=new SimpleDateFormat("yyyy-MM-dd");
		Date d=df.parse(str);
		Calendar cal=new GregorianCalendar();
		cal.setTime(d);
		int nowDate =cal.get(Calendar.DAY_OF_MONTH);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		int dayOfWeek=cal.get(Calendar.DAY_OF_WEEK);
		System.out.println("日\t一\t二\t三\t四\t五\t六");
		for(int i=1;i<dayOfWeek;i++) {
			System.out.print("\t");
		}
		int dayMax=cal.	getActualMaximum(Calendar.DAY_OF_MONTH);
		for(int i=1;i<=dayMax;i++) {
			System.out.print(i);
			if(i==nowDate) {
				System.out.print("*");
			}
			 	System.out.print("\t");
			 if(cal.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY) {
				System.out.println();
			}
		      cal.add(Calendar.DAY_OF_MONTH, 1);
			
		}
		
		
		
}
}

 cal.add(Calendar.DAY_OF_MONTH, 1);循环每循环一次就增加一天，这个地方没有理解，我把这行代码删除后，

不是已经有判断是星期六就换行么？为什么这个代码删除后

 if(cal.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY) {
				System.out.println(); 就没有自动换行呢

老师，您好：

这里fos,fis输入输出流为什么要分别关闭，有什么说法嘛。。。我一想到关闭就下意识想把fos,fis写一个try里，fos,与fis写一个try中有什么隐患么？谢谢老师。

守护进程是一对一的吗？同一守护进程可以同时守护多个用户进程吗

这为什么空指针异常啊

ce.zip

所有代码写完测试出异常求老师解惑

/**
 * 接受客户端消息的线程类
 */
class ChatReceive implements Runnable{
    private Socket socket;
    public ChatReceive(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        this.receiveMsg();
    }
    /**
     * 实现接收客户端发送的消息
     */
    private void receiveMsg(){
        try(BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()))){
            while (true){
                String msg = br.readLine();
                synchronized ("abc"){
                    //将读取到的数据写入到公共数据区
                    ChatRoomServer.buf = "[" + this.socket.getInetAddress() + "]: " + msg;
                }
                //唤醒发送消息的线程对象
                "abc".notifyAll();
            }

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

    }


}

/**
 * 向客户端发送消息的线程类
 */
class ChatSend implements Runnable{
    private Socket socket;
    public ChatSend(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 将公共数据区的消息发送给客户端
     */
    private void sendMsg(){
        try (PrintWriter pw = new PrintWriter(this.socket.getOutputStream());){

            while (true){
                synchronized ("abc"){
                    //让发消息的线程处于等待状态
                    "abc".wait();
                    //将公共数据区中的消息发送给客户端
                    pw.println(ChatRoomServer.buf);
                    pw.flush();
                }
            }

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

}


public class ChatRoomServer {
    //定义公共数据区
    public static String buf;

    public static void main(String[] args) {
        System.out.println("Chat Server Version 1.0");
        System.out.println("Listen at 8888.....");
        try(ServerSocket serverSocket = new ServerSocket(8888)){
            while (true){
                Socket socket = serverSocket.accept();
                System.out.println("连接到：" + socket.getInetAddress());

                Thread t1 = new Thread(new ChatReceive(socket));
                Thread t2 = new Thread(new ChatSend(socket));
                t1.start();
                t2.start();

            }

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

    }
}

连接成功后:客户端一直循环输出他说：null

服务端报异常

老师，这个可以用数据流读吗，用readUTF进行读取

next()方法是返回当前元素并指向下一个元素，remove()方法是删除当前元素，那按照老师的代码，next()返回元素c时，指针已经指向d了，remove()应该删掉d啊，为什么却删除了c呢。

老师为什么我进行拷贝处理后的文本内容不是一致的而是一堆乱码呀

package cn.work.com.bjsxt2.netWork;

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 send extends Thread {
    private Socket socket;
    private Scanner scanner;
    public send(Socket socket , Scanner scanner){
        this.socket = socket;
        this.scanner = scanner;
    }

    @Override
    public void run() {
        this.sendMsg();
    }

    private void sendMsg(){
        PrintWriter pw = null;
        try {
            pw = new PrintWriter(this.socket.getOutputStream());
            while (true){
                String str = scanner.nextLine();
                pw.println(str);
                pw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(pw != null){
                    pw.close();
                }
                if(socket != null){
                    socket.close();
                }
                if(scanner != null){
                    scanner.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
//接收信息线程
class receive extends Thread{
    private Socket socket;
    public receive (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 str = br.readLine();
                System.out.println("他说："+str);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
                try {
                    if(br != null){
                    br.close();}
                } catch (IOException e) {
                    e.printStackTrace();
                }

            if(this.socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}


//主方法
public class goodTCP13 {
    public static void main(String[] args) {
        Scanner scanner = null;
        ServerSocket serverSocket = null;
        Socket socket = null;
        try{
            scanner = new Scanner(System.in);
            System.out.println("请输入:server,<port>或者:IP,<port>");
            String str = scanner.nextLine();
            String [] arr = str.split(",");
            if("server".equals(arr[0])){
                //启动服务端
                System.out.println("TCP Server Listen at"+arr[1]+".......");
                serverSocket = new ServerSocket(Integer.parseInt(arr[1]));
                socket = serverSocket.accept();
                System.out.println("连接成功!");
            }else {
                //启动客户端
                socket = new Socket(arr[0],Integer.parseInt(arr[1]));
                System.out.println("连接成功！");
            }
            //启动发送消息线程
            new send(socket,scanner).start();
            //启动接收消息线程
            new receive(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

老师帮我看一下

老师，我io流输出了乱码怎么解决呢，代码都是一样的，是我idea编码有问题吗，怎么解决呢呢

老师，为啥对象的引用要向上呢，实例化自己不是更加确切嘛

HashMap也是假排序的吗？因为我看输出是按字典序进行排序的

老师，上面是ChatRoomServer类中，向客户端发送消息线程类的发送消息方法代码。我说下总体逻辑，你看看有哪些不对的地方？

1. 接收客户端消息的线程、向客户端发送消息的线程都持有字符串对象锁，所有线程都实现同步

2. 如果客户端发送消息线程抢到锁，则发送消息到服务端，然后唤醒所有客户端接收线程接收消息

3. 如果接收客户端接收消息线程抢到锁，则进入等待，让出锁客户端发送消息线程，让客户端向服务端发送消息，然后不断重复这个流程。
   

老师，这个Object对象意思是说   为成员变量赋值和获取时不知道对象的时候   使用是吗？

自定义异常中throw和throws的区别是什么