老师，我想问一下，这个主机和客户端难道不是指的同一台电脑吗，为什么它们的IP不一样：

老师请问，我看到下面有老师对其他同学的回答"使用字符流操作文件时，当写入文件时，一定要关闭或者清空缓存，因为字符串还在缓存区中"。请问这里的清空缓存是指while循环中的bw.flush()吗？

另外我试了下删掉这句话，程序运行结果没有影响。请问加入数据量很大的话，如果不flush是不是才会出现缓存用尽新的数据读不进来的现象？

谢谢！

老师你好

问题：o和p为我自定义缓存范围外的值，o=300，p=300，o==p  返回为false，按说 o.equals(p)  应该返回的为true啊，但我实际的运行结果是 o.equals(p) 的结果也为false，这是什么原因了？ 代码如下：

package com.bjsxt.test;

public class MyInteger {

    private int value;
    private static MyInteger[] cache = new MyInteger[256];

    public static final int LOW = -128;
    public static final int HIGH = 127;

    static{
        //[-128,127]
        for(int i=LOW;i<=HIGH;i++){
            //-128,0;-127,1;-126,2;~~~
            cache[i+128] = new MyInteger(i);
        }
    }


    public static MyInteger valueOf(int i){
        if(i>=LOW&&i<=HIGH){
            return cache[i+128];
        }
        return new MyInteger(i);
    }

private MyInteger(int i){
        this.value = i;
}

    @Override
    public String toString() {
        return this.value+"";
    }
    //MyInteger类对象转化为基本数据类型
    private int intValue() {
        return value;
    }


    public static void main(String[] args) {
        MyInteger m =MyInteger.valueOf(-128);
        MyInteger n =MyInteger.valueOf(-128);
        MyInteger o =MyInteger.valueOf(300);
        MyInteger p =MyInteger.valueOf(300);
        int a = m.intValue();
        int b = n.intValue();
        System.out.println(o.equals(p));
        System.out.println(o==p);
        System.out.println(m.equals(n));
        System.out.println(m==n);
        System.out.println(a==b);
    }
}

老师，我想问一下通信方法前面的super写了有什么用呢，我不写也可以正常运行，结果也是一样的

InputStream  是一个抽象类，为什么这里可以调用read()方法呢？？

老师，我这个为啥会报错呢，写数据和读数据顺序都是对应的呀

代码：

import java.io.*;
import java.util.Date;

/**
 * @author LLLYF
 *
 */
public class Test3 {
    public static void main(String[] args) throws IOException {
        //write();
          read();

    }
    //读取数据的方法
    public static void read() throws IOException {
        //（1）数据源
        FileInputStream fis=new FileInputStream("E:\\date.txt");
        //(2)提高读取效率
        BufferedInputStream bis=new BufferedInputStream(fis);
        //(3)处理java的基本数据类型和字符串
        DataInputStream dis=new DataInputStream(bis);
        //(4)读数据--（读数据的顺序要与写数据的顺序完全一致）
        System.out.println(dis.readInt());
        System.out.println(dis.readDouble());
        System.out.println(dis.readBoolean());
        System.out.println(dis.readChar());
        System.out.println(dis.readUTF());
        //关闭
        dis.close();
    }
    public static void write() throws IOException {
        //(1)目的地
        FileOutputStream fos=new FileOutputStream("E:\\date.txt");
        //(2)缓冲流提高写入效率
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //(3)数据流，增加对java基本数据类型和String的处理
        DataOutputStream dos=new DataOutputStream(bos);
        //(4)写入数据
        dos.writeInt(98);
        dos.writeDouble(98.5);
        dos.writeBoolean(true);
        dos.writeChar('a');
        dos.writeUTF("helloworld");
        //(5)关闭流
        if(dos!=null){
                    dos.close();
        }
    }

}

运行结果：

老师，我想问一下，我把解决线程安全性的方法在卖票的程序中试了一下为什么不行啊，还是会出现数据错乱的问题：

因为join()方法是停止一个线程而运行另一个线程，这个程序主要是只运行Ticket线程，所以这个方法在这儿不适用，但是另外两个方法的运行结果是这样的：

这是什么原因呢

老师，我想问一下：

    这是我自定义线程里的run方法：

    如果我主线程的for循环里的输出语句中线程名字后面不加i，输出结果的顺序不论试几遍都一直不变

    输出结果就一直是这样的：

但是如果我在主线程的for循环中输出时在线程名字后加一个i,顺序就会变成随机的：

这是怎么回事呢？

老师，在short type=childNode.getNodeType()中，节点的类型怎么都 是short类型呢，而且type的值怎么又是1呢？

老师Collection接口中的hasCode方法是干嘛的，是不是返回集合中数据的哈希码值

老师，我想问一下是代理角色对象创建后线程才处于新生状态还是真实角色创建后线程就处于新生状态，真实角色是线程类吗？

问题：为什么便利的顺序是world、java、hello，不是hello、world、java

代码：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

/**
 * @author LLLYF
 */
public class Test3 {
    public static void main(String[] args) {
        ArrayList<String> al =new ArrayList<String>();
        al.add("hello");
        al.add("world");
        al.add("java");

        Iterator<String> ite = al.iterator();
        while (ite.hasNext()){
            System.out.println(ite.next());
        }
        HashSet<Integer> hs=new HashSet<Integer>();
        hs.add(123);
        hs.add(345);
        hs.add(456);
        Iterator<Integer> ite2=hs.iterator();
        while (ite2.hasNext()){
            System.out.println(ite2.next());
        }

    }
}

结果：

老师，我想问一下通过继承Thread类来实现多线程有什么优点和缺点，通过实现Runnable接口来实现多线程有什么优点和缺点，还有静态代理模式和设计IO流技术的设计模式之间有什么联系吗？

老师视频里面讲，数据存储和删除数据的效率非常低，是需要干什么？声音听的不是清楚