com.itbaizhan.SocketDemo;

java.io.BufferedReader;
java.io.InputStreamReader;
java.io.PrintWriter;
java.net.ServerSocket;
java.net.Socket;
java.util.Scanner;
Send1 Thread{
    Socket ;
    Scanner ;
    Send1(Socket socket,Scanner scanner){
        .=scanner;
        .=socket;
    }

    run() {
        .SendMsg();
    }
    SendMsg(){
        (PrintWriter pw=PrintWriter(.getOutputStream());){
            (){
                String msg=.nextLine();
                pw.println(msg);
                pw.flush();
            }
        }
        (Exception e){
            e.printStackTrace();}
    }
}
Receive1 Thread{
    Socket ;
    Receive1(Socket socket){
        .=socket;
    }

    run() {
        .receiveMsg();
    }
    receiveMsg(){
        (BufferedReader br=BufferedReader( InputStreamReader(.getInputStream()));
        ){
            (){
                String msg=br.readLine();
                System..println(+msg);
            }
        }
        (Exception e){
            e.printStackTrace();}

    }
}
GoodTCP {
    main(String[] args) {
        ServerSocket serverSocket=;
        Socket socket=;
        {
            Scanner scanner=Scanner(System.);
            System..println();
            String str= scanner.nextLine();
            String[] arr=str.split();
            String[] split=str.split();
            (.equals(arr[])){
                System..println(+arr[]+);
                serverSocket =ServerSocket(Integer.(arr[]));
                 socket = serverSocket.accept();

            }{
                socket =Socket(arr[],Integer.(arr[]));
                System..println();

            }
            Send1(socket,scanner).start();
            Receive1(socket).start();
        }
        (Exception e){
            e.printStackTrace();
        }{
            (serverSocket!=){
                {
                    serverSocket.close();
                }(Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

com.itbaizhan.SocketDemo;

java.io.BufferedReader;
java.io.InputStreamReader;
java.io.PrintWriter;
java.net.ServerSocket;
java.net.Socket;

Msg Thread{
    Socket ;
    Msg(Socket socket){
        .= socket;
    }
    run() {
        .msg();
    }

    msg(){
        (BufferedReader br = BufferedReader(InputStreamReader(..getInputStream()));
            PrintWriter pw = PrintWriter(..getOutputStream())){
            (){
                pw.println(br.readLine()+);
                pw.flush();
            }
        }(Exception e){
            e.printStackTrace();
            System..println(..getInetAddress()+);
        }
    }
}
EchoServer {
    main(String[] args) {
        (ServerSocket serverSocket = ServerSocket()){
            (){
                Socket socket = serverSocket.accept();
                Msg(socket).start();
            }
        }(Exception e){
            e.printStackTrace();
        }
    }
}

不知道为什么会报错，代码运行没问题。

老师什么时候创建对象用new 什么时候不用啊？

老师，还是和上一节一样的问题，年龄一样后通过name来排序，调用name的compareto方法，但是重写的compareto方法不是里面不是只有age的比较方法吗我的意思就是说为什么不用写如果o1.name==o2.name这样

突然想问一下定义比较规则返回的不是1或者0吗为什么是username  userage呢

public List<E> getBrother(E item) {
    E parent = this.getParent(item);
    if (parent==null)return null;
    else {
        List<E> child = this.getChild(parent);
        List<E> brother = new ArrayList<>();
        brother.addAll(child);
        brother.remove(item);
        return brother;
    }
}

老师我这样写好吗

如果父节点为空那就没有兄弟节点了

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

    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 发送消息
     */
    private void sendMsg(){
        //创建向对方输出消息的流对象
        try (PrintWriter pw = new PrintWriter(socket.getOutputStream())){
            while (true){
                String msg = scanner.nextLine();
                pw.println(msg);
                pw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

/**
 * 接收消息的线程
 */
class Receive1 extends Thread{
    private Socket socket;
    public Receive1(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();
                System.out.println("他说："+msg);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
public class GoodTCP {
    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 Send1(socket,scanner).start();
            //启动接收消息的线程
            new Receive1(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(serverSocket != null){
                try {
                    serverSocket.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

请输入：server,<port> 或者：<ip>,<port>

server，8888

java.lang.ArrayIndexOutOfBoundsException: Index 1 out of bounds for length 1

at GoodTCP.main(GoodTCP.java:88)

老师，这是数组越界吗？我该怎么解决呢？

请问在hashmap在进行扩容时，是否会对已存储的元素重新计算在数组中的位置？因为元素在数组中的位置=（数组长度-1）&hash;那数组长度变了，已存储的元素存储位置是否也需要改变？

老师，这结课里的hash(key)的方法，为什么通过把这个key的哈希值的前16位与后16位进行异或，就能让数在HashMap的数组中分布均匀啊？

老师这里为啥不用Thread thread=new Thread(new DrawThread())呢

老师我已经自己解决了，不用麻烦了

为什么客户端不直接使用服务器端定义的线程而要重新定义呢

老师为什么我调用不了呀

package com.itbaizhan;
import java.util.Arrays;//自定义一个简单的包装类,仅限于练习
public class MyInteger {
    private final int value;
    private static MyInteger[]cache;//缓存【-128,127】之间的数字
    private static  final int LOW=-128;
    private static  final  int HIGH=127;
    static {
        cache=new MyInteger[HIGH-LOW+1];
        for(int i=LOW;i<HIGH;i++){
            cache[i-LOW]=new MyInteger(i);
        }
        System.out.println(Arrays.toString(cache));
    }
    public MyInteger(int value){
        this.value=value;
    }
    @Override
    public String toString() {
        return value+"";
    }
    public static MyInteger valueof(int value){
        if(value>=LOW&&value<=HIGH){
            return  cache[value-LOW];
        }
        return  new MyInteger(value);}
    public static void main(String[] args) {
        MyInteger a=new MyInteger(10);
        MyInteger b= new MyInteger(100);
        MyInteger b2= new MyInteger(100);
        MyInteger b3 = new MyInteger(1000);
        MyInteger b4 = new MyInteger(1000);
        System.out.println(b==b2);
        System.out.println(b3==b4);
        int c=b.intvalue();  }
    public int intvalue(){
        return  value;
    }
}

不清楚为什么会输出两个false

老师这是什么问题

请问通过哪个快捷键可以直接返回啊