IO 流
1、流,在我们程序中,所操作数据,以各种格式,从一个地方传输到另一个地方,这个过程就是
数据流。
2、I,Input,输入。
3、O,output ,输出。
4、输入,输出,基于 程序 是输入还是输出。
5、程序---文件(常用), 程序---网络 , 程序----内存。
6、java jdk 中给我们提供了很多,操作各种流的类型。
7、基于数据的本身,格式,分为:
a、字节流 (InputStream,OutputStream)
b、字符流 (Reader ,Writer)
8、基于流向:
a、输入流 (InputStream,Reader)
b、输出流 (OutputStream ,Writer)
9、流操作方式:
a、节点流(原始流)
b、处理流(封装流)
10、File ,文件流, 可以代表文件对象,也可以代表文件夹。
可以创建文件,也可以创建文件夹。
判断是不是文件,是不是文件夹,是不是隐藏文件。
可以拿到某个文件夹中的所有文件名,和文件对象。
11、基于字节流,输入流,对指定一个文件进行读取,
FileInputStream(new File("d://test.txt"))
FileInputStream("d://test.txt")
一个字节一个字节的度,read() ,返回一个 int 的字节数据。
一次性把所有的字节读到一个byte 数组中, read(bs),byte bs[] = new byte[in.avilable()];
12、文件copy
一边读取,另一边输出。
FileOutputStream(new File(“.....”),true);
FileOutputStream(".....",true);
第二个参数,代表不覆盖原来有的这个文件中数据,而是在文件上追加数据。
writer(int); 一次写一个字节。
writer (byte[]); 一次写一组字节。
flush();
colse(); finally 中关闭。
13、如果你是按照字节流来处理文件,是一个字节一个字节的读取,
这种情况下,如果有中文,中文会分为两个字节读取,那么在类型转换的时候,就会乱码。
如果要避免这个情况,我们就得使用字符流读取。
14、使用字符流,输入流,原始流,读取一个指定的文件
15、把Demo.java 这个文件 从D盘中,copy 到test 文件夹中,字符流,原始流。
16、 缓冲字节流,输入和输出,处理流
BufferedInputStream BufferedOutputStream
17、缓冲字符串,输入和输出,处理流
BufferedReader BufferedWriter
要求: 针对这几个类型,api 文档看看。
18、BufferedReader 中的两个方法。这两个方法在BufferedInputStream 中也有。
mark reset
19、处理流,转换流
InputStreamReader(in);
OutputStreamWriter(out);
20、数据流(数据类型流),在读取数据的时候或者输出数据的时候,是按照java 中的数据类型
而定义的(按照本身数据类型所占字节大小)。
DataInputStream DataOutputStream
利用数据流对内存进行一次操作。
字节数组流(ByteArrayInputStream,ByteArrayOutputStream)
数据流读取的时候,(要按照数据类型和读取的顺序)
1、流,在我们程序中,所操作数据,以各种格式,从一个地方传输到另一个地方,这个过程就是
数据流。
2、I,Input,输入。
3、O,output ,输出。
4、输入,输出,基于 程序 是输入还是输出。
5、程序---文件(常用), 程序---网络 , 程序----内存。
6、java jdk 中给我们提供了很多,操作各种流的类型。
7、基于数据的本身,格式,分为:
a、字节流 (InputStream,OutputStream)
b、字符流 (Reader ,Writer)
8、基于流向:
a、输入流 (InputStream,Reader)
b、输出流 (OutputStream ,Writer)
9、流操作方式:
a、节点流(原始流)
b、处理流(封装流)
10、File ,文件流, 可以代表文件对象,也可以代表文件夹。
可以创建文件,也可以创建文件夹。
判断是不是文件,是不是文件夹,是不是隐藏文件。
可以拿到某个文件夹中的所有文件名,和文件对象。
11、基于字节流,输入流,对指定一个文件进行读取,
FileInputStream(new File("d://test.txt"))
FileInputStream("d://test.txt")
一个字节一个字节的度,read() ,返回一个 int 的字节数据。
一次性把所有的字节读到一个byte 数组中, read(bs),byte bs[] = new byte[in.avilable()];
12、文件copy
一边读取,另一边输出。
FileOutputStream(new File(“.....”),true);
FileOutputStream(".....",true);
第二个参数,代表不覆盖原来有的这个文件中数据,而是在文件上追加数据。
writer(int); 一次写一个字节。
writer (byte[]); 一次写一组字节。
flush();
colse(); finally 中关闭。
13、如果你是按照字节流来处理文件,是一个字节一个字节的读取,
这种情况下,如果有中文,中文会分为两个字节读取,那么在类型转换的时候,就会乱码。
如果要避免这个情况,我们就得使用字符流读取。
14、使用字符流,输入流,原始流,读取一个指定的文件
15、把Demo.java 这个文件 从D盘中,copy 到test 文件夹中,字符流,原始流。
16、 缓冲字节流,输入和输出,处理流
BufferedInputStream BufferedOutputStream
17、缓冲字符串,输入和输出,处理流
BufferedReader BufferedWriter
要求: 针对这几个类型,api 文档看看。
18、BufferedReader 中的两个方法。这两个方法在BufferedInputStream 中也有。
mark reset
19、处理流,转换流
InputStreamReader(in);
OutputStreamWriter(out);
20、数据流(数据类型流),在读取数据的时候或者输出数据的时候,是按照java 中的数据类型
而定义的(按照本身数据类型所占字节大小)。
DataInputStream DataOutputStream
利用数据流对内存进行一次操作。
字节数组流(ByteArrayInputStream,ByteArrayOutputStream)
数据流读取的时候,(要按照数据类型和读取的顺序)
package com.salmon.test;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
public class Demo {
/**
* 使用字符流,输入流,原始流,读取一个指定的文件
*/
public static void test1() {
File file = new File("d://test/test2/test1.txt");
Reader r = null;
try {
r = new FileReader(file);
// 一个字符,两个字节
int i = 0;
while ((i = r.read()) != -1) {
System.out.print((char) i);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
r.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void test2() {
Reader r = null;
try {
//r = new FileReader("d://test/test2/test1.txt");
r = new FileReader("d://Demo.java");
char cs[] = new char[1000];
r.read(cs);
for (int i = 0; i < cs.length; i++) {
System.out.print(cs[i]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e){
e.printStackTrace();
} finally{
try {
r.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 字符流 输出流 原始流
* @param args
*/
public static void test3(){
File file = new File("d://demo.java");
Writer out = null;
try {
out = new FileWriter(file);
String msg = "public class HelloWorld{"
+ " public static void main(String args[]){"
+ "}"
+ "}";
//
out.write(msg);
//
out.flush();
} catch (IOException e) {
e.printStackTrace();
} finally{
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 使用字符流来对文件进行copy
* @param args
*
*/
public static void copy(){
File file = new File("D://Demo.java");
File newFile = new File("D://test/Demo.java");
Reader r = null;
Writer w = null;
try {
r = new FileReader(file);
w = new FileWriter(newFile);
//
int i = 0;
while((i = r.read()) != -1){
w.write(i);
}
w.flush();
} catch (Exception e) {
e.printStackTrace();
} finally{
try {
w.close();
r.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
//test2();
copy();
}
}
package com.salmon.test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;
public class Demo2 {
/**
* 字节 缓冲 输入 封装
*/
public static void test1() {
InputStream in = null;
BufferedInputStream bis = null;
try {
File file = new File("d://Demo.java");
in = new FileInputStream(file);
bis = new BufferedInputStream(in);
// 仅仅提供了缓冲区 提高了读取效率
byte bs [] = new byte[bis.available()];
bis.read(bs);
//
for (int i = 0; i < bs.length; i++) {
System.out.print((char)bs[i]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e){
e.printStackTrace();
} finally{
try {
in.close();
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 字节流 缓冲 输出流 处理流
* @param args
*/
public static void test2(){
BufferedOutputStream bos = null;
try {
bos = new BufferedOutputStream(
new FileOutputStream(
new File("d://test88.txt")));
String msg = "hello";
bos.write(msg.getBytes());
bos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e){
e.printStackTrace();
} finally{
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 字符 缓冲 输入流 处理流
* @param args
*/
public static void test3(){
BufferedReader br = null;
try {
br = new BufferedReader(
new FileReader(
new File("d://Demo.java")));
// 不光 提供了 缓冲区 还提供了 比较方便的方法
String msg = null;
while((msg = br.readLine()) != null){
System.out.println(msg);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e){
e.printStackTrace();
} finally{
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 字符流 输出流 缓冲 处理流
* @param args
* @throws IOException
*/
public static void test4() throws IOException{
File file = new File("d://test99.txt");
Writer out = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(out);
String msg = "hello world! 你好";
bw.write(msg);
bw.newLine();// 换行
bw.write("public class Hello{}");
bw.flush();
bw.close();
}
/**
* 字符 缓冲 输入流 处理流
* @param args
*/
public static void test5(){
BufferedReader br = null;
try {
br = new BufferedReader(
new FileReader(
new File("d://Demo.java")));
// 设置一个 标记
br.mark(100);
// 先读取一行
String msg = br.readLine();
System.out.println(msg);
String msg2 = br.readLine();
System.out.println(msg2);
String msg3 = br.readLine();
System.out.println(msg3);
// 回到那个标记点 再开始读取
br.reset();
// 不光 提供了 缓冲区 还提供了 比较方便的方法
String msg4 = null;
while((msg4 = br.readLine()) != null){
System.out.println(msg4);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e){
e.printStackTrace();
} finally{
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
/*try {
test4();
} catch (IOException e) {
e.printStackTrace();
}*/
test5();
}
}
package com.salmon.test;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
public class Demo3 {
/**
* 转换流 处理流 输入流
*/
public void test(){
try {
// 使用字节流 读取文件
File file = new File("d://Demo.java");
InputStream in = new FileInputStream(file);
// 把字节流 转换成 字符流
Reader isr = new InputStreamReader(in);
// 把字符流 封装成 缓冲流
BufferedReader br = new BufferedReader(isr);
String msg = "";
while((msg=br.readLine()) != null){
System.out.println(msg);
}
// 关闭资源 就近原则
br.close();
isr.close();
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
File file = new File("D://Demo22.java");
try {
OutputStream out = new FileOutputStream(file);
// 输出转换
Writer w = new OutputStreamWriter(out);
//
BufferedWriter bw = new BufferedWriter(w);
//
String msg = "hello world 你好";
//
bw.write(msg);
//
bw.newLine();
//
bw.write("dajiahao");
//
bw.flush();
//
bw.close();
w.close();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
package com.salmon.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class Demo4 {
public void test(){
// 在内存中 定义一个 能够存储数据的结构 (在内存中 新建了一个字节类型数组)
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 封装流 数据类型 来操作
DataOutputStream out = new DataOutputStream(baos);
try {
// 根据类型 和 顺序
out.writeInt(25);
out.writeBoolean(false);
out.writeUTF("hello");// 按照指定编码格式 把这个字符串写入到 内存中
// 输入流
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
//
DataInputStream in = new DataInputStream(bais);
// 根据类型 和 顺序
System.out.println(in.readInt());
System.out.println(in.readBoolean());
System.out.println(in.readUTF());
//
in.close();
bais.close();
out.close();
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
OutputStream w = new FileOutputStream(
new File("d://test77.txt"));
DataOutputStream dos = new DataOutputStream(w);
dos.writeInt(34);
dos.writeDouble(34.5);
dos.writeBoolean(true);
dos.flush();
dos.close();
w.close();
//
InputStream in = new FileInputStream("d://test77.txt");
DataInputStream dis = new DataInputStream(in);
System.out.println(dis.readInt());
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
dis.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}