------- android培训、java培训、期待与您交流！ ----------
IO流用来处理设备之间的数据传输。
java对数据的操作是通过流的方式。
java用于操作流的对象都在IO包中。
流按照操作数据分为两种：字节流和字符流。
流按照流向分为：输入流和输出流。
IO流常用基类
字节流的抽象基类：
InputStream，OutputStream
字符流的抽象基类：
Reader，Writer
字符流
字符流继承体系图示：
向文件中写入数据
class FileWriterDemo
{
public static void main(String[] args)
{
FileWriter fw = null;
try
{
fw = new FileWriter("demo.txt");
fw.write("abcdefg");
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}public FileWriter(File file,boolean append)：将append的值设置为true表示追加。
从文件中读取内容
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("demo.txt");
//定义一个字符数组。用于存储读到字符。
//该read(char[])返回的是读到字符个数。
char[] buf = new char[1024];
int num = 0;
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num));
}
fr.close();
}
}/*
通过缓冲区复制一个.java文件。
*/
import java.io.*;
class CopyTextByBuf
{
public static void main(String[] args)
{
BufferedReader bufr = null;
BufferedWriter bufw = null;
try
{
bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));
String line = null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
字节流
字节流继承体系图示：
综合案例：
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
* 使用带缓冲功能的字节流复制文件。
* 思路：
* 1.创建copyFile方法，该方法接收两个参数，一个是源文件的完整路径srcPath，另一个是源文件所要复制到的目标目录destDir。
* 2.进行一系列的判断：
源文件是否存在？
目标目录是否存在？如果不存在，系统将自动进行创建。
目标目录下是否有同名文件？
* 3.创建输入流和输出流。
* 4.对文件大小进行判断。如果文件过大，会出现内存溢出情况，我们选择每次读一个字节的方法；反之，我们用数组接收读取到的字节，然后再把数组的数据一次性写入输出流。
* 5.最后关闭资源。
* @author Administrator
*/
public class Test {
public static void main(String[] args)
{
String srcPath = args[0];
String destDir = args[1];
CopyFile.copyFile(srcPath,destDir);
}
}
class CopyFile
{
public static void copyFile(String srcPath,String destDir)
{
File srcFilePath = new File(srcPath);
File destFileDir = new File(destDir);
//判断源文件是否存在
if(srcFilePath.exists() == false || srcFilePath.isFile() == false)
{
System.out.println("无效的文件，请检查!");
System.exit(0);
}
//判断所复制到的目标目录是否存在
if(destFileDir.isDirectory() == false)
{
System.out.println("您指定的目录不存在，系统将帮您自动创建!");
destFileDir.mkdirs();
}
//判断目标目录下是否有同名文件
File destFilePath = new File(destFileDir + "\\" +srcFilePath.getName());
if (destFilePath.isFile())
{
System.out.println("您指定的目录下具有同名文件!");
System.exit(0);
}
//创建输入流和输出流，并对不同大小的文件分别处理。
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try
{
FileInputStream fis = new FileInputStream(srcFilePath);
bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream(destFilePath);
bos = new BufferedOutputStream(fos);
long len = bis.available();
if(len > 1024*1024*200)
{
int b;
while((b=bis.read())!=-1)
{
bos.write(b);
}
}
else
{
byte[] bytes = new byte[(int)len];
bis.read(bytes);
bos.write(bytes);
}
bis.close();
bos.close();
System.out.println("文件复制已经完成！");
}
catch (Exception e)
{
e.printStackTrace();
}
}
}File类
用来将文件或者文件夹封装成对象，方便对文件和文件夹的属性信息进行操作。
File对象可以作为参数传递给流的构造函数。
File类常见方法：
1.创建
boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。
2.删除
boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
void deleteOnExit();在程序退出时删除指定文件。
3.判断
boolean exists() :文件是否存在.
isFile():
isDirectory();
isHidden();
isAbsolute();
4.获取信息
getName():
getPath():
getParent():
用递归的调用方式列出指定目录下的全部内容
import java.io.File;
public class FileDemo {
public static void main(String[] args) {
File directory = new File("D:" + File.separator);
print(directory);
}
public static void print(File file)
{
if(file != null)
{
if(file.isDirectory())//判断是否是目录
{
File[] f = file.listFiles();//如果是目录，则列出全部的内容
if(f != null)
{
for(int i=0;i<f.length;i++)
{
print(f[i]);
}
}
}
}
else
{
System.out.println(file);//如果不是目录，则直接打印路径信息
}
}
}
Properties是Hashtable的子类。
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
特点：
1.可以持久化存储数据。
2.键值都是字符串。
3.一般用于配置文件。
常见操作：
load()：将流中的数据加载进集合。
store()：写入各个项后，刷新输出流。
list()：将集合的键值数据列出到指定的目的地。
IO包中的其他流
打印流
该流提供了打印方法，可以将各种数据类型的数据都原样打印。
字节打印流：
PrintStream
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream
字符打印流：
PrintWriter
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream
4，字符输出流，Writer。
例：
import java.io.*;
class PrintStreamDemo
{
public static void main(String[] args) throws IOException
{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line.toUpperCase());
}
out.close();
bufr.close();
}
}序列流
import java.io.*;
import java.util.*;
class SplitFile
{
public static void main(String[] args) throws IOException
{
splitFile();
merge();
}
public static void merge()throws IOException
{
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=1; x<=3; x++)
{
al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
}
final Iterator<FileInputStream> it = al.iterator();
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
{
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
public static void splitFile()throws IOException
{
FileInputStream fis = new FileInputStream("c:\\1.bmp");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count = 1;
while((len=fis.read(buf))!=-1)
{
fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
}该类不算是IO体系中的子类，而是直接继承自Object。但是它是IO包中成员，因为它具备读和写功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。
其实完成读写的原理就是内部封装了字节输入流和输出流。
通过构造函数可以看出，该类只能操作文件。
而且操作文件还有模式：只读r，，读写rw等。
如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
writeFile()
readFile();
}
public static void readFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
//跳过指定的字节数
raf.skipBytes(8);
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println("name="+name);
System.out.println("age="+age);
raf.close();
}
public static void writeFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.write("李四".getBytes());
raf.writeInt(97);
raf.write("王五".getBytes());
raf.writeInt(99);
raf.close();
}
}主要作用是可以进行两个线程间的通信，分为管道输出流和管道输入流。
import java.io.*;
class Read implements Runnable
{
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
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);
in.close();
}
catch (IOException e)
{
throw new RuntimeException("管道读取流失败");
}
}
}
class Write implements Runnable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out = out;
}
public void run()
{
try
{
System.out.println("开始写入数据，等待6秒后。");
Thread.sleep(6000);
out.write("piped lai la".getBytes());
out.close();
}
catch (Exception e)
{
throw new RuntimeException("管道输出流失败");
}
}
}
class PipedStreamDemo
{
public static void main(String[] args) throws IOException
{
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);
Read r = new Read(in);
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
}
}
扫一扫
4014
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
