Arraylist和vector区别是什么

老师，这是我创建的一个在指定位置添加元素

// 校验index合法性  0<=index<=size
private void checkIndex02(int index){
    if(!(index >=0 && index <= this.size)){
        throw new IndexOutOfBoundsException("index:"+index+"  size:"+size);
    }
}

// 指定位置添加元素
private void LinkIndex(int index,E element){
    // 检验index合法性 0=<index<=size
    this.checkIndex02(index);
    // 如果index == size 元素添加至尾部
    if(index == size){
        this.LinkLast(element);
    } else if(index == 0){ // index==0 元素添加至头部
        this.LinkFirst(element);
    } else {
        Node<E> node =  this.getNode(index); // 获取指定位置节点
        Node<E> temp = new Node<>(node.prev,element,node); // 创建新节点，位于node前面
        node.prev = temp;
        node.prev.next = temp; //node节点的前一节点指向temp
    }
    // 记录元素个数
    this.size++;
}

// 将节点对象元素添加到双向链表头部
private void LinkFirst(E element){
    Node<E> head = this.head;
    Node<E> node = new Node<>(null,element,head);
    this.head = node;
    if(head == null){
        this.tail = node; 
    } else { 
        head.prev = node;
    }
    // 记录元素个数
    this.size++;
}

// 将节点对象元素添加到双向链表尾部 LinkLast
private void LinkLast(E element){
    // 获取尾节点
    Node<E> t = this.tail;
    Node<E> node = new Node<>(t,element,null);
    this.tail = node;
    if(t == null){ 
        this.head = node;
    } else { 
        t.next = node; 
    }
    // 记录元素个数
    this.size++;
}
// 指定位置添加元素
public void addIndex(int index,E element){
    this.LinkIndex(index,element);

}

测试后运行时正常的，您帮我看看有没有问题，谢谢

老师，我用这样的方式获取祖先节点，可能报错吗？

public List<E> getAncestor(E item){
    //获取当前节点的父节点
    E parent = this.getParent(item);
    List<E> ancestorList = new ArrayList<>();
    while (parent != null){
        ancestorList.add(parent);
        this.getParent(parent);
    }
    return ancestorList;
}

大多数的稍微能看懂一点，但是这个

equals是谁和谁比较内容？前面还加个(!)非，这是用来表示输入的内容和“over”相等就结束的作用吗

关于system.out.println的讲解中，

说的System类下有一个成员变量out，下面有个方法println

这里我不懂成员变量为什么下面还可以有方法？方法不就应该咋类下面吗？

然后就是

System.out::out

对于静态方法，冒号的左边是静态方法所在的类，这里的类不应该是System吗？为什么这里是System.out作为静态方法所在的类，而不是System？

问题：

    老师能讲解下字符流和字节流俩者之间使用的区别别吗，在应用当中。视频内使用方法基本类似，但不清楚实际运用的选择。

public class BasicSocketClient {
    public static void main(String[] args) {
        //创建Socket对象
        try(Socket socket = new Socket("192.168.0.178",8888);
            //创建向服务端发送消息的输出流对象
            PrintWriter pw = new PrintWriter(socket.getOutputStream())
        ){
            pw.println("服务端你好");
            pw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
public class BasicSocketServer {
    public static void main(String[] args) {
        System.out.println("服务器启动等待监听...");
        //创建ServerSocket服务端
        try(ServerSocket ss = new ServerSocket(8888)){
            //监听8888端口，此时线程会处于阻塞状态
            Socket socket = ss.accept();
            //连接成功后会得到与客户端对应的Socket对象，并解除线程阻塞
            //通过客户端对应的Socket对象中的输入流对象，获取客户端发送过来的的消息
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("服务器创建失败...");
        }
    }
}

老师你好，请问这个连接成功了，但是为什么没有打印客户端的那一句“服务端你好”啊？

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();

老师,我的eclipse一点安装就会跳转至这个界面,怎么办呢?

package com.itbaizhan;
import java.util.Arrays;//自定义一个简单的包装类,仅限于练习
public class MyInteger {
    private final int value;
    private static MyInteger[]cache;//缓存【-128,127】之间的数字
    private static  final int LOW=-128;
    private static  final  int HIGH=127;
    static {
        cache=new MyInteger[HIGH-LOW+1];
        for(int i=LOW;i<HIGH;i++){
            cache[i-LOW]=new MyInteger(i);
        }
        System.out.println(Arrays.toString(cache));
    }
    public MyInteger(int value){
        this.value=value;
    }
    @Override
    public String toString() {
        return value+"";
    }
    public static MyInteger valueof(int value){
        if(value>=LOW&&value<=HIGH){
            return  cache[value-LOW];
        }
        return  new MyInteger(value);}
    public static void main(String[] args) {
        MyInteger a=new MyInteger(10);
        MyInteger b= new MyInteger(100);
        MyInteger b2= new MyInteger(100);
        MyInteger b3 = new MyInteger(1000);
        MyInteger b4 = new MyInteger(1000);
        System.out.println(b==b2);
        System.out.println(b3==b4);
        int c=b.intvalue();  }
    public int intvalue(){
        return  value;
    }
}

不清楚为什么会输出两个false

老师这个Compartor接口中不是挺多方法吗 OrderByName类只实现他的一个方法怎么不会报错啊

老师，请问反射机制在接下来什么章节会使用比较多？

1---老师,那个String对象 的synchronized锁的对象是哪个，那个代码块里的对象？

2---还是说只要是相同String对象加锁的代码块就会变成一个顺序执行的队列？不关乎里面的对象？

3---还是说只要是被String对象加锁了，在这个代码块里面的对象，在外部的没有加synchronized锁的方法里也不允许使用？

老师，麻烦回答的仔细点，有点懵圈。

老师为什么，我用视频里的代码总是能正常输出四个线程的结果？即使多输出几次也这样？

——————————————————————

视频中说，数据错乱的原因在于，

B窗口和C窗口判断a>0,成立后，时间片到了，给其他资源。

下次获得时间片后，从断掉的开始执行，才导致出现负数。

问题：

老师，为什么？

b的时间片断后，不是另一个线程从断的地方继续执行。而是下次获得时间片后，由本线程继续从断的地方执行？

之前不是说线程之间共享代码吗？