在9:30秒那里，为什么不直接弄一个8192大小的FileInputStream呢？

/**
 * 测试if单分支
 */






public class TestIf01 {

    public static void main(String[] args){

        double i=(int)(Math.random()*6)+1;
        double j=(int)(Math.random()*6)+1;
        double k=(int)(Math.random()*6)+1;
        int count=i+j+k;
        System.out.println("第一次投骰子："+i);
        System.out.println("第二次投骰子："+j);
        System.out.println("第三次投骰子："+k);
        if(count>15){
            System.out.println("运气不错！再来一把！");
        }
       if(count>=10&&count<15){
           System.out.println("手气一般");
       }
       if(count<10){
           System.out.println("手气不行，回家吧");
       }
        System.out.println("今天得分"+count);


    }








}

老师，为什么在程序运行后，能够正常运行，但总是出现异常呢？我根据老师的源码检查了多次，没有发现哪里有问题啊？

package cn.sxt.game;

import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JFrame;

/**
 * 容器和数组产生多发炮弹
 * @author Administrator
 *
 */
public class MyGameFrame extends Frame{
	
	Image planeImg = GameUtil.getImage("images/plane.png");
	Image bg = GameUtil.getImage("images/bg.jpg");
	//创建飞机的对象，并调用Plane
	Plane plane = new Plane(planeImg,250,250);
	//创建炮弹的对象，并调用Shell
	Shell[] shells = new Shell[50];
	
	
	@Override
	public void paint(Graphics g) {//自动被调用。g变量相当于画笔
		
		g.drawImage(bg, 0, 0, null);
		plane.drawSelf(g);//画飞机
		
		//画50个炮弹
		for(int i = 0;i<shells.length;i++) {
			shells[i].draw(g);
			
			//飞机和炮弹的碰撞检测
			boolean peng = shells[i].getRect().intersects(plane.getRect());
			
			if(peng) {
				plane.live = false;
			}
		}
	}
	
	//定义一个内部类并继承线程
	class PaintThread extends Thread{
		
		@Override
		public void run() {
			while(true) {
				repaint();//重画窗口
			
			
				try {
					Thread.sleep(40);//1秒等于1000毫秒
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			
			}	
		}
	}
	
	//定义键盘监听的内部类，并继承KeyAdapter
	class KeyMonitor extends KeyAdapter{

		@Override
		//按一下键，会获得那些信息
		public void keyPressed(KeyEvent e) {
			plane.addDirection(e);//调用Plane中的按下方法
		}

		@Override
		//释放按键，会获得哪些信息
		public void keyReleased(KeyEvent e) {
			plane.minusDirection(e);
		}
	
	}
	
	
	/**
	 * 初始化窗口
	 */
	public void launchFrame() {
		this.setTitle("2D经典");//窗口名称
		this.setVisible(true);
		this.setSize(Constant.GAME_WIDTH, Constant.GAME_HEIGHT);//设置窗口大小
		this.setLocation(300, 300);//设置窗口位置
		
		//定义窗口关闭程序
		this.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);//表示直接关闭
			}
		});
		
		new PaintThread().start();//启动重化窗口的线程
		addKeyListener(new KeyMonitor());//给窗口增加键盘的监听	
		
		//初始化50个炮弹
		for(int i = 0;i<shells.length;i++) {
			shells[i] = new Shell();
		}
	
	
	}
	
	public static void main(String[] args) {
		MyGameFrame f = new MyGameFrame();
		f.launchFrame();
	}
	
	private Image offScreenImage = null;
	
	public void update(Graphics g) {
		if(offScreenImage == null)
			offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT);//窗口的宽度和高度
		
		Graphics gOff = offScreenImage.getGraphics();
		paint(gOff);
		g.drawImage(offScreenImage, 0, 0, null);
	}
}

	

说句玩笑话，关于ThreadLocal 分析的视频是认真做的吗？

1. 关于set方法和get方法的顺序问题，视频先介绍的set方法

   

   视屏并未说明为何3个ThreadLocalMap中的Number为何不是同一个对象？因为我们要保证的ThreadLocalMap 键值对对象中的value值为不同的？实际上传入的value对象才是关键吧。

   此set方法只是展示了：将value设置到自己线程的ThreadLocalMap键值对中，其中key为线程对象本身，值为value对象；但是并不能判断对象（图示中的number为不同的对象）

    

2.实际上set方法之所以设置的value为不同的对象，是因为get方法,

视频中分析的get方法通过线程对象得到value 而get方法源码为：

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

正是由于第一次执行get方法时，ThreadLocalMap map = getMap(t);中map为null

所以执行 return setInitialValue();其中setInitialValue()方法源码为：

private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

是因为第一次执行setInitialValue()方法时，返回的是执行 ，T value = initialValue();中value的值

而 initialValue()方法是我们自己实现的；

也就是说，每个ThreadLocalMap键值对的值的初始值（对象），都是通过initialValue()方法新创建不同对象。因为是不同的对象，但是状态相同，所以才有每个副本的值相同吧.

所以视频的源码分析是故意没讲完全？

maven的结构完全不讲清楚，我该怎么创建呢？

老师好，MySQL和Oracle都要安装吗，还是只安装一个就可以了？

子查询和内连接的效率哪个更高呢？在开发的过程中用哪一个会更好一点？

老师日志输出总是有乱码。我百度设置了一下也不行

也是启动时报这个错误  Starting rabbitmq-server: FAILED - check /var/log/rabbitmq/startup_{log, _err}
rabbitmq-server.

删除/var/lib/rabbitmq/mnesia 目录下的 rabbit@localhost.pid、rabbit@localhost、rabbit@localhost-plugins-expand 但我进去这个目录里面是空的  而且也不好找到解决方法 请问可以帮忙解决一下吗  目前在尚学堂北京总部

这段代码错误在哪里。。。。。。。。。。。。。。。。。。。。。。。。。

write函数往文件里追加写入数据时，会自动换行，如何让他不自动换行

老师这个shiro是什么时候走的controller层

老师，结合之前电话本儿项目的验证功能做了一些调整， 能跑通 还请老师指点下代码设计上有没有啥毛病

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

class SendMsg extends Thread{
    private Socket socket;
    public SendMsg(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }
    private void sendMsg(){
        try(PrintWriter pw=new PrintWriter(this.socket.getOutputStream());
            Scanner scanner=new Scanner(System.in)) {
            while(true){
                String msgSengding=scanner.nextLine();
                pw.println(msgSengding);
                pw.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class ReceiveMsg extends Thread{
    private Socket socket;
    public ReceiveMsg(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
        this.receiveMsg();
    }
    private void receiveMsg(){
        try (BufferedReader br=new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){
            String msgReceive=br.readLine();
            System.out.println(msgReceive);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class Regex {
    public Regex() {
    }
    public int orderValidate(){
        String regex="[1-2]{1}";
        Scanner scanner=new Scanner(System.in);
        while (true){
            System.out.println("请输入启动类型（数字1或2）");
            System.out.println("1.启动服务端\t2.启动客户端");
            String order=scanner.nextLine();
            if (order.matches(regex)){
                if ("1".equals(order)){
                    System.out.println("准备启动服务端...");
                }else{
                    System.out.println("准备启动客户端...");
                }
                return Integer.parseInt(order);
            }else {
                System.out.println("输入有误，请重试");
                System.out.println();
            }
        }
    }
}
public class GoodTcp {
    public static void main(String[] args) {
        Regex regex=new Regex();
        int order=regex.orderValidate();
        if (order==1){
            try(ServerSocket serverSocket=new ServerSocket(8888)) {
                System.out.println("服务端启动成功，正在监听端口8888");
                Socket socket=serverSocket.accept();
                System.out.println("已成功建立连接");
                new SendMsg(socket).start();
                new Receive(socket).start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else{
            try{
                Socket socket=new Socket(InetAddress.getLocalHost().getHostAddress(),8888);
                System.out.println("已建立连接");
                new SendMsg(socket).start();
                new Receive(socket).start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
}