字节流、字符流复习

最新推荐文章于 2022-11-14 16:52:42 发布
最新推荐文章于 2022-11-14 16:52:42 发布
阅读量92 收藏
点赞数
分类专栏： 关于Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/isccai/article/details/111876705
版权

IO字节流，字符流

IO的分类

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

  • 输入流：把数据从其他设备上读取到内存中的流。硬盘–>内存
  • 输出流：把数据从内存中写出到其他设备上的流。内存–>硬盘
    格局数据的类型分为：字节流和字符流。
  • 字节流：以字节为单位，读写数据的流。
  • 字符流：以字符为单位，读写数据的流。

字节流

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

  • public void close()：关闭此输出流并释放与此流相关联的任何系统资源。
  • public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出。
  • public void write(byte[] b)：将b.length字节从指定的字节数组写入此输出流。
  • public void write(byte [] ,int off , int len)：从指定的字节数组写入len字节，从便宜量off开始输出到此输出流。
    2.FileOutputStream类
    java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。
    构造方法
  • public FileOutputStream(File file)：创建文件输出流以写入由指定的File对象表示的文件。
  • public FileOutputStream(String name)：创建文件输出流以指定的名称写入文件。
    当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。
    代码演示：
public class FileOutputStreamConstructor throws IOException {
public static void main(String[] args) {
// 使用File对象创建流对象
File file = new File("a.txt");
FileOutputStream fos = new FileOutputStream(file);
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("b.txt");
	}
}

写出字节数据

  1. 写出字节：write(int b)方法，每次可以写出一个字节数据，代码演示：
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 写出数据
fos.write(97); // 写出第1个字节
fos.write(98); // 写出第2个字节
fos.write(99); // 写出第3个字节
// 关闭资源
fos.close();
}
}
输出结果：
abc
  1. 写出字节数组：write(byte [] b)，
    代码演示
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串转换为字节数组
byte[] b = "黑马程序员".getBytes();
// 写出字节数组数据
fos.write(b);
// 关闭资源
fos.close();
}
}
输出结果：
黑马程序员```
  1. 写出指定长度字节数组：write (byte[] b,int off,int len)，每次写出从off索引开始，len个字节
    代码演示：
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
fos.write(b,2,2);
// 关闭资源
fos.close();
}
}
输出结果：
cd

数组追加续写
每次程序运行，创建输出流对象，都会清空目标文件中的数据，那么如何保留目标文件中数据，还能继续添加新数据呢？

  • public FileOutputStream(File file,boolean append)：创建文件输出流以写入由指定的File对象表示的文件。
  • public FileOutputStream(String name, boolean append)：创建文件输出流以指定的File对象 表示
    这两个构造方法，参数中都需要传入一个boolean类型的值，true表示追加数据，false表示清空原有数据。
    代码演示：
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt"，true);
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
fos.write(b);
// 关闭资源
fos.close();
}
}
文件操作前：cd
文件操作后：cdabcde

写出换行
Windows系统里，换行符号是\r\n。

public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 定义字节数组
byte[] words = {97,98,99,100,101};
// 遍历数组
for (int i = 0; i < words.length; i++) {
// 写出一个字节
fos.write(words[i]);
// 写出一个换行, 换行符号转成数组写出
fos.write("\r\n".getBytes());
}
// 关闭资源
fos.close();
}
}
输出结果：
a
b
c
d
e

字节输入流 InputStream

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

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

FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。
构造方法：

  • FileInputStream(File file)：通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的File对象file命名。
  • FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名。
    当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件，会抛出FileNoFoundException。
  • 构造举例，代码如下：
public class FileInputStreamConstructor throws IOException{
public static void main(String[] args) {
// 使用File对象创建流对象
File file = new File("a.txt");
FileInputStream fos = new FileInputStream(file);
// 使用文件名称创建流对象
FileInputStream fos = new FileInputStream("b.txt");
	}
}

读取字节数据

  1. 读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码演示：
public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");
// 读取数据，返回一个字节
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((char) read);
read = fis.read();
System.out.println((char) read);
// 读取到末尾,返回‐1
read = fis.read();
System.out.println( read);
// 关闭资源
fis.close();
}
}
输出结果：
a
b
c
d
e
‐1

使用循环改进读取方式：

public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");
// 定义变量，保存数据
int b ；
// 循环读取
while ((b = fis.read())!=‐1) {
System.out.println((char)b);//强制转换为char类型输出，循环之后自动提升为int类型
}
// 关闭资源
fis.close();
	}
}
输出结果：
a
b
c
d
e

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

public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象.
FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
// 定义变量，作为有效个数
int len ；
// 定义字节数组，作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=‐1) {
// 每次读取后,把数组变成字符串打印
System.out.println(new String(b));
}
// 关闭资源
fis.close();
}
}
输出结果：
ab
cd
ed

字符流

字符输入流：Reader

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

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

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

  1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表，idea中是UTF-8
  2. 字节缓冲区：一个字节数组，用来临时存储字节数据。
    构造方法：
  • FileReader(File file)：创建一个新的FileReader，给定要读取 的File对象
  • FileReader(String fileName)：创建一个新的FileReader，给定要读取 的文件的名称。
public class FileReaderConstructor throws IOException{
public static void main(String[] args) {
// 使用File对象创建流对象
File file = new File("a.txt");
FileReader fr = new FileReader(file);
// 使用文件名称创建流对象
FileReader fr = new FileReader("b.txt");
}
}

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

public class FRRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量，保存数据
int b ；
// 循环读取
while ((b = fr.read())!=‐1) {
System.out.println((char)b);
}
// 关闭资源
fr.close();
}
}
输出结果：
黑
马
程
序
员
  1. 使用字符数组读取：read(char [] byte) ,每次读取b的长度到字符数组中，返回读取到的有效字符个数，读取到末尾时，返回-1，代码演示：
public class FRRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量，保存有效字符个数
int len ；
// 定义字符数组，作为装字符数据的容器
char[] cbuf = new char[2];
// 循环读取
while ((len = fr.read(cbuf))!=‐1) {
System.out.println(new String(cbuf));
}
// 关闭资源
fr.close();
}
}
输出结果：
黑马
程序
员序

获取有效的字符改进，代码使用演示：

public class FISRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量，保存有效字符个数
int len ；
// 定义字符数组，作为装字符数据的容器
char[] cbuf = new char[2];
// 循环读取
while ((len = fr.read(cbuf))!=‐1) {
//输出cbuf数组，从第0个开始，输出len个字符。
System.out.println(new String(cbuf,0,len));
}
// 关闭资源
fr.close();
}
}
输出结果：
黑马
程序
员

字符输出流

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()：关闭此流。

FileWriter类

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

public class FileWriterConstructor {
public static void main(String[] args) throws IOException {
// 使用File对象创建流对象
File file = new File("a.txt");
FileWriter fw = new FileWriter(file);
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("b.txt");
}
}

基本写出数据：

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 写出数据
fw.write(97); // 写出第1个字符
fw.write('b'); // 写出第2个字符
fw.write('C'); // 写出第3个字符
fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
/*
【注意】关闭资源时,与FileOutputStream不同。
如果不关闭,数据只是保存到缓冲区，并未保存到文件。
*/
// fw.close();
}
}
输出结果：
abC田

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

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 写出数据，通过flush
fw.write('刷'); // 写出第1个字符
fw.flush();
fw.write('新'); // 继续写出第2个字符，写出成功
fw.flush();
// 写出数据，通过close
fw.write('关'); // 写出第1个字符
fw.close();
fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
fw.close();
}
}

写出其他数据

  1. 写出字符数组 ： write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数
    组中的数据，用法类似FileOutputStream，代码使用演示：
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 字符串转换为字节数组
char[] chars = "黑马程序员".toCharArray();
// 写出字符数组
fw.write(chars); // 黑马程序员
// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
fw.write(b,2,2); // 程序
// 关闭资源
fos.close();
}
}
  1. 写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的
    数据，更为方便，代码使用演示：
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 字符串
String msg = "黑马程序员";
// 写出字符数组
fw.write(msg); //黑马程序员
// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
fw.write(msg,2,2); // 程序
// 关闭资源
fos.close();
}
}
  1. 续写和换行：操作类似于FileOutputStream。
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象，可以续写数据
FileWriter fw = new FileWriter("fw.txt"，true);
// 写出字符串
fw.write("黑马");
// 写出换行
fw.write("\r\n");
// 写出字符串
fw.write("程序员");
// 关闭资源
fw.close();
}
}

属性集

概述：
java.util.Properties 继承于Hashtable，来表示一个持久的属性集。它使用简直结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，System.getProperties方法就是返回一个Properties对象。
Properties类
构造方法

  • public Properties()：创建一个空的属性列表。
    基本的存储方法
  • public Object setProperty(String key , String value)：保存一对属性。
  • public String getProperty(String key)：使用此属性列表中指定的键搜索属性值。
  • public Set stringProperteNames()：所有键的名称的集合。
public class ProDemo {
public static void main(String[] args) throws FileNotFoundException {
// 创建属性集对象
Properties properties = new Properties();
// 添加键值对元素
properties.setProperty("filename", "a.txt");
properties.setProperty("length", "209385038");
properties.setProperty("location", "D:\\a.txt");
// 打印属性集对象
System.out.println(properties);//{filename=a.txt, length=209385038, location=D:\a.txt}
// 通过键,获取属性值
System.out.println(properties.getProperty("filename"));//a.txt
System.out.println(properties.getProperty("length"));//209385038
System.out.println(properties.getProperty("location"));//D:\a.txt
// 遍历属性集,获取所有键的集合
Set<String> strings = properties.stringPropertyNames();
// 打印键值对
for (String key : strings ) {
System.out.println(key+" ‐‐ "+properties.getProperty(key));
//filename ‐‐ a.txt
//length ‐‐ 209385038
//location ‐‐ D:\a.txt
		}
	}
}
输出结果：

209385038
D:\a.txt
filename ‐‐ a.txt
length ‐‐ 209385038
location ‐‐ D:\a.txt

与流相关的方法

  • public void load(InputStream inStream)：从字节输入流中读取键值对。
public class ProDemo2 {
public static void main(String[] args) throws FileNotFoundException {
// 创建属性集对象
Properties pro = new Properties();
// 加载文本中信息到属性集
pro.load(new FileInputStream("read.txt"));
// 遍历集合并打印
Set<String> strings = pro.stringPropertyNames();
for (String key : strings ) {
System.out.println(key+" ‐‐ "+pro.getProperty(key));
}
}
}
输出结果：
filename ‐‐ a.txt
length ‐‐ 209385038
location ‐‐ D:\a.txt
isccai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 9 新特性 – 增强流 ( Stream ) API
qq_33291299的博客
01-17 210
Java 中引入了流 ( Stream ) 的概念，真的是大大方便了我们 java 程序员，我们可以使用流从一系列对象中执行聚合操作。其实，Java 8 中的流已经很强大了，而且只要涉及到 IO，只要涉及到对一系列数据进行操作，几乎都有流的影子。当然了，Java 9 还不忘对其继续增强，这次的改进主要是如何设置停止流的条件上。
java增强IO流--字节缓冲流&字符缓冲流
cat marshal的博客
05-13 570
缓冲流 之前学习了基本的一些流，作为IO流的入门，今天我们要见识一些更强大的流。 比如： 能够高效读写的缓冲流 能够转换编码的转换流 能够持久化存储对象的序列化流等等 这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。 1.1 概述 缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类： 字...
【Java】18 增强流
Demo_Null
05-07 301
功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。
Java中的IO流及其“增强流”
m0_51257288的博客
10-26 213
1 IO流 I代表输入，O代表输出，流代表数据流。 根据数据的流向分为：输入流和输出流。（内存与其他设备之间） 根据数据的类型分为：字节流和字符流。 2 字节流 不管是文件，图片，视频，在计算机中都是以二进制储存，所以字节流可以传输任何文件。 2.1 OutputStream字节输出流 OutputStream是所有字节输出流的父类。常用方法有： public void close();//关闭此输出流并释放与此流相关联的任何系统资源。 public void flush();//刷新此输出流并强制任何缓冲
缓冲流+转换流+序列化流+打印流
sgw101的博客
09-25 188
文章目录一.缓冲流1.1 概述1.2 字节缓冲流1.2.1 构造方法1.2.2 效率测试1.3 字符缓冲流1.3.1 构造方法1.3.2 特有方法1.4 练习:文本排序1.4.1 案例分析1.4.2 案例实现二.转换流2.1 字符编码和字符集2.1.1 字符编码2.1.2 字符集2.2 编码引出的问题2.3 InputStreamReader类2.3.1 构造方法2.3.2 指定编码读取2.4 O...
IO流(2)缓冲流：增强型字节流、字符流
超级无敌小胖头
03-25 230
文章目录一、缓冲流概述1. 缓冲流的基本原理二、字节缓冲流1. 构造方法2. 缓冲流的高效性（缓冲流实现大文件的复制）三、字符缓冲流1. 构造方法2. 字符缓冲流特有方法(readLine()/writeLine())2.1 readLine()2.2 newLine()3. 缓冲字符流实现对文本的排序 一、缓冲流概述 是对前面学习的4个基础的字节字符流的增强 FileOutputStream ...
JavaSE之IO流加强
最新发布
weixin_47543906的博客
11-14 170
Properties类介绍： 1.Properties实现了Map接口,就是一个双列集合可以存储键值对数据, 键和值都是字符串类型 2.Properties可以结合流进行操作, 可以把集合中的数据保存到流中, 也可以从流中来加载数据 Properties作Map集合的特有方法: Object setProperty(String key, String value) 添加键值对,修改键值对 String getProperty(Str
JAVA io流笔记05 增强流
wuyunhao 博客
12-22 183
package FileText; //字节流使用byte 数组！！！ //字符流使用char 数组！！！ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import ...
IO流加强(总结)--IO流总结和练习
weixin_37720904的博客
04-02 254
IO流知识点小结1.流都是用来传输数据的。2.传输数据时，一定要明确数据源和数据目的地（数据汇）3.数据源可以是文件、键盘和其他流。4.数据目的地可以是文件、显示器或者其他流。5，流只是帮助数据进行传输，可以在传输数据的时候进行处理。比如过滤处理、转换处理等。  使用要点：看顶层（字符流还是字节流，父类公共性功能），                  用底层（in，out或者其他子类具体对象）IO
Java IO流加强版实例
11-09
Java IO流加强版实例,均可使用，可以作为参考。
字节流和字符流的使用记录
qq_41286138的博客
08-27 313
一、FileInputSream基本用法 FileInputStream是按字节流读取数据的，读取文件时采用的编码方式即为文件自身编码方式，不需要手动指定。 FileInputStream in = new FileInputStream("test.txt"); read()方法会返回一个字节值，类型为int int a=in.read(); 或者一次读入多个字节，参数为byte数组 byte[] bytes = new byte[10]; in.read(bytes); 将得到的字节数组还原为字符
Java提高（五）IO流
ThinkMore
02-01 242
javaIO流 IO流对象继承关系 其他常用与流有关的对象： 字节流 字符流 文件类 File 打印流 PrintStream、PrintWriter 管道流 PipedInputStream、PipedOutputStream 序列流 SequenceI
Java学习之IO流的简单使用
码小春的博客
10-14 578
在我们平时使用图形化界面的时候，会发现来建立一个文件夹或者一个文档的时候很简单，只需要在桌面单击鼠标右键就可以了。但是，在我们写项目的时候想要把一些东西存到文件夹里面怎么办呐？ 不可能程序运行到需要文件夹的时候我再来到桌面或者哪里来手动建立一个文件或者文档吧？不要怀疑自己这样操作是肯定不行的，那有的人就会想了那我们怎么办呐？这不博主就来帮大家的忙了嘛，在java中有个东西叫做IO流就可以很好的解决这个问题。什么是IO流呐？接下来就由我来带领大家了解什么是IO流！ ...
Java中IO流的介绍和使用
qq_69401634的博客
07-02 526
此博客写了有关IO流的内容，包括IO简介、IO流入门案例、File类的使用、常用流对象、ApacFileReaderhe IO包等等
Java 9：流API的增强
最佳 Java 编程
06-06 122
Java 9向Stream接口添加了4种新方法： 1. dropWhile dropWhile方法类似于skip方法，但使用Predicate而不是固定的整数值。 当Predicate为true时，它将从输入流中删除元素。 然后将所有剩余的元素传递到输出流。 例如： IntStream.range(0, 10) .dropWhile(i -> i < 5)...
java中字符流读写文件_java 字符流实现文件读写操作（FileReader-FileWriter）
weixin_42121905的博客
02-27 207
java 字符流实现文件读写操作(FileReader-FileWriter) 备注：字符流效率高，但是没有字节流底层 字节流地址：http://pengyan5945.iteye.com/blog/1092120 Java代码 收藏代码 package com.frank.io; import java.io.BufferedReader; import java....
字节流和字符流的转换（及BufferedReader类的重要性）
lpp1234567的专栏
03-04 7207
一、简单介绍 Java支持字节流和字符流，也支持它们之间的转换。通过两个类实现：InputStreamReader、OutputStreamWriter。 1.  InputStreamReader java.lang.Object java.io.Reader java.io.InputStreamReader public class InputStr
java如何实现字符流_Java基于字符流形式读写数据的两种实现方法示例
weixin_39946313的博客
02-19 174
本文实例讲述了Java基于字符流形式读写数据的两种实现方法。分享给大家供大家参考，具体如下：第一种方式：逐个字符进行读写操作(代码注释以及详细内容空闲补充)package IODemo;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class CopyFileDemo {/...
增强流、转换流、打印流、序列化流
weixin_43917392的博客
12-14 159
增强流、转换流、打印流、序列化流 一、增强流 1、增强流 读取 BufferedReader A. 构造 BufferedReader br = new BufferedReader(new FileReader("路径")); B. 特有 String line = br.readLine(); //一次读取一行数据 2、增强流 写入 BufferedWriter A. 构造 Buff...
记录学习Android基础的心得04：Android五大存储&P1
YQYUN的博客
02-11 338
文章目录前言一、java语言原生支持的文件读写1.文件内容的操作2.文件的操作二、SharedPreferences共享参数1.三、基于application的全局内存四、SQLite轻量级数据库五、contentprovider内容提供器总结 前言 有什么东西始终掌握在我们手中呢？知识技能才是唯一的东西！ Android提供了各种各样的存储方式，总结来说有以下五种：基于java语言原生支持的文件读写，采用.xml格式存储简单数据的SharedPreferences共享参数，基于application

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值