MyInteger b =MyInteger. valueOf(100);

老师这个MyInteger.valueOf 是什么意思，方法的调用吗，还是什么别的固定写法。

老师，这个循环要执行index-1次，如果被删除的的元素在循环次数的中间，怎么办，还有这个循环最后得到的不是最后一个数吗，咋又成了被删除的前一个数，好乱

为什么这段代码会有两个return，如果多个return不是只执行一个吗？这样写的话就会执行两个return啊

老师，return返回一个值，是将这个值返回到哪里呢

老师，在判断为空的方法里为什么不加if条件判断

老师 能不能全部都按照String类型传输

在服务端去做String到基本数据类型的转换啊

可以少开好几个IO流了

服务端：

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDP_basicDataServer {
    public static void main(String[] args) {
        try(DatagramSocket datagramSocket=new DatagramSocket(9999)) {
            byte[] bytes=new byte[1024];
            DatagramPacket datagramPacket=new DatagramPacket(bytes,bytes.length);
            datagramSocket.receive(datagramPacket);
            byte[] data = datagramPacket.getData();
            String dataReceive=new String(data,0,datagramPacket.getLength());
            System.out.println("String:"+dataReceive);
            System.out.println(Long.parseLong(dataReceive));

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

客户端：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class UDP_basicDataClient {
    public static void main(String[] args) {
        //消息需要进行类型转换，转换为字节数组类型
        long n=2000L;
        byte[] bytes =String.valueOf(n).getBytes();
        //创建数据报包
        DatagramPacket datagramPacket=new DatagramPacket(bytes,bytes.length,new InetSocketAddress("127.0.0.1",9999));
        //创建数据发送对象，指定发送端口
        //端口是基于本机的，这里和TCP协议有所不同
        try(DatagramSocket datagramSocket=new DatagramSocket(9090)){
            datagramSocket.send(datagramPacket);
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

上边的那个是我眼看花了   没有问题了

a

为什么  a.addAll(b)返回的是false

            b.addAll(a)饭后true的是

就是说我写的这代码要带上throw才不报错，视频中的没有加也bubaoc

老师，请问一下，我的代码也是遇到了一个接一个线程运行的问题，也看了之前同学的提问也尝试重复运行很多次，但还是一模一样，也把t1放t2后面还是一个接一个运行，这是什么原因造成的，谢谢！

package com.bjsxt;

public class TestThread extends Thread{
    public TestThread() {
        System.out.println(this.getName());
    }

    /*
    *
    * 线程的线程体
    *
    * */

    @Override
    public void run() {

            System.out.println(this.getName()+"线程开始");
            for (int i=0;i<20;i++){
                System.out.println(this.getName()+ " "+i);
            }
            System.out.println(this.getName()+"线程结束");
        }


    public static void main(String[] args) {
        System.out.println("主线程开始");
        TestThread t1 = new TestThread();
        //启动线程
        
        TestThread t2 = new TestThread();
        t1.start();
        //启动线程
        t2.start();
        
        System.out.println("主线程结束");

    }
}

老师这里不是很懂，为什么child前面是List<E>

老师 为什么new Date(); 报错。

不管怎么看，这里实现的test()方法才对，怎么会是调用isEqualne ?

是不是只要是函数式接口，里面所有的方法（static、abstract、default）都可以用lambda调用？

老师，结合之前电话本儿项目的验证功能做了一些调整， 能跑通 还请老师指点下代码设计上有没有啥毛病

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

class SendMsg extends Thread{
    private Socket socket;
    public SendMsg(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }
    private void sendMsg(){
        try(PrintWriter pw=new PrintWriter(this.socket.getOutputStream());
            Scanner scanner=new Scanner(System.in)) {
            while(true){
                String msgSengding=scanner.nextLine();
                pw.println(msgSengding);
                pw.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class ReceiveMsg extends Thread{
    private Socket socket;
    public ReceiveMsg(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
        this.receiveMsg();
    }
    private void receiveMsg(){
        try (BufferedReader br=new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){
            String msgReceive=br.readLine();
            System.out.println(msgReceive);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class Regex {
    public Regex() {
    }
    public int orderValidate(){
        String regex="[1-2]{1}";
        Scanner scanner=new Scanner(System.in);
        while (true){
            System.out.println("请输入启动类型（数字1或2）");
            System.out.println("1.启动服务端\t2.启动客户端");
            String order=scanner.nextLine();
            if (order.matches(regex)){
                if ("1".equals(order)){
                    System.out.println("准备启动服务端...");
                }else{
                    System.out.println("准备启动客户端...");
                }
                return Integer.parseInt(order);
            }else {
                System.out.println("输入有误，请重试");
                System.out.println();
            }
        }
    }
}
public class GoodTcp {
    public static void main(String[] args) {
        Regex regex=new Regex();
        int order=regex.orderValidate();
        if (order==1){
            try(ServerSocket serverSocket=new ServerSocket(8888)) {
                System.out.println("服务端启动成功，正在监听端口8888");
                Socket socket=serverSocket.accept();
                System.out.println("已成功建立连接");
                new SendMsg(socket).start();
                new Receive(socket).start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else{
            try{
                Socket socket=new Socket(InetAddress.getLocalHost().getHostAddress(),8888);
                System.out.println("已建立连接");
                new SendMsg(socket).start();
                new Receive(socket).start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
}