java IO（基本流）

最新推荐文章于 2024-06-21 12:00:11 发布
最新推荐文章于 2024-06-21 12:00:11 发布
阅读量135 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44996014/article/details/100566057
版权

字节流 字符流

一、IO概述

1.1 IO是什么

生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写入数据。

1.2 IO的分类

根据数据的流向分为：输入流和输出流。

  • 输入流 ：把数据从其他设备上读取到内存中的流。
  • 输出流 ：把数据从内存 中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

  • 字节流 ：以字节为单位，读写数据的流。
  • 字符流 ：以字符为单位，读写数据的流。

1.3 父类

在这里插入图片描述

二、字节流

2.1 万物皆是字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

2.2 字节输出流【OutputStream】

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

  • public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
  • public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
  • public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
  • public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
  • public abstract void write(int b) ：将指定的字节输出流。

注意：当完成流操作时，必须调用close()方法，释放系统资源

2.3FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

构造方法

  • public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
  • public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件（注意是文件而不是文件夹）。如果有这个文件，会清空这个文件的数据。

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {

        try {
            File file = new File("a.txt");
            //使用File对象创建流对象（注意这里如果File对象包含多级目录，而且没有这些文件夹，就会抛出异常）
            FileOutputStream fis = new FileOutputStream(file);

            //使用文件名创建流对象
            FileOutputStream fis1 = new FileOutputStream("b.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

1.写出字节数组 write(byte[] b)，每次可以写出数组中的数据，代码如下：

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            //创建流对象
            FileOutputStream fos = new FileOutputStream("a.txt");
            //字符串转换为字节数组
            byte[] b = "Hello World".getBytes();
            //写出字节数组
            fos.write(b);
            //关闭资源
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

2.写入指定数组长度 write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，代码如下：

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            //创建流对象
            FileOutputStream fos = new FileOutputStream("a.txt");
            //字符串转换为字节数组
            byte[] b = "Hello World".getBytes();
            //写出索引从2开始的5个字节。索引2是l，5个字节也就是llo W
            fos.write(b, 2, 5);
            //关闭资源
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

  • public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。
  • public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码如下：

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            //创建流对象
            FileOutputStream fos = new FileOutputStream("a.txt", true);
            //字符串转换为字节数组
            byte[] b = "Hello World".getBytes();
            //写出索引从2开始的5个字节。索引2是l，5个字节也就是llo W
            fos.write(b, 2, 5);
            //关闭资源
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

写出换行

Windows系统里，换行符号是\r\n 。把以指定是否追加续写了，代码如下：

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            //创建流对象
            FileOutputStream fos = new FileOutputStream("a.txt", true);
            //字符串转换为字节数组
            byte[] b = "Hello World".getBytes();
            int len = b.length;
            for (int i = 0; i < len; i++) {
                //写出一个字节
                fos.write(b[i]);
                //写出一个换行符，换行符转成数组写出
                fos.write("\r\n".getBytes());
            }
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

注意：- 回车符\r和换行符\n ：
- 回车符：回到一行的开头（return）。
-换行符：下一行（newline）。
- 系统中的换行：
- Windows系统里，每行结尾是 回车+换行 ，即\r\n；
- Unix系统里，每行结尾只有 换行 ，即\n；
- Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

2.4 字节输入流【InputStream】

java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

  • public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
  • public abstract int read()： 从输入流读取数据的下一个字节。
  • public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

注意：当完成流操作时，必须调用close()方法，释放系统资源

2.5 FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法

  • FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
  • FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
    当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。
package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            File file = new File("a.txt");
            //使用File对象创建流对象
            FileInputStream fis = new FileInputStream(file);

            //使用文件名创建流对象
            FileInputStream fis1 = new FileInputStream("a.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }

}

读取字节数据

1.读取字节 read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码如下：

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            File file = new File("b.txt");
            //使用File对象创建流对象
            FileInputStream fis = new FileInputStream(file);
            int read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println(read);
            //释放资源
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }

}

a.txt文件：
在这里插入图片描述
结果：
在这里插入图片描述
循环改进读取方式，代码如下：

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            File file = new File("a.txt");
            //使用File对象创建流对象
            FileInputStream fis = new FileInputStream(file);
            int a = 0;
            while ((a = fis.read()) != -1) {
                System.out.println((char) a);
            }
            //释放资源
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

2.使用字节数组读取： read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码如下：

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            File file = new File("a.txt");
            //使用File对象创建流对象
            FileInputStream fis = new FileInputStream(file);
            //定义字节数组，作为装字节数据的容器
            byte[] b = new byte[3];
            //定义变量，作为有效读取个数
            int len;
            //循环读取
            while ((len = fis.read(b)) != -1) {
                //把读入数组b的字节转换成字符串
                String str = new String(b);
                System.out.println(str);
            }
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

a.txt文件如下：
在这里插入图片描述
结果如下：
在这里插入图片描述
错误数据a，是由于最后一次读取时，只读取俩个字节bb，数组中，上次读取的数据没有被完全替换，所以要通过len ，获取有效的字节，代码如下：

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            File file = new File("a.txt");
            //使用File对象创建流对象
            FileInputStream fis = new FileInputStream(file);
            //定义字节数组，作为装字节数据的容器
            byte[] b = new byte[3];
            //定义变量，作为有效读取个数
            int len;
            //循环读取
            while ((len = fis.read(b)) != -1) {
                //把读入数组b的字节转换成字符串,参数的意思是从第0个开始读取len个长度
                String str = new String(b, 0, len);
                System.out.println(str);
            }
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

结果：
在这里插入图片描述

案例（图片复制）

package com.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @author:王先生
 * @date:公元2019/9/5 19:59
 */
public class FIStest {
    public static void main(String[] args) {
        try {
            File file = new File("C:\\Users\\DELL\\Desktop\\nz.jpg");
            //创建桌面图片为输入流对象
            FileInputStream fis = new FileInputStream(file);
            File file1 = new File("img");
            //判断此项目下有没有img这个文件夹，如果没有则创建
            if (!file1.exists()) {
                file1.mkdir();
            }
            //创建输出流对象在本项目下
            FileOutputStream fos = new FileOutputStream("img/nz.jpg", true);
            //定义字节数组，作为装图片的容器
            byte[] b = new byte[1024];
            //定义读取的有效字节数
            int len;
            while ((len = fis.read(b)) != -1) {
                fos.write(b, 0, len);
            }
            fos.close();
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

第三章 字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

3.1 字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

  • public void close() ：关闭此流并释放与此流相关联的任何系统资源。
  • public int read()： 从输入流读取一个字符。
  • public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

3.2 FileReader类

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

小贴士：

  1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。
    idea中UTF-8
  2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

  • FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
  • FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。
    当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。
  • 构造举例，代码如下：
package com.io;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

/**
 * @author:王先生
 * @date:公元2019/9/7 21:37
 */
public class FRtest {
    public static void main(String[] args) {
        try {
            File file = new File("c.txt");
            //使用File对象创建流对象
            FileReader fr = new FileReader(file);

            //使用文件名创建流对象
            FileReader fr1 = new FileReader("c.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

读取字符数据

1.读取字符 read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码如下：

package com.io;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

/**
 * @author:王先生
 * @date:公元2019/9/7 21:37
 */
public class FRtest {
    public static void main(String[] args) {
        try {
            File file = new File("c.txt");
            //使用File对象创建流对象
            FileReader fr = new FileReader(file);
            int b;
            while ((b = fr.read()) != -1) {
                System.out.println((char) b);
            }
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：虽然读取了一个字符，但是会自动提升为int类型。

输出结果：
在这里插入图片描述
2.使用字符数组读取 read(char[] c)，每次读取c的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 ，代码使用演示：

package com.io;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

/**
 * @author:王先生
 * @date:公元2019/9/7 21:37
 */
public class FRtest {
    public static void main(String[] args) {
        try {
            File file = new File("b.txt");
            //使用File对象创建流对象
            FileReader fr = new FileReader(file);
            //定义读取的有效长度
            int len;
            //定义字符型数组，容纳读取的字符
            char[] c = new char[2];
            while ((len = fr.read(c)) != -1) {
                String str = new String(c, 0, len);
                System.out.println(str);
            }
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

结果：
在这里插入图片描述

3.3 字符输出流【Writer】

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

  • void write(int c) 写入单个字符。
  • void write(char[] cbuf)写入字符数组。
  • abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
  • void write(String str)写入字符串。
  • void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
  • void flush()刷新该流的缓冲。
  • void close() 关闭此流，但要先刷新它。

3.4 FileWriter类

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

  • FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
  • FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。
    当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。
  • 构造举例，代码如下
package com.io;

import java.io.*;

/**
 * @author:王先生
 * @date:公元2019/9/7 21:37
 */
public class FRtest {
    public static void main(String[] args) {
        try {
            //使用File对象创建流对象
            File file = new File("e.txt");
            FileWriter fw = new FileWriter(file);

            // 使用文件名创建流对象
            FileWriter fw1 = new FileWriter("e.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

写出字节数据

1.写出字节 write(int b) 方法，每次可以写出一个字符数据，代码如下：

package com.io;

import java.io.*;

/**
 * @author:王先生
 * @date:公元2019/9/7 21:37
 */
public class FRtest {
    public static void main(String[] args) {
        try {
            //使用File对象创建流对象
            File file = new File("e.txt");
            FileWriter fw = new FileWriter(file,true);
            fw.write('你');
            fw.write('好');
            fw.close();
            /*
        【注意】关闭资源时,与FileOutputStream不同。
      	 如果不关闭,数据只是保存到缓冲区，并未保存到文件。
        */
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

  • flush ：刷新缓冲区，流对象可以继续使用。
  • close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
package com.io;

import java.io.*;

/**
 * @author:王先生
 * @date:公元2019/9/7 21:37
 */
public class FRtest {
    public static void main(String[] args) {
        try {
            //使用File对象创建流对象
            File file = new File("e.txt");
            FileWriter fw = new FileWriter(file, true);
            fw.write('你');
            fw.flush();
            fw.write('好');
            fw.flush();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

写出其他数据

  1. 写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码如下：
package com.io;

import java.io.*;

/**
 * @author:王先生
 * @date:公元2019/9/7 21:37
 */
public class FRtest {
    public static void main(String[] args) {
        try {
            //使用File对象创建流对象
            File file = new File("e.txt");
            FileWriter fw = new FileWriter(file, true);
            //将字符串转换为字符数组
            char[] c = "我是攻城狮".toCharArray();
            //写入字符数组
            fw.write(c);
            //写入数组c，从索引1开始，写入俩个字符 '是''攻'
            fw.write(c, 1, 2);
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便，代码如下：

package com.io;

import java.io.*;

/**
 * @author:王先生
 * @date:公元2019/9/7 21:37
 */
public class FRtest {
    public static void main(String[] args) {
        try {
            //使用File对象创建流对象
            File file = new File("e.txt");
            FileWriter fw = new FileWriter(file, true);
            //定义字符串
            String str = "我是攻城狮";
            //写入字符串
            fw.write(str);
            //写入字符串str，从索引0开始，写入俩个字符 '我''是'
            fw.write(str, 0, 2);
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.续写和换行：操作类似于FileOutputStream。

package com.io;

import java.io.*;

/**
 * @author:王先生
 * @date:公元2019/9/7 21:37
 */
public class FRtest {
    public static void main(String[] args) {
        try {
            //使用File对象创建流对象
            File file = new File("e.txt");
            FileWriter fw = new FileWriter(file, true);
            //定义字符串
            String str = "我是攻城狮";
            //写入字符串
            fw.write(str);
            //写出换行
            fw.write("\r\n");
            //写入字符串str，从索引0开始，写入俩个字符 '我''是'
            fw.write(str, 0, 2);
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

结果：
在这里插入图片描述
注意：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。
当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流。

写代码的蜗牛丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java IO流（一）基础知识
Xinghf
04-17 1584
<!-- @font-face {font-family:宋体} @font-face {font-family:宋体} @font-face {font-family:Calibri} @font-face {font-family:"\@宋体"} p.MsoNormal, li.MsoNormal, div.MsoNormal {margin:0cm; mar
Java IO流（一）
苦行僧的博客
06-16 153
IO流概述及其分类：1.概念:    .IO流用来处理设备之间的数据传输。       . Java对数据的操作是通过流的方式。       . Java用于操作IO 流的类都在IO包（java.io）中。       . 流按流向分为两种：输入流，输出流。       . 流按操作类型分为两种：字节流与字符流。（字节流：字节流可以操作任何数据，因为在计算机中任何数据都是以字节的形式  存储的；字...
Java IO详解
liwangcuihua的博客
06-06 7119
IO即Input和Output，即输入和输出。这里的输入和输出都是相对于内存来说的。
【JAVA IO 详细介绍】
weixin_44273248的博客
12-20 2867
Java IO流
JavaIO流,Properties集合,IO工具类详细介绍
最新发布
几许的博客
06-21 812
IO流的介绍 , 分类 ; 字节输出流 , 输入流以及缓冲区流介绍 ; Properties集合使用
Java IO学习和总结（超详细）
我的青春一去不复返
01-09 3009
Java IO详细解读
怒肝两万字 Java 中的 IO（详细篇）
lt_xiaodou的博客
10-09 1438
Java BIO 就是传统的 Java IO 编程，其相关的类型和接口是在 java.io 包中。BIO（blocking I/O）同步阻塞，服务器实现模式为一个连接一个线程，即客户端游连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情就会造成不必要的线程开销，可以通过线程池机制来进行改善（实现多个客户连接服务器）
Java IO流 文件传输基础
09-02
在Java中，IO流提供了多种类来处理文件操作，如`FileInputStream`和`FileOutputStream`用于基本的字节流操作，`FileReader`和`FileWriter`用于字符流操作。这些类允许开发者读取或写入文件，同时可以配合缓冲区(`...
javaIO流javaIO流javaIO流
07-02
理解并熟练掌握IO流的使用是Java开发者的基本功，也是提升程序性能和可维护性的关键。通过合理选择和组合不同的流类型，可以实现复杂的数据处理需求。在分析给定的压缩包文件“file-io-app”和“io-app2”，我们可以...
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而字符流用于处理文本数据。 Java中的...
Java IO流文档
03-31
### Java IO流详解 #### 一、Input和Output Stream概览 在Java中，输入输出流（简称IO流）是用来处理文件读写的核心技术之一。它主要包括两类：以字节为导向的流和以字符为导向的流。 ##### 1.1 以字节为导向的流...
Java-Io流，练习
07-06
Java的IO流分为四种基本类型，按照数据流动方向可分为： - 输入流（InputStream/Reader）：用于数据的读取。 - 输出流（OutputStream/Writer）：用于数据的写入。 - 双向流（如PipedInputStream/PipedOutputStream，...
JSD-2204-API-JavaIO-Day02
TheNewSystrm的博客
05-31 530
API-JavaIO
JAVA IO
南 阳 的博客
07-23 647
在Java编程中，输入和输出（Input/Output，简称I/O）是非常重要的概念。Java提供了丰富和强大的I/O类库，用于处理各种输入和输出操作。本文将介绍Java中的I/O概念以及常用的I/O类的使用方法。以上是关于Java I/O的简要介绍和常用类的示例。Java的I/O类库提供了丰富的功能和灵活的操作方式，可以满足各种输入和输出需求。希望本文对小伙伴们理解和使用Java I/O类库有所帮助！
Java I/O流详解
qq_28791753的博客
03-21 2003
JAVA I/O流详解，字节流，字符流
java io
喵酱
10-06 1310
java io
Java之I\O操作-超详细
玩转Java
10-09 1075
I\O流
Java IO流详解：InputStream核心方法
在Java的IO系统中，InputStream是所有字节输入流的基类，它提供了读取字节数据的基本方法。以下是对这些方法的详细说明： 1. `int read()`：此方法读取输入流中的一个字节，并以整数形式返回（0到255之间）。如果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值