黑马程序员之java学习笔记15

字符流：

1.       一个字节8bit，一个字符（character）16bit.

2.       字节流对应的是inputStream,outputStream抽象类，字符流对应的是W riter,Reader抽象类。字符流和字节流处理的方式相似，就是处理的对象不一样。

3.       InputStreamReader是 Reader抽象类的具体实现类，一个InputStreamReader是一个从字    节流通向字符流的桥梁。使用InputStreamReader是对inputStream的封装，可以直接操作字符串，读入程序或内存。它的两个构造方法是：InputStreamReader(InputStream is);InputStreamReader(InputStream is,String EncodingStyle);

4.       OutputStreamWriter是Writer抽象类的具体实现类，一个OutputStreamWriter是一个从字符流通向字节流的桥梁。使用OutputStreamWriter是对OutputStream的封装，就直接操作字符串，写入文件。OnputStreamWriter(OutputStream os);OutputStreamReader(OutputStream os,String EncodingStyle);

5.       InputStreamReader和OutputStreamWriter具体实现：

FileOutputStream fos = new FileOutputStream(“c:aaa.txt”);

OutputStreamWriter osw = new OutputStreamWriter(fos);

BufferWriter bw = new BufferWriter(osw);

String str = “abcdefg”;

bw.write(str);//将字符串写入bw流中，最后到文件中。

bw.close;

FileInputStream fis = new FileInputStream(“c:aaa.txt”);

InputStreamReader isr = new InputStreamReader(fis);

BufferReader br = new BufferReader(isr);

//System.out.println(br.readline());

String str2 = br.readline();//BufferReader的readline()方法是每次读文本中一行，当返回null,表示读到了文本的末尾。

While(null!=str2){

System.out.println(str2);

Str2= br.readline();

}

br.close();

 

6.       如何从标准的输入设备中读取字符串内容，使InputStreamReader对 System.in(是一个标准的输入流)进行封装，然后进行读取操作：

InputStreamReader isr = new InputStreamReader(System.in);

BufferReader  br= new BufferReader(isr);

String str;

While(null!=str=br.readline()){

System.out.println(str);

}

br.close();

 

7.       FileReader是Reader抽象类的一个子类，实现对文件读取字符串的操作。它的构造方法是：FileReader(String pathName); FileReader(File file);

8.       FileWriter是向指定文件中写入东西，操作的是字符或字符数组。三种构造方法：FileWriter(String pathname);FileWriter(File file);FileWriter(String pathname, Boolean append);

关键代码如下：

String s = “abcdefg”;

Char[] buffer = new Char[s.length];

s.getChars(0, s.length, buffer,0);//将字符串s中的内容从下标0开始拷贝到字符数组buffer中，字符数组也是从下标0开始。

FileWriter fw = new FileWriter(“file.txt”);

For(int i =0; i<buffer.length;i++){

 fw.write(buffer[i]);

}

fw.close();

9.       线程：

1）  线程是在程序内单独顺序执行的控制流，只能使用分配给程序的资源和环境。

2）  进程，本质来说就是执行中的程序，换句话说，一个程序运行起来就会产生一个进程。

3）  多线程:单个程序中可以同时运行多个不同线程来执行不同的任务。多线程的目的是最大限度地利用CPU。

4）  线程和进程之间的区别：A. 多个进程之间的数据和状态是相互独立;而多个线程之间是共享同一块内存空间和系统资源，是可能相互影响的。B.线程之间的切换会比进程之间的切换负担要小，速度要块。

5）  单线程：当程序运行时，就会自动产生一个线程。主方法Main就在这个主线程中运行。程序都是由线程来执行的。

6）  实现线程的两种方式：(当该类已经继承了一个类时，使用B方式)

A． 继承Thread类，并重写run方法。

class thread1 extends Thread{

public void run(){

for(int i=0; i<50;i++){

   System.out.println(i);}

             }  }

          public class ThreadTest{

             public static void main(String[] args){

                Thread1 th1= new Thread1();

                th1.start();}}

B． 通过实现Runnable接口，进而实现run方法。

class Thread2  implements Runnable{

public void run(){

for(int i=0; i<50;i++){

         System.out.println(i);}

             }  }

   public class ThreadTest{

        public static void main(String[] args){

            Thread2 th1= new Thread(new Runnable() ); //Runnable接口中没有start()方法，要调用Thread2类中的run方法，须得借用父类Thread中的start()方法。所以将一个实现了Runnable接口对象作为参数传入给Thread类的构造方法。

                th1.start();}}

 

 

7)  线程调用的过程：通过调用线程的start方法，让线程启动，并为线程分配相应的系统的资源，然后再调用run方法。

   8) 线程只能调用一次;一旦执行完了，就不能再被调用了。线程一旦启动，就不受控了。9) Thread类也实现Runnable接口，因此也必须实现Runnable接口中的run方法。

  10)线程名问题：当没有特别指定线程的名称，调用getName()方法那么线程名称是以Thread-0,Thread-1…这样的默认方式命名。当在线程的构造方法中Thread(String name)通过name指定线程名称，那么线程名称就不会以默认的方式指定而会以自己指定的name作为线程的名称。如:Thread t1 =new Thread(“hello”); System.out.println(t1.getName()).将会得到hello。

11) 线程的消亡不能通过调用stop()方式来令其消亡，而应让run()方法执行完，就自行消亡；

或是自己编写代码，让线程停止。

   如：class thread1 extends Thread{

         Private Boolean flag=ture;

         Private int I =0;

public void run(){

   while(flag){

              System.out.println(i++);}

                     }  }

                   Public void setFlag(Boolean flag){

                     This.flag =flag;

                 public class ThreadTest{

                    public static void main(String[] args){

                    Thread1 th1= new Thread1();

th1.start();

th1.setFlag(false);

}}

12) 一个线程的生命周期：创建状态new Thread()，可执行状态(runnable)，执行状态(running),阻塞状态(blocked)，消亡状态(dead)。

13)线程由执行状态到阻塞状态的原因：

a.要执行I/O操作

b. 线程调用了yield()方法，让出了CPU的使用权。

c. 线程调用了wait()方法，让线程休息。

d.线程调用了静态方法sleep()，让线程进入睡眠状态。

e.一个拥有更高优先权的线程的出现。

f .线程时间片用完

 14) 线程优先级问题：优先级，是用数字1-10表示，数字越大，优先级越高。每一个线程都有一个默认的优先级，用数字5表示。线程创建后，可以通过setPriority()改变线程的优先级。不能依靠线程的优先级来决定线程执行的顺序。

 15) 线程类中的成员变量和局部变量问题：

     A．多个线程对象访问成员变量i时，结果是相互影响的。也就是说一个线程对成员变量改变会影响到其它线程。

     B. 多个线程对象访问局部变量i时，结果相互独立。因为每一个run方法中都会有一个自己局部变量。线程每调用一次run方法，就会访问一次自己的局部变量。

     publicclass MultiThreadFieldvsVariable {

   

     publicstaticvoid main(String[] args){

       

        Runnable r = new MyThread();

       

        Thread t1 = new Thread(r);

       

        //r= new MyThread();

       

        Thread t2 = new Thread(r);

       

        t1.start();

       

        t2.start();

       

       

    }

   

 

}

 

class MyThread implements Runnable{

   

    privateinti;

   

    publicvoid run(){

       

        for(i =0; i<20; i++){

           

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

           

            System.out.println("hi : "+i);

        }

    }

}