IO基本流:
字符流:
读操作:
Reader 字符输入流 抽象类
Reader r = new FileReader(File f);
构造方法:
FileReader(File file) ;
FileReader(String fileName) ;
方法:
//读取一个字符并以整数的形式返回(0~255),
//如果返回-1已到输入流的末尾。
int read() throws IOException
//读取一系列字符并存储到一个数组buffer,
//返回实际读取的字符数,如果读取前已到输入流的末尾返回-1
int read(char[] cbuf) throws IOException
//关闭流释放内存资源
void close() throws IOException
写操作:
Writer 字符输出流 抽象类
构造方法:
FileWriter(File file)
根据给定的 File 对象构造一个 FileWriter 对象。
FileWriter(File file, boolean append)
根据给定的 File 对象构造一个 FileWriter 对象。
FileWriter(String fileName)
根据给定的文件名构造一个 FileWriter 对象。
FileWriter(String fileName, boolean append)
根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造FileWriter 对象。
基本方法
//向输出流中写入一个字符数据,该字节数据为参数b的低16位
void write(int c) throws IOException
//将一个字符类型的数组中的数据写入输出流,
void write(char[] cbuf) throws IOException
//将一个字符串中的字符写入到输出流
void write(String string) throws IOException
//关闭流释放内存资源
void close() throws IOException
//将输出流中缓冲的数据全部写出到目的地
void flush() throws IOException
处理流:
缓存区--内存当中的一小块区域
(直接从文件读取快还是从缓存区读取快?)
字节缓存流 BufferedInputStream BufferedOutputStream
字符缓存流 BufferedReader BufferedWriter
BufferedInputStream 字节输入缓存流
构造方法
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。
基本方法
read()
int read(byte[] b)
BufferedOutputStream 字节输出缓存流
从程序写到缓存区,如果要写到文件里面需要有一个动作flush()
构造方法
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流,以将数据写入指定的底层输出流。
基本方法
write(int b) 将指定的字节写入此缓冲的输出流。
write(byte[] b) 将指定的字节数组写入此缓冲的输出流。
flush() 刷新此缓冲的输出流。
BufferedReader 字符输入缓存流
构造方法
BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流
基本方法
int read(); 读取单个字符。
int read(char[] cbuf); 将字符读入数组
String readLine(); 读取一个文本行。
BufferedWriter 字符输出缓存流
构造方法
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流。
基本方法
write(int c) 写入单个字符。
write(char[] c) 写入字符数组。
write(String s) 写入字符串。
newLine() 写入一个行分隔符。
转换流:
InputStreamReader 是字节流通向字符流的桥梁
构造方法
InputStreamReader(InputStream in)
创建一个使用默认字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
创建使用指定字符集的 InputStreamReader。
基本方法
int read(); 读取单个字符。
int read(char[] cbuf); 读取字符数组,返回的是长度。
OutputStreamWriter
构造方法
OutputStreamWriter(OutputStream out)
创建使用默认字符编码的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName)
创建使用指定字符集的 OutputStreamWriter。
基本方法
write(int c) 写入单个字符。
write(char[] cbuf) 写入字符数组。
write(String str) 写入字符串。
--------------------------------------------------
数据流:
DataInputStream
构造方法:DataInputStream(InputStream in) ;
基本方法
boolean readBoolean()
byte readByte()
double readDouble()
float readFloat()
int readInt()
long readLong()
short readShort()
String readUTF()
DataOutputStream
构造方法:DataOutputStream(OutputStream out)
基本方法
boolean writeBoolean()
byte writeByte()
double writeDouble()
float writeFloat()
int writeInt()
long writeLong()
short writeShort()
String writeUTF()
一、键盘输入输出流:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/*
读取键盘录入
System.out:对应的是标准的输出设备,控制台
System.in:对应的是标准输入设备,键盘
需求:
通过键盘录入数据,当录入一行数据后,就将该行数据进行打印,
如果录入的数据是over,那么停止录入
流操作的基本规律:
最痛苦的就是流对象很多,不知道该用哪一个。
通过三个明确来完成:
1、明确源和目的。
源:输入流。InputStream Reader
目的:输出流。 OutputStream Writer.
2、操作的数据是否是纯文本。
是:字符流
不是:字节流
3、当体系明确后,在明确要使用哪个具体的对象
通过设备来进行区分:
源设备:内存,键盘,硬盘
目的设备:内存,硬盘,控制台
*/
public class ReaderIn {
public static void main(String[] args) {
BufferedReader br = null;
BufferedWriter bw = null;
try {
//键盘的最常见写法
br = new BufferedReader(new InputStreamReader(System.in));
bw = new BufferedWriter(new OutputStreamWriter(System.out));
String line = null;
while ((line = br.readLine()) != null) {
if("over".equals(line))
break;
bw.write(line.toUpperCase());
bw.newLine();
bw.flush();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
try {
if(br != null)
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(bw != null)
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
二、管道流
package io;
//管道流:可以将输入流和输出流连接在一起,形成一个管道
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
public class PipedStreamDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
PipedInputStream in = null;
PipedOutputStream out = null;
try {
in = new PipedInputStream();
out = new PipedOutputStream();
in.connect(out); //将输入流和输出流连接
Read r = new Read(in);
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//输入流
class Read implements Runnable{
private PipedInputStream in = null;
public Read(PipedInputStream in) {
// TODO Auto-generated constructor stub
this.in = in;
}
public void run() {
// TODO Auto-generated method stub
try {
byte[] buf = new byte[1024];
System.out.println("读取前。。。。没有数据阻塞");
int len = in.read(buf);
System.out.println("读到数据。。。。阻塞结束");
String s = new String(buf,0,len);
System.out.println(s);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
finally{
try {
if(in != null)
in.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
//输出流
class Write implements Runnable{
private PipedOutputStream out = null;
public Write(PipedOutputStream out) {
// TODO Auto-generated constructor stub
this.out = out;
}
public void run() {
// TODO Auto-generated method stub
try {
System.out.println("休眠5秒");
Thread.sleep(5000);
byte[] b = "piped lai le".getBytes();
out.write(b,0,b.length);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
finally{
try {
if(out != null)
out.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
三、文件及文件夹操作:
查询:
package file;
import java.io.File;
/*
目的:列出指定目录下文件或者文件夹,包含子目录中的内容
思路:
也就是列出指定目录下所有内容,因为目录中还有目录,只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话,还可以再次调用本功能,也就是函数自身调用自身。
这种表现形式,或者编程手法成为递归。
递归要注意:
1、限定条件
2、要注意递归的次数,尽量避免内存溢出。
*/
public class FileDemo3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
File dir = new File("E:/eclipseWorkspace/github/java");
showDir(dir);
}
public static void showDir(File dir){
System.out.println(dir);//打印文件夹名称
File[] files = dir.listFiles();
for(int x = 0; x < files.length; x++){
if(files[x].isDirectory())
showDir(files[x]);
else
System.out.println(files[x]);//打印文件名称
}
}
}
建立文件列表:
package file;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/*
目的:建立一个java文件列表文件
思路:
1、对指定的目录进行递归
2、获取递归过程所有的java文件的路径
3、将这些路径存储到集合中
4、将集合中的数据写入到一个文件中
*/
public class JavaFileList {
public static void main(String[] args) {
// TODO Auto-generated method stub
File dir = new File("E:/eclipseWorkspace/github/java");
List<File> list = new ArrayList<File>();
fileToList(dir, list);
System.out.println(list.size());
File file = new File("E:/eclipseWorkspace/github/java/sonyi_20/javaListFile.txt");
writeToFile(list,file.toString());
}
public static void fileToList(File dir, List<File> list){
//System.out.println(dir.getName());
File[] files = dir.listFiles();
for(File file: files){
if(file.isDirectory()){
fileToList(file, list);
}
else {
if(file.getName().endsWith(".java"))
//System.out.println(file.getName());
list.add(file);
}
}
}
public static void writeToFile(List<File> list,String javaListFile){
BufferedWriter bw = null;
try {
bw = new BufferedWriter(new FileWriter(javaListFile));
for(File f : list){
String path = f.getAbsolutePath();
//System.out.println(path);
bw.write(path);
bw.newLine();
bw.flush();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
try {
if(bw != null)
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
删除:
package file;
import java.io.File;
/*
目的:
删除一个带内容的目录:
删除原理:
在windows中,删除目录从里面往外面删除的
既然是从里往外删除,就需要用到递归。
*/
public class RemoveDir {
public static void main(String[] args) {
File dir = new File("e:/delete");
removeDir(dir);
}
public static void removeDir(File dir){
File[] files = dir.listFiles();
for(int x = 0; x < files.length; x++){
if(files[x].isDirectory())
removeDir(files[x]);
else
System.out.println(files[x].toString() + "::" + files[x].delete());
}
System.out.println(dir + ":: dir ::" + dir.delete());
}
}
四、Properties类:
package file;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
/*
Properties是hashtable的子类。也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
Properties是集合和IO技术相结合的集合容器。
该对象的特点:可以用于键值对形式的配置文件,那么在加载数据时,需要数据有固定格式:键-值
*/
public class PropertiesDemo {
public static void main(String[] args) {
//setAndGet();
//method_1();
loadDemo();
}
public static void loadDemo(){
Properties prop = new Properties();
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("info.txt");
prop.load(fis);//将流中的数据加载到集合中
//System.out.println(prop);
prop.setProperty("wangwu", "15");//只在内存中修改
prop.list(System.out);
//将在内存中修改后的信息存储到硬盘的文件内
fos = new FileOutputStream("info.txt");
prop.store(fos, "heheh");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//演示:如何将流中的数据存储到集合中
//想要将info.txt中键值对数据存储到集合中进行操作
/*
思路:
1、用一个流和info.txt文件相关联
2、读取一行数据,将该行数据用"="进行切割
3、等号左边作为键,右边作为值,存入到properties集合中即可。
*/
public static void method_1(){
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader("info.txt"));
String line = null;
Properties prop = new Properties();
while((line = br.readLine()) != null){
//System.out.println(line);
String[] arr = line.split("=");
prop.setProperty(arr[0], arr[1]);
}
System.out.println(prop);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
try {
if(br != null)
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//设置和获取元素
public static void setAndGet(){
Properties prop = new Properties();
prop.setProperty("zhangsan", "30");
prop.setProperty("lisi", "39");
System.out.println(prop);
String value = prop.getProperty("lisi");
System.out.println(value);
prop.setProperty("lisi", 89 + "");
Set<String> name = prop.stringPropertyNames();
for(String s : name){
System.out.println(s + ": " + prop.getProperty(s));
}
}
}
练习一:记录软件运行次数
package file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
/*
目的:记录一个软件的运行次数,并达到一定次数后,给出相应的提示信息
思路:
用于记录应用程序运行次数。如果使用次数已经达到,那么给出注册提示
很容易想到的是计数器,可是该计数器定义在程序中,随着程序的运行而在内存中存在,并进行了自增。
可是随着该应用程序的退出,该计数器也在内存中消失了。
下一次再启动该程序,又重新开始从0计数。这样不是我们想要的。
程序即使结束,该计数器的值也存在,下一次程序启动会先加载该计数器的值,并加1后重新存储起来。
所以要建立一个配置文件,用于记录该软件的使用次数。
该配置文件使用键值对的形式。这样便于阅读数据并操作数据。
键值对数据是map集合。数据是以文件的形式存储,使用IO技术。
那么map+io就是properties,配置文件可以实现应用程序的共享。
*/
public class RunCount {
public static void main(String[] args) {
Properties prop = new Properties();
FileInputStream fis = null;
FileOutputStream fos = null;
File file = new File("count.ini");
try {
if(!file.exists())
file.createNewFile();
fis = new FileInputStream(file);
prop.load(fis);
int count = 0;
String value = prop.getProperty("time");
if(value != null){
count = Integer.parseInt(value);
if(count >= 5){
System.out.println("您好,使用次数已到,拿钱!");
return ;
}
}
count++;
prop.setProperty("time", count + "");
fos = new FileOutputStream(file);
prop.store(fos, "记录程序使用次数");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
try {
if(fis != null)
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(fos != null)
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
练习二:切割文件
package file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
//目的:将一mp3文件切割成几份存储,然后再将这几份文件合并成一个mp3文件。
public class SplitFile {
public static void main(String[] args) {
// TODO Auto-generated method stub
//splitFile();
merge();
}
//合并文件
public static void merge(){
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
int count = 1;
try {
for(int x = 0; x < 6; x++){
al.add(new FileInputStream("切割" + (count++) + ".part"));
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
final Iterator<FileInputStream> it = al.iterator();
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {
public boolean hasMoreElements() {
// TODO Auto-generated method stub
return it.hasNext();
}
public FileInputStream nextElement() {
// TODO Auto-generated method stub
return it.next();
}
};
SequenceInputStream sis = null;
FileOutputStream fos = null;
try {
sis = new SequenceInputStream(en);
fos = new FileOutputStream("复制1.mp3");
byte[] buf = new byte[1024];
int len = 0;
while ((len = sis.read(buf)) != -1) {
fos.write(buf,0,len);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
try {
if(sis != null)
sis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(fos != null)
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//切割文件
public static void splitFile(){
FileInputStream fis = null;
FileOutputStream fos = null;
File f = null;
try {
f = new File("1.mp3");
System.out.println(f.exists());
fis = new FileInputStream(f);
byte[] buf = new byte[1024*1024];
int len = 0;
int count = 1;
while((len = fis.read(buf)) != -1){
System.out.println(buf.toString());
fos = new FileOutputStream("切割" + (count++) + ".part");
fos.write(buf,0,len);
fos.close();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
try {
if(fis != null)
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(fos != null)
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}