java编程操作心血3

Demo1

 

package pc3;

import java.io.*;

/*

本例用System.in.read(buffer)从键盘输入一行字符，存储在缓冲区buffer中，count保存实际

读入的字节个数，再以整数和字符两种方式输出buffer中的值。Read方法在java.io包中，

而且要抛出IOException异常。程序如下：

*/

public class Input1 {

public static void main(String[] args)throws IOException{

// TODO Auto-generated method stub

System.out.println("Input:");

byte buffer[]=new byte[512];

int count=System.in.read(buffer);

System.out.println("Output:");

for(int i=0;i<count;i++)

{

System.out.print(" "+buffer[i]);//ASCII之间有间隔

}

System.out.println();

for(int i=0;i<count;i++)

{

System.out.print((char)buffer[i]);//字符间没有间隔

}

}

 

}

输入：1空格2空格q空格回车

输出：

Output:

 49 32 50 32 113 32 13 10

1 2 q 

解析：1对应的ASCII码为49，空格对应的32，回车键代表转义字符\r,\n对应的ASCII为13 10

第二行输出字符，间隔代表空格，回车转义字符没有被显示出来

 

 

Demo2：System.in.read进一步理解

package pc3;

 

import java.io.IOException;

import java.io.InputStream;

 

public class Input3 {

 

/**

* @param args

*/

public static void input(InputStream in)

{

int i;

int count=0;

try

{

System.out.println("please input a sequence,use 'a'to break off");

while(true)

{

i=in.read();

if(i==97)

break;

if(i>=65&&i<=90)

count++;

}

System.out.println("大写字母数为"+count);

}

catch(IOException e)

{

System.err.println("发生异常:" + e);

           e.printStackTrace( );

 

}

}

public static void main(String[] args) {

// TODO 自动生成方法存根

       input(System.in);//System。in对应的输入流是键盘

}

 

}

 

结果：

please input a sequence,use 'a'to break off

A S d a

大写字母数为2

补充：

package pc1;

import java.io.IOException;

import java.io.OutputStream;

public class Write_Test {

 

public static void mb_write(OutputStream out)

   {

       String s = "输出流例程";

       byte[ ] b = s.getBytes( );

       try

       {

           out.write(b);

           out.flush( );

       }

       catch (IOException e)

       {

           System.err.println("发生异常:" + e);

           e.printStackTrace( );

       } // try-catch结构结束

   } // 方法mb_write结束

 

   public static void main(String args[ ])

   {

       mb_write(System.out);

   } // 方法main结束

} // 类J_Write结束

 

 

 

Demo3

package pc3;

import java.io.*;

/*本例以FileInputStream的read(buffer)方法，每次从源程序文件OpenFile.java中读取512个字节

 * ，存储在缓冲区buffer中，再将以buffer中的值构造的字符串new String(buffer)显示在屏幕上。程序如下：

 * */

public class OpenFile {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

try

{

FileInputStream rf=new FileInputStream("D:/Student.txt");

int n=512;

byte buffer[]=new byte[n];

while((rf.read(buffer,0,n)!=-1)&&n>0)//rf等同与前面的System.in，只不过一个是 文件，一个是键盘

{

System.out.print(new String(buffer));

}

System.out.println();

rf.close();

}

catch (IOException ioe)

{

System.out.println(ioe);

}

catch (Exception e)

{

System.out.println(e);

}

}

 

}

 

Demo4

 

package pc1;

/*

 缓冲区的出现是为了提高 流的操作效率而出现的

 所以在创建缓冲区之前必须要有流对象

 该缓冲区提供了一个跨平台的换行符

 */

import java.io.*;

public class BufferedWriteDemo {

 

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

//创建一个字符写入流对象

FileWriter fw=new FileWriter("E:\\test.txt",true);

//继承 OutputStreamWriter（OutputStream out）

//FileWriter(File file,boolen y)

BufferedWriter bufw=new BufferedWriter(fw);//缓冲技术封装了数组

//BufferedWriter(Writer out) 

        //创建一个使用默认大小输出缓冲区的缓冲字符输出流。新的newline（）方法

for(int i=0;i<4;i++)

{

bufw.write("abce"+i); 

bufw.newLine();//

//只有用到缓冲区，就要记得刷新

bufw.flush();

}

bufw.close();//缓冲区的关闭就是被提高效率的流对象

System.out.println("finish");

}

 

}

 

在E:\\test.txt，写入

abce0

abce1

abce2

abce3

 

Demo6

采用字节流将一个文件的数据读出来，并且写入另一个文件里

package pc1;

 

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

 

public class Bytstest {

 

 

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

FileInputStream in=null;

FileOutputStream out=null;

try

{

in=new FileInputStream("E:\\java_file\\origin.txt");

//FileInputStream（File file）构造函数

out=new FileOutputStream("E:\\java_file\\byteout.txt");

int c;

while((c=in.read())!=-1)

{

out.write(c);

}

}

catch(Exception e)

{

e.printStackTrace();

}

finally

{

if(in!=null)

{

in.close();

}

if(out!=null)

{

in.close();

}

}

}

 

}

/*尽管BytesTest能够顺利执行，可它并不完美。字节流一般用在原始的I/O里

 * （即操作字节数据的时候），而original.txt包含的确是一些字符数据，所以更好的处理方式应该是使用字符流

 * 。可为什么要先谈字节流呢？？因为其他流都是建立在字节流之上的。*/

Demo7

/*字节流，相比于demo6有更高的效率*/

package pc1;

/*通过缓冲区来复制一个Java文件*/

import java.io.*;

public class CopyTextByBuf {

  public static void main(String args[])

  {

 BufferedReader bufr=null;

 BufferedWriter bufw=null;

 try

 {

 bufr=new BufferedReader(new FileReader("e:\\java_file\\origin1.txt"));

     bufw=new BufferedWriter(new FileWriter("e:\\java_file\\origin.txt")); 

     String line=null;

     while((line=bufr.readLine())!=null)

     {

     bufw.write(line);

     bufw.newLine();

     bufw.flush();

     }

 }

 catch(IOException e)

 

 {

 throw new RuntimeException("读写失败");

 

 }

 finally

 {

 try

 {

 if(bufr!=null)

 bufr.close();

 }

 catch(IOException e)

 

 {

 throw new RuntimeException("读取关闭失败");

 

 }

 try

 {

 if(bufw!=null)

 bufw.close();

 }

 catch(IOException e)

 

 {

 throw new RuntimeException("写入读取关闭失败");

 

 }

 }

  }

}

 

Demo8

/*

采用字节流将一个图片复制到另一个图片

*/

package pc1;

 

import java.io.*;

 

public class CopyPic {

 

public static void main(String[] args) {

// TODO Auto-generated method stub

FileOutputStream fos=null;

FileInputStream fis=null;

try

{

fos=new FileOutputStream("e:\\java_file\\2.jpg");

fis=new FileInputStream("e:\\java_file\\1.jpg");

byte buf[]=new byte[1024];

int len=0;

while((len=fis.read(buf))!=-1)

{

fos.write(buf,0,len);

}

System.out.println("sucess");

}

catch(IOException e)

{

throw new RuntimeException("读写失败");

}

finally

{

try

{

if(fos!=null)

fos.close();

}

catch(IOException e)

{

throw new RuntimeException("写入关闭失败");

}

try

{

if(fis!=null)

fis.close();

}

catch(IOException e)

{

throw new RuntimeException("读取关闭失败失败");

}

}

}

 

}

 

demo9

字节流的各种情况

/*字符流FileReader,FileWriter

 字节流 InputStream,OutputStream

 */

package pc1;

 

import java.io.*;

 

public class FileStream {

 

public static void main(String[] args) throws IOException {

readFile_1();

 

}

 

public static void writeFile() throws IOException {

FileOutputStream fos = new FileOutputStream("e:\\java_file\\1.txt");

fos.write("abcd".getBytes());

fos.close();

}

 

public static void readFile_1() throws IOException {

FileInputStream fis = new FileInputStream("e:\\java_file\\1.txt");

int ch = 0;

while ((ch = fis.read()) != -1) {

System.out.print((char) ch);

}

fis.close();

}

 

public static void readFile_2() throws IOException {

FileInputStream fis = new FileInputStream("e:\\java_file\\1.txt");

byte buf[] = new byte[1024];

int len = 0;

while ((len = fis.read(buf)) != -1)// 不断的装，一次性全部打印出来

{

System.out.println(new String(buf, 0, len));

}

fis.close();

}

 

public static void readFile_3() throws IOException {

FileInputStream fis = new FileInputStream("e:\\java_file\\1.txt");

int num = fis.available();

System.out.println("num=" + num);

fis.close();

}

 

public static void readFile_4() throws IOException {

FileInputStream fis = new FileInputStream("e:\\java_file\\1.txt");

byte buf[] = new byte[fis.available()];// 定义一个缓冲区，不必在循环了，相比于2

fis.read(buf);

System.out.println(new String(buf));

fis.close();

}

}