String str2 = "hellojava";
String str3 = "hello";
String str4 = " java";
String str5 = str3 + str4;
System.out.println(str2 == str5)//false

str5拼接后的字符串也是"hellojava",和str2一样，指针也会指向hellojava，引用地址不是应该和str2相同吗，为什么返回false

老师 bat文件闪退是啥情况啊

抛出异常后，交给jvm处理是什么意思？我只看到了有异常然后print报错了而已，jvm也没帮我解决异常呀

老师，视频里整理的笔记呢 左面为啥没有文档了

public class MyInteger {
    private static int value;

    private static MyInteger[] cache;
    private static final int HIGH=127;
    private static final int LOW=-128;
    static {
        cache=new MyInteger[HIGH-LOW+1];
        for(int i=LOW;i<=HIGH;i++){
            cache[i+128]=new MyInteger(i);
        }
        System.out.println(Arrays.toString(cache));
    }

    @Override
    public String toString() {
        return value+"";
    }

    public MyInteger(int value){
        this.value=value;
    }

    public static MyInteger ValueOf(int value){
        return new MyInteger(value);
    }

    public int intValue(){return value;}

    public static void main(String[] args) {
        MyInteger a=new MyInteger(100);
        MyInteger b=a.ValueOf(100);
        System.out.println(a+"\n"+b);
        int c=a.intValue();
        System.out.println(c);
    }



}

老师，请问我这个结果为什么都是一样的，哪里出问题了吗？

public class TwoWaySocketClient {
    public static void main(String[] args) {
        try(Socket socket = new Socket("127.0.0.1", 8888);
            //创建键盘输入对象
            Scanner scanner = new Scanner(System.in);
            //通过与服务端对应的Socket对象获取输入流对象
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //通过与服务端对应的Socket对象获取输出流对象
            PrintWriter pw = new PrintWriter(socket.getOutputStream());){

            while (true) {
                String keyInput = scanner.nextLine();
                pw.println(keyInput);
                pw.flush();
                String input = br.readLine();
                System.out.println("服务端说：" + input);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Generic<String> generic = new Generic<String>();

老师我发现如果去掉第一个<String>数据类型就会变成object类，那第二个<String>的作用是什么呢

老师我测试了一下，string循环在4308时候就会对数据产生影响，这个时候stringbuild循环占用内存数归零，是因为达到了创建对象数的上限吗

12分03秒的时候，他按了什么操作生成的后面那一段代码呢

为什么没有办法用for-each遍历，报错

public static void main(String[] args) {
    MyStack<String> a = new MyStack<>();
    a.push("a");
    a.push("b");
    a.push("c");
    a.push("D");
    a.push("F");
    System.out.println(a.size);
    System.out.println(a.empty());
    System.out.println(a.pop());
    System.out.println(a.pop());
    System.out.println(a.pop());
    for (String b:a){

    }
    }
}

这里获取Class对象为什么用getClass不应该直接用Class吗？

这个获取Class对象为什么用的getClass不应该直接用Class吗

老师这里有个Node<E>x=last/first;这个的作用是什么

import java.lang.reflect.Constructor;

/**
 * 通过Class对象获取类的构造方法
 */
public class GetConstructor {
    public static void main(String[] args) throws Exception{
        Class clazz = Users.class;
        //通过getDeclaredConstructors();获取构造方法，是所有修饰类型的
        Constructor[] arr = clazz.getDeclaredConstructors();
        for (Constructor s:arr){
            System.out.println(arr);
        }
        System.out.println("-------------------------");
        //通过getConstructors获取构造方法，只显示public修饰的构造方法
        Constructor[] arr1 = clazz.getConstructors();
        for (Constructor s:arr1){
            System.out.println(arr1);
        }
        System.out.println("-------------------------");
        //通过getDeclaredConstructors方法给定参数获取构造方法，显示所有修饰的
        Constructor arr2 = clazz.getDeclaredConstructors(int.class);
        System.out.println(arr2);
        System.out.println("-------------------------");
        //getConstructors方法给定参数获取构造方法，只显示public修饰的
        Constructor arr3 =clazz.getConstructors(null);
        System.out.println(arr3);

    }
}

为什么会报错？

public class TestFileByteBuffer {
    public static void main(String[] args) {
     long time1 = System.currentTimeMillis();
     copyFile("d:/1.jpg","d:/2.jpg");
     long time2 = System.currentTimeMillis();
        System.out.println(time2-time1);
    }

    /**
     *
     * @param src 源文件
     * @param desc 目标文件
     */
    public static void copyFile(String src,String desc){
        //“后开的先关闭！”按照他们被创建顺序的逆序来关闭
        try(FileInputStream fis =new FileInputStream("src");
            FileOutputStream fos =new FileOutputStream(desc)){
            //创建一个缓冲区，提高读写效率
            byte[] buffer = new byte[1024];

            int temp = 0;
            while ((fis.read(buffer))!=-1){
                //将缓存数组中的数据写入文件中，注意：写入的是读取的真实长度;
                fos.write(buffer,0,temp);
            }
            //将数据从内存中写入到磁盘中
            fos.flush();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

java.io.FileNotFoundException: src (拒绝访问。),输出结果是这样