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();
}
}
}
}
655
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
