package com.bjsxt;

/*
 * 定义程序员类
 * */
class Programmer{
    private String name;
    public Programmer(String name){
        this.name = name;
    }
    /*
     * 打开电脑
     * */
    public void computer(){
        synchronized (this) {
            try {
                System.out.println(this.name + "接通电源");
                Thread.sleep(500);
                System.out.println(this.name + "按开机按键");
                Thread.sleep(500);
                System.out.println(this.name + "系统启动中");
                Thread.sleep(500);
                System.out.println(this.name + "系统启动成功");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /*
     * 编码
     * */
    public void coding(){
        synchronized (this){
            try {
                System.out.println(this.name+"双击IDEA");
                Thread.sleep(500);
                System.out.println(this.name+"IDEA启动完毕");
                Thread.sleep(500);
                System.out.println(this.name+"开开心心的写代码");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
/*
 * 打开电脑的工作线程
 * */
class Working1 extends Thread{
    private Programmer p;
    public Working1(Programmer P){
        this.p = p;
    }
    @Override
    public void run() {
        this.p.computer();
    }
}
/*
 * 编写代码的工作线程
 * */
class Working2 extends Thread {
    private Programmer p;

    public Working2(Programmer P) {
        this.p = p;
    }

    @Override
    public void run() {
        this.p.coding();
    }
}
public class TestSyncThread {
    public static void main(String[] args) {
        Programmer p = new Programmer("张三");
        new Working1(p).start();
        new Working2(p).start();
    }

}

代码反复看了两遍，还是出现异常。

静态方法，对象可以调用的吧？，为何在测试线程是否存活时，sleep()方法是静态方法，使用Thread引用的对象却调用不了呢？

class Node<E>{
private E item;// 存储元素
private Node next;// 存储下一个节点对象的地址
Node(E item,Node next){
this.item = item;
this.next = next;
}
}
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.next = next;
}
}

老师，同样是定义节点类，为什么单向链表就需要写

private Node next;

双向链表就需要加泛型

Node<E> next;

老师，我这跟上课讲的一样的，为啥报这样错。

System Volume Information

老师，这个是我突然想到的问题，就是有的时候在磁盘上，或者优盘上会发现这个文件，删不了，这个文件名，是代表的什么，不太理解这个，请老师指教。

老师，就是我这个Fx<String> k4=new Fx<>() 传入的是String 但是k4.name="zhangsan";的话会报出null，但是要是是k3.name="zhangsan";就不会报出null，但是Fx<Integer> k3=new Fx<>();传入的类型明明是int类型

不是用的idea吗，怎么变成用Eclipes了，看的有点蒙，idea中怎么创建XML呢？

为啥 我这反射0,普通方法252- -,不是反射比普通方法运行慢吗

package com.a.cx;

import java.lang.reflect.Method;

/**
 * 测试反射机制的效率
 */
public class TestReflectDemo2 {
    public static void main(String[] args) {
        try {
            //反射耗时
            Class clazz = Class.forName("com.a.cx.Users");
            //newInstance() 返回的是Object类型的结果,这里强制类型转换为Users类型
            Users users = (Users)clazz.newInstance();
            long reflectStart = System.currentTimeMillis();
            Method method = clazz.getMethod("setUsername", String.class);
            for (int i=0;i<100000000;i++){
                method.invoke(users,"李二狗");
            }
            long refectEnd = System.currentTimeMillis();

            //非反射方式耗时
            long start = System.currentTimeMillis();
            Users u = new Users();
            for (int i=0;i<100000000;i++){
                u.setUsername("oldlu");
            }
            long end = System.currentTimeMillis();
            System.out.println("反射执行时时间:"+(refectEnd-refectEnd));
            System.out.println("非反射执行时时间:"+(end-start));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

老师，我15行怎么会报错，视频里老师也不是传了一个Integer的数据类型吗？

package Test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 接收客户端消息的线程类
 */
class ChatReceive extends Thread{
    private Socket socket;

    public ChatReceive(Socket socket) {
        this.socket = socket;
    }


    @Override
    public void run() {
        this.receiveMsg();
    }
    /**
     * 实现接收客户端发送的消息
     */
    private void receiveMsg(){
        BufferedReader br=null;
        try{
            br=new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
                String msg=br.readLine();
                synchronized ("abc"){
                    //把读取到的数据写入公共数据区
                    ChatRoomServer.buf="["+this.socket.getInetAddress()+"]"+msg;
                    "abc".notifyAll();

                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
         
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

/**
 * 向客户端发送消息的线程类
 */
class ChatSend extends Thread{
    private Socket socket;

    public ChatSend(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        this.SendMsg();
    }
    /**
     * 将公共数据区的数据发送到客户端
     */
    private void SendMsg(){
        PrintWriter pw=null;
        try{
            pw=new PrintWriter(this.socket.getOutputStream());
            while (true){
                synchronized("abc"){
                    //让线程处于等待状态
                    "abc".wait();
                    pw.println(ChatRoomServer.buf);
                    pw.flush();

                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (pw!=null){
                pw.close();
            }
            if (this.socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class ChatRoomServer {
    public static  String buf;
    public static void main(String[] args) {
        System.out.println(" 1.0");
        System.out.println("Listen at 8888");
        ServerSocket serverSocket=null;
        try {
            serverSocket=new ServerSocket(8888);
            while (true){
                Socket socket=serverSocket.accept();
                System.out.println("连接到 "+socket.getInetAddress());
                new ChatReceive(socket).start();
                new ChatSend(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

老师我这里代码怎么报错，没找到问题

老师，请问一下为什么要定义一个Node<k,V>pl=tab[i = (n - 1) & hash]；来进行判断，不直接用tab[i = (n - 1) & hash]判断呢？

//服务端代码
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;

public class BasicSocketClient {
    public static void main(String[] args) {
        Socket socket=null;
        PrintWriter pw=null;

        try {
            //创建Socket对象，两个参数：1.服务端的IP地址，2.服务端所监听的端口
            socket =new Socket("127.0.0.1",8888);
            pw.println("服务端 你好");
            pw.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if (pw!=null){
                pw.close();
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
//客户端代码

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

public class BasicSocketServer {
    public static void main(String[] args) {
        Socket socket=null;
        BufferedReader br=null;
        try {
            ServerSocket serverSocket=new ServerSocket(8888);
            System.out.println("服务器启动等待监听。。");
            //启动服务器监听
            socket= serverSocket.accept();
            //读取客户端发送的消息
            br= new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println(br.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}
为啥我的结果报错，服务端输出null

如果当添加结点的时候二叉树正好为空没有元素结点，无法进行判断，是不是需要进行判断一下二叉树是否为空，定义添加结点就为根结点

视频里面说，hashset容器的元素是放在数组中的，那么按视频老师举的例子，假如a和b用哈希算法最终得出来存放位置的索引值都是2，在a已经先放入2的位置后，那b最终是放在数组中哪个索引位置了呢？

为什么初始化数据时用左移，而不直接用16等数字初始化呢？