黑马程序员_毕向东_Java基础视频教程第十八天-IO流---学习笔记

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

一、其他对象(System)：类中的方法和属性都是静态的。

1、out：标准输出，默认是控制台
1、in：标准输入，默认是键盘
描述系统一些信息。
获取系统属性信息：Properties getProperties();

1. import java.util.*;  
2. class Demo{  
3.     public static void main(String args[]) throws Exception{  
4.         Properties prop = System.getProperties();  
5.         //因为Properties是Hashtable的子类，也就是Map集合的一个类的对象。   
6.         //那么可以通过Map的方法获取出该集合中的元素。   
7.         //该集合中存储都是字符串，没有泛型定义   
8.           
9.         //如何在系统中自定义一些特有信息呢？   
10.         System.setProperty("mykey","myvalue");  
11.           
12.         //可不可以在jvm启动时，动态加载一些属性信息呢   
13.         //命令行   java -Dhaha=qqqq 类   
14.           
15.         //获取指定属性信息   
16.         String value2 = System.getProperty("os.name");  
17.         System.out.println("value="+value2);  
18.         //获取所有属性信息。   
19.         for(Object obj : prop.keySet()){  
20.             String value = (String)prop.get(obj);  
21.             System.out.println(obj+"::"+value);  
22.         }  
23.     }  
24. }  

二、Runtime对象
Runtime对象
该类并没有提供构造函数，
说明不可以new对象。那么会直接想发到该类中的方法都是静态的
但是，该类中还有非静态方法。
说明该类肯定会提供了方法获取本类的对象。而且该方法是静态的，并且返回类型是本类类型。
该方式是 static Runtime getRuntime();
Process p = r.exec("winmine.exe");
p.destroy();
r.exec("notepad.exe **.txt");

 

三Date对象和Calendar对象

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class DateDemo {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
     Date d=new Date();
     System.out.println(d);
     SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 E hh:mm:ss");
     //其中E被本地化，E直接是表示了星期几。
  
     System.out.println(sdf.format(d));
  
     Calendar c= Calendar.getInstance();//也即这个类仅仅维护一个实例对象，单身模式的意思是，一个类保持始终是一个对象，外界调用无法自己另行通过构造器实例新对象。

    
     String mon[]={"一月","二月","三月","四月","五月","六月","七月","八月",
       "九月","十月","十一月","十二月",};//查表法
    
     String weeks[]={"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
   int index=c.get(Calendar.MONTH);
   int index1=c.get(Calendar.DAY_OF_WEEK);
     sop(c.get(Calendar.YEAR));
     sop(mon[index]);
     sop(c.get(Calendar.DAY_OF_MONTH));
     sop(weeks[index1]);
 }
   public static void sop(Object obj)
   {
    System.out.println(obj);
   }
}

四、其他对象(Math-Random)
 double d=Math.ceil(12.33);//ceil返回大于指定数据的最小整数。
   double d1=Math.floor(12.33);
   double d2=Math.round(12.33);//四色五入
   double d3=Math.random();//大于0.0小于1.0
   sop(d);
   sop(d1);
   sop(d2);
   sop(d3);
   Random r=new Random();
   for(int i=0;i<10;i++)
   {
    int n=r.nextInt(10)+1;
    sop(n);
   }

五、IO流(概述)  Input Output
1、IO流用来处理设备之间的数据传输
2、Java对数据的操作是通过流的方式
3、Java用于操作流的对象都在IO包中
4、流按操作数据分为两种：字节流与字符流
5、流按流向分为：输入流，输出流
6、字节流的抽象基类
InputStrea,OutputStream
7、字符流的抽象基类
Reader,Writer
8、注：由这四个类派生出来的子类名称都是以其父类名作为子类明的后缀
(1)、InputStream的子类FileInputStream
(2)、Readerde 子类 FileReader

六、IO流(FileWriter)
1、用于操作文件的Writer子类对象，FileWriter。后缀名是父类名，前缀名是该流对象的功能

1. import java.io.*;  
2. class Demo{  
3.     public static void main(String args[]) throws Exception{  
4.         //创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件   
5.         //而且该文件会被创建到指定目录下，如果该目录下已有同名的文件，将被覆盖。   
6.         //其实该步就是明确数据要存放的目的地   
7.         FileWriter fw = new FileWriter("Demo.txt");  
8.         //调用writer方法，将字符串写入到流中，会产生异常   
9.         fw.write("abc");  
10.         //刷新该流的缓冲。将数据刷新到文件中   
11.         fw.write("def");  
12.         fw.flush();  
13.         //关闭刘子源，但是关闭之前会刷新一次内部的缓冲的数据。，将数据刷到目的地中，和flush区别，flush(),刷新后，流可以继续使用，close刷新后，会将流关闭。   
14.         //操作完，必须关闭   
15.         fw.close();  
16.     }  
17.     public static void sop(Object obj){  
18.         System.out.println(obj.toString());  
19.     }  

七、IO异常处理方式和文件的续写

FileWriter(String fileName) 
          根据给定的文件名构造一个 FileWriter 对象。 
FileWriter(String fileName, boolean append) 
          根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。 
windows中，换行是 \r\n
linux 是\n

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {

 public static void main(String[] args)  {
  // TODO Auto-generated method stub
  
     FileWriter fw=null;
     try{
     fw=new FileWriter("g:/java/java基础1/demo.txt",true);//为true表示不覆盖已有文件，并且续写
     
     fw.write("adadaaa");
     }catch(IOException e)
     {
      System.out.println(e);
     }
     finally{
      try{
       if(fw!=null)//文件存在时才关闭
       fw.close();
      }catch(IOException e)
         {
          System.out.println(e);
         }
     }
  
    
 }

}

九、IO流——文本文件读取方式一
 int read()  读取单个字符。 

1. import java.io.*;  
2. class Demo{  
3.     public static void main(String args[]) throws Exception{  
4.         //创建一个文件读取流对象，和指定名称的文件相关联。   
5.         //要保证该文件是已经存在的，如果不存在，会发生异常 FileNotFoundException   
6.         FileReader fr = new FileReader("Demo.txt");  
7.         //read()方法，读取一个字符，每次读一个，并且会接着上一个往下读，若达到末尾，则返回-1   
8.         int ch = 0;  
9.         while( (ch=fr.read())!=-1){  
10.             System.out.print((char)ch);  
11.         }  
12.     }  
13. }  

 

文本文件读取方式二
int read(char[] cbuf) 将字符读入数组。

1. import java.io.*;  
2. class Demo{  
3.     public static void main(String args[]) throws Exception{  
4.         FileReader fr = new FileReader("Demo.txt");  
5.         //定义一个字符串数组，用于存储到的字符   
6.         //该 read(char[])返回的是读到的字符个数   
7.         char[] buf = new char[1024];  
8.         int num = 0;  
9.         while((num = fr.read(buf))!=-1){  
10.             System.out.println(num+"..."+new String(buf,0,num));  
11.         }  
12.     }  
13. }  

十、IO流(文本文件读取练习)
//读取一个java文件，并打印

1. import java.io.*;  
2. class Demo{  
3.     public static void main(String args[]) throws Exception{  
4.         FileReader fr = new FileReader("Demo.java");  
5.         //定义一个字符串数组，用于存储到的字符   
6.         //该 read(char[])返回的是读到的字符个数   
7.         char[] buf = new char[50];  
8.         int num = 0;  
9.         while((num = fr.read(buf))!=-1){  
10.         //不可以换行   
11.             System.out.print(num+"..."+new String(buf,0,num));  
12.         }  
13.     }  
14. }  

十一IO流(拷贝文本文件)
复制的原理，其实就是将一个文件的数据存储到另一个文件中
//复制文件

1.   
2. import java.io.*;  
3. class Demo{  
4.     public static void main(String args[]) throws Exception{  
5.         copy_2();  
6.           
7.     }  
8.     public static void copy_1() throws Exception{  
9.         //创建目的地   
10.         FileWriter fw = new FileWriter("Demo_copy.java");  
11.         //与已有文件关联   
12.         FileReader fr = new FileReader("Demo.java");  
13.         int ch = 0;  
14.         while((ch = fr.read())!=-1){  
15.             fw.write(ch);  
16.         }  
17.         fw.close();  
18.         fr.close();  
19.     }  
20.     public static void copy_2() throws IOException{  
21.         //创建目的地   
22.         FileWriter fw = null;  
23.         //与已有文件关联   
24.         FileReader fr = null;  
25.         try{  
26.             fw = new FileWriter("Demo_copy.java");  
27.             fr = new FileReader("Demo.java");  
28.             char[] buf = new char[1024];  
29.             int len = 0;  
30.             while((len=fr.read(buf))!=-1){  
31.                 fw.write(buf,0,len);  
32.             }  
33.         }catch(IOException e){  
34.             throw new RuntimeException("读写失败");  
35.         }finally{  
36.             if(fr!=null)  
37.                 try{  
38.                     fr.close();  
39.                 }catch(IOException e){  
40.                       
41.                 }  
42.             if(fw!=null)  
43.                 try{  
44.                     fw.close();  
45.                 }catch(IOException e){  
46.                       
47.                 }  
48.         }  
49.     }  
50. }

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima