黑马程序员——13JavaIO输入输出1

------------ android培训 、 java培训 、期待与您交流！------------

 

1，System:类中的方法和属性都是静态的。out：标准输出，默认是控制台。in：标准输入，默认是键盘。
    描述系统的一些信息，获取系统属性信息：Properties getProperties();
        import java.util.*;
        class SystemDemo{
                 public static void main(String[] args){
                         Properties prop=System.getProperties();
         //因为Properties是Hashtable的子类，也就是Map集合的一个子类对象，那么可以通过map的方法取出该集合中的元素。
                         //该集合中存储的都是字符串，没有泛型定义。
                         //在系统中自定义一些特有信息
                         System.setProperty("mykey","myvalue");
                         //获取指定属性信息。
                         String value1=System.getProperty("os.name");
                         System.out.println("value:"+value1);
                         //在jvm启动时，动态加载一些属性信息。
                         String v=System.getProperty("haha");
                         System.out.println("v="+v);
                         //获取所有属性信息。
                         for(Object obj:prop.keySet()){
                                 String value=(String)prop.get(obj);
                                 System.out.println(obj+"===="+value);
                         }
                 }
        }
2，Runtime对象。该类并没有提供构造函数，说明不可以new对象，那么会直接想到该类中的方法都是静态的。
    发现该类中还有非静态方法。说明该类肯定会提供方法获取本类对象，而且该方法是静态的，并返回值类型是本类类型。
     由这个特点可以看出该类使用了单例设计模式完成。
    该方法是static Runtime getRuntime();
        class RuntimeDemo{
                 public static void main(String[] args)throws Exception{
                        //启动记事本。 
                         Process p=Runtime.getRuntime().exec("notepad.exe");
                         Thread.sleep(6000);
                         p.destroy();
                 }
        }
3， 日期时间的表示。
       1）Date类。
         Date d=new Date();
         System.out.println(d);    //打印的时间看不懂，希望有些格式。
         //将模式封装到SimpleDateFormat对象中。
         SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日，E，aahh:mm:ss");
         //调用format方法让模式格式化指定Date对象。
         String time=sdf.format(d);
         System.out.println("本机时间："+time);
       2）Calendar类。
         public static void test(int year) {
         Calendar c=Calendar.getInstance();
         c.set(year,2,1);
         c.add(Calendar.DAY_OF_MONTH,-1);
         System.out.println(year+"年的二月有"+c.get(Calendar.DAY_OF_MONTH)+"天。");
         }
4，Math类。
         double d=Math.ceil(-12.34);      //ceil返回大于指定参数的最小整数。
         double d=Math.floor(12.34);     //floor返回小于指定参数的最大整数。
         int i=Math.round(12.6f);            //round返回四舍五入的int整数。
        double d=Math.pow(2,3.5);       // 返回第一个参数的第二个参数次幂的值。

        double d=Math.random();        // 返回带正号的  double  值，该值大于等于  0.0  且小于  1.0 。

5，IO 流用来处理设备之间的数据传输。 java 对数据的操作是通过 流 的方式。 java 用于操作流的对象都在 IO 包中。
        流按操作数据分为两种： 字节流和字符流 。
        流按流向分为： 输入流和输出流 。
        字节流的抽象基类： InputStream，OutputStream 。
         字符流的抽象基类： Reader，Writer 。
         注意：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
        如： InputStream 的子类 FileInputStream 。 Reader 的子类 FileReader 。
       // 对已有文件的数据续写。
        import java.io.*;
        class FileWriterDemo {
                public static void main(String[] args) {
                        FileWriter fw=null;
                            try {
                                      fw=new FileWriter("Demo.txt",true);    //true,代表不覆盖已有的文件，在已有文件末尾处续写。
                                     fw.write("heiheihei,\r\n俺添加成功了");
                                     fw.close();    //关闭前系统又一次刷新动作flush。
                             }
                             catch (IOException e) {    
                                     System.out.println(e.toString());
                             }
                             //特别注意此处关闭流操作
                             finally {
                                     try{
                                            if(fw!=null)
                                                     fw.close();
                                      }
                                      catch (IOException e) {
                                             System.out.println(e.toString());
                                      }
                            }
                      }

             }

6，读取文件的两种方式：
        1）一个字符一个字符读取。
       //创建一个文件读取流对象，和指定名称的文件相关联。
       FileReader fr=new FileReader("demo.txt");
       //调用读取流对象的read方法， 一次读一个字符，而且会自动往下读。
       int ch=0;
       while((ch=fr.read())!=-1) {
               System.out.print((char)ch);
       }
       fr.close();
2） 定义一个字符数组，用于存储读到字符。
     //该read(char[])返回的是读到的字符个数。
     char[] cbuf=new char[1024];    //1024的整数倍。
  int num=0;
  while((num=fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,num));
  }
  fr.close();

7，复制文件的原理图： 

8， 字符流的缓冲区。缓冲区的出现提高了对数据的读写效率。对应类 BufferedWriter,BufferedReader 。缓冲区要结合流才可以使用，在流的基础上对流的功能进行了增强。
        readLine 方法的原理：每次读一行，获取多个字符，其实最终都是在硬盘上一个一个读取。所以最终使用的还是 read 方法一次读一个的方法。
         // 通过缓冲区复制一个文件
  public static void copy() {
  BufferedWriter bufw=null;
  BufferedReader bufr=null;
  try {
  //创建目的地。
  FileWriter fw=new FileWriter("C:\\Documents and Settings\\Administrator\\桌面\\Demo.java");
  //读取文件。
                         FileReader fr=new FileReader("Demo.java");
  bufw=new BufferedWriter(fw);
  bufr=new BufferedReader(fr);
  String line=null;    //相当于一个数据中转站
  while((line=bufr.readLine())!=null) {
  bufw.write(line);
  bufw.newLine();    //加入换行
  bufw.flush();    //必须刷新
  }
  }
  catch (IOException e) {
  throw new RuntimeException("读写失败");
  }
  finally {    //关闭资源。
  if(bufr!=null)
  try {
  bufr.close();
  }
  catch (IOException e) {
  throw new RuntimeException("读取关闭失败");
  }
  if(bufw!=null)
          try {
  bufw.close();
  }
  catch (IOException e) {
  throw new RuntimeException("写入关闭失败");
  }
  }
  }

9， 装饰设计模式。
           MyReader      //专门用于读取数据的类。
          |--MyMediaReader
           |--MyBufferedTextReader
           |--MyTextReader
          |--MyBufferedMediaReader
          |--MyDataReader
          |--MyBufferedDataReader
    上面这个设计的扩展性很差，找到共同类型。通过多态的形式提高扩展性。
    通过装饰设计模式的优化后的体系结构为：
      MyReader    //专门用于读取数据的类。
       |--MyMediaReader
       |--MyTextReader
       |--MyDataReader
       |--MyBufferedReader
     优点：装饰模式比继承要灵活，避免了继承体系臃肿， 而且降低了类与类之间的关系。
      装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能。 所以装饰类和被装饰类通常是都属于一个体系中的。

10， 带行号的缓冲字符输入流 LineNumberReader 。
           此类定义了方法  setLineNumber(int)  和  getLineNumber() ，它们可分别用于设置和获取当前行号
           FileReader fr=new FileReader("PersonDemo.java");

  LineNumberReader lnr=new LineNumberReader(fr); 

11，字节流。
        1)字节输入流的三种读取方式：第二种最优。
        第一种没有缓冲技术，第二种取1024的整数倍，第三种取文件的大小。
          public static void readFile_3()throws IOException {
          FileInputStream fis=new FileInputStream("fos.txt");
          byte[] buf=new byte[fis.available()];    //定义一个刚刚好的缓冲区，不用在循环了。容易造成内存溢出。
          fis.read(buf);
          System.out.println(new String(buf));
          fis.close();
          }
          public static void readFile_2()throws IOException {
          FileInputStream fis=new FileInputStream("fos.txt");
          byte[] buf=new byte[1024];    //缓冲数组取1024的整数倍，最合理的方案。
          int len=0;
          while((len=fis.read(buf))!=-1) {
          System.out.println(new String(buf,0,len));
          }
          fis.close();
          }
          public static void readFile_1()throws IOException {
          FileInputStream fis=new FileInputStream("fos.txt");
          int ch=0;
          while((ch=fis.read())!=-1) {
          System.out.println((char)ch);
          }
          fis.close();
          }
            2)字节输出流。
          public static void writeFile()throws IOException {
          FileOutputStream fos=new FileOutputStream("fos.txt");
          fos.write("abcdefg".getBytes());    //传入一个bytes数组.
          fos.close();
          }
    12，键盘录入。 
              InputStream in=System.in;    //标准输入设备，即键盘。
            StringBuilder sb=new StringBuilder(); //定义一个缓冲区。
            while(true){
                    int ch=in.read();
                    if(ch=='\r')
                            continue;
                    if(ch=='\n'){
                            String s=sb.toString();
                            if("over".equals(s)) //输入over，结束转换。
                                    break;
                            System.out.println(s.toUpperCase());     //转换成大写字母打印在控制台。
                            sb.delete(0,sb.length()); //每次打印完一行，清空缓冲区。
                    }
                    else
                            sb.append((char)ch);     //往缓冲区加数据。

            }

            
             13，转换流的应用。
                    通过上述的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理， 也就是readLine方法。但 readLine方法是BufferedReader类中的方法， 而键盘录入的read是字节流InputStream的方法。这就需要 将字节流转成字符流，再使用字符流缓冲区的readLine方法。
                //获取键盘录入对象。
InputStream in=System.in;
//将字节流对象转成字符流对象，使用转换流 InputStreamReader
InputStreamReader isr=new InputStreamReader(in);
//为了提高效率，将字符流进行缓冲技术高效操作。
BufferedReader bufr=new BufferedReader(isr);
//BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();     //特别注意一此处需要刷新。
}
bufr.close();
bufw.close();
 
            14，流操作的基本规律。
                    通过两个明确来完成。
                            1，明确源和目的。
                             源：输入流。InputStream Reader
                             目：输出流。OutputStream Writer
                            2，操作的数据是否是纯文本。
                             是：字符流。
                             否：字节流。
                    当体系明确后，在明确要使用那个具体的对象。
                 通过设备来进行区分：
                         源设备：内存，硬盘，键盘。
                         目设备：内存，硬盘，控制台。
             
            15，打印流PrintStream。
                    1）用作异常信息的管理。
                  catch (Exception e) {
try {
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");
String s=sdf.format(d);
                                //PrintStream流具有自动刷新的功能，且方法println()可以换行。 
PrintStream ps=new PrintStream("exception.log");
ps.println(s);
System.setOut(ps);     // 重新分配“标准”输出流。
}
catch (IOException ex) {
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
                }
                  2）系统属性信息。
            //Properties  类表示了一个持久的属性集。 Properties  可保存在流中或从流中加载。  
                     Properties prop=System.getProperties();
                    // 将属性列表输出到指定的输出流。
                     prop.list(new PrintStream("sysinfo.txt"));  

 

------------ android培训 、 java培训 、期待与您交流！------------

 

详情请查看：http://edu.csdn.net/heima