运行出来，年龄相等的情况下不按照字母顺序排序呢？

package 容器;

import java.util.Objects;

public class Users implements Comparable<Users>{
   private String username;
   private int userage;

    public Users(String username, int userage) {
        this.username = username;
        this.userage = userage;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Users users = (Users) o;
        return userage == users.userage &&
                Objects.equals(username, users.username);
    }

    @Override
    public int hashCode() {
        return Objects.hash(username, userage);
    }

    public Users() {
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getUserage() {
        return userage;
    }

    public void setUserage(int userage) {
        this.userage = userage;
    }

    @Override
    public String toString() {
        return "Users{" +
                "username='" + username + '\'' +
                ", userage=" + userage +
                '}';
    }

    //定义比较规则
    //正数:大,  负数:小,  0:相等
    @Override
    public int compareTo(Users o) {
        if (this.userage>o.getUserage()){
            return 1;
        }
        if (this.username==o.getUsername()){
            return this.username.compareTo(o.getUsername());
        }
        return -1;
    }

}

System.out.println("==================");
Set<Users> set2=new TreeSet<>();
Users u=new Users("wzx",22);
Users u2=new Users("jxm",18);
Users u3=new Users("lyx",18);
Users u4=new Users("yj",18);
set2.add(u);
set2.add(u2);
set2.add(u3);
set2.add(u4);
for (Users users:set2){
    System.out.println(users);
}

老师，在用add方法添加元素时，元素的hashcode值已经确定，但是因为是调用object的hashcode方法所以值可能是不相同的。
所以需要重写hashcode方法根据添加元素的属性字段将相同属性字段的元素的hashcode值变为一样的，再利用equals方法比较，如果一样则不添加。
如果没有重写hashcode方法，hashcode值不同就不会去调用equals方法比较。老师，我理解的对吗？
 
但是如果添加的元素的hashcode值在添加时就是相等的，那么是调用object的equals方法比较，相同则不添加；还是调用重写的equals方法比较呀

老师想问一下这里没有继承thread为什么还可以用sleep 和currentThread

为什么需要跟红色的一样才行呢？

老师，那个字符串类型我写字母也报错了为什么？

fw.write("中国、俄罗斯、美国、欧洲、非洲\r");

问题：为啥直接\r 也能打出同样的效果

老师想问一下

1. 为什么运行结果不显示getPriority

2. 为什么第二章截图会出现如图形式

public class FileStreamBuffedDemo {
    public static void main(String[] args) {
        //创建文件字节输入流对象
        FileInputStream fis=null;
        //创建文件字节输出流对象
        FileOutputStream fos=null;

//        File file=new File("d:/aa.jpg");
        try {
            //创建文件字节输入流对象
            fis=new FileInputStream("d:/a.jpg");
            //创建文件字节输出流对象
            fos=new FileOutputStream("d:/aa.jpg");
            //创建一个缓冲区，提高字节读写效率

            byte[] buff=new byte[1024];

//            file.createNewFile();
            int i=0;//计数器
            int temp=0;

            while((temp=fis.read(buff)) != -1){

                fos.write(buff,0,buff.length);
                i++;//循环次数

            }
            //将数据从内存中写入到磁盘中
            fos.flush();
            //看看循环了几次
            System.out.println(i);




        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {

                if(fis !=null){
                    fis.close();
                }
                if(fos!=null){
                    fos.close();
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }

问题：(   (temp=fis.read(buff)) != -1  )循环条件的理解，由于我加了个循环计数器，发现fis.read(buff)还是一个字节一个字节的往外读的,对于老师说file.read(buff) 返回的数组的长度有点疑问，如果返回的是数组的长度的话，那 赋完 fis.read(buff)值后的temp应该永远满足不了temp != -1这个条件啊，应该是个死循环啊，请老师帮忙解下惑

还有就是开头的时候创建了一个字节输出流对象变量 fos，然后我的d盘里并没有这个文件，不要创建一个File对象然后调用createFile的方法创建这个文件嘛

public class FileStreamDemo {
    public static void main(String[] args) {
        //创建文件字节输入流对象
        FileInputStream fis=null;
        //创建文件字节输出流对象
        FileOutputStream fos=null;
        File file=new File("d:/aa.jpg");
        try {
            fis=new FileInputStream("d:/a.jpg");
            fos=new FileOutputStream("d:/aa.jpg");
            file.createNewFile();
            int temp=0;
            while((temp=fis.read()) != -1){
                fos.write(temp);
            }
            //将数据从内存中写入到磁盘中
            fos.flush();




        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {

                if(fis !=null){
                    fis.close();
                }
                if(fos!=null){
                    fos.close();
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }









    }
}

问题：

 while((temp=fis.read()) != -1)

这个判断条件的理解是：

先执行括号里的temp=fis.read(),

每次fis.read()方法的调用都会返回一个int值给temp，然后就是相当于比如：（temp=97)  != -1，这样的表述

然后完成temp =97这样的赋值操作

最后这个表述是不是就是判断temp != -1呢

不知道我的理解是否正确

package com.bisxt;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {
        //实例化ReflectDemo
        ReflectDemo rd = new ReflectDemo();
        if (args!=null  &&  args.length>0){
            //获取ReflectDemo的Class对象
            Class clazz = rd.getClass();
            //通过反射获取ReflectDemo下的所有方法
            Method[] methods = clazz.getMethods();
            for (String str:args){
                for (int i = 0;i<methods.length;i++){
                    if (str.equalsIgnoreCase(methods[i].getName()));
                        methods[i].invoke(rd);
                        break;

                }
            }
        }else{
            rd.method1();
            rd.method2();
            rd.method3();
        }
    }

}


package com.bisxt;

public class ReflectDemo {
    public void method1(){
        System.out.println("method1...............");
    }
    public void method2(){
        System.out.println("method2...............");
    }
    public void method3(){
        System.out.println("method3...............");
    }



}

不知道为什么得不到相对应的顺序？老师帮我看一下

老师您好，这里调用的是isEuqals这个静态方法，为啥就可以直接写成调用这个静态方法里面的方法体了？静态方法的调用不是类名/实例名.这个静态方法的名字吗？

老师 为什么Lambda引用 静态方法不需要实例化能引用

非静态方法需要实例化才能引用

jdk9Class下的newInstance()已经弃用了

老师想问一下为什么这里不是先执行儿子买烟的线程再执行“等待儿子买烟回来”呢？毕竟t.start在前啊