IO流的分类与 FileOutputStream的构造方法
package outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* IO流的分类与 FileOutputStream的构造方法
*
* IO流的分类:
* 流向:
* 输入流 读取数据
* 输出流 写出数据
* 数据类型:
* 字节流:
* 字节输入流 读取数据 InputStream
* 字节输出流 写出数据 OutputStream
* 字符流:
* 字符输入流 读取数据 Reader
* 字符输出流 写出数据 Writer
* 注意:
* 一般在讨论IO流的时候,如果没有明确说出按哪种分类来说,默认情况下按数据分类来使用
*
* 需求:我要往一个文本文件中输入一句话:hello,io.
*
* 分析:
* A:本操作最好使用字符流使用,但现在使用字节流演示
* B:由于是写入一句话,所以使用字节输出流
*
* 所以要使用:OutputStream.
* 但通过查看API,发现该流对象是一个抽象类,不能实例化.
* 所以使用一个具体的子类:FileOutputStream
*
* FileOutputStream的构造方法:
* FileOutputStream(File file);
* FileOutputStream(String name);两种方法其实相同
*
* 字节输出流操作步骤:
* 创建字节输出流对象
* 写数据
* 释放资源
*/
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
// 创建字节流输出对象
// FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("fos.txt");
// 创建字节流输出对象做了几件事情
// 1.调用系统功能去创建文件
// 2.创建fos对象
// 3.把fos对象指向这个文件
// 写数据
fos.write("hello,io".getBytes());
// 释放资源
// 关闭此文件输出流并释放与此流有关的所有系统资源
fos.close();
/*
* 为什么一定要close()呢?
* 1.让流对象变成垃圾,以被垃圾回收器回收
* 2.通知系统去释放跟该文件有关的系统资源
*/
}
}
FileOutputStream的三个Write()方法
package outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* FileOutputStream的三个Write()方法
* 字节输出流操作步骤:
* 创建字节输出流对象
* 写数据
* 释放资源
*
* public void write(Int b);写一个字节
* public void write(byte[] b);写一个字节数组
* public void write(byte[] b,int off,int len);写一个字节数组的一部分
*/
public class FileOutputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 创建字节流输出对象
FileOutputStream fos = new FileOutputStream("fos2.txt");
// 调用write();
fos.write(97);
// public void write(byte[] b);写一个字节数组
byte[] b = { 97, 98, 99, 100, 101 };
fos.write(b);
// public void write(byte[] b,int off,int len);写一个字节数组的一部分
fos.write(b, 1, 3);
// 释放资源
fos.close();
}
}
数据的换行和数据的追加写入
package outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 数据的换行和数据的追加写入
*
* 如何实现数据的换行?
* 写入换行符号即可
*
* 注意:
* 不同的系统对于不同的换行符识别不一样
* windows:\r\n
* linux:\n
* Mac:\r
* 常见的高级笔记本可以任意识别换行符
*
* 如何实现数据的追加写入?
* public FileOutputStream(String name,boolean append)
* 如果第二个参数为true,则将字节写入文件末尾处,而不是写入文件开始处
*/
public class FileOutputStreamDemo3 {
public static void main(String[] args) throws IOException {
// 创建字节流输出对象
FileOutputStream fos = new FileOutputStream("fos3.txt");
// 如果第二个参数为true,则将字节写入文件末尾处,而不是写入文件开始处
FileOutputStream fos2 = new FileOutputStream("fos3.txt", true);
// 写数据
for (int i = 0; i < 10; i++) {
fos.write(("hello" + i).getBytes());
fos.write("\r\n".getBytes());
}
for (int i = 0; i < 10; i++) {
fos2.write(("hello" + i).getBytes());
fos2.write("\r\n".getBytes());
}
// 释放资源
fos.close();
}
}
加入异常处理的字节输出流
package outputstream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 加入异常处理的字节输出流
*/
public class FileOutputStreamDemo4 {
public static void main(String[] args) {
// 分开做异常处理,可读性很差
// FileOutputStream fos=null;
// try {
// fos = new FileOutputStream("fos4.txt");
// } catch (FileNotFoundException e) {
// e.printStackTrace();
// }
//
// try {
// fos.write("保护刘波".getBytes());
// } catch (IOException e) {
// e.printStackTrace();
// }
//
// try {
// fos.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// 一起做异常处理
// try {
// FileOutputStream fos = new FileOutputStream("fos4.txt");
// fos.write("保护刘波".getBytes());
// fos.close();
// } catch (FileNotFoundException e) {
// e.printStackTrace();
// } catch (IOException e) {
// e.printStackTrace();
// }
// 改进版
FileOutputStream fos = null;
try {
fos = new FileOutputStream("fos4.txt");
fos.write("保护刘波".getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 如果fos不是null,才需要close
if (fos != null) {
// 为了保证close一定会执行,所以放到这里
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileInputStream的read()方法
package inputstream;
import java.io.FileInputStream;
import java.io.IOException;
/*
* FileInputStream的read()方法
*
* 字节输入流操作步骤:
* 创建字节输入流对象
* 调用read()读取数据,并输出在控制台
* 释放资源
*
* 读取数据的方式:
* int read();一次读取一个字节
* int read(byte[] b);一次读取一个字节数组
*/
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("fis.txt");
// //调用read()读取数据,并输出在控制台
// int by=fis.read();
// System.out.println(by);
// System.out.println((char)by);
//
// 改进版代码
int by = 0;
// 读取,赋值,判断
while ((by=fis.read()) != -1) {
System.out.print((char) by);
}
fis.close();
}
}
计算机是如何识别什么时候该把两个字节转化成一个中文呢
package example;
import java.util.Arrays;
/*
* 计算机是如何识别什么时候该把两个字节转化成一个中文呢
*
* 在计算机中中文的存储分两个字节:
* 第一个字节肯定是负数。
* 第二个字节常见的是负数,可能有正数。但是没影响
*
*/
public class StringDemo {
public static void main(String[] args) {
// String s = "abcd";
String s = "我爱你中国";
// [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
byte[] bys = s.getBytes();
System.out.println(Arrays.toString(bys));
}
}
一次读取一个字节数组:int read(byte[] b)
package inputstream;
import java.io.FileInputStream;
import java.io.IOException;
/*
* 一次读取一个字节数组:int read(byte[] b)
* 返回其实是实际读取取的字节个数。
*
*/
public class FileInputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
// FileInputStream fis = new FileInputStream("fis2.txt");
FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
// 读取数据
// 定义一个字节数组
// 第一次读取
// byte[] bys = new byte[5];
// int len = fis.read(bys);
// System.out.println(len);
// System.out.println(new String(bys, 0, len));
//
// // 第二次读取
// len = fis.read(bys);
// System.out.println(len);
// System.out.println(new String(bys, 0, len));
//
// // 第三次读取
// len = fis.read(bys);
// System.out.println(len);
// System.out.println(new String(bys, 0, len));
//
// // 第四次读取
// len = fis.read(bys);
// System.out.println(len);
// System.out.println(new String(bys, 0, len));
// // 代码重复了,用循环改进
// // 但是我不知道循环条件
// len = fis.read(bys);
// System.err.println(len);
// len = fis.read(bys);
// System.err.println(len);
// 如果读取到的实际数据是-1,就说明没有数据了
// byte[] bys = new byte[115];
// int len = 0;
// while ((len = fis.read(bys)) != -1) {
// System.out.print(new String(bys, 0, len));
// // System.out.println(new String(bys));//千万要带上len的使用
// }
// 最终代码版
// 数组的长度一般是1024或者1024的整倍数
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
// 释放资源
fis.close();
}
}