老师，用add方法和push方法有什么区别，好像两个都可以用在栈容器里

老师，这里面的map.entrySet()方法返回的Set<Map.Entry<String,String>>,这个Entry是Map的内部接口，里面的getKey和getValue方法都是抽象方法，没有具体实现类，那怎么能直接调用？

老师，

1. 当链表长度大于8时就会转换为红黑树，这个的前提条件是不是数组长度大于等于64才能转换？

2. 如果链表长度大于8，数组长度小于64，是不是链表不会转换成红黑树，而是数组进行扩容？

3. 如果上面的两个问题是对的话，那激发数组扩容的条件是不是有两个，一个就是当数组被沾满75%，另一个是链表长度大于8（数组长度小于64）

为什么Node<K,V>实现了Map.Entry<K,V>   Set<> 里放Map.Entry<K,V>就等于放Node<K,V>   

implements中 父类可以使用子类的方法吗？

2020 12 04-----------------------------

package com.bjsxt;
package com.bjsxt;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapTest {
    public static void main(String[] args) {
        //实例化HashMap容器
        Map<String,String> map = new HashMap<>();
        //添加元素
        map.put("a","A");
        String value = map.put("a","B");
        System.out.println(value);

        System.out.println("---------------------------");
        String val = map.get("a");
        System.out.println(val);

        System.out.println("------------------------------");
        map.put("b","B");
        map.put("c","C");
        map.put("d","D");
        map.put("e","E");
        //获取HashMap容器中所有的元素，可以使用keySet方法与get方法一并完成。
        Set<String> keys = map.keySet();
        for(String key:keys){
            String v1 = map.get(key);
            System.out.println(key+" ---- "+v1);
        }
        System.out.println("-----------------");
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        for(Map.Entry<String,String> entry:entrySet){
            String key = entry.getKey();
            String v = entry.getValue();
            System.out.println(key+" ---------- "+v);
        }
      }
}

为什么这里是String value = map.put("a","B");  而不是String value = new map.put("a","B");

Set<Map.Entry<String,String>> entrySet = map.entrySet();  而不是

Set<Map.Entry<String,String>> entrySet =  new map.entrySet();

老师，java容器中跟c++的区别在哪，我之前学了c++，想知道两者的区别

老师，new  后面的可以看做 调用这个类，   s.()这个点 后面的可以看做是使用这个方法输出什么，是这样吗？

老师，字节流是面向字节的，一个字节是8位，范围是0~255，那字节流是如何读取写入那些占两个字节的字符的（比如汉字）？

老师，这里使用BufferedInputStream和BufferedOutputStream定义的处理流，是不是与自定义byte[]数组缓冲区然后read(byte[] b)并不一样？

我的理解：

1）处理流仍然是一个字节一个字节从数据源中读取数据，只是将这些字节缓存在处理流定义的字节数组中，之后等满了以后（达到8192个字节）再读入到程序中；

2）而自定义的缓冲区是一次直接从数据源中读取多个字节（比如定义的1024个字节数组）到程序中。

处理小文件的时候，自定义的会不会效率更高一下？

处理大文件的时候使用那个更好一些？

两个结合在一块使用适用吗？（比如第二段代码中的适用）

第一段代码：

package cn.ljp;

import java.io.*;

public class TestBufferedInputStream02 {
    public static void main(String[] args) {
        // 1) 定义字节流和处理流
        InputStream fis = null;
        InputStream fib = null;
        OutputStream fos = null;
        OutputStream fob = null;
        try{
            fis = new FileInputStream("f:/a.png");
            fib = new BufferedInputStream(fis);
            fos = new FileOutputStream("f:/aa.png");
            fob = new BufferedOutputStream(fos);
            int emp = 0;
            long start = System.currentTimeMillis();
            while((emp = fib.read()) != -1){
                System.out.println(emp);
                fob.write(emp);
            }
            fob.flush();
            long stop = System.currentTimeMillis();
            System.out.println("花费时间" + (stop - start) + "毫秒");
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(fib != null)
                    fib.close();
                if(fis != null)
                    fis.close();
                if(fob != null)
                    fob.close();
                if(fos != null)
                    fos.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

第二段代码：

package cn.ljp;

import java.io.*;

public class TestBufferedInputStream {
    public static void main(String[] args) {
        // 1) 定义字节流和处理流
        InputStream fis = null;
        InputStream fib = null;
        OutputStream fos = null;
        OutputStream fob = null;
        try{
            fis = new FileInputStream("f:/a.png");
            fib = new BufferedInputStream(fis);
            fos = new FileOutputStream("f:/aa.png");
            fob = new BufferedOutputStream(fos);
            byte[] buff = new byte[1204];
            int emp = 0;
            long start = System.currentTimeMillis();
            while((emp = fib.read(buff)) != -1){
                System.out.println(emp);
                fob.write(buff,0,emp);
            }
            fob.flush();
            long stop = System.currentTimeMillis();
            System.out.println("花费时间" + (stop - start) + "毫秒");
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(fib != null)
                    fib.close();
                if(fis != null)
                    fis.close();
                if(fob != null)
                    fob.close();
                if(fos != null)
                    fos.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }

    }
}

老师，为啥？不能改成T，？和T在这里的作用不是一样的吗

老师，怎么用时是0，明明就是调用了递归函数呀

老师，不是说静态方法无法访问类上定义的泛型吗？为什么我加了一个<T>在T前面就没有报错了

讲话太快了，可不可以慢点啊，有的还没听清楚讲了什么就过去了

,老师好，这个电话本项目在分目录下每次调用这个

menuItemValidate方法时，

else语句里时我都想让它重新加载当前方法，比如在图中我每次都想让它重新加截addMenu方法，但是下次使用searchMenu方法时如果输入的数字超了我就想让它重新加截searchMenu方法，这样该怎么写？