java io与线程

1.io流
一、字节流
输入流InputStream,输出流OutputStream，这两个是抽象里，分别包括read(byte[] b,int off,int len)和write(byte[] b,int off,int len)
文件流FileInputStream,FileOutputStream，这个类分别是上面两个类的子类。分别用来从文件中读入和写入数据；
//文件输入流
File fromfile=new File("D:/file/from.txt");//定义一个文件对象
FileInputStream fis=new FileInputStream(fromfile);//定义一个文件输入流对象
byte[] buffer=new byte[1024];//定义byte数组，该数组用来存放从文件中读取的数据；
int temp=fis.read(buffer,0,buffer.length);//执行完读功能后，该buffer数组里有就内容了。
(疑惑：调用这个read方法，传入一个数组对象，然后在这个调用方法中给数组对象赋值，神奇的是在这个调用对象的数据中居然有值了。经过测试，数组对象确认可以这样用，但是不太理解？)


//文件输出流
File tofile=new File("D:/file/to.txt");
FileOutputStream fos=new FileOutputStream(tofile);
fos.write(buffer,0,temp);


二、字符流
输入流Reader,<---FileReader, int read(char[] c,int off,int len);
输出流Writer,<---FileWriter, int write(char[] c,int off,int len);
使用方法同字节流相似，不同的是读写的是char类型的字符数组；
三、处理流
BufferReader装饰字符流，其中的BufferReader.readLine()用于按行读取(一行一行的读取),他的构造函数new BufferReader(FileReader对象);
2、内部类，匿名内部类 
内部类：指的是在一个类的内部声明的类，这个内部类可以使用它所在内的成员变量和成员函数，但是并不用拥有它们，这是因为在使用内部类的对象的时候，并需先定义所在类的对象，在这个类的对象中再生成这个内容类的对象。
比如类A的内部类B，如果要使用这个内部类的对象，需要这样写new A().new B();
匿名内部类:指的是在一个类中使用一个内部类的对象，但是这个内部类没有名字，通过这个内容类都是指实现一个接口或者抽象类，然后在这个内部类直接实现或复写这个接口或抽象类的方法
public interface A{
public void funA();
}
public class B{ 
public void funB(A a)
{
a.funA();
};
}
public class Test{
    public static void main(String args[])
    {
B b=new B();
b.funB(new A(){
public void funA(){...}
});
//new A(){ public void funA(){...} }生成了一个A的对象，并实现了接口A的方法，这个B中执行的funA就是这段代码块中的实现方法；
    } 
}
3.线程
方法一：
线程类Thread,这个线程类中有一些线程相关的处理方法，重要的是run(),我们需要声明一个类去继承Thread，并复写run(),这个run()里面就是我们要放在线程中处理的事情。注意启动一个线程是调用start()，不然直接调用这个类的run()方法，并没有新开一个线程，而是仍然运行在主线程中。
1.声明一个线程类继承Thread,复写run()；
2.在需要使用线程的地方，生成该线程类的对象，使用该线程类的对象的start()，启动一个新线程。
注意：启动一个线程后，并没有立即执行，因为计算机的cpu同一时刻只能处理一条线程，计算机中有许多线程，他们都在争抢CPU，当一个线程抢到CPU，其他线程都是出于等待状态，所以线程之前其实是交替执行的，而并不是同时执行，只是这个交替执行非常快，感觉好像是同时执行一样。
class MyThread extends Thread{
public void run(){
dosomething...
}
}
class Test{
public static void main(String args[]){ 
MyThread thread=new MyThread();
thread.start();
}
} 
方法二
1.实现Runable接口，并实现这个接口中的run()方法。这个run()中写你要处理的事情
2.在要使用的地方，先生成一个Runable实现类的对象
3.然后生成一个Thread对象，在这个Thread对象的构造函数中传入Runable实现类的对象，调用该线程的start()方法；
class RunableImpl implements Runable{
public void run(){
dosomething...
}
}
class Test{
public static void main(String args[]){
RunableImpl impl=new RunableImpl();
Thread thread=new Thread(impl);
thread.start();
}
}
Thread.sleep()线程阻塞，在sleep()之后出于就绪状态，重新争夺CPU时间执行；
Thread.yield()，让出cpu时间，然后重新一起争夺CPU。
Thread.setProority()Thread.getProority()设置或获取线程的优先级，但是并不是线程优先级越高就一定会先执行。只是执行的概率大。最小值1，最大值10；
4.线程同步
当多个线程对象调用一个同一个run()方法时候，容易出现错误，这就需要使用线程同步synchronized，用这个锁住run方法内的执行提，让一个线程执行完这个方法体，另一个才可能执行。
class RunableImpl implements Runable{
public void run(){
synchronized(this){
dosomething...
}
}
}