Java当中的IO
IO的分类
第一种分：输入流和输出流
第二种分：字节流和字符流
第三种分：节点流和处理流
节点流处理数据，处理流是节点流基础上加工的。
IO中的重点：
InputStream
OutputStream
FileInputStream
FileOutputStreamInputStream
int read(byte[] b,int off,int len)OutputStream
void write(byte[] b,int off,int len)// 第一步，导入类import java.io.*;class Demo { public static void main(String[] args){ // 声明输入流的引用
FileInputStream fis = null; // 声明输出流的引用
FileOutputStream fos = null; try{ // 生成输入流的对象
fis = new FileInputStream("e:/from.txt"); // 生成代表输出流的对象
fos = new FileOutputSteam("e:/to.txt"); // 生成一个字节数组
byte[] buffer = new byte[100]; // 调用输入流对象的read方法
int temp = fis.read(buffer,0,buffer.length);
fos.write(buffer,0,temp); for(int i=0; i<buffer.length; i++){
System.out.println(buffer[i]);
}
}catch(Exception e){
System.out.println(e);
}
}
}
IO是为了对数据进行读写操作，数据的流向是以Java程序为参照物的，注意read方法和write方法。
流：在Java中输入和输出是通过流的类来实现的，Java提供了一套丰富的流类，可导入java.io，这样就可以完成输入和输出了，也同样可以实现网络操作等。
听到流，是不是很形象了呢？流好比一个走向，当程序中需要读取数据时，就会开启一个通向数据源的流，这个数据源可以是文件，内存，网络连接等，需要写入数据时，也会开启一个通向目的地的流。流好比连接起点到终点的路。
输入流：源到程序，即读，从数据源的地方输入到程序中，读即 一个文件里的内容读到程序中。
输出流：程序中输出到目的地，输出流，即写，一个文件写到另一个文件，从这边输出到另一边。
在Java中流：字节流，字符流都要掌握
InputStream
OutputStream
Reader
Writer重点早期的Java内容：InputStream和OutputStream，这两个都是基于字节流。
字符流：Reader和Writer
Java语言中的流分：文本流（字符序列）和二进制流
输入流和输出流
InputStream类为基本的输入流类，是抽象的类，在InputStream类中定义了read方法，用于读取数据的，读的。
OutputStream类为基本的输出类，是抽象的类，在OutputStream类中定义了write方法，用于输出数据，写的。
OutputStream类
清除缓冲区：public void flush()
关闭输出流：public void close()
其他重点：
在Java中提供了DataInputStream类与DataOutputStream类，数据输入流和数据输出流。在JDK1.1版本提供了InputStreamReader类与OutputStreamWriter类，它们是Reader、Writer类的子类，提供了字节流到字符流的转换。
字符流
BufferedReader类与BufferedWriter类分别是Reader类和Writer类的子类，输入和输出的缓冲区得以提供。
文件类
FileInputStream类为输入操作，是文件输入流类
import java.io.*;public class Demo{ public static void main(String[] args){ byte buffer[] = new byte[1024]; try{ // 创建FileInputStream类对象
FileInputStream fis = new FileInputStream("from.txt"); int temp = fis.read(buffer,0,buffer.length);
String str=new String(buffer,0,temp); // 输出字符串内容
System.out.println(str);
}catch(Exception e){
System.out.println(e);
}
}
}FileOutputStream类为输出类，与FileInputStream同理即可。
FileInputStream类，FileOutputStream类DataInputStream类，DataOutputStream类InputStream类，OutputStream类BufferedReader类，BufferedWriter类
说说IO
//第一种：输入流输出流//第二种：字节流字符流//第三种：节点流处理流//FileInputStreamclass Test{ public static void main(String args[]){
FileInputStream fis = null; try{
fis = new FileInputStream("e:/read.txt"); byte[] buffer = new byte[100];
fis.read(buffer,0,buffer.length); for(int i = 0;i<buffer.length;i++){
System.out.println(buffer[i]);
}
} catch(Exception e){
System.out.println(e);
}
}
}class Test{ public static void main(String args[]){
FileInputStream fis = null;
FileOutputStream fos = null; try{
fis = new FileInputStream("e:/read.txt");
fos = new FileOutputStream("e:/write.txt"); byte[] buffer = new byte[100]; int temp = fis.read(buffer,0,buffer.length);
fos.write(buffer,0,temp);
} catch(Exception e){
System.out.println(e);
}
}
}class Test{ public static void main(String args[]){
FileInputStream fis = null;
FileOutputStream fos = null; try{
fis = new FileInputStream("e:/read.txt");
fos = new FileOutputStream("e:/write.txt"); byte[] buffer = new byte[1024]; while(true){ int temp = fis.read(buffer,o,buffer.length); if(temp = -1){ break;
}
fos.write(buffer,0,temp);
}
}catch(Exception e){
System.out.println(e);
}finally{ try{
fis.close();
fos.close();
}catch(Excepiton e){
System.out.println(e);
}
}
}
} //字符流public class TextChar public static void main(String args[]){
FileReader fr = null;
FileWriter fw = null; try{
fr = new FileReader("e:/read.txt");
fw = new FileWriter("e:/write.txt");
char[] buffer = new char[100]; int temp = fr.read(buffer,0,buffer.length);
fw.write(buffer,0,temp);
} catch(Exception e){
System.out.println(e);
}finally{ try{
fr.close();
fw.close();
} catch(Excepiton e){
System.out.println(e);
}
}
}//FileReader和BufferedReaderclass Test{ public static void main(String args[]){
FileReader fileReader = null;
BufferedReader bufferedReader = null;try{
fileReader = new FileReader("e:/read.txt");
bufferedReader = new BufferedReader(fileReader);
String line = null; while(true){
line = bufferedReader.readLine(); if(line == null){
break;
}
System.out.println(line);
}
}catch(Exception e){
System.out.println(e);
} finally{ try{
bufferedReader.close();
fileReader.close();
} catch(Exception e){
System.out.println(e);
}
}
}
}public class Test{ public static void main(String[] args) throws Exception{ //字节流
FileInputStream in = new FileInputStream("c:/read.txt");
FileOutStream out = new FileOutputStream("c:/write.txt"); byte[] buffer = new byte[1024]; int len; while( (len = in.read(buffer)) != -1){
out.write(buffer,0,len);
}
in.close();
out.close(); //字符流
BufferedReader bf = new BufferedReader(new FileReader("c:/read.txt");
BufferedWriter bw = new BufferedWriter(new FileWriter("c:/write.txt");
String str; while( (str=bf.readLine()) != null ){
bw.write(str);
bw.newLine();
}
bf.close();
bw.close();
}
}字节流: InputStream字节输入流,OutputStream字节输出流
字符流 : Reader字符输入流 ,Writer字符输出流
数据流: DataInputStream 数据输入流 ,DataOutputStream 数据输出流
文件读写
目的
1 掌握文件读写的几种方法
2 FileOutputStream和FileInputStream类的使用。
3 基本数据类型之间的转换
实现文件读取后转换为大写后写入到目标文件中，其中src是指源文件，des是目标文件目录。
public class FileDemo { //创建一个文件夹
public static void createFolder(String path){
File folder=new File(path); if(folder.exists()){
System.out.println("文件夹已存在！");
}else{ //不存在时去创建
folder.mkdir();
}
} //创建一个文件
public static void createFile(String path,String filename){
File file=new File(path,filename); //文件判断是否已存在
if(file.exists()){
System.out.println("文件已存在！");
System.out.println(file.length());
}else{ try{
file.createNewFile();
}catch(IOException e){
System.out.println("文件创建失败！");
}
}
} //写文件
public static void write(String path,String filename){ try{
String str="0123456789/nac";
String Upstr = str.toUpperCase();//
byte b[]=Upstr.getBytes();//
FileOutputStream fos=new FileOutputStream(new File(path,filename));
fos.write(b);
fos.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("写文件失败");
}
} //读文件
public static void read(String path,String filename){ try{ int length=0;
String str="";
byte buffer[]=new byte[10];
FileInputStream fis=new FileInputStream(new File(path,filename));
while((length=fis.read(buffer, 0, buffer.length)) !=-1){
str+=new String (buffer, 0, length);
}
System.out.println(str);//
fis.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
e.printStackTrace();
}
}//
public static void FileReaderCopy(String src,String des){ try{
FileReader fr=new FileReader(src);
FileWriter fw=new FileWriter(des); char c[]=new char[1024]; int len=0;
while((len=fr.read(c, 0, c.length)) != -1){
fw.write(c, 0, c.length);
}
fw.close();
fr.close();
} catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("读写失败");
}
} //
public static void BufferedReaderCopy(String src,String des){ try{
BufferedReader br=new BufferedReader(new FileReader(src));
BufferedWriter bw=new BufferedWriter(new FileWriter(des));
String str=""; while((str=br.readLine()) != null){
String Upstr = str.toUpperCase();//加入大写的变换
bw.write(Upstr);//
bw.newLine();
}
bw.close();
br.close();
} catch(FileNotFoundException e){
System.out.println("文件存在");
}catch(IOException e){
System.out.println("读写失败");
}
} //复制
public static void copy(String src,String des){ try{
FileInputStream fis=new FileInputStream(src);
FileOutputStream fos=new FileOutputStream(des); int c; while((c=fis.read()) != -1){
fos.write(c);
}
fos.close();
fis.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("读写失败");
}
} //复制文件
public static void copy1(String src,String des){ try{
FileInputStream fis=new FileInputStream(src);
FileOutputStream fos=new FileOutputStream(des); int c; byte buff[]=new byte[1024]; while((c=fis.read(buff,0,buff.length)) != -1){
fos.write(buff,0,c);
}
fos.close();
fis.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("读写失败");
}
} public static void main(String[] args) { // TODO Auto-generated method stub
FileDemo.createFolder("c:/test");
FileDemo.createFile("c:/test", "1.txt");
FileDemo.write("c:/test", "1.txt");
FileDemo.read("c:/test", "1.txt");
FileDemo.read("c:/test", "FileDemo.java");
FileDemo.BufferedReaderCopy("c:/test/FileDemo.java", "c:/test/FileDemo2.java");
FileDemo.copy1("c:/test/1.mp3", "c:/test/2.mp3");
}
}读文件
//读文件public static void read(String path,String filename){ try{ int length = 0;
String str = ""; byte buffer[]=new byte[10];
FileInputStream fis=new FileInputStream(new File(path,filename));
while((length=fis.read(buffer,0,buffer.length))!=-1){
str+=new String(buffer,0,length);
}
System.out.println(str);
fis.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
e.printStackTrace();
}
}文件的创建
public class FileDemo{
public static void createFolder(String path){
File folder = new File(path); if(folder.exists()){
System.out.println("文件已存在!");
}else{
folder.mkdir();
}
} public static void createFile(String path,String filename){
File file = new File(path,filename); if(file.exists()){
System.out.println("文件已存在!");
System.out.println(file.length());
}else{ try{
file.createNewFile();
}catch(IOException e){
System.out.println("文件创建失败");
}
}
}public static void main(String[] args){
FileDemo.createFolder("c:/test");
FileDemo.createFile("c:/test","1.txt");
}
}写文件
public static void write(String path,String filename){ try{
String str = "234455"; byte b[] = str.getBytes();
FileOutputStream fos = new FileOutputStream(new File(path,filename));
fos.write(b);
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("写文件失败");
}
}文件的读写
重点：
文件类主要功能：创建，读属性，写属性，删除等
文件读写操作
File类File类的对象
用来获取文件本身的信息，如文件所在目录、文件长度、文件读写权限等，不涉及文件的读写操作。
构造函数
File(String filename)
File(String directoryPath,String filename)
File(File f,String filename)获取文件的属性
String getName()boolean canRead()boolean canWrite()long length()boolean isFile()等目录操作
boolean mkdir()：创建目录。String[] list()：以字符串的形式返回目录下所有文件。File[] listFiles()：以File对象形式返回目录下所有文件。文件操作
boolean createNewFile()：创建一个新的文件。boolean delete()：删除一个文件流的概念
Java输入输出功能是借助输入输出流类来实现的。
java.io包中包含大量用来完成输入输出流的类。
Java中流的分类：
流的运动方向，可分为输入流和输出流两种。
流的数据类型，可以分为字节流和字符流。
输入流类都是抽象类InputStream（字节输入流）或抽象类Reader类（字符输入流）的子类。
输出流类都是抽象类OutputStream（字节输出流）或抽象类Writer类（字符输出流）的子类。
输入流
输入流用于读取数据，用户可以从输入流中读取数据，但不能写入数据。
输入流读取数据过程如下：
（1）打开一个流。
如：FileInputStream inputFile=new FileInputStream("数据源");
（2）从信息源读取信息。
如：inputFile.read();
（3）关闭流。
如：inputFile.close();
输出流
输出流用于写入数据。只能写，不能读。
写数据到输出流过程如下：
（1）打开一个流。
如：FileOutputStream outFile=new FileOutputStream("数据源");
（2）写入信息到目的地。
如：outFile.write(inputFile.read()):
（3）关闭流。如：
如：outFile.close();
IO
I/O操作的目标IO的分类方法读取文件和写入文件的方法
I/O操作的目标
目标是从数据源中读取数据，将数据写入到数据目的地中。
从一个地方输入到java程序中输出到另外一个地方。
文件与数据流
写入和读出数据文件，在Java的输入/输出操作采用数据流的形式，数据流的两种形式为16位字符或8位字节
数据流的操作对象：
数据文件的读写
线程间的数据传输
网络间的数据传播读/写步骤：
导入输入/输出包，导入java.io.*包
创建文件对象
FileReader/FileWriter类用于文本文件的读写操作DataInputStream（用于文件读出）和DataOutputStream（用于文件写入）类文件的读写FileInputStream（用于文件读出）和FileOutputStream对象（用于文件写入）
关闭文件
close函数关闭文件
File对象的特性
创建文件
boolean createNewFile();创建子目录
boolean mkdir();boolean mkdirs();重命名/移动文件
boolean renameTo(File dest);删除文件
boolean delete();检查文件是否存在
boolean exists();检查是否为文件
boolean isFile();检查是否为文件夹
boolean isDirectory();查询文件长度
long length();往后余生，唯独有你
简书作者：达叔小生
90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通
简书博客：https://www.jianshu.com/u/c785ece603d1
结语
下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
小礼物走一走 or 点赞
这是一个有质量，有态度的公众号
喜欢本文的朋友们
欢迎长按下图关注订阅号
收看更多精彩内容