一、控制台的输入

读取控制台的输入,首选方式为字符流。

   
   
   
   
  1. BufferedReader(Reader inputReader) 
  2. ↓↓ 
  3. InputStreamReader(InputStream inputStream) 
  4. ↓↓ 
  5. new BufferedReader(new InputStreamReader(System.in)) 

1.读取字符

从BuffererdReader读取字符,用read()方法

该方法每次执行都从输入流获取一个字符,以整型返回

下面例子表示了从控制台输入一个字符,然后从控制台输出

   
   
   
   
  1. public static void main(String[] args) { 
  2.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
  3.         try { 
  4.             System.out.println((char) br.read()); 
  5.         } catch (IOException e) { 
  6.             // TODO Auto-generated catch block 
  7.             e.printStackTrace(); 
  8.         } 
  9.     } 

2.读取字符串

从BufferedReader读取字符串,用readLine()方法,该方法返回一个String对象

   
   
   
   
  1. public static void main(String[] args) { 
  2.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
  3.         try { 
  4.             System.out.println(br.readLine()); 
  5.         } catch (IOException e) { 
  6.             // TODO Auto-generated catch block 
  7.             e.printStackTrace(); 
  8.         } 
  9.     } 

 


二、控制台输出

   
   
   
   
  1. void write(int byteval) 

write不常用,常用的为print和println


三、PrintWriter

 尽管Java 允许用System.out向控制台写数据,但建议仅用在调试程序时或在例题中,这

在本书中得到充分体现。对于实际的程序,Java 推荐的向控制台写数据的方法是用

PrintWriter流。

PrintWriter定义了多个构造函数,我们所用到的一个如下:

   
   
   
   
  1. //flushOnNewline 控制Java是否在println方法被调用时刷新输出流 
  2. PrintWriter(OutputStream outputStream, boolean flushOnNewline)  

 写个例子看下:

   
   
   
   
  1. public static void main(String[] args) { 
  2.         PrintWriter pw=new PrintWriter(System.out, true); 
  3.         pw.println("1231"); 
  4.         pw.println(true); 
  5.         pw.println(123123); 
  6.     } 

 


四、文件的读写

在Java中,所有的文件都是字节形式。

两个最常用的流类:FileInputStream 和 FileOutputStream

   
   
   
   
  1. FileInputStream(String fileName) throws FileNotFoundException  
  2. FileOutputStream(String fileName) throws FileNotFoundException  

filename是文件名  当创建了对象而文件不存在时 抛出异常

当文件操作结束之后要调用close()关闭文件

   
   
   
   
  1. void close( ) throws IOException 

读文件,可以使用在FileInputStream中定义的read( ) 方法

   
   
   
   
  1. int read( ) throws IOException  

从文件读取一个字节,以整数形式返回,当读到文件尾端时 返回-1;

下面的例子 说明了read的用法,输出了文本的全部内容

   
   
   
   
  1. public static void main(String[] args) { 
  2.         try { 
  3.             FileInputStream inputStream = new FileInputStream("D:\\test.txt"); 
  4.             int i; 
  5.             do { 
  6.                  i = inputStream.read(); 
  7.                 if(i!=-1
  8.                 System.out.println((char)i); 
  9.             }while (i != -1); 
  10.             inputStream.close(); 
  11.         } catch (Exception e) { 
  12.             // TODO Auto-generated catch block 
  13.             e.printStackTrace(); 
  14.         } 
  15.     } 

向文件中写数据,需用FileOutputStream定义的write()方法

   
   
   
   
  1. void write(int byteval) throws IOException  

接下来写个例子  看下怎么使用write()

   
   
   
   
  1. public static void main(String[] args) { 
  2.         FileInputStream inputStream; 
  3.         FileOutputStream outputStream; 
  4.         String inputfilename = "D:\\test.txt"
  5.         String outputfilename = "E:\\test.txt"
  6.  
  7.         try { 
  8.             inputStream = new FileInputStream(inputfilename); 
  9.         } catch (FileNotFoundException e) { 
  10.             // TODO Auto-generated catch block 
  11.             e.printStackTrace(); 
  12.             System.err.println("文件不存在!"); 
  13.             return
  14.         } 
  15.  
  16.         try { 
  17.             outputStream = new FileOutputStream(outputfilename); 
  18.         } catch (FileNotFoundException e) { 
  19.             // TODO Auto-generated catch block 
  20.             e.printStackTrace(); 
  21.             System.err.println("文件不存在!"); 
  22.             return
  23.         } 
  24.  
  25.         int i = -1
  26.         do { 
  27.             try { 
  28.                 i = inputStream.read(); 
  29.                 if (i != -1
  30.                     outputStream.write(i); 
  31.             } catch (IOException e) { 
  32.                 // TODO Auto-generated catch block 
  33.                 e.printStackTrace(); 
  34.                 return
  35.             } 
  36.         } while (i != -1); 
  37.  
  38.         System.out.println("写入完毕"); 
  39.         try { 
  40.             inputStream.close(); 
  41.             outputStream.close(); 
  42.         } catch (IOException e) { 
  43.             // TODO Auto-generated catch block 
  44.             e.printStackTrace(); 
  45.         } 
  46.     }