JAVA中的那些流 你知道么
导读：字节输出流FileOutputStream(String name 创建一个向具有指定名称的文件中写入数据的输出文件流FileOutputStream(file file 创建一个向指定file对象中写入数据的输出文件流作用：1.创建一...
字节输出流
FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(file file) 创建一个向指定file对象中写入数据的输出文件流
作用：
1.创建一个FileOutputStream对象
2.会根据构造方法中传递的文件文件路径 创建一个空的文件
3.会把FileOutputStream对象指定向创建好的文件
使用：
1.创建一个FileOutputStream对象，写入目的地
2.调用FileOutputStream对象中的方法，写入数据
3.释放资源
close() 关闭输出流释放资源
flush() 刷新内容
write(byte[] b) 把字节数组写入输出流
write(byt[] b,int off,int len) 从指定的字节数组邪恶如len字节，从偏移量off开始输出到此输出流
write(int b) 将指定的字节输出流
写单个字节
import java.io.FileOutputStream;
import java.io.IOException;
public class DemoFileOutputStream {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a.txt");
fos.write(97);
fos.close();
}
}
写多个字节
package file;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
public class DuoFileOutputStream {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\b.txt");
// 字节数组
byte[] bytes = {
66,67,68,69,70}
;
fos.write(bytes);
// 字节数组 分割
byte[] bytes1 = {
65,66,67,68,69,70}
;
// 从索引2开始 ，写为五个字节
fos.write(bytes1,2,2);
// 中文字符写入
byte[] bytes2 = "你好".getBytes();
System.out.println(Arrays.toString(bytes2));
//[-28, -67, -96, -27, -91, -67]
fos.write(bytes2);
fos.close();
}
字节追加写入 换行
true : 追加写入
flase：覆盖重写
package file;
import java.io.FileOutputStream;
import java.io.IOException;
public class Huanhang {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\c.txt",true);
for (int i = 0;
i 10 ;
i++) {
fos.write("你好".getBytes());
fos.write("\r\n".getBytes());
}
fos.close();
}
}
字节输入流
读取字节
import java.io.FileInputStream;
import java.io.IOException;
public class DemoRead {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt");
int a = 0;
while ((a = fis.read())!= -1){
System.out.println((char)a);
}
fis.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
public class Duoread {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt");
// 字符读取
byte[] bytes = new byte[4];
// 布尔表达式
int len = 0;
while ((len = fis.read(bytes))!=-1){
System.out.println(new String(bytes));
}
}
}
文件复制
数据源：c:\\1.jpg
目的地：c:\\2.jpg
创建字节输入流，读取图片
创建字节输出流，写入图片
字节输入流，读取文件
字节输出流，写入文件
关闭资源
package file;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("D:\\1.jpg");
FileOutputStream fos = new FileOutputStream("D:\\2.jpg");
// 第一种
//int len = 0;
//while ((len = fis.read())!=-1){
// fos.write(len);
//}
// 第二种
byte[] bytes = new byte[1024];
int a = 0;
while ((a = fis.read(bytes))!=-1){
fos.write(bytes,0,a);
}
fos.close();
fis.close();
}
}
GBK: 两个字节
UTF-8: 三个字节
字节流读取文件 中文字符 导致乱码 故引用字符输入流
字符输入流
字符出入流，是字符输入流的顶层父类，定义一些共性成员方法，一个抽象类
read() 读取单个字符并返回
read(char[] cbuf) 读取多个字符 并返回数组
close() 关闭资源
package file;
import java.io.FileReader;
import java.io.IOException;
public class ZiFuRead {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("D:\\Program Files\\jichu\\src\\file\\c.txt");
// 第一种方法 单个读取
// int len = 0;
// while ((len = fr.read())!= -1){
// System.out.println((char)len);
// }
// 第二种方法 字符数组
char[] chars = new char[4];
int ch = 0;
while ((ch = fr.read(chars))!=-1){
System.out.println(new String(chars));
}
fr.close();
}
字符输出流
write(int c) 写入单个字符
write(char[] char) 写入字符数组
write(char[] char,int off,int len) 写入字符某一部分，从索引n开始，写入n个字符
write(String str) 写入字符串
write(String str,int off,int len) 写入字符串某一部分，从索引n开始，写入n个字符
flush() 刷新缓冲
close() 关闭资源
package file;
import java.io.FileWriter;
import java.io.IOException;
public class DuoWrite {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("D:\\Program Files\\jichu\\src\\file\\d.txt");
fw.write("abc");
fw.write("你好");
fw.write(97);
char[] bytes = {
96,97,99}
;
fw.write(bytes);
fw.flush();
fw.close();
}
}
追加换行写入
package file;
import java.io.FileWriter;
import java.io.IOException;
public class HuanhangWriter {
public static void main(String[] args) throws IOException {
// true 追加写入
// false 覆盖重写
FileWriter fw = new FileWriter("D:\\Program Files\\jichu\\src\\file\\f.txt",true);
fw.write("test, 你好");
fw.write("\r\n");
fw.write("heihie");
fw.close();
}
属性集合
properties 表示一个持久性的属性集，可保存在流中或从流中加载
可以使用store 把集合中的临时数据 持久化写入到硬盘中
可以使用load ，把硬盘中保存的文件，读取到集合中使用
properties 是一个双列集合 key 和value 都是字符串 默认
setProperty(String key,String value) 写数据
getProperty(String key) 读数据 指定key 读value
stringPropertyNames() 返回此属性集列表中的键集，相当于map中的keyset方法
package file;
import java.util.Properties;
import java.util.Set;
public class DemoProperties {
public static void main(String[] args) {
// 创建属性集
Properties p = new Properties();
// 添加数据
p.setProperty("张三","166");
p.setProperty("李四","176");
p.setProperty("王五","186");
// 获取key 存储到集合里
SetString>
s = p.stringPropertyNames();
// 遍历集合 获取key值
for (String key : s) {
// 通过key 获取value
String value = p.getProperty(key);
System.out.println(key +"---"+ value);
}
}
}
store写入文件
package file;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class DemoProperties {
public static void main(String[] args) throws IOException {
// 创建属性集
Properties p = new Properties();
// 添加数据
p.setProperty("张三","166");
p.setProperty("李四","176");
p.setProperty("王五","186");
// 创建字符写入流
FileWriter fw = new FileWriter("D:\\Program Files\\jichu\\src\\file\\properties.txt");
// 使用store写入数据到文件
p.store(fw,"save data");
// 关闭资源
fw.close();
}
}
load读取文件
package file;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class DemoProperties {
public static void main(String[] args) throws IOException {
// 创建属性集
Properties p = new Properties();
// 使用load 读取文件
p.load(new FileReader("D:\\Program Files\\jichu\\src\\file\\properties.txt"));
// 获取key 存储set集合
SetString>
set = p.stringPropertyNames();
// 遍历数据
for (String key : set) {
String value = p.getProperty(key);
System.out.println(key +"----"+value);
}
}
}
缓冲流
缓冲流 也叫高效流
字节缓冲流 BufferedInputStream BufferedOutputStream
字符缓冲流 BufferedReader BufferedWriter
缓冲流的基原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统ID次数，从而提高读写的效率。
节流
BufferedInputStream() 创建一个新的缓冲输入流
BufferedOutputStream() 创建一个新的缓冲输出流
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class DemoBufferedOutputStream {
public static void main(String[] args) throws IOException {
FileOutputStream fs = new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\e.txt");
BufferedOutputStream bs = new BufferedOutputStream(fs);
bs.write("你好".getBytes());
bs.close();
}
}
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class DemoBufferedOutputStream {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("D:\\program Files\\jichu\\src\\file\\e.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
int len = 0;
while ((len = bis.read())!=-1){
System.out.println(len);
}
bis.close();
}
}
文件复制
package file;
import java.io.*;
public class DemoBufferedOutputStream {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis();
// C:\Users\20185\Desktop\1.jpg
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\20185\\Desktop\\1.jpg"));
// C:\Users\20185\Desktop\2.jpg
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\20185\\Desktop\\2.jpg"));
byte[] bytes = new byte[1024];
int len = 0;
while ((len = bis.read(bytes))!=-1){
bos.write(bytes,0,len);
}
bos.close();
bis.close();
long e = System.currentTimeMillis();
System.out.println("共花费"+(e-s)+"毫秒");
}
}
字符缓冲流
写文件
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class DemoBufferedWirte {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("D:\\Program Files\\jichu\\src\\file\\g.txt");
BufferedWriter bw = new BufferedWriter(fw);
bw.write("你好");
bw.newLine();
bw.write("世界");
bw.close();
}
}
读文件
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class DemoBufferedWirte {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("D:\\Program Files\\jichu\\src\\file\\g.txt"));
// 获取内容 一行输出
// String s = br.readLine();
// System.out.println(s);
// 定义一个空字符
String len ="";
// 当字符不为null 循环打印
while ((len = br.readLine())!=null){
System.out.println(len);
}
br.close();
}
}
文本内容排序
3.老虎没打到
4.打到小松鼠
2.上山打老虎
1.一二三四五
package file;
import java.io.*;
import java.util.HashMap;
public class DemoBufferedWirte {
public static void main(String[] args) throws IOException {
// 定义一个集合 存储键值
HashMapString,String>
map = new HashMap>
();
// 读文件
BufferedReader br = new BufferedReader(new FileReader("D:\\Program Files\\jichu\\src\\file\\g.txt"));
// 写文件
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\Program Files\\jichu\\src\\file\\out.txt"));
// 读行文字
String line ="";
while ((line = br.readLine())!=null){
// . 分割内容 存储到集合里
String[] array = line.split("\\.");
map.put(array[0],array[1]);
}
// 遍历集合 取key 和 value 重新组合
for (String key : map.keySet()) {
String vaule = map.get(key);
line = key +"."+vaule;
bw.write(line);
bw.newLine();
}
bw.close();
br.close();
}
}
1.一二三四五
2.上山打老虎
3.老虎没打到
4.打到小松鼠转换流
OutputStreamWrite() 写文件
InputStreatRead() 读文件
写文件
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class DemoOutputStreamWrite {
public static void main(String[] args) throws IOException {
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"),"gbk");
osw.write("你好");
osw.close();
}
读文件
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class DemoOutputStreamWrite {
public static void main(String[] args) throws IOException {
InputStreamReader isr =new InputStreamReader(new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"),"gbk");
int len = 0;
while ((len = isr.read())!=-1){
System.out.println((char)len);
}
isr.close();
}
文件类型转换
gbk 转 utf-8
import java.io.*;
public class DemoOutputStreamWrite {
public static void main(String[] args) throws IOException {
// gbk 格式读取文件
InputStreamReader isr =new InputStreamReader(new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"),"gbk");
// utf-8 格式 保存文件
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a1.txt"),"utf-8");
// 读文件 二写入 utf-8的格式
int len = 0;
while ((len = isr.read())!=-1){
osw.write(len);
}
osw.close();
isr.close();
}
序列化流
ObjectOutputStream() 写文件
ObjectInputStream() 读文件
特有方法：
writeObject() 写文件
readObjet() 读文件
写文件
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class DemoObjectOutputStream {
public static void main(String[] args) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"));
oos.writeObject("test");
oos.close();
}
}
读文件
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class DemoObjectOutputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"));
Object o = ois.readObject();
System.out.println(o);
ois.close();
}
}
序列化练习
package file;
import java.io.Serializable;
public class Persin implements Serializable {
private String name;
private int age;
public Persin(){
}
public Persin(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Persin{
" +
"name='" + name + '\'' +
", age=" + age +
'}
';
}
}
package file;
import java.io.*;
import java.util.ArrayList;
public class DemoObjectOutputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ArrayListPersin>
list = new ArrayList>
();
list.add(new Persin("张三",18));
list.add(new Persin("李四",19));
list.add(new Persin("王五",20));
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"));
oos.writeObject(list);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"));
Object o = ois.readObject();
ArrayListPersin>
list1 = (ArrayListPersin>
) o;
for (Persin p : list1) {
System.out.println(p);
}
ois.close();
oos.close();
}
}
打印流
PrintStream() 创建文件
import java.io.*;
public class DemoOutputStreamWrite {
public static void main(String[] args) throws IOException {
PrintStream ps = new PrintStream("D:\\Program Files\\jichu\\src\\file\\a.txt");
ps.println("aaa");
ps.println(97);
ps.print("test");
ps.close();
}
}
声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！
若转载请注明出处： JAVA中的那些流 你知道么
本文地址： https://pptw.com/jishu/303128.html