为什么是index-1？那个index是从1开始的吗？

老师，C语言的链表带头结点的，那个头节点是空的，但是这个好像head不是空的呀，创建时，那个element不就赋值进去了

为啥没有显示最大值？

(minmax){
    String regex= Scanner scanner = Scanner(System.)(){
        System..println(+min++)String input = scanner.nextLine()(input.matches(regex)){
            inputNum = Integer.(input)(inputNum>=min && inputNum <= max){
                inputNum}{
                System..println()}

        }{
            System..println()}

    }

}

老师，URL和TCP一般都是URL用的多是吗？

老师，不是说实例化不能用new吗？

还有获取计算机的IP地址不应该直接是isa.getHostAddress();吗？这个getAddress()是什么意思？

不写这段代码也可以输出？？

class ConsumerImpl implements Consumer{
    @Override
    public void accept(Object o) {
        System.out.println(o);
    }
}

老师你好

请问在本视频中的那个MyInteger类的构造器，MyInteger（）{this value=i}

1、如果没有这个构造器会怎样？是否在传参数时会报错，因为编译器自己添加的是无参构造器？

2、在构造器中写MyInteger（）{ value=i}是否可以？如果可以是因为构造器中的形参没有重名？

在本视频中的静态代码块是为了在类加载时初始化数组

3、初始化数组在类加载时和非在类加载时完成有什么区别和影响？

老师好，有如下代码，我有三个问题：

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        for(int i = triangle.size()-2 ; i>=0; i--){
            List<Integer> temp = triangle.get(i);
            for(int j = 0; j<=i; j++){
                int num1=triangle.get(i+1).get(j);
                int num2= triangle.get(i+1).get(j+1);
                temp.set(j,Math.min(num1, num2) + temp.get(j));
            }
        }
        return triangle.get(0).get(0);
    }
}

1. 第四行的temp，是从原来的二维list中取出的一行，为什么之后修改temp的值，triangle对应的行的数据也会改变呢？

2. 如果希望只修改temp值，而不修改triangle对应的行，要怎么改？

3. 二维的arraylist，取出元素，这里用的是 triangle.get(i).get(j)

   添加元素和修改元素，是否也同理?如把i行j列的元素修改/添加为100，用：

   triangle.set(i).set(j, 100)

   triangle.add(i).add(j,100)

谢谢

为啥不是呢？原来有一位了，既然3+1都可以等于4，为啥不可以8+1等于9？

PriorityTest Runnable {
    =Boolean =@override
    (){
        (.){
            System..println(Thread.().getName()+)}
    }
    (){
        .=}
}
PriorityTest{
    (String args){
        Priority p1=Priority()Priority p2=Priority()Thread t1=Thread(p1name:)Thread t2=Thread(p2name:)t1.setPriority(Thread.)t2.setPriority(Thread.)t1.start()t2.start()Thread.(millis:)}

}

接上一个问题，删除当前节点的最后几个步骤里，当前节点的prev和next都置空了，这个节点的item不能也滞空吧，不然最后返回就是空了，我们不是要返回 所要删除的节点 的item吗？为什么要置空？

老师，视频里的关键步骤：当前节点的前驱节点和后继节点直接挂接，不把判断是首节点和尾节点，分开为2个if-else语句，直接放在一个if-else if-else里好像更好？放在多重判断里，逻辑更清晰。如下

对于private修饰的成员变量应该怎么操作？使用set会报错

老师，视频里老师用的1.8的中文版api给我下好么，我之前下载的丢了，找不到了

package H_Socket.C_Tcp;

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

/**
 * 聊天室，一个客户端发送消息其他的客户端也可以接收到消息
 */
//创建一个消息接收线程
class ChatReceive extends Thread{
    BufferedReader bufferedReader;
    Socket socket;
    public ChatReceive(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
                synchronized ("a"){
                    //把从客户端接收到的信息给缓冲区
                    ChatServer.buf = bufferedReader.readLine();
                    //唤醒发送信息的线程对象
                    "a".notifyAll();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bufferedReader != null){
                    bufferedReader.close();
                }
                if (socket != null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
//创建一个消息发送线程
class ChatSend extends Thread{
    PrintWriter printWriter;
    Socket socket;
    public ChatSend(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            while (true){
                synchronized ("a"){
                    //让发送消息的线程处于等待状态
                    "a".wait();
                    //把接缓冲区的信息发送给其他的客户端
                    printWriter.println(ChatServer.buf);
                    printWriter.flush();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (socket != null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
public class ChatServer {
    //定义公共区域
    public static String buf;
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            System.out.println("监听83端口");
            serverSocket = new ServerSocket(83);
            while(true){
                Socket socket = serverSocket.accept();
                System.out.println("连接到" + socket.getInetAddress());
                new ChatSend(socket).start();
                new ChatReceive(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (serverSocket != null){
                    serverSocket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

package H_Socket.C_Tcp;

import java.io.*;
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){
        this.socket = socket;
    }
    PrintWriter printWriter = null;
    @Override
    public void run() {
        try {
            printWriter = new PrintWriter(this.socket.getOutputStream());
            scanner = new Scanner(System.in);
            while (true){
                String message = scanner.nextLine();
                printWriter.println(message);
                printWriter.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (scanner != null){
                    scanner.close();
                }
                if (printWriter != null){
                    printWriter.close();
                }
            }catch (Exception e){
                printWriter.println();
            }
        }
    }
}
//接收线程
class Receive extends Thread{
    private Socket socket;
    public Receive(Socket socket){
        this.socket = socket;
    }
    BufferedReader bufferedReader = null;
    @Override
    public void run() {
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
               String string = bufferedReader.readLine();
               System.out.println("他说：" + string);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bufferedReader != null){
                    bufferedReader.close();
                }
                if (socket != null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
public class GoodTcp {
    public static void main(String[] args) throws Exception {
        Socket socket = null;
        ServerSocket serverSocket = null;
        Scanner scanner = null;
        try {
            scanner = new Scanner(System.in);
            System.out.println("请输入：server,<port> 或者：<ip>,<port>");
            String s = scanner.nextLine();
            String[] arrays = s.split(",");
            if ("server".equals(arrays[0])){
                //启动服务端
                System.out.println("TCP服务端监听" + arrays[1] + "端口，等待连接");
                serverSocket = new ServerSocket(Integer.parseInt(arrays[1]));
                socket = serverSocket.accept();
                System.out.println("连接成功");
            }else {
                //启动客户端
                socket = new Socket(arrays[0],Integer.parseInt(arrays[1]));
                System.out.println("连接成功");
            }
            //启动发送线程
            new Send(socket).start();
            //启动接收线程
            new Receive(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (serverSocket != null){
                    serverSocket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

显示连接成功，但是不能进行相互之间的通信