老师这个为什么是二叉树，这个元素没有顺序啊

那如果通过命令行执行程序要怎么给定args

老师，缓冲字节流需要将字节流对象放入缓冲字节流中，代码：

 = FileInputStream();
 = FileOutputStream(, );
BufferedInputStream bis = BufferedInputStream();
BufferedOutputStream bos = BufferedOutputStream();

而字符流直接就可以创建,代码：

BufferedReader reader = new BufferedReader();

BufferedWriter writer = new BufferedWriter();

而不是这样，

FileReader = FileReader();
FileWriter= FileWriter(, );
BufferedReader bufreader = BufferedReader();
BufferedWriter bufwriter = BufferedWriter();

还是说这是俩种方式，不管是字节流还是字符流都可以随意用这俩种方式中的任何一种呐？？

IO流不是使用的是装饰设计模式吗？

在此贴出装饰设计模式和静态代理模式的区别：

装饰器模式关注于在一个对象上动态地添加方法，而代理模式关注于控制对对象的访问。换句话说，用代理模式，代理类可以对它的客户隐藏一个对象的具体信息。因此当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例；当使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数传给装饰器的构造器。

装饰器模式和代理模式的使用场景不一样，比如IO流使用的是装饰者模式，可以层层增加功能。而代理模式则一般是用于增加特殊的功能，有些动态代理不支持多层嵌套。

代理和装饰其实从另一个角度更容易去理解两个模式的区别：代理更多的是强调对对象的访问控制，比如说，访问A对象的查询功能时，访问B对象的更新功能时，访问C对象的删除功能时，都需要判断对象是否登陆，那么我需要将判断用户是否登陆的功能抽提出来，并对A对象、B对象和C对象进行代理，使访问它们时都需要去判断用户是否登陆，简单地说就是将某个控制访问权限应用到多个对象上；而装饰器更多的强调给对象加强功能，比如说要给只会唱歌的A对象添加跳舞功能，添加说唱功能等，简单地说就是将多个功能附加在一个对象上。

所以，代理模式注重的是对对象的某一功能的流程把控和辅助，它可以控制对象做某些事，重心是为了借用对象的功能完成某一流程，而非对象功能如何。而装饰模式注重的是对对象功能的扩展，不关心外界如何调用，只注重对对象功能加强，装饰后还是对象本身。

链接：https://www.cnblogs.com/yanggb/p/10952843.html

class A implements Runnable{
    private Thread b;
    public A(Thread b){
        this.b=b;
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+" A "+i);
            if (i==6){
                try {
                    b.join();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class B implements Runnable{

    @Override
    public void run() {
        for (int i =0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+" B "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class TestJoinThread{
    public static void main(String[] args) {
        Thread t1 = new Thread(new A(t));
        Thread t = new Thread(new B());
        t1.start();
        t.start();
        for (int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+" 主线程 "+i);
            if (i==4){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

Thread t1 = new Thread(new A(t));
        Thread t = new Thread(new B());

为什么写成这样报错，不都是把B给A里了吗

视频是这样的

还有为什么要先创建线程B的对象

代码：

com.bjsxt.homework.Thread;

JoinThread {
    main(String[] args) {
        System..println();
        Thread  t1 = Thread(A());

        t1.start();
        (i =;i<;i++){
            System..println(Thread.().getName()++i);

            (i == ) {

            {
                t1.join();
            } (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
        System..println();
    }
}
 A Runnable{
    Thread = B();

    run() {
        .run();
        (i =;i<;i++){
        System..println(Thread.().getName()++i);
        {
            Thread.();
        } (InterruptedException e) {
            e.printStackTrace();
        }

        (i==){
            {
                .join();
            } (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }}

}
 B Thread{
     run() {
         (i =;i<;i++){
             System..println(Thread.().getName()++i);
             {
                 Thread.();
             } (InterruptedException e) {
                 e.printStackTrace();
             }
     }

     }
 }

运行结果：
main线程开始
main正在运行0
main正在运行1
main正在运行2
main正在运行3
Thread-1正在运行！！！0
Thread-1正在运行！！！1
Thread-1正在运行！！！2
Thread-1正在运行！！！3
Thread-1正在运行！！！4
Thread-1正在运行！！！5
Thread-1正在运行！！！6
Thread-1正在运行！！！7
Thread-1正在运行！！！8
Thread-1正在运行！！！9
Thread-1正在运行0
Thread-1正在运行1
Thread-1正在运行2
Thread-1正在运行3
Thread-1正在运行4
Thread-1正在运行5
Thread-1正在运行6
Thread-1正在运行7
Thread-1正在运行8
Thread-1正在运行9
main正在运行4
main正在运行5
main正在运行6
main正在运行7
main正在运行8
main正在运行9
main线程结束

Process finished with exit code 0

请问为什么线程中不能创建线程呢？？？只有一个Thread1

下面为什么报错？是用泛型接口子类向上转型进行的

class Server {
    public static void main(String[] args) {
        System.out.println("服务器开始监听...");
        try(
            //创建服务端套接字
            ServerSocket serverSocket = new ServerSocket(8888);
            //开始监听
            Socket socket = serverSocket.accept();
            //创建输入输出字符流
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter pw = new PrintWriter(socket.getOutputStream());){

            System.out.println("连接成功");
            //循环接收客户端信息,直到接收数据为exit时退出程序
            while(true){
                //读取客服端数据
                String str = reader.readLine();
                //显示数据
                System.out.println("客户端: " + str);
                //当输入为exit时退出
                if ("exit".equals(str)){
                    break;
                }
                //返回数据
                pw.print(str);
                pw.flush();
            }
        } catch (IOException e) {
            System.out.println("服务器启动失败");
        }
    }
}
class Client {
    public static void main(String[] args) {
        try(Socket socket = new Socket("127.0.0.1",8888);
            Scanner scanner = new Scanner(System.in);
            PrintWriter pw = new PrintWriter(socket.getOutputStream());
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))){

            //循环接收键盘输入信息并发送给服务端,当输入信息为exit时,发送服务端后退出程序
            while(true){
                //接受键盘输入
                System.out.println("请输入: ");
                String str = scanner.nextLine();
                //发送到服务端
                pw.print(str);
                pw.flush();
                //当输出为exit时关闭客户端
                if ("exit".equals(str)){
                    break;
                }
                //接受服务端数据
                System.out.println("服务端返回: " + reader.readLine());
            }
        }catch (Exception e){

        }
    }
}

老师，为什么在发送数据时，用print()方法会显示不出来，用println()方法则是正常的

老师，这里我没有加上utf-8字符编码反而能成功输出，加了反而乱码是什么情况呢

// 通过流输出到客户端
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
bw.write(sb.toString());
bw.flush();
bw.close();

// 通过流输出到客户端
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream(),"utf-8"));
bw.write(sb.toString());
bw.flush();
bw.close();

从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点

老师这句话什么意思，简单说明一下吧（我学过数据结构的，有点忘记了）

不管怎么看，这里实现的test()方法才对，怎么会是调用isEqualne ?

打开html之后没响应，已经修改了好几次还是不行，是哪部分出错了，这是源码。

<html>
	<head>
		<title>登陆</title>
	</head>
	<body>
		<form action="http://localhost:8888/log" method="get">
			<p>用户名:<input  type="text" name="username" id="username"/></p>
			<p>密码:<input  type="password" name="pwd" id="password"/></p>
			<p>
			        爱好：<input  type="checkbox" name="hobby" value="ball"/>足球
			        	  <input  type="checkbox" name="hobby" value="read"/>读书
			       	  <input  type="checkbox" name="hobby" value="paint"/>画画
			</p>
			<p><input  type="submit" value="登陆"/></p>
		</form>
	</body>
</html>

this：多线程同一时间执行一个对象，会乱套

字符串和class：都是不同线程分别执行同一个对象，有序，谁先谁后按cpu运行来

老师我这样理解的对吗

package com.bjsxt.Set_TreeSet;

import java.util.Comparator;

public class ComCharactorAndAge implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {

        Person p1 = (Person) o1;
        Person p2 = (Person) o2;
        if (p1.getName().compareTo(p1.getName()) < 0) {
            return -1;
        }
        if (p1.getName().compareTo(p1.getName()) > 0) {
            return 1;
        }
        if (p1.getName().compareTo(p1.getName()) == 0){
            return p1.getAge() - p2.getAge();
        }
         return 0;
    }
}

为什么我这么写if语句最后要再加个return 0；呢

老师那么写就不需要加 return 0；

我a文件内容是abcdef 像我这个第19 20行这么写，先判断读取的文件到没到最后，再赋值给a输出为什么结果是bdf呢