Java常用IO流
来源:互联网 发布:怎么安装mysql-5.7.1 编辑:程序博客网 时间:2024/06/06 07:05
File类
构造方法:
File f1=new File(“K:\XiKai\Java\d17\fa.txt”);
//将f1指向当前目录:K:\XiKai\Java\d17\fa.txt
创建文件:
若此时所指向的目录若不存在便会出现IOException:系统找不到指定路径
File fa=new File(“E:\XiKai\Java\d17\fa.txt”);
fa.createNewFile()在指定目录下创建一个新文件:fa.txt
//不带盘符默认在当前项目下创建指定的文件
File fa2=new File(“fa2.txt”);
fa2.createNewFile();
创建目录:
File fa1=new File(“E:\XiKai\Java\d17\myFiles”);
//在指定路径下生成指定创建的目录
fa1.mkdir();//在E:\XiKai\Java\d17下创建了一个文件夹myFiles
创建多级目录:
//public boolean mkdirs()
File file4 = new File(“E:\aaa\bbb\ccc\ddd”) ;
file4.mkdirs();//在在E盘下生成目录aaa\bbb\ccc\ddd
删除
删除文件
public boolean delete()删除此抽象路径名表示的文件或目录
删除不能删除带有文件或者文件夹的目录
File fa=new File(“E:\XiKai\Java\d17\fa.txt”);
fa.createNewFile();
//删除文件fa.txt
fa.delete();
//需求:删除aaa\bbb\ccc
File file3 = new File(“aaa\bbb\ccc”) ;
System.out.println(“delte:”+file3.delete());
File file4 = new File(“aaa\bbb”) ;
System.out.println(file4.delete());
File file5 = new File(“aaa”) ;
System.out.println(file5.delete());
//重命名
File fb1=new File(“E:\XiKai\Java\d17\fos.txt”);
//fb1.createNewFile();
//fb2与fb1的抽象路径不一致,fb1.renameTo(fb2);将fos.txt从fb1所指的路径下剪切到了fb2所在的路径下
File fb2=new File(“fb2.txt”);//默认指向当前项目所在的路径
//fb1.renameTo(fb2);//将fb2.txt剪切到了当前项目路径下
//当两者抽象路径一致时 File fb3=new File("E:\\XiKai\\Java\\d17\\fb3.txt"); fb1.renameTo(fb3); System.out.println(fb1.getName());//fos.txt System.out.println(fb3.getName());//fb3.txt //相当于将fos.txt复制到了fb3的位置,且为fb3的指定文件名
/*File类的高就获取功能:
* public String[] list():返回对象是一个字符串数组,当前哪个一盘符下的所有的文件以及文件夹的字符串名称数组
* public File[] listFiles():返回对象是一个File数组,当前哪个盘下的所有的文件以及文件夹的File数组
*/
//需求:获取e盘下所有的文件夹以及文件的字符串名称数组
//用File对象封装下e盘 File file = new File("E:\\") ; //// public String[] list() String[] strArray = file.list() ; //遍历:遍历之前,一定要做非空判断 if(strArray!=null){ //增强for遍历 for(String s:strArray){ System.out.println(s); } } System.out.println("------------------------------------------"); //public File[] listFiles(): File[] fileArray = file.listFiles() ; if(fileArray !=null){ for(File f :fileArray){ System.out.println(f.getName()); } }
文件过滤器:Xi-Java.myFile.FileFilter
IO流:
指的是设备和设备之间的的数据传输,即硬盘和内存之间的数据传输.
IO流的分类:
按流的方向分:
* 输入流:读数据的
* 输出流:写数据的
*
* 按数据类型分:
* 字节流:
* 字节输入流:InputStream
* 字节输出流:OutputStream
* 字符流
* 字符输入流:Reader
* 字符输出流:Writer
- 需求:输出一个文本文件,给文本文件中写一句话:hello,IO,Im’coming…
-
- 分析:
- 一旦提到文本文件,那么就是用字符流,但是字符流是在字节流之后出现的,所以先学习字节流!
- 用windows自带的记事本打开一个文件,你自己看懂,一般情况使用字符流最好.如果打开之后,读不懂,那么使用字节流.
- 使用字节流,来输出这个文件
- OutputStream:字节输出流,该类是抽象类,不能实例化,但是这里提到文件,刚才学习的File类就是描述文件的.
- FileOutputStream:OutputStream的子类
- 构造方法:
- public FileOutputStream(String name)
- 在抽象类的前面加上前缀:
- XXXInputStream
- XXXOutputStream
- XXXReader
- XXXWriter
- FileInputStream
字符流: - FileReader
- FileWriter
-
- 开发步骤”
- 1)创建文件输出流对象
- 2)写数据
- 3)关闭资源
- @author Apple
*/
public class OutputStreamDemo {
public static void main(String[] args) throws IOException {
//创建输出流对象
// OutputStream os = new FileOutputStream(“os.txt”) ;//抽象类多态FileOutputStream fos = new FileOutputStream("fos.txt") ;/** * 创建文件输出流对象做了哪些事情: * Java语言不能创建系统资源,通过C或C++间接创建系统资源 * 创建的这个输出流对象,并指向这个fos.txt文件进行输出. *///有对象了,写数据//String类中一个方法: //getBytes() ;fos.write("hello,io,i'm coming...".getBytes()) ;//释放流资源fos.close() ;/** * 关闭流资源,关闭了就不能在写数据了 * 并且该流对象输出完毕之后,不指向这个文件了,所以需要将它关闭掉 *///java.io.IOException: Stream Closed:流已经关闭了,不能在操作了!
// fos.write(“高圆圆”.getBytes()) ;
}
}- @author Apple
/**
* 针对输出流中写数据的方法:
* public abstract void write(int b):将指定的字节写入到输出流中
* public void write(byte[] b):将指定的字节数组写入到输出流中
* public void write(byte[] b, int off,int len):将字节数组的一部分写入到输出流中
//创建一个文件输出流对象
FileOutputStream fos = new FileOutputStream(“fos2.txt”) ;
//写数据 // public abstract void write(int b):将指定的字节写入到输出流中
// fos.write(97) ;//—->二进制数据—–>记事本打开—>就找会找ASCII码表中找有没有该值对应的一个字符: a
// fos.write(55) ;
// fos.write(57) ;
// fos.write(65) ;
//public void write(byte[] b):将指定的字节数组写入到输出流中 byte[] bys = {97,98,99,100,101} ; fos.write(bys) ; //public void write(byte[] b, int off,int len):实际开发中:该方法和读数据一块使用 fos.write(bys, 1, 3) ; //关闭资源 fos.close() ;
将文件写到文件末尾:
public FileOutputStream(File file,Booean append)
第二个参数设置为true表示从文件的末尾开始写入内容
(
关于换行符号:
对于windows操作系统来说:换行符号:\r或者\n
* 对于Linux操操作系统来说:\n
* 对于Mac操作系统来说:\r
)
FileOutputStream fos=new FileOutputStream(“fb2.txt”,true);//File f=new File(“fb2.txt”);
for(int i=0;i<3;i++)
{
fos.write((i+1+”朵小花”).getBytes());
fos.write(“\n”.getBytes());
}
fos.close();
/**
* 运行结果:
*
* fb2.txt中的内容:
*
* 1朵小花
* 2朵小花
* 3朵小花
*
*/
//IO流中加入异常操作的标准用法:
//加入标准格式:try…catch…finally
//声明一个变量
FileOutputStream fos = null ;
try { fos = new FileOutputStream("fos4.txt") ; //写数据 fos.write("hello,Javaweb".getBytes()) ; } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ //释放资源的 //由于是流对象,要对流对象做非空判断 if(fos !=null){ try { fos.close() ; } catch (IOException e) { e.printStackTrace(); } } }
文件的读写:
读文件:
字节输入流(InputStream的子类):
1)public int read();一次读取一个字节
2)public int read(byte[] b);一次读取一个字节数组
//从此输入流中最多将b.length个字节的数据读入到一个byte数组中.
字符流(Reader的子类):
1)public int read();一次读取一个字节
2)public int read(byte[] b);一次读取一个字节数组
写文件:
字节输出流(OutputStream的子类):
1)public void write();一次写入一个字节
2)public void write(byte[] b);一次写入一个字节数组
字符输出流:(Writer的子类):
2
字节流文件读取示例:
假设当前项目下有一个a.txt文件,要将它的内容写到当前项目下的b.txt文件中.
//首先创建一个输入流对象,指向要读取的文件,即a.txt
InputStream is=new FileInputStream(“a.txt”);
//再创建一个输出流对象,指向要写入的文件,即b.txt
OutputSream os=new FileOutputStream(“b.txt”);
/*1)一次读取一个字节
int by=0;
while((by=is.read())!=-1)//到达文件末尾时返回-1
{
//对应的一次写入一个字节
os.write(by);
}
*/
//2)一次读取一个字节数组(比一次读取一个字节要快)
byte[] bys=new byte[1024];//一次最多读取的字节数,通常取2^10B即,1KB的大小
int length=0;//每次实际所读取的字节数
while((length=is.read(bys))!=-1)
{
//对应的一次写入一个实际读取到的字节数组
os.write(bys);
}
缓冲流:
BufferedInputStream
BufferedOutputStream
缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所以缓冲流不能直接对文件操作.
flush()和close()方法的区别?
* flush():刷新缓冲区的流,强迫将缓冲字节都写到该流中,刷新之后是可以写数据的.
* close():关闭流对象所指向指向的这个资源文件,一旦关闭,写数据,写不进去的!
使用缓冲流为什么比基本流要快?
缓冲流会有一个缓冲区.
当从从文件中读数据时,将读入的字符先存在缓冲区,如果缓冲区空间不足时,才会将数据存在流中.然后再次访问文件,从文件中读取内容.
当向文件中写入数据时,输出缓存流调用write方法将数据写在缓冲区中,等到缓冲区满了之后才将数据发送到流中.所以写入缓冲区的数据太小时,就经常会写不到指定文件中,所以最好在调用write方法后再调用flush方法,调用flush方法可以强制的将缓冲区中的数据发送到流中,不必等到缓冲区满.
使用缓冲流与基本流相比避免了多次访问文件.
GBK一个中文对应两个字节
unicode一个中文对应三个字节
字符流:
Reader
writer
字符输入流=字节输入流+编码格式(默认GBK)
public InputStreamReader(InputStream in,charset sc) ;
OutputStreamWriter——>字符转换流:可以将字节输出流转换字符流
Reader—->InputStreamReader(InputStream in):字符转换输入流
* 目的地:b.txt—->Writer—->OutputStreamWriter(Outputstream out):字符转换输出流
便捷类:
FileReader,FileWriter
FileReder(String fileName)
FieWriter(String fileName)
//1)封装数据源和目的地 FileReader fr = new FileReader("a.txt") ; FileWriter fw = new FileWriter("b.txt") ; //一次读取一个字符数组 char[] chs = new char[1024] ; int len = 0 ; while((len=fr.read(chs))!=-1){ fw.write(chs, 0, len) ; fw.flush() ; } //关闭资源 fw.close() ; fr.close() ;
关于字符缓冲输入流的特有功能:
* BufferedWriter:
* public void newLine():写入一个换行符号
* BufferReader:
* public String readLine():一次读取一行
BufferedReader:字符缓冲输入流
* BufferedWriter:字符缓冲输出流
* 将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。
* 可以指定缓冲区的大小,或者接受默认的大小
*
* 构造方式:
* public BufferedWriter(Writer out):创建默认缓冲区大小的一个字符缓冲输出流
使用BufferedReader自定义输入:
package d18File;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.OutputStream;
/**
* 一次读取一行,同时写入文件
* @author Administrator
*
*/
public class InputStreamReader1 {
public static void main(String[] args) throws IOException { System.out.println("请输入一行数据"); InputStreamReader isr=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(isr); OutputStream os=new FileOutputStream("fis.txt"); BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os)); String str=null; while((str=br.readLine())!=null){ if(str.equals("886")){//自定义结束标记 break ; } bw.write(str); bw.newLine() ; bw.flush() ; }}
}
DataOutputStream和DataInputStream
* 都属于数据流:可以针对Java基本数据类型的数据进行读写操作
*
* DataOutputStream构造方法
* public DataOutputStream(OutputStream out)
PrintWriter:有自动刷新功能:
* public PrintWriter(Writer out,boolean autoFlush)
* 第二个参数指定为true,则启动自动刷新
* PrintWriter pw = new PrintWriter(new FileWriter(“pw.txt”),true) ;
* 加入自动刷新功能并且在写数据的时候,使用println():换行
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/**
* ByteArrayInputStream和ByteArrayOutStream(重点)
* 内存操作流:针对内存的数据进行操作的,程序一结束,这些内存中的数据就消失掉了!
* 特点:针对小文件进行操作!(聊天室项目中使用它进行发送文件)
*
*
* ByteArrayOutputStream:
* public ByteArrayOutputStream():创建默认的缓冲区大小的内存操作输出流(单位是字节)
* 成员方法:
* public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
* void reset():重置内存操作输出流
* ByteArrayInputStream:内存操作输入流:
* public ByteArrayInputStream(byte[] buf):参数数一个字节数组(缓冲数组)
*
* @author Apple
*/
public class ByteArrayStreamDemo {
public static void main(String[] args) throws IOException { //创建内存操作输出流对象 ByteArrayOutputStream baos = new ByteArrayOutputStream() ; //写数据 for(int x = 0 ; x <5 ; x ++){ baos.write(("hello"+x).getBytes()) ; } /** * 内存操作流:查看其释放流对象的源码: * public void close() throws IOException {} * 并没有具体的关闭流对象,所以此流对象可以不关闭 */ //关闭资源
// baos.close() ;
//将内存操作输出流对象转换成字节数组 //public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组) byte[] buffer = baos.toByteArray() ; //创建内存操作输入流对象 ByteArrayInputStream bais = new ByteArrayInputStream(buffer) ; //一次读取一个字节 int by = 0 ; while((by=bais.read())!=-1){ System.out.print((char)by); } //关闭
// bais.close() ;
}
}
标准输入和输出流
* System类中有两个字段:
* in:—–>InputStream is = System.in ;
* out—–>PrintStream ps = System.out ;
SequenceInputStream:合并流(读数据):表示其他输入流的逻辑串联
* 合并流在复制文件的时候,只能操作数据源,不能操作目的地
*
* 之前的操作:
* a.txt–>b.txt
* c.txt—>d.txt
*
SequenceInputStream(合并流)
* 现在有合并流(将两个文件中的内容复制到另一个文件中)
* a.txt+b.txt—>c.txt文件中
* 构造方法:
* public SequenceInputStream(InputStream s1,InputStream s2)
* 需求:将DataStreamDemo.java和ByteArrayStreamDemo.java两个java文件中的内容复制
*/
public class SequenceInputStreamDemo {
public static void main(String[] args) throws IOException { //分别封装这个两个java文件 InputStream s1 = new FileInputStream("DataStreamDemo.java") ; InputStream s2 = new FileInputStream("ByteArrayStreamDemo.java") ; //创建合并流对象 SequenceInputStream sis = new SequenceInputStream(s1, s2) ; //封装目的地 BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("Copy.java")); //一次一个字节数组 byte[] bys = new byte[1024] ; int len = 0 ; while((len = sis.read(bys))!=-1){ //写数据 bos.write(bys, 0, len) ; bos.flush() ; }
// 释放资源
sis.close() ;
bos.close() ;
}
}
package org.westos_06;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
/**
* SequenceInputStream的另一种构造方法:复制多个文件
* public SequenceInputStream(Enumeration
- Java常用IO流
- java中的常用IO流
- Java基础:常用IO流
- Java IO-常用流总结
- java 中常用的io流总结
- java io流常用类的使用
- JAVA输入输出(IO)之常用流
- Java 常用IO流操作详解
- java常用IO流集合用法模板
- java IO流File常用的方法
- java IO流的基本常用操作
- java io流常用方法总结
- Java 常用IO流操作详解
- Java.io流的基本常用类
- Java--IO 常用流的操作
- Java 常用IO流操作详解
- Rhyme/Java 常用IO流总结
- java常用IO流简介(一)
- [课程设计]Java实现图形化窗口界面可存储ATM机(自助取款机)
- python 生成字符图片
- ESLint (一)简介与安装
- 安卓源码google安卓设备OTA升级包及工厂镜像下载
- sass
- Java常用IO流
- 2.Binary Heap[数据结构]
- ESLint (二)配置文件
- 文章标题
- zookeeper-服务器角色介绍(如何实现一致性)
- 令人拍案叫绝的Wasserstein GAN
- Windows下在Anaconda3中安装python版的XGBoost库
- 你妹, 不修改word文档, 直接对word进行ctrl + s操作, md5值居然变了!
- 刷题笔记:牛客字符串专项练习5