问题：在循环时，-1是作为结束的标志，那如果在文本数据中就有-1这个数据，理论上会在此-1就截止，但是我再遍历时，程序却把-1分别转换成了ASCII码，进行输出，若是我就想实现在-1就截止，该如何做？？？

程序代码如下：

实验结果：

txt文本图：

程序代码：

txt内容：

程序结果：

问题：使用字节流对象读取字符内容，为啥读取中文字符，就是给人一种，一个汉子对应三个数字？？？

老师 删除全部元素的时候也可以用list.removeAll()方法呀，它需要传一个参数，如何实现和clear一样的效果呢？

老师你好，我这个为什么前面输出的是编码，后面就是乱码了？图片我是在网上随便找了一张

package yx.sudayIo;

import java.io.*;

public class FirstDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
            try {
                fis = new FileInputStream("/Users/yangxi/Desktop/zx.png");
                StringBuffer sb = new StringBuffer();
                int temp;
                while ((temp = fis.read()) != -1){
                    System.out.println(temp);
                    sb.append((char)temp);
                }
                System.out.println(sb.toString());
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    if(fis != null){
                        fis.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    }
}

public class Generic01<T> {
    private T flag;

    public void setFlag(T flag){
        this.flag = flag;
    }

    public T getFlag(){
        return this.flag;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Generic01<String> generic = new Generic01<>();//<>里不给出类型默认Object
        generic.setFlag("第一个泛型诞生");
        System.out.println(generic.getFlag());

        Generic01<Integer> generic2 = new Generic01<>();
        generic2.setFlag(629);
        Integer integer = generic2.getFlag();
        System.out.println(integer);
    }
}

我可以直接定义两个对象，就可以输出不一样类型的了，为什么还要多定义一个类用无界通配符？

老师，想问一下以下这段代码。

List<E> list = this.map2.get(parent);
//判断当前结点下是否含有子结点，如果没有则创建一个新的list
if (list==null){
    list=new ArrayList<>();
    this.map2.put(parent,list);

此处这个list本身就是map2 中parent对应的value，为什么在这个list为空的时候，还要把它重新put进map2。

List<E> list = this.map2.get(parent);

package cn.work.com.bjsxt2.netWork;

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 send extends Thread {
    private Socket socket;
    private Scanner scanner;
    public send(Socket socket , Scanner scanner){
        this.socket = socket;
        this.scanner = scanner;
    }

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

    private void sendMsg(){
        PrintWriter pw = null;
        try {
            pw = new PrintWriter(this.socket.getOutputStream());
            while (true){
                String str = scanner.nextLine();
                pw.println(str);
                pw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(pw != null){
                    pw.close();
                }
                if(socket != null){
                    socket.close();
                }
                if(scanner != null){
                    scanner.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
//接收信息线程
class receive extends Thread{
    private Socket socket;
    public receive (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 str = br.readLine();
                System.out.println("他说："+str);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
                try {
                    if(br != null){
                    br.close();}
                } catch (IOException e) {
                    e.printStackTrace();
                }

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


//主方法
public class goodTCP13 {
    public static void main(String[] args) {
        Scanner scanner = null;
        ServerSocket serverSocket = null;
        Socket socket = null;
        try{
            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();
                System.out.println("连接成功!");
            }else {
                //启动客户端
                socket = new Socket(arr[0],Integer.parseInt(arr[1]));
                System.out.println("连接成功！");
            }
            //启动发送消息线程
            new send(socket,scanner).start();
            //启动接收消息线程
            new receive(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

老师帮我看一下

老师，在二叉树遍历时，是不是说在递归后左子树为空，打印了当前值后，根类的left就变成空了。否则的话为什么会打印根类呢

if(this.left!=null){
    this.left.inorderTraversal();
}
    System.out.println(this.item);
if (this.right!=null){
    this.right.inorderTraversal();
}

老师我们怎么知道端口号是80呢？视频有说吗？

public class HelloWorld {
    public static void main(String[] args) {
		
		Integer a=100;
   		Integer b=100;

		Integer c=200;
   		Integer d=200;
		
		
		System.out.println(a == b);	//true	
		System.out.println(a == 100);    //true
		
		System.out.println(c == d);//false
		System.out.println(c == 200);//true

	}
}

为什么会出现这种结果？

System.out.println(c == d)

这个为什么a == b,c == d 的结果竟然不一样！？

关于书中3.7.9.1中的代码，

if(o1.getAge() >o2.getAge()){...}

我不懂这里为什么不能用

o1.age 和o2.age 进行比较，而必须写set和get方法？谢谢

public class TestShowMsg {

    public static void main(String[] args) {

        ShowMsg sm = new ShowMsg();
        Generic3<Integer> g = new Generic3<>();
        sm.showFlag(g); // null 这里null 是因为这时候Generic3的对象没有任何值为空
        g.setFlag(20); // 为Generic3中的flag赋值20
        sm.showFlag(g); // 20 将Generic3对象g传入
       /*
        Generic3<Number> g2 = new Generic3<>();
        sm.showFlag(g2);
        g.getFlag(50);
        sm.showFlag(g);
        这里都报错的原因是泛型只确定了你要使用的类型或者类型识别，不考虑继承关系，只看类型！！
*/

        System.out.println("=============================================");
        Generic3<Integer> g2 = new Generic3<>();
        sm.showFlag(g2); 
        g2.setFlag(30); 
        sm.showFlag(g2); 
        Generic3<Number> g3 = new Generic3<>();
        sm.showFlag2(g3); // 因为showFlag2(Generic3<?> generic3)的参数泛型是? 任意类型 所以这里不会报错
        g3.setFlag(50);
        sm.showFlag2(g3);


    }
}
class ShowMsg{
    public void showFlag(Generic3<Integer> generic3){  // 这里传入的参数是Generic3对象 泛型类型定义为Integer
        System.out.println(generic3.getFlag());
    }

    // ? 无界通配符
    public void showFlag2(Generic3<?> generic3){  // 不能确定传入的是什么类型时 泛型类型定义为? 任意类型都可以
        System.out.println(generic3.getFlag());
    }
}

class Generic3<T>{
    private T flag;

    public T getFlag() {
        return flag;
    }

    public void setFlag(T flag) {
        this.flag = flag;
    }
}

老师，我这样理解对吗？

然后还有两个问题：

1、为什么传入参数Generic3<T> generic会报错？  我创建的泛型类是Generic3<T>，T不是表示简单的JAVA类么，

为什么传参时不可以使用？

public void showFlag(Generic3<T> generic3){  
    System.out.println(generic3.getFlag());
}

2、T是简单JAVA类 ?是任意类型 那这里用?作为传入参数的泛型，会不会出现超出T表示的范围？

public void showFlag2(Generic3<?> generic3){  
        System.out.println(generic3.getFlag());
    }

public class Test {
    public static void main(String[] args) {
        Generic2 g = new Generic2();
        g.setName("lili");
        g.setName(123);
        String name = g.getName("lili"); // 报错
        Object name1 = g.getName("lili"); // 没有报错

        Integer flag = Generic2.getFlag(222);
        Generic2.setFlag("dd");
    }
}

class Generic2<N>{

    // 非静态方法
    public<T> void setName(T name){
        System.out.println(name);
    }
    public<T> T getName(T name){
        return name;
    }

    // 静态方法
    public static <T> void setFlag(T flag){
        System.out.println(flag);
    }
    public static <T> T getFlag(T flag){
        return flag;
    }

}

报错：

java: 不兼容的类型: java.lang.Object无法转换为java.lang.String

老师，如果类和方法都定义了泛型，类是<N>，方法是<T> 

String name = g.getName("lili"); // 报错

1、为什么这句会报错，如果把String name改成Object name就不会报错。把类改成Generic2<T>，方法和类都是T，但还是报错，这是为什么？看报错的内容觉得能明白，但是想把原因写出来记笔记，又不知道该怎么写

2、静态方法的泛型和类的泛型没有关系是么？

关于实例化TreeSet

Set<String> set = new TreeSet< >

前面为什么使用Set，而不是用TreeSet,

我是否可以理解为：

因为Set接口下的TreeSet， HashSet没有自己独有的方法，所以这里用Set？

像List接口中，若使用ArrayList中独有的方法，则必须用

ArrayList<String>= New ArrayList< >?

另外，这里Set和TreeSet是否是一种继承关系，前面写TreeSet，即

TreeSet<String> set = new TreeSet<>

也不会报错？

谢谢

老师这种操作最早是在哪节课讲的，意思是把第一个实例出来的对象作为第二个的实参吗，我有点懵。能解释下流程吗