IO 流
IO 流: 存储和读取数据的解决方案.
程序示例:
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo1 {
public static void main(String[] args) throws IOException {
/*
* 演示：字节输出流FileOutputStream
* 实现需求：写出一段文字到本地文件中。（暂时不写中文）
*
* 实现步骤：
* 创建对象
* 写出数据
* 释放资源
* */
// 1.创建对象
// 写出 输出流 OutputStream
// 本地文件 File
FileOutputStream fos = new FileOutputStream("myio\\a.txt");
// 2.写出数据
fos.write(97);
// 3.释放资源
fos.close();
}
}
程序示例:
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo2 {
public static void main(String[] args) throws IOException {
/*
字节输出流的细节：
1.创建字节输出流对象
细节1：参数是字符串表示的路径或者是File对象都是可以的
细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
细节3：如果文件已经存在，则会清空文件
2.写数据
细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符
‘9’
‘7’
3.释放资源
每次使用完流之后都要释放资源
*/
// 1.创建对象
FileOutputStream fos = new FileOutputStream("myio\\a.txt");
// 2.写出数据
fos.write(57);
fos.write(55);
// 3.释放资源
fos.close();
while (true) {
}
}
}
FileOutputStream 写数据的 3 种方式:
程序示例:
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo3 {
public static void main(String[] args) throws IOException {
/*
void write(int b) 一次写一个字节数据
void write(byte[] b) 一次写一个字节数组数据
void write(byte[] b, int off, int len) 一次写一个字节数组的部分数据
参数一：
数组
参数二：
起始索引 0
参数三：
个数 3
*/
// 1.创建对象
FileOutputStream fos = new FileOutputStream("myio\\a.txt");
// 2.写出数据
// fos.write(97); // a
// fos.write(98); // b
byte[] bytes = {97, 98, 99, 100, 101};
/* fos.write(bytes);*/
fos.write(bytes, 1, 2);// b c
// 3.释放资源
fos.close();
}
}
程序示例:
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo4 {
public static void main(String[] args) throws IOException {
/*
换行写：
再次写出一个换行符就可以了
windows： \r\n
Linux: \n
Mac: \r
细节：
在windows操作系统当中，java对回车换行进行了优化。
虽然完整的是\r\n，但是我们写其中一个\r或者\n，
java也可以实现换行，因为java在底层会补全。
建议：
不要省略，还是写全了。
续写：
如果想要续写，打开续写开关即可
开关位置：创建对象的第二个参数
默认false：表示关闭续写，此时创建对象会清空文件
手动传递true：表示打开续写，此时创建对象不会清空文件
*/
// 1.创建对象
FileOutputStream fos = new FileOutputStream("myio\\a.txt", true);
// 2.写出数据
String str = "kankelaoyezuishuai";
byte[] bytes1 = str.getBytes();
fos.write(bytes1);
// 再次写出一个换行符就可以了
String wrap = "\r\n";
byte[] bytes2 = wrap.getBytes();
fos.write(bytes2);
String str2 = "666";
byte[] bytes3 = str2.getBytes();
fos.write(bytes3);
// 3.释放资源
fos.close();
}
}
FileInputStream:
程序示例:
import java.io.FileInputStream;
import java.io.IOException;
public class ByteStreamDemo1 {
public static void main(String[] args) throws IOException {
/*
* 演示：字节输入流FileInputStream
* 实现需求：读取文件中的数据。（暂时不写中文）
*
* 实现步骤：
* 创建对象
* 读取数据
* 释放资源
* */
// 1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
// 2.读取数据
int b1 = fis.read();
System.out.println((char) b1);
int b2 = fis.read();
System.out.println((char) b2);
int b3 = fis.read();
System.out.println((char) b3);
int b4 = fis.read();
System.out.println((char) b4);
int b5 = fis.read();
System.out.println((char) b5);
int b6 = fis.read();
System.out.println(b6);//-1
// 3.释放资源
fis.close();
}
}
程序示例:
import java.io.FileInputStream;
import java.io.IOException;
public class ByteStreamDemo2 {
public static void main(String[] args) throws IOException {
/*
字节输入流的细节：
1.创建字节输入流对象
细节1：如果文件不存在，就直接报错。
Java为什么会这么设计呢？
输出流：不存在，创建
把数据写到文件当中
输入流：不存在，而是报错呢？
因为创建出来的文件是没有数据的，没有任何意义。
所以Java就没有设计这种无意义的逻辑，文件不存在直接报错。
程序中最重要的是：数据。
2.写数据
细节1：一次读一个字节，读出来的是数据在ASCII上对应的数字
细节2：读到文件末尾了，read方法返回-1。
3.释放资源
细节：每次使用完流之后都要释放资源
*/
// 1.创建对象
FileInputStream fis = new FileInputStream("myio\\b.txt");
// 2.读取数据
int b1 = fis.read();
System.out.println((char) b1);
// 3.释放资源
fis.close();
}
}
程序示例:
import java.io.FileInputStream;
import java.io.IOException;
public class ByteStreamDemo3 {
public static void main(String[] args) throws IOException {
/*
字节输入流循环读取
*/
// 1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
// 2.循环读取
int b;
while ((b = fis.read()) != -1) {
System.out.println((char) b);
}
// 3.释放资源
fis.close();
/* *//*
*
* read :表示读取数据，而且是读取一个数据就移动一次指针
*
* *//*
FileInputStream fis = new FileInputStream("myio\\a.txt");
//2.循环读取
while ((fis.read()) != -1) {
System.out.println(fis.read());//98 100 -1
}
//3.释放资源
fis.close();*/
}
}
程序示例:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo4 {
public static void main(String[] args) throws IOException {
/*
* 练习：
* 文件拷贝
* 把D:\itheima\movie.mp4拷贝到当前模块下。
*
* 注意：
* 选择一个比较小的文件，不要太大。大文件拷贝我们下一个视频会说。
*
* 课堂练习：
* 要求统计一下拷贝时间，单位毫秒
* */
long start = System.currentTimeMillis();
// 1.创建对象
FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");
// 2.拷贝
// 核心思想：边读边写
int b;
while ((b = fis.read()) != -1) {
fos.write(b);
}
// 3.释放资源
// 规则：先开的最后关闭
fos.close();
fis.close();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
按字节读取, 一次读取一个字节, 文件有多少个字节, 就要循环多少次.
FileInputStream 一次读取多个字节:
注意: 一次读一个字节数组的数据, 每次读取会尽可能把数组装满.
数组本身也是要占用存储空间的, 一般建议数组的长度为 1024 的整数倍, 例如 1024×1024×5.
程序示例:
import java.io.FileInputStream;
import java.io.IOException;
public class ByteStreamDemo5 {
public static void main(String[] args) throws IOException {
/*
public int read(byte[] buffer) 一次读一个字节数组数据
*/
// 1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
// 2.读取数据
byte[] bytes = new byte[2];
// 一次读取多个字节数据，具体读多少，跟数组的长度有关
// 返回值：本次读取到了多少个字节数据
int len1 = fis.read(bytes);
System.out.println(len1);// 2
String str1 = new String(bytes, 0, len1);
System.out.println(str1);
int len2 = fis.read(bytes);
System.out.println(len2);// 2
String str2 = new String(bytes, 0, len2);
System.out.println(str2);
int len3 = fis.read(bytes);
System.out.println(len3);// 1
String str3 = new String(bytes, 0, len3);
System.out.println(str3);// ed
// 3.释放资源
fis.close();
}
}
程序示例:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo6 {
public static void main(String[] args) throws IOException {
/*
* 练习：
* 文件拷贝
* 把D:\itheima\movie.mp4 (16.8 MB) 拷贝到当前模块下。
*
* */
long start = System.currentTimeMillis();
// 1.创建对象
FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");
// 2.拷贝
int len;
byte[] bytes = new byte[1024 * 1024 * 5];
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
// 3.释放资源
fos.close();
fis.close();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
浙公网安备 33010602011771号