------- android培训、java培训、期待与您交流! ----------
一、File类
File类:文件和目录路径名的抽象表示形式。
File类的方法:
long length() 获取File构造方法中封装的文件的字节数。
long lastModified() 获取File构造方法中封装的文件的最后修改时间的毫秒值。
File getParentFile() 获取构造方法中封装的路径的父路径,返回值是File对象。
String getParent() 获取父路径。获取构造方法中封装的路径的父路径。
String getPath 将构造方法中封装的路径,转成一个字符串。
String[] list() File构造方法,写的路径,获取路径下的文件和文件夹。
File[] listFiles() File构造方法,写的路径,获取路径下的文件和文件夹。返回File数组,获取全路径。
listFiles(FileFilter filter) 传递参数,参数就是文件过滤器,参数FileFilter接口,java.io.FileFilter。传递实现类,自己写实现类,实现接口,重写方法 boolean accept(File pathname)
class myFilter implements FileFilter{
//在File类的 listFiles方法中,被调用的
//传递参数pathname,结果就是listFiles()获取到的全路径
//接收路径pathname,当方法返回的是真,路径装到集合中
//文件名是.java文件返回真
public boolean accept(File pathname){
//判断传递参数pathname的文件名后缀是不是.java,如果是就返回true
return pathname.getName().endsWith(".java");
// return true;
}
}
public class FileDemo2{
public static void main(String[] args) {
File file = new File("c:\\demo");
File[] files = file.listFiles( new myFilter());
for(File f : files){
System.out.println(f);
}
}
}
二、IO流
IO流用来处理设备之间的数据传输。
java对数据的操作时通过流的方式。
java用于操作流的对象都在IO包中。
流按操作数据分为两种:字节流与字符流。
流按流向分为:输入流,输出流。
IO常用基类
字节流的抽象基类:InputStream,OutputStream
字符流的抽象基类:Reader,Writer
数据的最常见体现形式是文件
字符流缓冲区
缓冲区的出现提高了对数据读写的效率。
对应类:BufferedReader
BurreredWriter
缓冲区要对应流才能使用。
在流的基础上对流功能进行增强。
装饰类通常会通过构造方法接收被装饰对象,并基于被装饰对象的功能提供更强的功能。
字符流:Reader,Writer
FileReader
FileWriter
BufferedReader
BufferedWriter
字节流:InputStream
OutputStream
FileInputStream 将数据读取到流中 都是相对于程序而言。
FileOutputSteam 将数据写入到文件
转换器:InputStreamReader OutputStreamWriter
流操作的基本规律:
1)明确源和目的
源:输入流InputStream Reader
目的:输出流 OutputStream Writer
2)明确操作的数据是否是纯文本。
是:Reader Writer
否:InputStream OutputStream
3) 当体系明确后,再明确具体要使用哪个对象。
通过设备来区分
设备:内存,硬盘,控制台,键盘.
1、FileWrite
import java.io.*;
class FileWriterDemo {
public static void main(String[] args) {
try{
FileWriter fw = new FileWriter("aaa.txt");
//必须指定要操作的文件。
//将文件创建到制定目录下,如果文件存在,则被覆盖。
fw.write("asdf");
//调用write方法,将字符串写入到流中。
fw.flush();
//刷新流对象中的缓冲数据,将数据刷到目的地中。
fw.write("123");
fw.flush();
fw.close();
}catch (IOException e){
System.out.println(e.toString());}
}
}
2、IOException处理
import java.io.*;
class FileWriterDemo2 {
public static void main(String[] args) {
FileWriter fw = null;
try{
fw = new FileWriter("aaa.txt");
//必须指定要操作的文件。
//将文件创建到制定目录下,如果文件存在,则被覆盖。
fw.write("asdf");
//调用write方法,将字符串写入到流中。
fw.flush();
//刷新流对象中的缓冲数据,将数据刷到目的地中。
fw.write("123");
fw.flush();
//fw.close();
//刷新并关闭流。
}catch (IOException e){
System.out.println(e.toString());
}finally{
try{
if(fw!=null)
fw.close();
}catch (IOException e){
System.out.println(e.toString());
}
}
}
}
3、文件续写
import java.io.*;
class FileWriterDemo3 {
public static void main(String[] args) {
FileWriter fw = null;
try{
fw = new FileWriter("aaa.txt",true);
//传递true参数代表不覆盖已有文件,并在已有文件的末尾处追加内容。
fw.write("\r\n");
fw.write("another line");
fw.flush();
}catch (IOException e){
System.out.println(e.toString());
}finally{
try{
if(fw!=null)
fw.close();
}catch (IOException e){
System.out.println(e.toString());
}
}
}
}
4、读取文件1
import java.io.*;
class FileReaderDemo{
public static void main(String[] args){
FileReader fr = null;
try{
//创建一个文件读取流对象,文件不存在时,抛出FileNotFoundException异常
fr =new FileReader("ttt.txt");
char temp =(char)fr.read();//此方法读取到结尾时返回-1;
System.out.println(temp);
int ch = 0;
while((ch=fr.read())!=-1){
System.out.println((char)ch);
}
}catch (IOException e){
System.out.println(e.toString());
}finally{
try
{
if(fr!=null)
fr.close();
}catch (IOException e){
System.out.println(e.toString());
}
}
}
}
5、读取方式2
import java.io.*;
class FileReaderDemo2{
public static void main(String[] args)throws IOException{
FileReader fr = new FileReader("aaa.txt");
int temp = 0;
char[] ch = new char[1024];
while((temp=fr.read(ch))!= -1){
System.out.println("....."+new String(ch,0,temp)+"......");
}
fr.close();
}
}
6、将文本文件打印到终端。
import java.io.*;
class FileReaderTest{
public static void main(String[] args){
printFile("CalendarDemo.java");
}
public static void printFile(String target){
FileReader fr = null;
int temp =0;
char[] ch = new char[1024];
try{
fr = new FileReader(target);
while((temp = fr.read(ch))!=-1){
System.out.print(new String(ch,0,temp));
}
}catch (IOException e){
System.out.println(e.toString());
}finally{
try{
if(fr!=null)
fr.close();
}catch (IOException e){
System.out.println(e.toString());
}
}
}
}
7、将指定文件复制到指定目录。
import java.io.*;
class CopyFileDemo{
public static void main(String[] args){
copyFile("FileWriterDemo.java","D:\\test.java");
}
public static void copyFile(String res,String des){
FileWriter fw = null;
FileReader fr = null;
char[] ch = new char[1024];
int temp = 0;
try{
fr = new FileReader(res);
fw = new FileWriter(des);
while((temp=fr.read(ch))!=-1){
fw.write(ch,0,temp);
fw.flush();//刷流
}
}catch (IOException e){
System.out.println(e.toString());
throw new RuntimeException();
}finally{
if(fr!=null){
try{
fr.close();
}catch (IOException e){
System.out.println(e.toString());
}finally{
if(fw!=null)
try{
fw.close();
}catch (IOException e){
System.out.println(e.toString());
}
}
}
}
}
}
8、写入字符流缓冲区BufferedWriter.
import java.io.*;
class BufferedWriterDemo{
public static void main(String[] args)throws IOException{
//创建文件写入字符流对象
FileWriter fw = new FileWriter("aaa.txt");
//将流传给给缓冲区构造函数。
BufferedWriter bfrt = new BufferedWriter(fw);
bfrt.write("asdfasdfasdfasdf");
bfrt.newLine();//跨平台换行方法。
bfrt.write("asdfasdfasdfasdf");
bfrt.flush();
bfrt.close();//关闭流。
}
}
9、读取字符流缓冲区BufferedReader
readLine返回的串不包含回车符。
readLine方法原理:
无论是读一行,或者读取多个字符,最终都是在硬盘上一个一个的读取,所以最终使用的还是read方法一次读取一个。
import java.io.*;
class BufferedReaderDemo{
public static void main(String[] args)throws IOException{
BufferedReader bfrd = new BufferedReader(new FileReader("aaa.txt"));
String s = null;
while((s=bfrd.readLine())!=null){//一次读取一行,BufferedReader特有方法。
System.out.println(s);
}
bfrd.close();
}
}
10、使用缓冲区复制文件。
import java.io.*;
class CopyFileWithBuffered
{
public static void main(String[] agrs)
{
copyFileByBuffered("CalendarDemo.java","D:\\test.txt");
}
public static void copyFileByBuffered(String res,String des)
{
BufferedReader br = null;
BufferedWriter bw = null;
try
{
br = new BufferedReader(new FileReader(res));
bw = new BufferedWriter(new FileWriter(des));
}
catch (IOException e)
{
System.out.println(e.toString());
throw new RuntimeException();
}
try
{
String s = null;
int x = 0;
while((s=br.readLine())!=null)//readLine返回的串不包含回车符。
{
bw.write(s);
bw.newLine();
x++;
if(x%5==0)
bw.flush();
}
bw.flush();
}
catch (IOException e)
{
throw new RuntimeException("读取或写入失败");
}
finally
{
if(br!=null)
try
{
br.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
if(bw!=null)
try
{
bw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
}
11、明白了BufferedReader类中特有方法readLine的原理后
自定义一个类中包含一个功能和readLine一致的方法。
装饰设计模式:
想要对已有对象进行功能增强时。
可以自定义类,将已有对象传入,基于已有功能,并提供增强功能。
自定义的该类就称为装饰类。
装饰模式比继承灵活,避免了继承体系的臃肿。并且降低了类与类之间的关系。
因为装饰类增强已有对象,具备的功能和已有功能是相同的,只不过提供了增强功能。
所以装饰类和别装饰类通常处于同一体系中。
import java.io.*;
class MyBufferedReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr = new FileReader("aaa.txt");
MyBufferedReader mbr = new MyBufferedReader(fr);
String s = null;
while((s=mbr.myReadLine())!=null)
{
System.out.println(s);
}
mbr.myClose();
}
}
class MyBufferedReader extends Reader
{
private Reader r;
MyBufferedReader(Reader r)
{
this.r =r;
}
public String myReadLine()throws IOException//定义一个和readLine方法功能一致的方法。
{
//定义一个临时容器存储独到的字符。
StringBuilder sb = new StringBuilder();
int temp = 0;
while((temp=r.read())!=-1)
{
if(temp=='\r')
continue;
if(temp=='\n')
return sb.toString();
sb.append((char)temp);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
public void close()throws IOException
{
r.close();
}
public int read(char[] cbuf,int off,int len)throws IOException
{
return r.read(cbuf,off,len);
}
public void myClose()throws IOException
{
r.close();
}
}
---------------------------------------------------------------------------------
LineNumberReader
int getLineNumber();
void setLineNumber(int lineNumber);
import java.io.*;
class LineNumberReaderDemo
{
public static void main(String[] args)throws IOException
{
LineNumberReader lnr = new LineNumberReader(new FileReader("BufferedReaderDemo.java"));
String s = null;
lnr.setLineNumber(100);//行号从一百开始
while((s=lnr.readLine())!=null)
{
int line = lnr.getLineNumber();//获取行号。
System.out.println(line+":"+s);
}
lnr.close();
}
}
12、字节流
操作图片数据,需要使用字节流。
InputStream
OutputStream
import java.io.*;
class FileStreamDemo
{
public static void main(String[] args)throws IOException
{
FileWrite();
FileRead_1();
FileRead_2();
FileRead_3();
}
public static void FileWrite()throws IOException
{
FileOutputStream os = new FileOutputStream("data.txt");
os.write("asdf".getBytes());//没有缓冲,不需刷新。
os.close();
}
public static void FileRead_1()throws IOException
{
FileInputStream is = new FileInputStream("data.txt");
int num = 0;
while((num=is.read())!=-1)
{
System.out.println((char)num);
}
is.close();
}
public static void FileRead_2()throws IOException
{
FileInputStream is = new FileInputStream("data.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len = is.read(buf))!=-1)
{
System.out.println(new String(buf,0,len));
}
is.close();
}
public static void FileRead_3()throws IOException//小文件可以使用该方法,大文件可能导致内存溢出。
{
FileInputStream is = new FileInputStream("data.txt");
int num = is.available();
byte[] buf = new byte[num];
is.read(buf);
System.out.println(new String(buf));
is.close();
}
}
13、复制图片到指定位置。
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
copyPic("temp.jpg","D:\\temp.jpg");
}
public static void copyPic(String res,String des)
{
FileInputStream is = null;
FileOutputStream os = null;
int num = 0;
byte[] buf = new byte[1024];
try
{
is = new FileInputStream(res);
os = new FileOutputStream(des);
while((num=is.read(buf))!=-1)
{
os.write(buf,0,num);
}
}
catch (IOException e)
{
throw new RuntimeException("创建流失败");
}
finally
{
if(is!=null)
{
try
{
is.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
if(os!=null)
{
try
{
os.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
}
}
}
14、字节流缓冲区BufferedInputStream BufferedOutputStream
拷贝MP3,通过缓冲区。
import java.io.*;
class CopyMp3
{
public static void main(String[] args)
{
long start = System.currentTimeMillis();
copyMp3("E:\\Music\\Adele - Someone Like You.mp3","D:\\someone.mp3");
long end = System.currentTimeMillis();
System.out.println(end-start);
}
public static void copyMp3(String res,String des)
{
BufferedInputStream bis =null;
BufferedOutputStream bos = null;
byte[] buf = new byte[1024];
int num = 0;
try
{
bis = new BufferedInputStream(new FileInputStream(res));
bos = new BufferedOutputStream(new FileOutputStream(des));
while((num=bis.read(buf))!=-1)
{
bos.write(buf,0,num);
}
}
catch (IOException e)
{
throw new RuntimeException("创建流失败");
}
finally
{
if(bis!=null)
{
try
{
bis.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
if(bos!=null)
{
try
{
bos.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
}
}
}
15自定义字节流缓冲区
import java.io.*;
class MyBufferedInputStream
{
private InputStream is;
private byte[] buf = new byte[1024];
private int pos = 0, count = 0;
MyBufferedInputStream(InputStream is)
{
this.is = is;
}
public int myRead()throws IOException
{
//通过is对象读取字节,并存入buf中。
if(count==0)
{
count = is.read(buf);
if(count<0)
return -1;
pos=0;
byte b = buf[pos];
count--;
pos++;
return b&255;
}
else if(count>0)
{
byte b = buf[pos];
count--;
pos++;
return b&255;
}
return -1;
}
public void myClose()throws IOException
{
is.close();
}
}
流文件可能出现以下数据形式
11111111-11100000-00000000-01010101-01010010-10101010-10110101-0....
一个字节为8位二进制代码
当读取一个字节为11111111时,此时该字节标示-1;
00000001去反
11111110+1
11111111=-1;
与结束标志相同。
为了避免上述情况发生
将byte转换成int
byte -1 --->int -1
11111111-11111111-11111111-11111111
&00000000-00000000-00000000-11111111
---------------------------------------
00000000-00000000-00000000-11111111=255 返回元数据,并避免了返回-1的情况。
16、读取转换流和写入转换流。
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
OutputStreamWriterDemo();
}
public static void InputStreamReaderDemo()throws IOException
{
BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream("www.txt")));
String s = null;
while(true)//这么写有问题。读取文件时,会抛出空指针异常。
{
s = bf.readLine();
if(s.equals("over"))
break;
System.out.println(s);
}
}
public static void OutputStreamWriterDemo()throws IOException
{
BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream("www.txt")));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
String s = null;
while((s=bf.readLine())!=null)//如果写while(true)的话在读取文件到最后时会导致s = null,后面输出无法进行,抛出空指针异常。
{
if(s.equals("over"))
break;
bw.write(s);
bw.newLine();
bw.flush();
}
bf.close();
bw.close();
}
}