package com.bjsxt;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class ObjectStreamObjectTypeDemo {


    public void ObjectOutputStreamObjectTypeDem(List<Person> list) {
        ObjectOutputStream oos = null;
        List<Person> list1 = new ArrayList<>();
        try {
            oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("J:\\课堂练习\\课程目录\\01.02JAVA入门与深化提高\\智能电话本项目实战\\电话簿.txt")));
            for (int i = 0; i < list.size(); i++) {
                list1.add(list.get(i));
            }
            oos.writeObject(list1);
            oos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public List<Person> ObjectInputStreamObjectTypeDemo(List<Person> list) {
        ObjectInputStream ois = null;
        List<Person> ls = null;
        try {
            ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("J:\\课堂练习\\课程目录\\01.02JAVA入门与深化提高\\智能电话本项目实战\\电话簿.txt")));
            ls = (List<Person>) ois.readObject();
            for(int i = 0;i<ls.size();i++){
                list.add(ls.get(i));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return list;
    }
}

老师的课堂作业，我写了一个类，然后在Operate 类中加了两个方法，一个是在退出时调用类下的方法 将list 遍历到自定义的数组然后将数组序列化到本地文件，

public void exit(){
    ObjectStreamObjectTypeDemo os = new ObjectStreamObjectTypeDemo();
    os.ObjectOutputStreamObjectTypeDem(this.list);
    System.exit(0);;
}

一个是初始化，运行项目时就调用类下的方法将文件的内容读到自定义数组 然后遍历给list，

/**
 * 传入电话薄
 */
public void Initialize(){
    ObjectStreamObjectTypeDemo os = new ObjectStreamObjectTypeDemo();
    os.ObjectInputStreamObjectTypeDemo(this.list);
}

不知道对不对，功能可以实现。就是我给的都是绝度路径，不知道怎么设定为相对路径，不知道制作成Jar包，能不能用

第二个问题

也有可能是我自己的问题，但视频里确实是这么说的，每次循环都减一

这里为什么oldValue == null  

oldValue明显不为null吧，那么value应该没有办法将值传递给e.value吧

这里会不会有问题呢？

 public int compareTo(Users o) {
        if(this.userage < o.getUserage()){
            return 1;
        }
        if(this.userage == o.getUserage()){
           return this.username.compareTo(o.getUsername());
        }
        return -1;
    }

Set<Student> set2 = new TreeSet<>(new StudentComparator());
        Student s = new Student("oldlu",7);
        Student s1 = new Student("admin",8);
        Student s2 = new Student("sxt",6);
        set2.add(s);
        set2.add(s1);
        set2.add(s2);
        for(Student student:set2){
            System.out.println(student)

是不是在s1进入的时候开始比较？this表示的就是s对象？

当s2进入的时候，它又是怎么比较的呢？s2对象怎么和两个对象进行比较的?

麻烦老师说一下他的比较执行的过程。

老师这个buf是个什么方法，，，，，，。。。。作用是啥，看他返回的是string类型的，那我可不可以定义个变量去把后面的那些存储呢，不用but这个方法

IP地址如何转换成真正我们需要的实际地址，当通过函数方法getHostAddress()方法时，是否有方法让其返回的是虚假的IP地址

问题：在循环时，-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();
}