创建开始Emelent.data=10,此时是空数组,暂定数组长度为10

因为暂时没有存放实际元素所以 minCapacit暂时为0,调用size也是显示实际元素长度0,

当每次添加add插入新元素,实际长度+1,当实际元素minCapacity=10的时候会判断实际元素长度-系统创建的长度>0,如果大于0就进行grow方法进行扩容,没有的话数组长度还是默认为10,是这样吗老师

老师，如下红线标记部分，这块用字符流获取浏览器的请求，但是字符流不是只能用于纯文本吗，有没有可能请求是一个图片呢，所以是不是用字节流就能完全放心了，相当于万金油了。

老师好，我有一些问题请教一下

1. 数组扩容的因子是0.75，是指数组中存放了%75的位置的键值对，还是要算上数组的成员连接的链表节点的个数呢？

2. 添加元素时，如果hash值相同，而数组长度并没有64位，那么当链表长度大于8时，冲突的键值对应该放在什么位置呢？是一直往更长的链表节点上放置吗？在视频中只讲了此时数组扩容。然后我看源码的时候也并没有看懂如何处理的，老师可以帮我找到相应处理的代码在哪里吗谢谢啦

   
   

   
   

先运行服务器端，服务器启动没报错，再启动客户端，也没报错，输入账号密码之后客户端报错如下截图，然后发现服务器端也报错，不知道是什么原因。

项目目录结构截图

错误截图：

客户端

服务器端

附上代码：

客户端

package com.cn.entity;

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

/**
 * 基于TCP协议的Socket编程_双向通信_实现模拟用户登录
 */
public class Client {

    public static void main(String[] args) throws IOException {
        //(1)创建Socket对象，用于连接服务器
        Socket client=new Socket("localhost", 8888);
        //(2)获取输出流  (对象流)
        ObjectOutputStream oos=new ObjectOutputStream(client.getOutputStream());
        //(3)创建User对象
        //调用获取用户对象的方法
        User u=getUser();//new User("bjsxt", "bjsxt");
        //(4)User对象发送到服务器
        oos.writeObject(u);

        //(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 User getUser(){
        Scanner input=new Scanner(System.in);
        System.out.println("请输入用户名:");
        String userName=input.next();
        System.out.println("请输入密码:");
        String password=input.next();
        //封装成User对象
        return new User(userName,password);
    }
}

User类

package com.cn.entity;

import java.io.Serializable;

public class User implements Serializable {

    private static final long serialVersionUID = -5699785428357564782L;
    private String userName;
    private String passWord;

    public User(String userName, String passWord) {
        this.userName = userName;
        this.passWord = passWord;
    }

    public User() {
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

服务器端

package com.cn.entity;

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

/**
 * 基于TCP协议的Socket编程_双向通信_实现模拟用户登录
 */
public class Server {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        System.out.println("--------------服务器端已启动---------------");
        //(1)创建SocketServer对象
        ServerSocket server = new ServerSocket(8888);  //10000是端口号
        Socket socket = server.accept();
        //(2)获取输入流（对象流） ，把字节流包装成对象流
        ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());

        //读Object类型，向上类型转换
        User2 user = (User2) ois.readObject();
        System.out.println(socket.getInetAddress().getHostAddress()+"请求登录");
        System.out.println("用户名："+user.getUserName());
        System.out.println("密码："+user.getPassWord());


        //(3)堆用户名和密码进行验证
        String str = "";
        if ("bjsxt".equals(user.getUserName())&&"bjsxt".equals(user.getPassWord())){
            str="登录成功";
        }else {
            str="对不起，账号密码不正确！";
        }
        //(4)获取输出流（数据流），把字节流包装成数据流
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        dos.writeUTF(str);
        //(5)关闭流，关闭SockerServer
        if (dos!=null){
            dos.close();
        }
        if (ois!=null){
            ois.close();
        }
        if (socket!=null){
            socket.close();
        }


    }

}

User2类

package com.cn.entity;

import java.io.Serializable;

public class User2 implements Serializable {

    private static final long serialVersionUID = -5699785428357564782L;
    private String userName;
    private String passWord;

    public User2(String userName, String passWord) {
        this.userName = userName;
        this.passWord = passWord;
    }

    public User2() {
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

我也不明白他到底是怎末压栈和出栈的

为什么输出后没有名字

/**
 * 定义程序员类
 */
class Programmer{
    private String name;
    public Programmer(String name){
        this.name=name;
    }
 /**
     * 上厕所
     */
    public void wc() {
        synchronized ("pp") {
            try {
                System.out.println("想要上厕所");
                Thread.sleep(500);
                System.out.println("打开厕所门");
                Thread.sleep(500);
                System.out.println("开始上厕所 ");
                Thread.sleep(500);
                System.out.println("排水");
                Thread.sleep(500);
                System.out.println("离开卫生间");
            } catch (InterruptedException e) {
                e.printStackTrace();

            }
        }
    }
}
   
/**
 * 上厕所的线程
 */
class Wc extends Thread{
    private Programmer p;
    public Wc(Programmer p) {
        this.p = p;
    }

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

public class TestSyncThread {
    public static void main(String[] args) {
        
        Programmer p = new Programmer("张三");
        Programmer p1= new Programmer("李四");
        new Wc(p).start();
        new Wc(p1).start();


    }
}

老师，为啥？不能改成T，？和T在这里的作用不是一样的吗

这个案例中为什么最后要转为字符流，是因为传输的是字符吗

老师Scanner为什么会报空指针异常

package internet;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Scanner;

public class TwoSever {

      public static void main(String[] args) {

      ServerSocket serverSocket = null;

try {

serverSocket = new ServerSocket(8888); 

System.out.println("服务端启动，监听端口8888");

Socket socket = serverSocket.accept();

System.out.println("连接成功！");

Thread t= new Thread(new ServiceRead(socket));

Thread t1= new Thread(new ServiceWrite(socket));

t1.start();

t.start();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally {

}

}

}

//接收消息的

class ServiceRead implements Runnable{

    private Socket socket;

    public ServiceRead(Socket socket) {

    this.socket=socket;

    }

@Override

public void run() {

regular();

}

private void regular() {

BufferedReader bu= null;

try {

bu = new BufferedReader(new InputStreamReader(socket.getInputStream()));

   while(true) {

   String str=bu.readLine();

   System.out.println("客户端说："+str); 

   }

}catch(Exception e) {

e.printStackTrace();

}finally {

try {

if(bu != null) {

bu.close();

}

if(socket != null) {

socket.close();

}

}catch(Exception e) {

e.printStackTrace();

}

}

}

}

//sever发送消息

class ServiceWrite implements Runnable{

    private Socket socket;

    public ServiceWrite(Socket socket) {

    this.socket=socket;

    }

@Override

public void run() {

send();

}

private void send() {

Scanner scanner = null;

PrintWriter bw =null;

try {

bw= new PrintWriter(this.socket.getOutputStream());

while(true) {

String str = scanner.nextLine();

    bw.print(str);

    bw.flush();

}

}catch(Exception e) {

e.printStackTrace();

}finally {

try {

if(scanner != null) {

scanner.close();

}

if(bw != null) {

bw.close();

}

if(socket !=null) {

socket.close();

}

}catch(Exception e) {

e.printStackTrace();

}

}

}

}

老师：

  您好，我的代码和运行结果如下：

package com.bjsxt;

public class MyDoublyLinkedList<E> implements MyList<E> {

    /**
     * 定义双向链表中的节点对象
     */
    class Node<E> {
        E item;         //记录元素
        Node<E> prev;   //记录前一个节点对象
        Node<E> next;   //记录下一个节点对象
        Node(Node<E> prev,E item, Node<E> next) {
            this.prev = prev;
            this.item = item;
            this.prev = next;
        }
    }

    private Node head;      //记录头节点
    private Node tail;      //记录尾节点
    private int size;       //记录元素个数

    /**
     * 向双向链表中添加元素
     */
    public void add(E element) {
        this.linkLast(element);
    }

    /**
     * 将节点对象添加到双向链表中的尾部
     */
    private void linkLast(E element) {
        //获取尾节点
        Node t = this.tail;

        //创建节点对象
        Node<E> node = new Node<>(t,element,null);

        //将新节点定义为尾节点
        this.tail = node;
        if(t == null) {
            this.head = node;
        }else {
            t.next = node;
        }
        this.size ++;
    }

    /**
     * 根据指定位置获取元素
     */
    public E get(int index){
        //对index进行合法性校验
        this.checkIndex(index);

        //根据位置查找节点对象
        Node<E> node = this.getNode(index);
        return node.item;
    }
    /**
     * 校验index的合法性
     */
    private void checkIndex(int index) {
        if(!(index >= 0 && index < this.size)) {
            throw new IndexOutOfBoundsException("index:"+index+"Size:"+size);
        }
    }

    /**
     * 根据位置获取指定节点对象
     */
    private Node getNode(int index) {

        //判断当前位置距离头或尾哪个更近些
        if (index < (this.size) >> 1){
            Node node = this.head;
            for(int i=0; i<index; i++) {
                node = node.next;
            }
            return node;
        }else{
            Node node = this.tail;
            for(int i = this.size-1;i>index;i--) {
                node = node.prev;
            }
            return node;
        }
    }

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

    /**
     *  根据指定位置删除元素
     */
    public E remove(int index) {

        //对index进行合法校验
        this.checkIndex(index);

        //根据指定位置获取节点对象
        Node<E> node = this.getNode(index);

        //获取节点对象中的元素
        E item =  node.item;

        //判断节点是否为头节点
        if(node.prev == null) {
            this.head = node.next;
        }else {
            //完成当前节点直接前驱节点与当前节点的直接后继节点的挂接
            node.prev.next = node.next;
        }

        //判断节点是否为尾节点
        if(node.next == null) {
            this.tail = node.prev;
        }else{
            node.next.prev = node.prev;
        }

        //当前节点断掉与它直接前驱节点的连接
        node.prev = null;

        //当前节点断掉与它直接后继节点的连接
        node.next = null;
        node.item = null;

        //记录元素个数
        this.size--;
        return item;
    }

    public static void main(String[] args) {
        MyList<String> myList = new MyDoublyLinkedList<>();
        myList.add("a");
        myList.add("b");
        myList.add("c");
        myList.add("d");
        myList.add("e");

        System.out.println(myList.size());
        System.out.println(myList.remove(0));
        for(int i=0;i<myList.size();i++) {
            System.out.println(myList.get(i));
        }
    }
}

运行结果是：

5

a

b

c

Exception in thread "main" java.lang.NullPointerException

at com.bjsxt.MyDoublyLinkedList.get(MyDoublyLinkedList.java:59)

at com.bjsxt.MyDoublyLinkedList.main(MyDoublyLinkedList.java:150)

TestFileReader和TestFileInputStream的代码高度一致，一个是字节流一个是字符流，除了数据单位二者还有什么明显不同吗，二者分别适用于什么情况能否举些例子？

老师：

    您好，为什么的apacha包导入成功了，使用时没有这个FileUtils类。我的JDK是12.0.2的。这个对应的Apacha包是哪个？

为什么synchronized加到run方法上就没有用？

不知道哪里问题，显示我要转换成布尔表达式

package com.baizhan.test;

public class MyDoubleLinkedList <E>implements MyList<E> {
    class Node<E>{
        E item;
        Node<E> prev; //记录前一个节点对象
        Node<E> next; //记录下一个节点对象

        public Node(E item, Node<E> prev, Node<E> next) {
            this.item = item;
            this.prev = prev;
            this.next = next;
        }
    }
    private Node head;
    private Node tail;
    private int size;
    @Override
    public void add(E element) {
        linkLast(element);
    }
  private void linkLast(E element){
        Node t=this.tail;  //获取尾节点
        Node<E> node=new Node<>(element,t,null);   //创建节点
      //将新节点定义为尾节点
        this.tail=node;
        if(t==null){
            this.head=node;
        }else{
            t.next=node;
        }
        size++;
  }
    @Override
    public E get(int index) {
        chickIndex(index);
        Node<E> node =getNode(index);
        return node.item;
    }
private void chickIndex(int index){
    if (!(index>0 && index<size)) {
        throw new IndexOutOfBoundsException("Index:"+index+"size:"+size);
    }
}
private Node getNode(int index){
        if(index<(this.size >>1)){
            Node node=this.head;
            for(int i=0;i<index;i++){
                node=node.next;
            }
            return node;
        }else{
            Node node=tail;
            for(int i=size-1;i>index;i--){
                node=node.prev;
            }
            return  node;
        }
}
    @Override
    public int size() {
        return size;
    }

    @Override
    public E remove(int index) {
        chickIndex(index);
        Node<E> node =getNode(index);
        E item=node.item;
        if(node.prev==null){
            this.head=node.next;
        }else{
            node.prev.next=node.next;
        }
        if(node.next==null){
            tail=node.prev;
        }
        else {
            node.next.prev=node.prev;
        }
        node.prev=null;
        node.item=null;
        node.next=null;
        
        size--;
        return item;

    }

    public static void main(String[] args) {
        MyDoubleLinkedList<String > m=new MyDoubleLinkedList<>();
        m.add("74");
        m.add("11");
        m.add("215");
        m.add("237");
        m.add("lierqing");
        m.add("127");
        System.out.println(m.size);
        System.out.println(m.size());
        System.out.println(m.remove(0));
        System.out.println(m.size);
        for(int i=0;i<m.size;i++){
            System.out.println(m.get(i));
        }
    }


}

老师，最后为啥会出现异常啊，我找了半天没看明白