Core Java(十)

知识点：IO

什么是IO？输入输出input output,这是指以程序为中心，就是站在程序的角度说的，程序其实是JVM,例如：写程序将一些信息存储到文件中，这叫输出（写入）；如果程序从文件得到信息，就叫输入（读取）

 

文件：

什么是文件？指计算机中的文件和目录

文件的作用就是存取查看

文件和java中的File类：File相当于指向文件的指针，它本身并不是文件，如果我们想通过程序来操作和使用文件，就需要使用File类

/**

 * 知识点：

 * File类：文件和目录的创建

 * 程序目标：

 * 测试File类和常用的方法

 */

package MY.module10.File;

import java.io.*;

public class TestFile {

       public static void test1(){

              File file1=new File("h://mytest//test1");

              if(!file1.exists()){//如果没有创建该对象指向的目录，就创建它

                     file1.mkdirs();//mkdirs和mkdir的区别在于，mkdirs创建整个目录

              }

             

              File file2=new File(file1,"test2");

              if(!file2.exists()){

                     file2.mkdir();

              }

             

              File file3=new File("h://mytest//test1","test3");

              if(!file3.exists()){

                     file3.mkdir();

              }

             

              File file4=new File(file3,"text.txt");

              if(!file4.exists()){

                     try {

                            file4.createNewFile();

                     } catch (IOException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                     }

              }

//          file1.delete();//error必须先删除子目录或文件

              System.out.println(file4.getAbsolutePath());

              System.out.println(file4.getPath());

              System.out.println(file4.getParent());

              System.out.println(file4.canRead());

              System.out.println(file4.isDirectory());

              System.out.println(file1.isDirectory());

              System.out.println(file4.length());

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test1();

       }

 

}

发现问题：如果让我们连接服务器，在服务器远程建立一个文件，该怎么做呢？

需要处理跨平台性：

对于命令：File f2=new file(“d://abc//789//1.txt”)

这个命令不具备跨平台性，因为不同的OS的文件系统的分隔符是不相同。

使用file类的separtor属性，返回当前平台文件分隔符。

File newD = new File("aa"+File.separator+"bb"+File.separator+"cc");

       File newF = new File(newD,"mudi.txt");

       try{

       newD.mkdirs();

       newF.createNewFile();

       }catch(Exception e){}

 

 

 

I/O框架：

什么是输入流？从外界流向程序，程序从外界得到资源

什么是输出流？从程序到外界的过程

比如：我们从文件中得到内容，并且显示在屏幕上，从文件得到内容，是输入（读取），将内容显示在屏幕上，显示到终端上是输出（写入），始终以程序为中心

什么是字节流？以字节为单位的数据传输方法进行传输

什么是字符流？以字符为单位的数据传输方法进行传输

什么是节点流？就是在输入输出两端建立一个管道

什么是处理流？给管道增加功能，比如加粗，过滤功能等等

 

字节流			字符流
输入流	节点流	FileInputStream	FileReader
	处理流	BufferedInputStream	BufferedReader
输出流	结点流	FileOutStream	FileWriter
	处理流	BufferedOutStream	BufferedWriter

 

字节流的作用？当我们处理的是二进制文件的时候，需要用字节流来进行传输，不能用字符流

什么是二进制文件？里面都是机器码，010101的机器码，他们需要按字节方式传输

未处理问题：什么情况下我们需要传输一个二进制文件呢？二进制文件对我们来说有什么用？

字符流的作用？以字符为单位传输数据，处理文本文件，里面的方法比较好用，简单

 

字节流：

父类：InputStream     OutputStream

InputStream:

Int Read()：一个一个字节的读取流中的数据，读一个，指针指向下一个，再读，再指向下一个，返回为整数，这个整数是编码，比如，文档有h这个字符，那么返回的是这个字符的编码104，那么，如果我想打印出h，需要强制转换,如果为-1，说明没有读取到内容

Int read(byte[] b):读取流中的内容，一个一个读，把读的内容存到数组中，返回int型，也就是数组的长度

int available(): 返回可从流中读取的字节数。

skip(long): 丢弃了流中指定数目的字符。

boolean markSupported()

void mark(int)

void rese()

 

OutputStream:

三个基本的write()方法

void write():

void write(byte[])：

void write(byte[], int , int)：

其它方法

void close(): 关闭流，如使用过滤器流，关闭栈顶部的流，会关闭其余的流。

void flush(): 允许你强制执行写操作。

注：在流中close()方法由程序员控制。因为输入输出流已经超越了JVM的边界，所以有时可能无法回收资源。

原则：凡是跨出虚拟机边界的资源都要求程序员自己关闭，不要指望垃圾回收。

 

FileInputStream:

/**

 * 知识点：

 * FileInputStream:字节流中的管道，节点流，输入

 * read()

 * 程序目标：

 * 从一个目录中的文件里得到里面的内容，显示在终端上

 */

package MY.module10.inputstreams;

import java.io.*;

public class TestFileInputStream {

       public static void test(){

              File f=new File("h://mytest//test1//test3","hello.txt");

              if(!f.exists()){

                     try {

                            f.createNewFile();

                     } catch (IOException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                     }

              }

             

              try {

                     FileInputStream fs=new FileInputStream(f);

                     int i=0;

                     while((i=fs.read())!=-1){

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

                     }

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

       }

 

}

/**

 * 知识点：

 * 使用read(byte[] b)

 * 程序目标：

 * test1：使用字节数组方式显示读取的内容

 * 发现问题：字节数组大小，开多大呢？两种解决办法

 * test2:第一种：定义一个小一些的数组，通过循环显示所有内容，因为

 * read()方法是一个一个读，跟指针一样，第一次写read()后，再写一次

 * 就会从上次结尾后开始读

 * test3:第二种：先得到目录文件中的内容大小，然后开这么大的空间

 */

package MY.module10.inputstreams;

import java.io.*;

public class TestFileInputStream2 {

       public static void test1(){

              FileInputStream fs=null;

              try {

                     fs=new FileInputStream("h://mytest//test1//test3//hello.txt");

                     byte[] b=new byte[32];

                     int length=fs.read(b);

                     System.out.println(length);

                     System.out.println(new String(b,0,length));

                     fs.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

      

       public static void test2(){

              FileInputStream fs=null;

              try {

                     fs=new FileInputStream("h://mytest//test1//test3//hello.txt");

                     byte[] b=new byte[10];

                     int length=fs.read(b);

                     while(length==10){

                            System.out.println(new String(b,0,length));

                            length=fs.read(b);

                     }

                     System.out.println(new String(b,0,length));

                     fs.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

      

       public static void test3(){

              File file=new File("h://mytest//test1//test3//hello.txt");

              long length=file.length();

              FileInputStream fs=null;

              try {

                     fs=new FileInputStream(file);

                     byte[] b=new byte[(int)(length)];

                     int x=fs.read(b);

                     System.out.println(new String(b,0,x));

                     fs.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

             

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

//          test1();

//          test2();

              test3();

       }

 

}

 

FileOutputStream:

/**

 * 知识点：

 * 输出和输入输出

 * 程序目标：

 * test1:将一个字符串写入一个文件中

 * test2:从一个文件读取字符串，并将这些内容写入到另一个文件中

 */

package MY.module10.outputstreams;

import java.io.*;

public class TestFileOutputStream {

       public static void test1(){

              FileOutputStream fs=null;

              try {

                     fs=new FileOutputStream("h://mytest//test1//test3//hello.txt");

                     String s="JAVA I LOVE YOU!";

                     fs.write(s.getBytes());

                     fs.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

      

       public static void copyFile(String file1,String file2){

              File f1=new File(file1);

              File f2=new File(file2);

             

              FileInputStream fis=null;

              FileOutputStream fos=null;

              try {

                     fis=new FileInputStream(f1);

                     fos=new FileOutputStream(f2);

                     int i=0;

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

                     //       fos.write((char)i);//写入文件就不用转换为char了，文档可以辨别出来数字的含义

                            fos.write(i);

                     }

                     fis.close();

                     fos.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

 

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

//          test1();

              String file1="h://mytest//test1//test3//hello.txt";

              String file2="h://mytest//test1//test3//text.txt";

              copyFile(file1,file2);

       }

 

}

 

在文件中追加一些字符：

FileOutputStream outfile = new FileOutputStream(“results.dat”,true);

              参数为true时输出为添加，为false时为覆盖。 

       FileOutputStream类代码：(为什么能建文件)

              Public FileOutputStream(String name){

                     This(name!=null？new File(String):null,false);

              }

 

BufferedInputStream：

输入：字节流中的处理流

/**

 * 知识点：

 * BufferedInputStream

 * 程序目标：

 * 读取文件中的内容显示在终端上，把管道的功能加强

 */

package MY.module10.inputstreams;

import java.io.*;

public class BufferInputStream {

       public static void  test1(){

              FileInputStream fis=null;

              BufferedInputStream bis=null;

              try {

                     fis=new FileInputStream("h://mytest//test1//test3//hello.txt");

                     bis=new BufferedInputStream(fis);

//                 int j=fis.available();

                     byte[] b=new byte[5];

                     int i=0;

                     i=bis.read(b);

                     while(i==5){

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

                            i=bis.read(b);

                     }

                     System.out.println(new String(b,0,i));

                     bis.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test1();

       }

 

}

 

BufferedOutputStream:

/**

 * 知识点：

 * BufferedOutputStream:输出：字节流中的处理流

 * 程序目标：

 * 在文件中写入一句话

 */

package MY.module10.outputstreams;

import java.io.*;

public class TestBufferedOutputStream {

       public static void test1(){

              BufferedOutputStream bos=null;

              try {

                     bos=new BufferedOutputStream(new FileOutputStream("h://mytest//test1//test3//hello.txt",true));

                     String s="zhen de ma?";

                     bos.write(s.getBytes());

                     bos.close();

                     } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                     }

             

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test1();

       }

 

}

 

字符流：

抽象父类：Reader  Writer

 

FileReader:

/**

 * 知识点：

 * 字符流：输入：结点流：FileReader

 * 程序目标：

 * 从文件中得到字符并输出到终端上

 */

package MY.module10.Reader;

import java.io.*;

public class TestFileReader {

       public static void test(){

              FileReader fr=null;

              try {

                     File file=new File("h://mytest//test1//test3//hello.txt");

                     fr=new FileReader(file);

                     long length=file.length();

                     char[] c=new char[(int)(length)];

                     fr.read(c);

                     System.out.println(c);

                     fr.close();

//                 char[] c=new char[5];

//                 int i=0;

//                 i=fr.read(c);

//                 while(i==5){

//                        System.out.println(new String(c));

//                        i=fr.read(c);

//                 }

//                 System.out.println(new String(c,0,i));

//                 fr.close();

                    

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

             

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

       }

 

}

 

 

 

 

 

 

FileWriter：

/**

 * 知识点：

 * FileWriter,FileReader

 * 程序目标：

 * 使用字符流，从一个文件得到内容并复制到另一个文件

 */

package MY.module10.FileWriter;

import java.io.*;

public class TestFileWriter {

       public static void test(){

              FileWriter fw=null;

              try {

                     fw=new FileWriter("h://mytest//test1//test3//hello.txt",true);

                     String s="I Love Java!";

                     fw.write(s);

                     fw.close();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

             

       }

       public static void copyFile(String file1,String file2){

              FileReader fr=null;

              FileWriter fw=null;

              try {

                     fr=new FileReader(file1);

                     fw=new FileWriter(file2);

                     int i=0;

                     while((i=fr.read())!=-1){

                            fw.write(i);

                     }

                     fr.close();

                     fw.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

//          test();

              String file1="h://mytest//test1//test3//hello.txt";

              String file2="h://mytest//test1//test3//text.txt";

              copyFile(file1,file2);

       }

 

}

 

BufferedReader:

/**

 * 知识点：

 * BufferedReader 字符流-输入-处理流

 * 程序目标：

 * 测试BufferedReader

 * 注意：readLine()，比较好用

 */

package MY.module10.Reader;

import java.io.*;

public class TestBufferedReader {

       public static void test(){

              BufferedReader br=null;

              try {

                     br=new BufferedReader(new FileReader("H://mytest//test1//test3//hello.txt"));

                     String s=null;

                     while((s=br.readLine())!=null){

                            System.out.println(s);

                     }

                     br.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

             

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

       }

 

}

BufferedWriter:

/**

 * 知识点：

 * BufferedWriter:输出流-字符流-处理流

 * 程序目标：

 * 使用BufferedWriter输出内容到文件

 */

package MY.module10.Writer;

import java.io.*;

public class TestBufferedWriter {

       public static void test(){

              FileWriter fw=null;

              BufferedWriter bw=null;

              try {

                     fw=new FileWriter("h://mytest//test1//test3//hello.txt" );

                     bw=new BufferedWriter(fw);

                     String s="China";

                     bw.write(s);

                     bw.close();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

                     test();

 

       }

}

字节数组流：ByteArrayInputStream,ByteArrayOutStream

/**

 * 知识点：

 * 字节数组ByteArrayInputStream,ByteArrayOutStream

 * 程序目标：

 * 将一个字符串转换为大写，使用字节数组流

 * 注意：ByteArrayOutStream的write方法是将内容写入字节数组中

 */

package MY.module10.TestArray;

import java.io.*;

public class TestArray {

       public static void test(){

              ByteArrayInputStream bis=null;

              ByteArrayOutputStream bos=null;

              String s="hello world";

              bis=new ByteArrayInputStream(s.getBytes());

              bos=new ByteArrayOutputStream();

              toDaxie(bis,bos);

              String jieguo=bos.toString();

              System.out.println(jieguo);

              try {

                     bis.close();

                     bos.close();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

 

       }

       public static void toDaxie(ByteArrayInputStream bis,ByteArrayOutputStream bos){

              int i;

              while((i=bis.read())!=-1){

                     int j;

                     j=Character.toUpperCase(i);

                     bos.write(j);

              }

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

       }

 

}

 

PipedInputStream,PipedOutputStream:

/**

 * 知识点：

 * Piped流

 * 用于线程间的通讯

 * 程序目标：

 * 一个线程控制输出，一个控制输入

 */

package MY.module10;

import java.io.*;

public class piped {

       public static void test(){

              send s=new send();

              gend g=new gend();

              PipedOutputStream pos=s.getPos();

              PipedInputStream pis=g.getPis();

              try {

                     pos.connect(pis);

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

              s.start();

              g.start();

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

       }

 

}

class send extends Thread{

       PipedOutputStream pos=new PipedOutputStream();

      

       public PipedOutputStream getPos() {

              return pos;

       }

      

       public void run(){

              String s="hello world!";

              try {

                     pos.write(s.getBytes());

                     pos.close();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

}

class gend extends Thread{

       PipedInputStream pis=new PipedInputStream();

      

       public PipedInputStream getPis() {

              return pis;

       }

 

       public void run(){

             byte[] b=new byte[32];

              try {

                     int length=pis.read(b);

                     System.out.println(new String(b,0,length));

                     pis.close();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

}

 

转换流：OutputStreamWriter,InputStreamReader:

/**

 *知识点：

 *转换流

 *程序目标：

 *将字节流转换为字符流进行输入输出

 */

package MY.module10.bytetochar;

import java.io.*;

public class TestByteToChar {

       public static void test1() throws IOException{

              FileOutputStream fos=null;

              fos=new FileOutputStream("h://mytest//test1//test3//hello.txt");

              OutputStreamWriter osw=new OutputStreamWriter(fos);

              BufferedWriter bw=new BufferedWriter(osw);

              String s="hello world!";

              bw.write(s);

              bw.close();

       }

       public static void test2() throws IOException{

              BufferedReader br=null;

              br=new BufferedReader(new InputStreamReader(new FileInputStream("h://mytest//test1//test3//hello.txt")));

              String s=null;

              while((s=br.readLine())!=null){

                     System.out.println(s);

                     s=br.readLine();

              }

              br.close();

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              try {

                     test1();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

              try {

                     test2();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

 

}

System.in:

/**

 * 知识点：

 * System.in

 * 程序目标：

 * 从键盘得到输入的字符，然后打印到屏幕上，并且保存在一个文件中

 */

package MY.module10.bytetochar;

import java.io.*;

public class TestSystemin {

       public static void test1() throws IOException{

              InputStreamReader isr=new InputStreamReader(System.in);

              OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("h://mytest//test1//test3//hello.txt",true));

              BufferedReader br=new BufferedReader(isr);

              BufferedWriter bw=new BufferedWriter(osw);

              String s=br.readLine();

              while(!s.equals("goodbye")){

                     System.out.println(s);

                     s=br.readLine();

                     bw.write(s);

              }

              bw.close();

              br.close();

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              try {

                     test1();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

 

}

PrintWriter:

/**

 * 知识点：

 * printWriter

 * 程序目标：

 * 将信息输出到一个文件中

 */

package MY.module10.printWriter;

import java.io.*;

public class printWriter {

       public static void test(){

              PrintWriter pw=null;

              try {

                     pw=new PrintWriter(new FileWriter("h://mytest//test1//test3//hello.txt"));

                     pw.println("asdkfjlakjdsflkj");

                     pw.println("hello world");

                     pw.close();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

             

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

       }

 

}

对象序列化：ObjectOutputStream

什么是对象序列化？就是将对象输出到文件中，属于对象流，可以对对象进行文件输入输出，作用就是可以将一个类中对象的信息输出到远程（或本地）文件中，并可以从里面读取这些对象信息

这个对象的类需要实现Serializable接口：这个接口只是一个标识

/**

 * 知识点：

 * 对象序列化：ObjectOutputStream,ObjectInputStream

 * Serializable接口：要想让一个类的对象序列化，必须让该类实现

 * Serizlizable接口

 * transient:如果不想让对象中的一个属性序列化，就使用这个修饰属性

 * 程序目标：

 * 将一个类的对象写入到一个文件中，并从这个文件中得到这个对象，

 * 并且打印出来

 */

package MY.module10.serializables;

import java.io.*;

public class TestObject {

       public static void test1() throws FileNotFoundException, IOException{

              ObjectOutputStream oos=null;

              oos=new ObjectOutputStream(new FileOutputStream("h://mytest//hello.txt"));

              Person p=new Person("luzhen",23);

              oos.writeObject(p);

              oos.close();

       }

       public static void test2() throws FileNotFoundException, IOException, ClassNotFoundException{

              ObjectInputStream ois=null;

              ois=new ObjectInputStream(new FileInputStream("h://mytest//hello.txt"));

              Person p1=(Person)ois.readObject();

              System.out.println(p1.getName()+":"+p1.getAge());

              System.out.println(p1);

              ois.close();

       }

 

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

              // TODO Auto-generated method stub

//          test1();

              test2();

       }

 

}

class Person implements Serializable{

       private String name;

       private transient int age;

       Person(String name, int age) {

              super();

              // TODO Auto-generated constructor stub

              this.name = name;

              this.age = age;

       }

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       @Override

       public String toString() {

              // TODO Auto-generated method stub

              StringBuffer sb=new StringBuffer();

              sb.append(name+":");

              sb.append(age);

              return sb.toString();

       }

      

}