java基础（一）IO流操作

今天药忘吃喽~ 2022-06-07 01:14 236阅读 0赞

java流是java基础中很重要的一个部分，也是经常在面试中被问到的内容。这部分内容个人感觉还有有一点java基础之后在回来看这些东西比较会有深刻的印象，毕竟如果是初学者的话这部分知识是很少用到的，用不到的东西就很容易忘记。

## **一、编码问题** ##

编码问题一直是写代码中一个比较常见的问题

java中代码的的默认编码是项目一开始设置的编码。

下面是最常用的编码格式：

*  utf-8 ————–中文三个字节，英文一个字节
 *  gbk—————中文两个字节，英文一个字节
 *  utf-16————中文三个字节，英文两个字节
 *  utf-16be———中文两个字节，英文两个字节

可以用代码来测试一下，我的项目默认的编码格式是UTF-8的。

public static void main(String[] args) throws Exception {
    
            String x = "测试ABCD";
            byte[] b1 = x.getBytes();
            System.out.println("UTF-8编码，项目默认的编码");
            for (byte b : b1) {
                System.out.print(Integer.toHexString(b & 0xff) + " ");
            }
            System.out.println();
    
            byte[] b2 = x.getBytes("gbk");
            System.out.println("gbk编码");
            for (byte b : b2) {
                System.out.print(Integer.toHexString(b & 0xff) + " ");
            }
            System.out.println();
    
            byte[] b3 = x.getBytes("utf-16");
            System.out.println("utf-16编码");
            for (byte b : b3) {
                System.out.print(Integer.toHexString(b & 0xff) + " ");
            }
            System.out.println();
    
            byte[] b4 = x.getBytes("utf-16be");
            System.out.println("utf-16be编码");
            for (byte b : b4) {
                System.out.print(Integer.toHexString(b & 0xff) + " ");
            }
            System.out.println();
    
        }

输出结果：

UTF-8编码，项目默认的编码
    e6 b5 8b e8 af 95 41 42 43 44 
    gbk编码
    b2 e2 ca d4 41 42 43 44 
    utf-16
    fe ff 6d 4b 8b d5 0 41 0 42 0 43 0 44 
    utf-16be
    6d 4b 8b d5 0 41 0 42 0 43 0 44

## **二、IO流体系** ##

从别人的网站上盗的图，在IO操作中主要是包括字符流和字节流，字符流就是一个字一个字的读取或者写入，比如“测试ABCD”要写入或者读出的时候就是逐个字符操作，“测”“试”“A”“B”“C”“D”这样逐个操作；字节流就是将内容转化为字节流在操作，比如“测试ABCD”在操作的时候转化为UTF-8编码时，就是e6 b5 8b e8 af 95 41 42 43 44 逐个操作。

字符流的都是继承自Reader或者Writer，字节流的都是继承自InputStream或者OutputStream；本文会主要介绍其中比较常用的类，其他的用法几乎相同，可自行查看文档。

需要注意的时候在操作IO流的时候需要在最后将流全部关闭。

![这里写图片描述][SouthEast]

## **三、随机存取文件RandomAccessFile** ##

如果操作的是文件，那么还可以使用RandomAccessFile来读写文件。

RandomAccessFile传入的参数是File类和文件的读写权限

在IO中主要的方法是read和write方法，在RandomAccessFile中扩张了很多的方法，如writeInt(int i),writeChars(String s)等方法，readInt(),readLine()等方法。

public static void main(String[] args) throws IOException {
            File file = new File("C:/Users/nc硪fl/Desktop/test.txt");
            RandomAccessFile raf = new RandomAccessFile(file, "rw");//后一个参数指定文件的权限，这里是可读写
            String test = "我就测试测试看看行不行\n";
            byte[] bytes = test.getBytes("utf-8");//将要写进文件的内容转化为字节数组后写入。
            raf.write(bytes);//写进文件
            //write方法中可传进的参数种类很多，自行查看文档，选择合适的方法
    
            raf.seek(0);//必须定位一下位置，否则从最后写的位置开始读
            byte[] r = new byte[(int) raf.length()];
            raf.read(r);//读文件
            //read方法扩展了很多其他的方法，自行查看文档，选择合适的方法
            System.out.println(new String(r));
            raf.close();
    
    
            //用Scanner
            File f = new File("C:/Users/nc硪fl/Desktop/ES笔记一.txt");
            Scanner in = new Scanner(f);
            while(in.hasNext())
                System.out.println(in.nextLine());
            in.close();
    
        }

上面的代码中还有Scanner方法读取文件的方法，就是将File对象创建Scanner中之后就可以想操作从控制台输入数据那样操作数据了，之前都是使用这种的，比较好记，这里顺便提一下。

## **四、字节流** ##

个人感觉采用字节流的场合比采用字符流的场合要多，因为在网络传输中，大多是以字节为单位传输的。

在字节流中主要的操作主要是通过实例化InputStream的不同实现，然后从InputStream中的read获取字节，这里主要采用的是byte数组，这样的效率相对而言比较高。文件在做读取操作的时候，若read返回-1，则表示文件读到文件的结尾了。要输出字节流则通过实例化OutputStream的不同实现，然后通过write方法进行写操作，这里也一般采用byte数组。

下面的代码主要实现的是文件的复制操作，也是在Web中应用比较广泛的一种示例。

FileInputStream——-文件操作，最基本的文件操作

public static void $FileInputStream() throws Exception {
            File f = new File("C:/Users/nc硪fl/Desktop/ES笔记一.txt");
            InputStream is = new FileInputStream(f);// 输入流
            byte[] a = new byte[1024];// 字节数组，相当于批量读取
    
            File file = new File("C:/Users/nc硪fl/Desktop/test.txt");
            OutputStream os = new FileOutputStream(file);// 输出流
            int n = 0;
            while ((n = is.read(a)) != -1) {
       // 文件拷贝
                System.out.print(new String(a));
                os.write(a, 0, n);
            }
            is.close();
            os.close();
    
        }

DataInputStream————对文件处理的很多方法进行封装，例如，在InputStream中，若要读取一个int数据，由于读取的时候只能一次读取8个字节，所以一个int数据需要连续读取四次才能读取完成，在DataInputStream就对这种方法进行了封装。可以自行去看源代码（这部分的源代码很容易看的）

public static void $DataInputStream() throws Exception {
            InputStream is = new FileInputStream("C:/Users/nc硪fl/Desktop/test.txt");
            DataInputStream dis = new DataInputStream(is);
            int n = 0;
            byte[] a = new byte[1024];
    
            OutputStream os = new FileOutputStream("C:/Users/nc硪fl/Desktop/test2.txt");
            DataOutputStream dos = new DataOutputStream(os);
            System.out.print(new String(a, 0, n));
            while ((n = dis.read(a)) != -1) {
                dos.write(a, 0, n);
            }
    
            dos.close();
            os.close();
            dis.close();
            is.close();
        }

BufferInputStream————通过使用缓存来进一步提高读写速度  
，需要注意的是使用这种方法的时候一定要通过flush提交缓存池里面的数据。

public static void $BufferInputStream() throws Exception {
            InputStream is = new FileInputStream("C:/Users/nc硪fl/Desktop/test.txt");
            BufferedInputStream bis = new BufferedInputStream(is, 1024 * 2);
            byte[] a = new byte[1024];
            int n = 0;
    
            OutputStream os = new FileOutputStream("C:/Users/nc硪fl/Desktop/test2.txt");
            BufferedOutputStream bos = new BufferedOutputStream(os);
            while ((n = bis.read(a)) != -1) {
                System.out.print(new String(a, 0, n));
                bos.write(a, 0, n);
                bos.flush();// 记得要flush提交缓存，
            }
    
            bis.close();
            is.close();
            bos.close();
            os.close();
    
        }

## **五、字符流** ##

对于IO流基本操作是一样的，字符流和字节流的操作是一样的。

在进行文件的输出的时候，可以采用PrintWriter/OutputStreamWriter这两种，这两种唯一的不同的是输出空格的方法，其实相差无几，这里不做比较了。

public static void test() throws Exception {
            File f = new File("C:/Users/nc硪fl/Desktop/test3.txt");
            InputStream is = new FileInputStream(f);
            InputStreamReader isr = new InputStreamReader(is);
            int n = 0;
            char[] a = new char[1024];
    
            File fout = new File("C:/Users/nc硪fl/Desktop/test4.txt");
            OutputStream os = new FileOutputStream(fout);
            OutputStreamWriter osw = new OutputStreamWriter(os);
            while ((n = isr.read(a)) != -1) {
                System.out.print(new String(a));
                osw.write(a, 0, n);
            }
    
            osw.close();//顺便说一个这个关闭的顺序需要先开的后关
            os.close();
            isr.close();
            is.close();
    
        }

## **六、对象的序列化** ##

在网络的传输中，一般都是字节流的，所以一个对象在网络传输中需要讲对象序列化成字节流，在java中只要对象实现了Serializable接口就可以将对象序列化，这个接口内部是没有任何实现的方法就是相当于一个标志。

假设有一个Student类

public class Student implements Serializable{ 
        private String name;
        private String password;
        private int sex;
        //setter...
        //getter...
        //toString...
        //Constructor...
    }

对象的序列化需要使用到的是ObjectInputStream类，将Student对象传进ObjectInputStream即可实现序列化：

public static void $ObjectInputStream() throws Exception {
            OutputStream os = new FileOutputStream("C:/Users/nc硪fl/Desktop/testObject.txt");
            ObjectOutputStream oos = new ObjectOutputStream(os);
            Student student = new Student("wahahah", "123", 1);
            oos.writeObject(student);
            oos.flush();
            InputStream is = new FileInputStream("C:/Users/nc硪fl/Desktop/testObject.txt");
            ObjectInputStream ois = new ObjectInputStream(is);
            System.out.println((Student) ois.readObject());
    
            ois.close();
            is.close();
            oos.close();
            os.close();
        }

若对象中的属性不想实现序列化，则可以使用transilent关键字修饰属性，被修饰的属性就不会被序列化，下面的代码中sex属性就不会被序列化，就是在文件传输过程中，这个属性的值，或者说这个属性就不会被传输。

public class Student implements Serializable{ 
        private String name;
        private String password;
        private transient int sex;
        //setter...
        //getter...
        //toString...
        //Constructor...
    }

## **七、使用IO流的地方** ##

基本上只要涉及到传输问题的都用的到IO流，这里主要介绍两个最近见得比较多的地方。

### 文件传输 ###

在SpringMVC中可以只用MultipartFile中的transferTo直接将文件写在服务器或者本地，其实只要点进去源代码就会最里面的源码和上面给出的示例代码其实是差不多的。这里不做介绍。把源代码放出来看看。

public static long copyLarge(InputStream input, OutputStream output) throws IOException {
            byte[] buffer = new byte[4096];
            long count = 0L;
    
            int n1;
            for (boolean n = false; -1 != (n1 = input.read(buffer)); count += (long) n1) {
                output.write(buffer, 0, n1);
            }
    
            return count;
        }

### TCP接口编程 ###

用java实现TCP通信，主要就是通过这个方式，一个进程作为客户端，另一个进程作为服务端，二者互相通讯的时候就是通过IO流的：

这是客户端代码

public class Client { 
    
        public static void main(String[] args) throws Exception {
            Socket s = new Socket("localhost", 10000);
    
            //向服务器发送数据
            OutputStream out = s.getOutputStream();
            out.write("这是客户端发出的".getBytes());
    
            //获取服务器的数据
            InputStream in = s.getInputStream();
            byte[] buff = new byte[1024];
            int len = in.read(buff);
            String data = new String(buff, 0, len);
            System.out.println("我是来自服务器的数据" + data);
    
            s.close();
        }
    }

服务端代码：

public class Server { 
    
        @SuppressWarnings("resource")
        public static void main(String[] args) throws Exception {
            ServerSocket ss = new ServerSocket(10000);
            Socket s = ss.accept();
    
            // 获取客户端传过来的数据
            InputStream in = s.getInputStream();
            byte[] buff = new byte[1024];
            int len = in.read(buff);
            String data = new String(buff, 0, len);
            System.out.println("客户端IP" + s.getInetAddress().getHostAddress());
            System.out.println("我是客户端的数据" + "::" + data);
    
            // 向客户端发送数据
            OutputStream out = s.getOutputStream();
            out.write("这是服务器发出的".getBytes());
    
            s.close();
        }
    
    }

先启动服务端的代码，监听是否有用户访问，然后启动客户端的代码，在客户端的控制台中输入两者通信的内容，即可在服务端的接收到信息。

[SouthEast]: /images/20220607/45d424686b8549689229ca487a123bd5.png