//对对象进行反序列化
public static void test2(){
    ObjectInputStream ois = null;
    try{
        ois = new ObjectInputStream(new
                FileInputStream("E:/object.txt"));
        Person p =(Person)ois.readObject();
        System.out.println(p);
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        try{
            if(ois != null){
                ois.close();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
java.io.InvalidClassException: cn.bzsxt.bytestream.User; local class incompatible: stream classdesc serialVersionUID = 1732458846381710476, local class serialVersionUID = -6028733942570062611
    at java.base/java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:689)
    at java.base/java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1898)
    at java.base/java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1764)
    at java.base/java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2055)
    at java.base/java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1586)
    at java.base/java.io.ObjectInputStream.readObject(ObjectInputStream.java:423)
    at cn.bzsxt.Test.Test.test2(Test.java:40)
    at cn.bzsxt.Test.Test.main(Test.java:11)

老师查了好久说不是代码问题 测了好几遍都报错

public class Person implements Serializable {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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 String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

import java.util.Calendar;
import java.util.GregorianCalendar;

public class Testcalendar {
    public static void main(String[] args) {
        GregorianCalendar calendar = new GregorianCalendar(2999, 10, 9, 22, 10, 50);

    }
    public static void printCalendar(Calendar calendar){

        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int date = calendar.get(Calendar.DAY_OF_WEEK);
        String week = "" + ((date == 0) ? "日" : date);
        int hour = calendar.get(Calendar.HOUR);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
        System.out.printf("%d年%d月%日，星期%s%d：%d：%d\n",year,month,day,week,hour,minute,second);
    }
}

老师，运行结果怎么啥也没有？

老师，关于t.schedule()方法中的第二个参数，它代表延迟多久之后开始运行程序，为什么用new Date(System.currentTimeMills()+1000)这种形式来写呢？貌似我直接用1000也可以顺利运行

package com.bjsxt.timer;

import java.util.Date;
import java.util.Timer;

public class TestTimer {
    public static void main(String[] args) {
        //创建Timer的对象
        Timer t=new Timer();
        //调用schedule()方法去执行任务
        //创建任务类的对象
        Clock task=new Clock();
        t.schedule(task,new Date(System.currentTimeMillis()+1000),1000);
    }
}

ObjectOutputStream  ObjectInputStream是不能同时打开吗

try(
        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("E:\\素材\\javaTest/c.txt")));
) {
    oos.writeInt(10);
    oos.writeFloat(1.2f);
    oos.flush();
} catch (IOException e) {
    e.printStackTrace();
}
try(
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("E:\\素材\\javaTest/c.txt")));
) {
    System.out.println(ois.readInt());
    System.out.println(ois.readFloat());
} catch (IOException e) {
    e.printStackTrace();
}

上面的正常运行

try(
        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("E:\\素材\\javaTest/c.txt")));
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("E:\\素材\\javaTest/c.txt")));
) {
} catch (IOException e) {
    e.printStackTrace();
}

上面的创建了就报错

public static void main(String[] args) {
  ageValidate();
    }
    public static int ageValidate() {
        //创建scanner对象
        Scanner scanner = new Scanner(System.in);
        String num ;
        while (true){
            System.out.println("输入您的年龄");
            if (scanner.hasNextInt()) {
                System.out.println("输入正确");
                num = scanner.nextLine();
                int age = Integer.parseInt(num);
                if(age>=10&&age<=99){
                    return age;
                }else{
                    System.out.println("输入格式有误，请重新输入");

                }
            } else {
                System.out.println("不是数字");
                num = null;
                ageValidate();
            }
        }


    }

老师我这个age使用的int类型，这个程序一直有问题，打断点也不知道怎么回事

package baozhuang;

public class zhengzongbaozhuang {
    public static void main(String[] args) {
        //基本数据类型转换为对象
        Integer i =Integer.valueOf(20);

        //包装类对象转换为基本数据类型
        double d=i.doubleValue();

        //将字符串数字转成包装类对象
        Integer i3=Integer.valueOf("234");
        Integer i4=Integer.parseInt("334");

        //将包装类对象转成字符串
        String str=i3.toString();

        //一些常用的常量
        System.out.println(Integer.MAX_VALUE);
    }
}


输出结果：2147483647

为什么最后的输出结果是上面那个？

Integer i =Integer.valueOf(20);     double d=i.doubleValue();

这两个都是什么意思？第一个20有什么用？

老师我想问下关闭资源这里为什么是不等于空就关闭资源啊,而不是等于空才关闭。不等于空不就说明fis还在使用，在使用的情况下怎么就关闭资源了呢？

老师，我按照视频上老师的方法敲了代码，运行都没问题，但是突然发现，这个程序并没有自动结束，IDEAL中的红色方块一直亮着，如下图：

麻烦老师帮忙看看是怎么回事，具体代码粘贴如下：

1.Printer类代码

package com.bjsxt.thread;

public class Printer {
    private int index=1;//用于统计第几次打印
    public synchronized void print(int number){
        while(index%3==0){
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print(number);
        index++;
        super.notifyAll();//唤醒所有在printer这个对象上所有等待的线程
    }
    public synchronized void print(char letter){
        while(index%3!=0){
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print(""+letter);
        index++;
        super.notifyAll();
    }
}

2.数字打印类代码

package com.bjsxt.thread;

public class NumberPrinter implements Runnable {
    private Printer printer;

    public NumberPrinter(Printer printer) {
        this.printer=printer;
    }

    @Override
    public void run() {
        for(int i=1;i<=52;i++){
            printer.print(i);
        }
    }
}

3.字母打印类代码

package com.bjsxt.thread;

public class LetterPrinter implements Runnable{
    private Printer printer;
    public LetterPrinter(Printer printer){
        this.printer=printer;
    }    @Override
    public void run() {
        for(char c='A';c<='z';c++){
          printer.print(c);
        }
    }
}

4.主线程测试代码

package com.bjsxt.thread;

public class Test {
    public static void main(String[] args) {
        //创建共享资源的对象
        Printer p=new Printer();
        NumberPrinter np=new NumberPrinter(p);
        LetterPrinter lp=new LetterPrinter(p);
        //创建代理类，并启动线程
        new Thread(np).start();
        new Thread(lp).start();
    }
}

为什么添加了一个元素，但是实现却不能运行呢？

Set<Users> set1=new TreeSet<>();
Users u =new Users("oldlu",18);
Users u1 =new Users("admin",22);
Users u2 =new Users("zyt",20);
set1.add(u);
set1.add(u1);
set1.add(u2);
for (Users users:set1){
    System.out.println(users);

}

Users{username='oldlu', userage=18}
Users{username='admin', userage=22}

结果就显示这两个

一、课堂代码

public void searchByName(){
    TelNoteRegex telNoteRegex = new TelNoteRegex();
    String name = telNoteRegex.nameValidate();
    boolean flag = true;
    for (Person i:this.list)
        if (name.equals(i.getName())){
            System.out.println(i);
            flag = false;
        }
    if(flag)
        System.out.println("查无此人");
}

二、尝试代码

public void searchByName(){
    TelNoteRegex telNoteRegex = new TelNoteRegex();
    String name = telNoteRegex.nameValidate();
    for (Person i:this.list)
        if (name.equals(i.getName())){
            System.out.println(i);
            return;
        }
    System.out.println("查无此人");
}

三、问题

感觉直接跳出的话会更省事，不知道对不对，这两种模式有什么差别？

老师，我也看了很多类似的问题，但是还是解决不了。麻烦帮忙看看路径有啥问题？谢谢！我也尝试着改绝对路径，还是解决不了

老师，对于服务端的主函数的代码这样子写可不可以呢

package cn.bjsxt;

//基于双向链表实现元素存取的容器
public class MyDoubleLinkList<E> implements Myist<E> {


    //记录头结点
    private Node head;
    //记录尾节点
    private Node tail;
    //记录元素个数
    private int size;

    //添加尾节点
    private void lastLinjk(E ele){
        //获取尾节点
        Node t = this.tail;
        //创建节点对象
      Node<E> node = new Node<>(ele,t,null) ;
      //将新节点定义为尾节点
        this.tail = node;
        if(t == null){
            this.head = node;
        }else {
            t.next = node;
        }
        this.size++;
    }
    //定一双向链表的节点对象
    class Node<E>{
        E item;//记录元素
        Node<E> prve;//记录前一个节点对象
        Node<E> next;//记录后一个节点对象
        Node(E item,Node<E> prve,Node<E> next){
            this.item = item;
            this.prve = prve;
            this.next = next;
        }
    }
    //添加元素的方法
    @Override
    public void add(E e) {
        this.lastLinjk(e);
    }
//获取元素的方法
    @Override
    public E get(int index) {
        //对index进行校验
        this.checkIndex(index);
        //根据索引获取节点对象
        Node<E> node = this.getNode(index);
        return node.item;
    }
//获取元素的个数
    @Override
    public int size() {
        return this.size;
    }
//删除元素
    @Override
    public E remove(int index) {
        //对index进行合法校验
        checkIndex(index);
        //根据指定位置获取节点对象
        Node<E> node = this.getNode(index);
        //获取节点对象中的元素
        E e = node.item;
        //判断当前节点是否为头节点
        if(node.prve == null){
            this.head =node.next;
        }else {
            //完成当前节点的直接前驱节点与当前节点的直接后继节点的挂接
            node.prve.next = node.next;
        }
        //判断当前节点是否为子节点
        if(node.next ==null){
            this.tail = node.prve;
        }else {
            //完成当前节点的直接后继节点与当前节点的直接前驱节点的链接
            node.next.prve = node.prve;
        }
        //当前节点断掉与他直接前驱节点的链接
        node.prve = null;
        //当前节点断掉与他直接后继节点的链接
        node.next = null;
        node.item = null;
        //记录元素个数
        this.size--;
        return e;
    }
    //校验index的特性
    private void checkIndex(int index){
        if(!(index >= 0 && index < this.size)){
            throw new IndexOutOfBoundsException();
        }
    }

    //根据索引获得指定对象
    private Node getNode(int index){
        if(index <(this.size>>1)){
            Node node = this.head;
            for (int i=0;i<index;i++){
                node = node.next;
            }
            return node;
        }else{
            Node node = this.tail;
            for (int i = this.size-1; i > index ; i--) {
                node = node.prve;
            }
            return node;
        }
        //在双向链表的头添加元素

    }
    public void addFirst(E e){
        lastLinjk(e);
    }
    //在链表头添加元素
    private void linkFirst(E e){
        //获取头节点对象
        Node head = this.head;

        Node node = new Node(e,null,head);
        //将新节点定义为头结点
        this.head = node;
        //判断当前节点中是否有头结点，如果没有，那么该节点是头结点也是尾节点
        if(head == null){
            this.tail = node;
        }else {
            head.prve = node;
        }
        //记录元素个数
        this.size++;
    }
    //在尾节点添加元素
    public void addLastLink(E e){
        this.lastLinjk(e);
    }
    public static void main(String[] args) {
        Myist<String> myist = new MyDoubleLinkList<>();
        myist.add("a");
        myist.add("b");
        myist.add("v");
        myist.add("d");
        myist.remove(2);
        for (int i = 0; i < myist.size(); i++) {
            System.out.println(myist.get(i));
        }
        System.out.println(myist.size());

        System.out.println("==============================");
        MyDoubleLinkList<String> list = new MyDoubleLinkList<>();
        list.add("a");
        list.addFirst("A");
        list.addLastLink("b");
        for (int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}
添加头结点元素添加失败？

只有一个端口怎样进行对服务器的输入啊。。。。。