package com.itbaizhan;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
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(){
        try(BufferedReader 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();
        }
    }
}

/**
 * 向客户端发送消息的线程类
 */
class ChatSend extends Thread{
    private Socket socket;
    public ChatSend(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 实现向客户端发送消息
     */
    private void sendMsg(){

        try(PrintWriter pw = new PrintWriter(this.socket.getOutputStream())){
            while (true){
                synchronized ("abc"){
                    //让发送消息的线程处于等待状态
                    "abc".wait();
                    //将公共区域中数据发送给客户端
                    pw.println(ChatRoomServer.buf);
                    pw.flush();



                }
            }

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


public class ChatRoomServer {
    //定义公共数据区
    public static String buf;

    public static void main(String[] args) {

        System.out.println("Chat Server Version V1.0");
        System.out.println("Listen at 8888........");
        try(ServerSocket serverSocket = new ServerSocket(8888)){
            while (true){
                Socket socket = serverSocket.accept();
                System.out.println("连接到:"+socket.getInetAddress());
                //将与客户端对应的socket对象床底到接收消息的线程中
                new ChatReceive(socket).start();
                //将与客户端对应的socket对象床底到发送消息的线程中
                new ChatSend(socket).start();

            }

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


//以下是客户端代码
package com.itbaizhan;

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(this.socket.getOutputStream());) {
            while (true) {
                String str = scanner.nextLine();
                pw.println(str);
                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(this.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) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        try{
            //键盘输入对象
            Scanner 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();


            }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();
                }
            }
        }


    }
}

启动客户端时，为啥报了索引越界。

老师看下，为什么我这代码会报错：

package com.liyang;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileStringDeme {
    public static void main(String[] args) {
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        try{
            fileOutputStream=new FileOutputStream("c:/flie/123.jpg");
            fileOutputStream=new FileOutputStream("c:/flie/234.jpg");
            int temp=0;
            while ((temp=fileInputStream.read())!=-1){
                 fileOutputStream.write(temp);
            }
            fileOutputStream.flush();//将数据从内存中写入到磁盘中
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (fileOutputStream!=null){
                    fileOutputStream.close();
                }
                if (fileOutputStream!=null){
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }




    }
}




下面是输出。

"C:\Program Files\Java\jdk-12.0.1\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2018.3.2\lib\idea_rt.jar=54637:C:\Program Files\JetBrains\IntelliJ IDEA 2018.3.2\bin" -Dfile.encoding=UTF-8 -classpath C:\java\worksprce\untitled\out\production\untitled com.liyang.FileStringDeme
java.lang.NullPointerException
	at com.liyang.FileStringDeme.main(FileStringDeme.java:16)

Process finished with exit code 0

老师，请问为什么会报错啊

package com.bjsxt;

/*
基于单向链表
 */
public class MySinglyLinkedList<E> implements MyList<E> {

    /*
    定义单向链表中的节点对象
     */
    class Node<E> {
        private E item;                  //存储元素
        private Node next;               //存储下一个节点对象的地址

        Node(E item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    private Node head;  //存放链表中的头节点
    private int size;   //记录元素个数

    //向链表中添加元素
    @Override
    public void add(E element) {
        //创建节点
        Node<E> node = new Node<>(element, null);
        //找到尾节点
        Node tail = getTail();
        if (tail == null) {
            this.head = node;
        } else {
            tail.next = node;
        }
        //记录元素个数
        this.size++;

    }

    private Node getTail() {
        //头节点是否存在
        if (this.head == null) {
            return null;
        }
        //查找尾节点
        Node node = this.head;
        while (true) {

            if (node.next == null) break;
            node = node.next;
        }
        return node;
    }

    //根据元素位置获取元素
    @Override
    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 < size)) {
            throw new IndexOutOfBoundsException();
        }
    }

    /*
    根据位置获取节点
     */

    private Node getNode(int index) {
        Node<E> node = this.head;
        for (int i = 0; i < index;i++) {
            node = node.next;
        }
        return node;
    }


    //获取元素个数
    @Override
    public int size() {
        return size;
    }

    //根据元素位置删除元素
    @Override
    public E remove(int index) {
        //检验index合法性
        this.checkIndex(index);
        //根据位置找到该节点对象
        Node<E> node = this.getNode(index);
        //获取该节点对象中的元素
        E item = node.item;
        //将还节点对象从单向链表中删除
        //判断当前删除订的节点是否尾头节点
        if (this.head == node) {
            this.head = node.next;
        } else {
            Node<E> temp = this.head;
            for (int i = 0; i < index - 1; i++) {
                temp = temp.next;
            }
            temp.next = node.next;
        }
        node.next = null;
        //记录元素个数
        this.size--;
        //将该元素返回
        return item;
    }

    public static void main(String[] args) {
        MySinglyLinkedList<String> my=new MySinglyLinkedList<>();
        my.add("a");
        my.add("b");
        my.add("c");
        my.add("d");
        System.out.println(my.size());
        System.out.println(my.get(3));
        System.out.println(my.remove(2));
        for(int i=0;i<my.size();i++){
            System.out.println(my.get(i));
        }
    }


}

package com.bjsxt;
/*
基于链表结构存取元素的方法API定义

 */


public interface MyList<E> {
    void add(E element);
    E get(int index);
    int size();
    E remove(int index);


}

老师这个标题的通配符的"通"字是统治的"统"吗?

为什么线程的名字没有被修改？

public static void main(String[] args)throws Exception {
    InetAddress inetAddress = InetAddress.getByName("39.156.66.18");
    System.out.println(inetAddress.getHostAddress());
    System.out.println(inetAddress.getHostName());
}

为什么获取主机名称返回的是IP地址

为什么没有办法用for-each遍历，报错

public static void main(String[] args) {
    MyStack<String> a = new MyStack<>();
    a.push("a");
    a.push("b");
    a.push("c");
    a.push("D");
    a.push("F");
    System.out.println(a.size);
    System.out.println(a.empty());
    System.out.println(a.pop());
    System.out.println(a.pop());
    System.out.println(a.pop());
    for (String b:a){

    }
    }
}

老师，请问下面初始化entrySet的时候使用Set来创建是不是可以理解为：把很多的K-V类型对象作为element 存到一个Set的容器里面？

IOUtils和 FileUtils中有没有可以copy整个文件夹的方法

老师关于课程：transient关键字是什么

在主线程里面调用futuretask的get方法会阻塞主线程的运行吗？

老师，path在配置的时候被我设置坏了，忘记复制下来了，之前按照您的步骤设置完了也不行，双击启动之后黑框一闪就没了。。没道理啊，您帮我看一下现在这path该怎么设置呀？

老师，当一个线程进入lock区域的时候，锁住的是对象吗？

package com.bjsxt.task;

/** 
 * <p>Title: Node</p>  
 * <p>Description: 自定义节点</p>  
 * @author xiaoding
 * @date Jun 2, 2020  
 * @version 1.0 
 */
public class Node<K,V> {
    K key;        //键
    V value;    //值
    int hash;    //hashCode值
    
    Node<K,V> next;    //节点
    
    //无参构造方法
    public Node() {}
    //有参构造方法
    public Node(K key,V value,int hash,Node<K,V> next) {
        this.key = key;
        this.value = value;
        this.hash = hash;
        this.next = next;
    }
    
    public K getKey() {
        return key;
    }
    public V getValue() {
        return value;
    }
    @Override
    public String toString() {
        return key + "=" + value + "," + next;
    }
    
    
}

package com.bjsxt.task;

import java.util.Arrays;
import java.util.HashMap;

/** 
 * <p>Title: MyHashMap</p>  
 * <p>Description: 自定义HashMap类</p>  
 * @author xiaoding
 * @date Jun 2, 2020  
 * @version 1.0 
 */
public class MyHashMap<K,V> {
    //功能属性
    private Node<K,V>[] table;    //存储数组
    private int size;    //存放节点的个数
    
    //无参构造方法
    public MyHashMap() {
        //默认数组长度
        this.table = new Node[10];
    }
    //有参构造方法
    public MyHashMap(int length) {
        //手动给数组定义长度
        this.table = new Node[length];
    }
    
    //根据键获取值的方法
//    public V get(Object key) {
//        
//    }
    
    //添加方法
    public void put(K key,V value) {
        //计算Hash值
        int num = key.hashCode();
        //创建一个节点对象并赋值
        Node<K, V> newNode = new Node<K,V>(key,value,putV(num),null);
        if (table[newNode.hash] == null) {
            table[newNode.hash] = newNode;
            size++;
        }else if (table[newNode.hash] != null) {
            //创建一个节点指向当前元素
            Node<K, V> i = newNode;
            for (int j = 0;j<size;j++) {
                if (j == i.hash) {
                    boolean flag = table[j].key.equals(i.key);
                    if (flag) {
                        table[j].key = i.key;
                        break;
                    }else {
                        table[j].next = i;
                        break;
                    }
                }
            }
        }
    }
    
    //计算存储位置的方法
    public int putV(int num) {
        return num % 11;
    }
    
    //重写一下HashCode方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + size;
        result = prime * result + Arrays.hashCode(table);
        return result;
    }
    
    //重写一下比较方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        MyHashMap other = (MyHashMap) obj;
        if (size != other.size)
            return false;
        if (!Arrays.equals(table, other.table))
            return false;
        return true;
    }
    
    
    @Override
    public String toString() {
        return "" + Arrays.toString(table);
    }
    public static void main(String[] args) {
        MyHashMap<String,Integer> i = new MyHashMap<String, Integer>();
        i.put("java", 123);
        i.put("good", 256);
        i.put("sxt", 2525);
        System.out.println(i);
    }
}

老师我这个相同位置。元素节点好像没有添加进去，还有那个get方法怎么写，我实在是想不出来

运行结果图：