老师 想要JDK1.8资源 之前发的链接打不开 过期了

如上图：while循环里面是一直在创建线程吧，那为什么老师说每有一个客户端就创建一个线程

图2:

package chatGroup;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.List;

/**
 * 服务器路径线程
 */
public class MyChannel implements Runnable{
    private DataInputStream dis;
    private DataOutputStream dos;
    private boolean flag=true;

    public MyChannel(Socket socket) {
        try {
            dis=new DataInputStream(socket.getInputStream());
        } catch (IOException e) {
            flag=false;
            CloseUtil.close(dis);
        }
        try {
            dos=new DataOutputStream(socket.getOutputStream());
        } catch (IOException e) {
            flag=false;
            CloseUtil.close(dos);
        }
    }

    @Override
    public void run() {
        while (flag){
            //this.send(gain());
            sendOther();
        }
    }
    public String gain(){
        String str="";
        try {
            str=dis.readUTF();
        } catch (IOException e) {
            flag=false;
            CloseUtil.close(dis);
            MyServer.list.remove(this);
        }
        return str;
    }
    public void send(String str){
        if (str!=null&&str.length()!=0){
            try {
                dos.writeUTF(str);
                dos.flush();
            } catch (IOException e) {
                flag=false;
                CloseUtil.close(dos);
                MyServer.list.remove(this);
            }
        }
    }
    public void sendOther(){
        String str=this.gain();
        List<MyChannel> list=MyServer.list;
        for (MyChannel other:list){
            if (other==this){
                continue;
            }
            other.send(str);
        }
    }
}

图2中：Myserver.list.remove(this),将元素从容器中移除，这里的元素就是客户端，如果客户端发送的流出了异常，接收流没有出异常，就删除该客户端吗，就是说接收和发送只要一个有异常就移除这个客户端吗？

老师，我这代码运行没问题，但是控制台没显示

老师，可以提供下视频上的API帮助文档吗?

bw.write(line);
bw.newLine();
bw.flush();

问题：1.为什么要newLine（）换行，我测试加与不加没区别

2.每次循环都要flush（）刷新缓冲区，如果放在循环外面可以吗？高层流close关闭的情况下不加flush是否可以，还是说操作规范来讲最好在循环中都加上flush？

老师，str5打印出来的不也是hello java吗，为什么str2==str5为false，不懂“hello”+" java"和str3+str4的区别

*;
;
;

{
    ([] args) {
        =ServerSocket();
        = .accept();
        = .getInputStream();
        =File();
        (!.exists()){
            .mkdirs();
        }
        =FileOutputStream(+);
len=;
[] =[];
((len=.read())!=-){
    .write(,,len);
}
        .getOutputStream().write(.getBytes());
        .close();
        .close();
        .close();
    }
}

客户端：
import java.io.*;
import java.net.Socket;

public class TPClient {
    public static void main(String[] args) throws IOException {

        Socket socket=new Socket("172.0.0.1",9999);
        FileInputStream fis=new FileInputStream("123.png");
        OutputStream ops = socket.getOutputStream();
        int len=0;
        byte[]bytes=new byte[1024];
        while((len =fis.read(bytes))!=-1){
        ops.write(bytes,0,len);
        }
        InputStream ips = socket.getInputStream();
        int len1=0;
        byte[]bytes1=new byte[1024];
        while((len1 =ips.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len1));
        }
        fis.close();
        ips.close();
        ops.close();
    }
}

为什么没有复制成功？

老师这边写这个为什么会有异常，里面写数字就不会

请问：为什么是{3,8}，而不是{4,8}或{3,7}？

.1提问:

老师,此方法中 next为一个节点,我不懂的是,为什么程序会认为next节点是下一个节点呢,他仅仅指的是一个节点,next就是一个属性,有不是方法,next也没有定义类似的index++,index--,为什么会认为他是指向下一个节点的呢?怎么实现元素指针的向后移动的呢?

老师写的if（isflag）{//相当于isflag==true   这里有点不明白呢 不应该是isflag==false吗 

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

private Object[] arr;               //存放元素的物理结构
private int stackLength = 4;        //给数组默认长度为4
private int size = 0;               //记录栈容器的元素个数
private int index = -1;  

//？？？？？？----------问题：此处扩容为什么stackLength要-1--------？？？？？？？

private void capacity(){
    if(this.size-(this.stackLength-1)>=0){                    
        this.stackLength = this.stackLength+(this.stackLength >> 1);
    }
}

public E push(E item){
    /*1.初始化数组
      2.向数组中添加元素
      3.记录元素个数*/
    this.capacity();
    this.arr[++index] = item;
    this.size++;
    return item;
}

描述：假设当前Object【】数组有3个元素，size=3，stackLength=4（默认长度）

当添加第四个元素时,调用push方法，执行this.capacity,,,,this.size-（this.stackLength-1）=3-（4-1）=0

此时0>=0，即添加第四个元素的时候，就执行扩容步骤，此时扩容结束后size=4，stackLength=6

是否是提前1次扩容了？

老师笔记上说

final void join() 

调用该方法的线程强制

执行，其它线程处于阻

塞状态，该线程执行完

毕后，其它线程再执行

public class TestJoin {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt,"线程1");
        Thread t2 = new Thread(mt,"线程2");
        // 启动线程
        t1.start();
        t2.start();
        // 以下代码是主线程的循环
        for(int i = 0;i<10;i++){
            if(i == 3){
                try {
                    t1.join(); 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程："+Thread.currentThread().getName()+"--->"+i);
        }


    }
}

t1.join()么应该是线程t1调用jion()方法，那不是应该t1线程强制执行，t2和主线程堵塞么。那为什么视频老师会说main线程堵塞，t2可以和t1抢占资源。后来在总结是又说join()方法会导致调用它的方法进入阻塞状态，其他线程不会

这让我有很懵啊

老师帮忙看一下我的代码有什么问题吗？

代码如下：

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapCompare {
    public static void main(String[] args) {
        Map<User, String> map = new TreeMap<>();
        User u1 = new User("Leo", 21);
        User u2 = new User("Fish", 23);
        User u3 = new User("Angela", 18);
        User u4 = new User("Orange", 20);

        map.put(u1, "Leo");
        map.put(u2, "Fish");
        map.put(u3, "Angela");
        map.put(u4, "Orange");

        Set<User> keys = map.keySet();
        for(User key: keys) {
            System.out.println(key + "---------" + map.get(key));
        }
    }
}

User代码如下：

import java.util.Objects;

public class User implements Comparable<User> {
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("equals start");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        System.out.println("equals end");
        return age == user.age &&
                Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(User o) {
        if(this.getAge() > o.getAge()) {
            return 1;
        }
        if(this.getAge() == o.getAge()) {
            this.getName().compareTo(o.getName());
        }
        return -1;
    }
}

运行结果：

通过Key无法获取TreeMap中的Value值，请问一下老师，我的代码中存在什么问题吗？