流(IO流)：inputStream outputStream 作用：实现两个设备之间的数据传输
设备：能够输入信息或者输出信息的东西：磁盘（硬盘），内存，键盘，文件，网络，控制台
网络：当前主机之外的网上资源
分类：
根据操作的方式：输入流和输出流
根据数据的类型：字节流和字符流
字节流：传输的是字节，可以操作任意类型的数据 ----音频，视频，文件，图片等
字符流：传输的是字节，不同点是在传输过程中加入编码的操作（例如在写时自动把字符串中的每个字符转成字节），让我们操作更方便--文本。
因内存作为参考
字节流：
字节输入流：InputStream
字节输出流：OutputStream
字符流的两个父类：
字符读入流（将数据输入内存[数组之类的]）:Reader
字符写出流（将数据从内存取出）：Writer
实例：研究字符流
以硬盘的数据存储为例，将数据写入文件
分析：操作的是文本文件。所以使用字符流
是将数据从内存写入硬盘，所以是字符写出流
import java.io.*;
public class Demo4 {
public static void main(String[] args) throws IOException {
//1创建FileWriter对象，并关联文件
//只写名字，不写具体路径的话：默认路径为当前的工程
//如果文件不存在的话FileWriter会自己创建一个文件
//当该文件已经存在，会清空并覆盖原文件
//可以创建自己的路径，但是一定要保证路径是真实存在的
//只能创建文件，不能创建路径
//否则报异常：FileNotFoundException这是一个典型的编译异常
FileWriter fw=new FileWriter("temp1.txt");
//2进行写操作
//在执行write方法时，临时将内容写入了流的字节数组中(内存)，这里会
//自动去查编码表,得到字节数组
fw.write("bingbing");
//刷新---会将真正的内容写入磁盘
fw.flush();//这句可以不写
fw.close();//这里的close有两个功能：刷新，关闭
//注意：流使用完必须关闭
//当流关闭后，不能再进行写操作，否则报异常
}
}package day21;
import java.io.*;
/*实现读入操作
* 分析：文件---字节流
* 读入操作---字节读入流---FileReader
*
*/
public class Demo5 {
public static void main(String[] args) throws IOException {
//1创建对象关联文件
FileReader fr=new FileReader("temp1.txt");
/*
* 进行读操作
* read()一次读一个字符
* read(数组)一次读多个字符，读到的字符会临时存放在临时数组(字符数组)中
*/
//read()一次读一个字符
//a:会将当前的字符读入，b会将指针指向下一个字符
//方法的返回值就是读到的字符，当将所有的字符读完的时候返回-1
int num=0;
while((num=fr.read())!=-1)
System.out.println(num);
fr.close();
}
}
package day21;
import java.io.*;
public class Demo6 {
public static void main(String[] args) throws IOException {
//read(数组)
//数组是临时存数据的地方，数组的大小决定了我们一次读到的字符个数
//一般这个数组的大小在1kb左右
//返回值代表：当次读到的真实字符的个数
//如果返回值是-1代表读完了
FileReader fr=new FileReader("temp1.txt");
int len=0;
char[] arr=new char[2];
while((len=fr.read(arr))!=-1)
{
System.out.print(new String(arr,0,len));
//左闭右开
}
fr.close();
}
}
package day21;
import java.io.*;
public class Demo7 {
/*
* 关于\
* \代表转义字符，它会把它后面紧跟着的字符转义，成为一个字符
* \t横向跳格
*\\才是\
* 在表示目录的时候\\和/都可以
*
* 关于绝对路径和相对路径
* 绝对路径：从根目录开始，到当前的文件
* 相对路径：从路径中的某一个部位开始一直到当前的文件
*
*/
public static void main(String[] args) throws IOException {
/*
* 实例：完成文件的复制
* 要求：将Demo1.java复制到temp2.txt它的路径是当前的工程
*/
//读入
FileReader fr=new FileReader("D:\\eclipseWorkSpace\\se1\\src\\day21\\Demo1.java");
//也可以写成：FileReader fr=new FileReader("D:/eclipseWorkSpace/se1/src/day21/Demo1.java");
//写出
FileWriter fw=new FileWriter("temp2.txt");
int len=0;
char[] arr=new char[2];
while((len=fr.read(arr))!=-1)//读到数组(内存)里
{
fw.write(arr,0,len);//写到文件里(硬盘)
fw.flush();
}
fw.close();
fr.close();
}
}
package day21;
import java.io.FileWriter;
import java.io.IOException;
/*
* 文件的续写--FileWriter(路径,value)
* 当value=true的时候，不会将原来的内容删掉，往后接着写
*/
public class Demo8 {
public static void main(String[] args) {
FileWriter fw=null;
try {
fw = new FileWriter("temp3.txt",true);
fw.write("aaaaaa");
fw.write("\r\n");//windows换行\r\n Linux换行:\n
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fw!=null)
//什么情况下fw会为null?路径不存在的时候，或者在过程中操作不当
//判断是因为关流会消耗资源，如果本来就是null再关流耗费了资源
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package day21;
import java.io.*;
/*
* 字符缓冲流(字符缓冲区)：本身没有读写的能力，可以提高读写的效率，如果要想进行读写，必须借助于字符流
* 可以将缓冲流比作：催化剂
* 字符缓冲流分类：
* 字符缓冲读入流：BufferedReader--提高读的能力
* 字符缓冲写出流：BufferedWriter--提高写的能力
*
*
*
*
*/
public class Demo9 {
public static void main(String[] args) throws IOException {
//使用字符缓冲写出流实现写
//1创建字符写出流并关联文件
//2创建字符缓冲写出流并关联字符写出流
BufferedWriter bw=new BufferedWriter(new FileWriter("temp4.txt"));
//3写
bw.write("bingbing");
//bw.write("\r\n");//windows上的换行\r\n Linux上为\n
bw.newLine();//换行，好处是自动跨平台实现换行
//这也是使用字符缓流的原因之一，该方法是字符缓冲写出流的。
bw.write("abcde");
//4关流
bw.close();
}
}
package day21;
import java.io.*;
//用符节缓冲流除了提高效率，是因为想用：
//readLine()
//newLine()
/*
* 字符缓冲读入流--BufferedReader
*/
public class Demo10 {
public static void main(String[] args) throws IOException {
//1创建字符缓冲读入流并关联字符读入流
BufferedReader br=new BufferedReader(new FileReader("TestDemo.txt"));
//2读
//一次读一个字符
int num=0;
while((num=br.read())!=-1)//字符对应的ascii码
{
System.out.print((char)num);
}
//一次读多个字符
char[] arr=new char[2];
while((num=br.read(arr))!=-1)
{
System.out.print(new String(arr,0,num));
}
//一次读一行readLine---返回值String(代表读到的内容)（BufferedReader特有的方法）
//原理：一个字符一个字符的读(一直读到换行符)，读到可变字符串中，返回
//注意点：a这里不会将换行符(\r\n)读进来 b返回值就是读到的内容，当所有的内容读完时返回null
String data=null;
while((data=br.readLine())!=null) {
System.out.print(data);
System.out.print("\r\n");//只能用于windows系统
}
//3关流
br.close();
}
}
package day21;
import java.io.*;
/*
* 使用字符缓冲流完成文件的复制
*/
public class Demo11 {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new FileReader("D:\\eclipseWorkSpace\\se1\\src\\day21\\Demo1.java"));
BufferedWriter bw=new BufferedWriter(new FileWriter("temp11.txt"));
String hehe=null;
while((hehe=br.readLine())!=null)
{
bw.write(hehe);
bw.newLine();
}
bw.close();
br.close();
}
}
package day21;
import java.io.*;
/*
* 特殊的缓冲流：
* LineNumberReader:是缓冲流，父类是BufferedReader，特有功能：
* 设置行号，获取行号
*
*/
public class Demo12 {
public static void main(String[] args) throws IOException {
LineNumberReader lnr=new LineNumberReader(new FileReader("temp1.txt"));
//设置行号：默认行号是从i行开始设置，从i+1开始计数
lnr.setLineNumber(5);//设置为从5开始设置,从6开始计数(第一行为6)
//我们可以根据具体情况指定行号
String data=null;
while((data=lnr.readLine())!=null) {
System.out.print(lnr.getLineNumber());
System.out.print(data);
System.out.println();
}
}
}
总结：
package day21;
import java.io.*;
public class TestDemo {
//总结：
//读的话每次都要存下来
//int a=fr.read() a为单个字符的ascii码
//int len=fr.read(arr) arr为字符数组，返回值是读入字符的有效长度
//fw.write(s);s为字符串
//fw.write(s,0,len);//写出[0,len-1]范围的字符串
//FileWriter fw=new FileWriter("文件名")覆盖写
//FileWriter fw=new FileWriter("文件名",true)追加写
//字符流绑定缓冲流用有的能力：
//bw.newLine()写出换行，适用于不同平台
//br.readLine()读入一行，返回值类型为String,不会把换行如\r\n读进来，读到文件末尾返回null
//
//用字节写出流在文件中写字符串
static void f1() throws IOException
{
FileWriter fw=new FileWriter("TestDemo.txt");
fw.write("bingbing");//可以直接写字符串
fw.close();//1.刷新2.关闭
}
//文件读入流读入文件中的内容，每次只读一个字符
static void f2() throws IOException
{
FileReader fr=new FileReader("TestDemo.txt");
int num=0;
while((num=fr.read())!=-1)//fr.read()返回值是int型，返回的是字符的ascii码
{
System.out.println(num);
}
fr.close();
}
//文件读入文件的内容，每次读到字符数组里
static void f3() throws IOException
{
FileReader fr=new FileReader("TestDemo.txt");
int len=0;
char[] arr=new char[2];
//该read方法参数为char[]，返回值为int为有效字符的个数
while((len=fr.read(arr))!=-1) {
System.out.println(new String(arr,0,len));
//该方法左闭右开
}
fr.close();
}
//文件的复制
static void f4() throws IOException {
FileReader fr=new FileReader("TestDemo.txt");
FileWriter fw=new FileWriter("TestDemo.txt.swp");
int len=0;
char[] arr=new char[2];
while((len=fr.read(arr))!=-1)
{
fw.write(arr,0,len);
fw.flush();//刷新**
}
fw.close();
fr.close();
}
//文件写：追加
static void f5()
{
FileWriter fw=null;
try {
fw=new FileWriter("TestDemo.txt",true);
fw.write("my name is juruo");
fw.write("\r\n");
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fw!=null)
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//字符缓冲流写
static void f6() throws IOException
{
//为true时可以追加
BufferedWriter bw=new BufferedWriter(new FileWriter("TestDemo.txt",true));
bw.write("today");
bw.newLine();
bw.write("my mind is not good");
bw.close();//注：关字符缓冲流的时候，它会自动帮你关掉里面绑定的字符流
}
//字符缓冲流读,一次读一个字节
static void f7() throws IOException
{
BufferedReader br=new BufferedReader(new FileReader("TestDemo.txt"));
int num=0;
while((num=br.read())!=-1)
{
System.out.print((char)num);
}
}
//字符缓冲流读,一次读一个字符数组
static void f8() throws IOException
{
BufferedReader br=new BufferedReader(new FileReader("TestDemo.txt"));
char[] arr=new char[2];
int len=0;
while((len=br.read(arr))!=-1)
{
System.out.print(new String(arr,0,len));
}
}
//字符缓冲流读，一次读一行
static void f9() throws IOException {
BufferedReader br=new BufferedReader(new FileReader("TestDemo.txt"));
String data=null;
while((data=br.readLine())!=null)
{
System.out.println(data);
System.out.println("\r\n");//写到控制台的话相当于连续换了两行
}
}
//使用字符缓冲流完成文件的复制
static void f10() throws IOException
{
BufferedReader br=new BufferedReader(new FileReader("TestDemo.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("TestDemo.txt.swp"));
String data=null;
while((data=br.readLine())!=null)
{
bw.write(data);
bw.newLine();
}
bw.close();
br.close();
}
//特殊的缓冲流：LineNumberReader
static void f11() throws IOException
{
LineNumberReader lnr=new LineNumberReader(new FileReader("TestDemo.txt"));
lnr.setLineNumber(0);
String data=null;
while((data=lnr.readLine())!=null) {
System.out.print(lnr.getLineNumber());
System.out.print(data);
System.out.println();
}
}
public static void main(String[] args) throws IOException {
//f1();
//f2();
//f3();
//f4();
//f5();
//f6();
//f7();
//f8();
//f9();
//f10();
f11();
}
}