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)

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

老师，这个在主线程的睡眠是让哪个子线程睡眠？

添加了在关闭前加个等待时间，还是报错

问题一：Server运行，游览器无响应啊？

问题二：StringBuilder sb，添加了那么多字符串的意义在哪里，响应只显示“成功”，其余的是被游览器解析的吗？

package cn.bjsxt.server;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {//服务器，启动和停止服务
	private ServerSocket server;
	public static void main(String[] args){
		Server server = new Server();//创建服务器对象
		server.start();
	}
	public void start(int port){
		try {
			server = new ServerSocket(port);
			this.receive();//调用接收请求信息的方法
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public void start(){
		this.start(8888);
	}
	private void receive() {
		
		try {
			//(1)监听
			Socket client = server.accept();
			//获取用户的请求
			/*InputStream is = client.getInputStream();
			byte [] buf = new byte[20480];
			int len = is.read(buf);
			System.out.println(new String(buf,0,len));*/
			Request req = new Request(client.getInputStream());
			//req.show();
			/**做出响应*/
			StringBuilder sb = new StringBuilder();
			sb.append("HTTP/1.1").append(" ").append(200).append(" ").append("OK").append("\r\n");
			sb.append("Content-Type:text/html;charset=utf-8").append("\r\n");
			//内容
			String str="<html><head><title>响应结果</ritle></head><body>成功</body></html>";
			sb.append("Content-Length:"+str.getBytes("utf-8").length).append("/r/n");
			sb.append("\r\n");
			sb.append(str);
			//通过输出流发送出去
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream(),"utf-8"));
			bw.write(sb.toString());
			bw.flush();
			bw.close();
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public void stop(){
		
	}

}

视频10:25处讲到了"int newCapacity = oldCapacity + (oldCapacity >> 1);"这一行代码。

视频中说newCapacity为10，为什么？是不是为0？我没有看懂，希望老师解答一下。

还有能再讲讲这一行代码的含义以及作用吗？

老师在自定义异常那节课上，我看老师教材上有讲到自定义类应包含2个构造器，但我看到高淇老师后来举得例子中并没有用到这个知识点呀，构造器并没有出现在老师后来举的例子之中呀

老师好，请看一下，

异常名称：Exception in thread "main" java.net.SocketException: Connection reset

想要知道怎么避免，怎么操作，请演示一下

已通过防火墙

客户端：

package cn.sxt.entity;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Scanner;

public class Client2 {
	public static void main(String[] args) throws IOException {
		//1创建socket对象，用于连接服务器
		Socket client = new Socket("localhost", 9999);
		//2获取输出流(对象流)
		ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream());
		//3创建user对象
					//获取user对象的方法
		User2 user = getUser();//new User2("sxt", "sxt");
		//4user对象发送到服务器
		oos.writeObject(user);//发生了向上转型
		//5获取输入流(数据流)
		DataInputStream dis = new DataInputStream(client.getInputStream());
		System.out.println(dis.readUTF());
		//6关闭流
		if (dis!=null) {
			dis.close();
		}
		if (oos!=null) {
			oos.close();
		}
		if (client!=null) {
			client.close();
		}
	}
	public static User2 getUser() {//获取对象的方法
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入账户名");
		String userName = sc.next();
		System.out.println("请输入密码");
		String passWord = sc.next();
		return new User2(userName, passWord);
	}
}

服务器端：

package cn.sxt.server;

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


import cn.sxt.entity.User2;

public class Server2 {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		System.out.println("----------服务器端已启动---------");
		//1.创建ServerSocket对象
		ServerSocket server = new ServerSocket(9999);
		Socket client = server.accept();
		//2.创建输入流--->ObjectInputStream
		ObjectInputStream ois = new ObjectInputStream(client.getInputStream());
		User2 user = (User2)ois.readObject();//向下转型
		System.out.println(client.getInetAddress().getHostAddress()+"请求登录：用户名："+user.getUserName()+"\t密码："+user.getPassWord());
		//3.对用户名和密码进行验证
		String str = "";
		if ("sxt".equals(user.getUserName())&&"sxt".equals(user.getPassWord())) {
			str = "登录成功";
		}else {
			str = "对不起，用户名或密码错误";
		}
		//4.获取输出流(数据流)
		DataOutputStream dos = new DataOutputStream(client.getOutputStream());
		dos.writeUTF(str);
		//5.关闭流
		if (dos!=null) {
			dos.close();
		}
		if (ois!=null) {
			ois.close();
		}
		if (client!=null) {
			client.close();
		}
	}
}

运行效果：

这里的index能换成size?

如果把这里的index-1看成index如果一共有4个节点那么尾结点的index就是3，这里i<3,那么也遍历不出尾结点的地址啊，这里遍历到第三个节点的地址

有一个有点奇怪的问题，我已经加add方法了，为什么我这边调用仍然不让我调用add方法，自动校正一直让我重新加一个private void add,  我前面写的那个

public void add(E element){

不知道为什么没有生效，完整code我附下面

package com.bjsxt;

public class BinaryTreeSort<E extends Integer> {
    class Node<E extends Integer>{
        private E item;
        private Node left;
        private Node right;
        Node(E item){
            this.item = item;
        }


        public void addNode(Node node){
            if(node.item.intValue() < this.item.intValue()){
                if(this.left == null){
                    this.left = node;
                }else{
                    this.left.addNode(node);
                }else{
                    if(this.right == null){
                        this.right = node;
                    }else{
                        this.right.addNode(node);
                    }
                }

            }
        }
        public void inorderTranversal(){
            if(this.left != null)this.left.inorderTranversal();
            System.out.println(this.item);
            if(this.right != null)this.right.inorderTranversal();
    }

    private Node root;

    public void add(E element){
        Node<E> node = new Node<>(element);
        if(this.root == null)
            this.root = node;
        else
            this.root.addNode(node);
    }
    public void sort(){
        if(this.root == null)return;
        this.root.inorderTranversal();
    }

    public static void main(String[] args) {
        BinaryTreeSort<Integer> sort = new BinaryTreeSort<>();
        sort.add();
    }

}

package com.dataStructure;

/**
 * 自定义基于单向链表实现存储数据的容器
 */
public class MySinglyLinkedList<E> implements MyList<E>{
    private myNode head;
    private int size;

    /**
     * 创建一个单线链表中用于存储数据的节点类
     * @param <E>
     */
    class myNode<E>{
        private E item;
        private myNode next ;
        public myNode(E item, myNode next) {
            this.item = item;
            this.next = next;
        }
    }

    private myNode<E> getTail (){
        myNode h = this.head;
        if(this.head == null){
            return null;
        }
        while (true){
            if(head.next == null){
                break;
            }else {
                h = h.next;
            }
        }return h;

    }

    /**
     * 根据下标获取节点的方法
     */
    private myNode getNode(int index){
        myNode n = head;
        for (int i = 0 ; i < index; i++){
            n = n.next;
        }
        return n;
    }

    /**
     * 校验下标合法性的方法
     */
    private void CheckIndex (int index){
        if(this.head == null||index>=size||index<0){
            throw new IndexOutOfBoundsException();
        }
    }

    @Override
    /**
     * 添加元素的方法
     */
    public void add(Object element) {
        myNode node = new myNode<>(element,null);
        myNode tail = getTail();
        if(tail == null){
            this.head = node;
        }else {
            tail.next = node;
        }
        this.size++;
    }

    @Override
    /**
     * 删除元素的方法
     */
    public E remove(int index) {
        CheckIndex(index);
        myNode node = getNode(index);
        E item = (E)node.item;
        //找到后把这个元素的前一个的next挂到此元素后一个
        if(node == this.head){//判断此节点是否是头结点
            this.head = node.next;
        }else {
            for (int f = 0 ; f < index-1; f++){
                getNode(f).next = node.next;
            }
        }
        this.size--;
        return item;
    }

    @Override
    /**
     * 获取元素的方法
     */
    public E get(int index) {
        this.CheckIndex(index);
        return (E) getNode(index).item;
    }

    @Override
    /**
     * 返回元素的个数
     */
    public int size() {
        return this.size;
    }
}

//新建测试类
package com.dataStructure;

public class TestMySinglyLinkedList {
    public static void main(String[] args) {
        MySinglyLinkedList<String> mySinglyLinkedList = new MySinglyLinkedList();
        mySinglyLinkedList.add("a");
        mySinglyLinkedList.add("b");
        mySinglyLinkedList.add("c");
        mySinglyLinkedList.add("d");
        mySinglyLinkedList.add("e");
        mySinglyLinkedList.add("f");
        System.out.println(mySinglyLinkedList.size());
        System.out.println(mySinglyLinkedList.get(3));
        System.out.println(mySinglyLinkedList.remove(5));
        System.out.println(mySinglyLinkedList.size());
    }
}

我有两个疑问：1、我执行测试类的时候，报了空指针异常，不懂为什么； 

 2、为什么我初始化E类型的变量时，要让我强转为E类型？

老师,讲的时候和敲代码的时候能不能不要那么快,看的一脸懵

一个守护线程可以同时守护几个用户线程，是随着最后一个用户线程消亡而消亡吗？

static void printFile(File file,int level){
    for (int i = 0;i<level;i++){
        System.out.print("-");
    }
    //输出文件名
    System.out.println(file.getName());

    if (file.isDirectory()){
        File[] files = file.listFiles();//列出他的所有子文件，子目录
        for (File temp:files){
            printFile(temp,level+1);
        }
    }
}

这个printFile方法下面的都不是很明白

判断他是不是文件之后更不明白能不能详细解释一下

如果说我们拆到"[" 请问添加的字符串"]"是加到"["左边还是右边