IO流(File概述)
1、File 类
l 用来将文件或者文件夹封装成对象
l 方便对文件与文件夹的属性进行操作
l File对象可以作为参数传递给流的构造函数
2、常用的构造方法和separator
/**
File类中
1,File类的构造方法:
1, File(Fileparent,String child)
2, File(Stringparent,String child)
3, File(Stringpathname)
注意:打印对象的时候,打印的是路径
2,字段:public static final String seprator
实现跨平台的分隔符。
*/
import java.io.*;
class Demo1
{
public static voidmain(String[] args)
{
//将指定的文件或者文件夹封装为对象,可以本身没有
File f1 = newFile("a.txt");
//第二种
File f2 = newFile("C:\\abc","c.txt");
//第三种
File d= newFile("C:\\cc");
File f3 =newFile(d,"a.txt");
System.out.println(f1);
//夸平台的分隔符
File f4 = newFile("C:"+File.separator+"a.txt");
System.out.println(f4);
}
}
IO流(File的常见方法)
/**
File类的常见的方法:
crud
1,创建
booleancreateNewFile() :
在指定的位置创建一个文件,如果该文件已经存在,
则不会被创建
booleanmkdir() :创建一个一级文件
booleanmkdirs():创建多级文件
2,删除
booleandelete(): 删除文件
voiddeleteOnExit():
在程序退出时,删除文件,这样的好处是防止文件正在被操作,而不能被删除
3,判断
booleanexists(): 判断文件是否存在
isFile():判断是否为文件
isDirectory():判断是否是文件夹(目录)
isHidden():判断是否为隐藏文件
isAbsolute():判断路径是否为绝对路径名
canExecute():判断文件是否可以执行
注意:
在用isFile和isDirectory的时候,首先要判断是否存在
即使用exists()
4,获取
getName():获取文件名
getPath():获取文件路径
getParent():获取父目录名(这个是创建File对象的时候,
我们写在里面那个)
getAbsolutePath():获取相对路径
lastModified():获取最后一次修改的时间
length():获取文件的大小
*/
import java.io.*;
class Demo2
{
//调用者
publicstatic void main(String[] args)throws IOException
{
//creat();
//delete();
//panDuan();
get();
}
//创建
publicstatic void creat()throws IOException
{
//创建一个文件
Filef =new File("a.txt");
sop("create:"+f.createNewFile());
//创建一个目录
Filef1= new File("F:"+File.separator+"abc");
sop("mkdir:"+f1.mkdir());
}
//删除
publicstatic void delete()
{
Filef =new File("a.txt");
sop("delete:"+f.delete());
}
//判断:
publicstatic void panDuan()throws IOException
{
Filef = new File("a.txt");
f.createNewFile();
//判断文件是否存在
sop("exists:"+f.exists());
//判断是否为文件
sop("isFiel:"+f.isFile());
//判断是否为文件夹
sop("isDirectory:"+f.isDirectory());
//判断是否为隐藏文件
sop("isHidden:"+f.isHidden());
//判断是否为绝对路径名
sop("isAbsolute:"+f.isAbsolute());
//判断是否为可执行文件
sop("canExecute:"+f.canExecute());
}
//获取
publicstatic void get()throws IOException
{
Filef = new File("F:"+File.separator+"b.txt");
sop("create:"+f.createNewFile());
//获取文件名称
sop("name:"+f.getName());
//获取父目录名
sop("parent:"+f.getParent());
//获取文件路径
sop("path:"+f.getPath());
//获取文件的绝对路径
sop("absolutePath:"+f.getAbsolutePath());
//获取最后一次修改的时间
sop("lastModify:"+f.lastModified());
//获取文件大小
sop("length:"+f.length());
}
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
}
IO流(文件列表)
/**
文件列表:
1,列出可用的文件系统根
publicstatic File[] listRoots()
2, 列出指定目录中的文件和目录
publicString[] list();
注意:这个方法在实际的开发中一般使用的是ListFiles()
因为它返回的是对象,可以进行操作
3,列出指定路径的文件
publicFile[] listFiles();
注意:列出的是文件,不包含目录
4,文件或者目录过滤器,返回的是指定路径下满足条件的
文件或者目录
publicString[] list(FilenameFilter filter)
关于FilenameFilter的介绍:
FilenameFilter是一个接口
就有一个抽象的方法;
publicabstract boolean accept(File dir,String name)
其中:dir 是指定目录, name:是对文件的要求
*/
import java .io.*;
class Demo3
{
publicstatic void main(String[] args)
{
//listRootMethod();
//listMethod();
//listFilesMethod();
fileFilterMethod();
}
publicstatic void listRootMethod()
{
File[]files = File.listRoots();
//高级for循环
for(File file :files )
{
System.out.println(file);
}
}
publicstatic void listMethod()
{
//将指定的目录封装成对象
Filedir = new File("C:"+File.separator);
//sop(dir);
String[]str = dir.list();
for(Strings : str)
{
sop(s);
}
}
publicstatic void listFilesMethod()
{
Filedir = new File("F:\\") ;
//返回的是对象
File[]files = dir.listFiles();
for(Filefile : files)
{
sop(file);
}
}
//使用文件过滤器,打印F:\盘下以.jpg结尾的文件
publicstatic void fileFilterMethod()
{
//将指定的目录封装成对象
Filedir = new File("F:\\");
//sop(dir);
//使用匿名内部类创建FilenameFileter对象
String[]names = dir.list(new FilenameFilter()
{
publicboolean accept(File dir,String name)
{
// sop(dir);
// sop(name.endsWith(".jpg") );
returnname.endsWith(".jpg") ;
}
});
for(String name : names)
{
sop(name);
}
}
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
}
IO流(列出目录下的所有的内容—递归)(很重要的思想)
1、思想:
递归:就是自己调用自己
使用递归的时候注意的事情:
1,限定条件
2,注意递归次数,防止内存溢出
2、例子:
使用递归方法,求和。
/**
使用递归求和:
*/
class Demo4
{
public static voidmain(String[] args)
{
}
//定义一个求和的方法
public static intgetSum(int num)
{
if (num==1)
{
return 1;
}
returnnum+getSum(num-1);
}
}
/**
使用递归列出指定目录下的所有的内容
思路:
1,将指定的目录封装成File对象
2,遍历指定目录下的文件
3,在遍历的过程中,如果文件是文件夹,那么调用这个方法
*/
import java.io.*;
class Demo5
{
public static voidmain(String[] args)
{
File dir = newFile("F:"+File.separator+"2014java");
showDir(dir);
}
//定义列出目录的方法
public static voidshowDir(File dir)
{
System.out.println(dir);
File[]files=dir.listFiles();
for(File file :files)
{
if(file.isDirectory())
showDir(file);
else
System.out.println(file);
}
}
}
IO流(删除带内容的目录)
1、在windows中,删除目录从里面向外删除
2、在java中delete删的是里面没有内容的文件,
3、在java中一般都不用这种方法
4、在做这个删除操作的时候,为了验证自己是否出错,那么可以再删除的时候打印一下。
5、例子:
/**
需求:删除带内容的目录
思路:用到了遍历
*/
import java.io.*;
class Demo6
{
public static voidmain(String[] args)
{
File dir = newFile("F:\\ab");
deleteDir(dir);
}
//删除目录
public static voiddeleteDir(File dir)
{
File[]files=dir.listFiles();
for(File file :files)
{
if(file.isDirectory())
deleteDir(file);
else
System.out.println(file.getName()+"jjjjjj"+file.delete()); //删除文件
}
//删除目录
System.out.println("dd"+dir.delete());
}
}
IO流(创建java文件列表)
/**
练习:
将一个指定目录下的java文件的绝对路径,存储到一个文本文件中
建立一个java文件的列表文件。
思路:
1,将指定的目录封装为File对象
11,创建一个集合,用来存储路径
2,遍历该目录,找到绝对路径
3,在遍历的过程中加上判断条件,如果是java文件,存在集合中
4,将集合中的路径,存在一个文件中
*/
import java.io.*;
import java.util.*;
class Demo7
{
publicstatic void main(String[] args)
{
Filedir =new File("F:"+File.separator+"2014java\\day05");
List<File>list = new ArrayList<File>();
FilejavaListFile = new File("f:\\javalist.txt");
FileToList(dir,list);
// System.out.println(list.size());
ListToFile(list,javaListFile);
}
//将指定目录中java文件存到一个集合中
publicstatic void FileToList(File dir,List<File> list) //void??? //有集合就别忘了加泛型
{
//列出路径下的文件
File[]files=dir.listFiles();
//遍历
for(Filefile :files )
{
//判断是否为目录
if(file.isDirectory())
//递归
FileToList(file,list);
else
{
//判断是否为.java文件
if(file.getName().endsWith(".java"))
list.add(file);
}
}
}
//将集合中的内容存到一个文件中
publicstatic void ListToFile(List<File> list,File javaListFile)
{
BufferedWriterbufw = null;
//1,确定操作的是目的,是文本的,设备是硬盘,提高效率
try
{
bufw =
newBufferedWriter(new FileWriter (javaListFile));
//遍历集合
for(Filef : list)
{
Stringname = f.getAbsolutePath();
bufw.write(name);
bufw.newLine();
bufw.flush();
}
}
catch(IOException e)
{
thrownew RuntimeException("存储到文件中失败");
}
finally
{
try
{
if(bufw!=null)
bufw.close();
}
catch(IOException e)
{
thrownew RuntimeException();
}
}
}
}
IO流(Properties简述)
1,Properties是hashtable的子类,也就是说它具备了map集合的特点,
而且在它里面存放的键值对都是字符串。
2,特点:是集合和io技术相结合的集合容器
3,该对象的特点:可以用于键值对形式的配置文件
IO流(Properties存取)
1、Properties在util包中
2、示例:
import java.util.*;
class Demo8
{
public static voidmain(String[] args)
{
//创建对象
Properties pro =new Properties();
//set方法存入数据
pro.setProperty("李华","23");
pro.setProperty("王芳","34");
//使用set方法改变数据
pro.setProperty("李华","09");
//使用getProperty方法获得单个的属性的值
String value =pro.getProperty("李华");
System.out.println(value);
//使用publicSet<String> stringPropertyNames() 方法获得键值
Set<String>set = pro.stringPropertyNames();
for (String str :set )
{
System.out.println(str+",,,"+pro.getProperty(str));
}
}
}
IO流(Properties练习)(挺好的)
/**
需求:做一个注册提示:
用于记录应用程序运行次数,如果次数已经到了,那么给出注册提示。
分析:
1,想到了计数器,用来记录次数
2,这个记录以键值对的形式保存起来,而键值对是map集合,
数据是以文件的形式保存起来的,使用到了io技术,
map+io=====properties
总结:配置文件可以实现程序数据的共享。
*/
import java.util.*;
import java.io.*;
class Test
{
publicstatic void main(String[] args)throws IOException
{
demo();
}
//
publicstatic void demo()throws IOException
{
//有一个properties对象
Propertiespro = new Properties();
//一般操作文件,先把文件封装
Filefile = new File("conf.ini");
//判断文件是否存在
if(!file.exists())
file.createNewFile();
//加载,注意是流
FileReaderfr = new FileReader(file);
pro.load(fr);
intcount =0;
Stringvalue=pro.getProperty("time");
if(value!=null)
{
count=Integer.parseInt(value);
if(count>=5)
{
System.out.println("您的使用期限已到,请交钱");
return;
}
}
count++;
//修改
pro.setProperty("time",count+"");
//保存
FileWriterfw = new FileWriter(file);
pro.store(fw,"");
//关流
fr.close();
fw.close();
}
}
IO流(PrintWriter)(记住)
/**
打印流:
PrintWriter 和 PrintStream 可以直接操作输入流和文件
打印流:该流提供了打印的方法,可以将各种数据类型的
数据原样打印。
字节打印流:
PrintStream
构造函数可以接收的参数类型:
1,file对象
2,字符串路径
3,字节输出流。 OutputStream
字符打印流:
PrintWriter
构造函数可以接收的参数类型:
1,file对象
2,字符串路径
3,字节输出流
4,字符输出流。
以上的要记住了,还有在流中和文件有关的都很重要。
记住:
PrintWriter(OutputStream out, booleanautoFlush)
中autoFlus 为true的时候,会对println自动刷新。
*/
import java.io.*;
class Test2
{
publicstatic void main(String[] args)throws IOException
{
//键盘录入
BufferedReaderbufr =
newBufferedReader(new InputStreamReader(System.in));
//创建打印流对象
PrintWriterout = new PrintWriter(System.out,true);//自动刷新
Stringline =null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line); //可以换行了
}
bufr.close();
}
}
IO流(序列流(合并流))
/**
序列流:
SequenceInputStream:将多个读取流合并为一个读取流
构造函数:
public SequenceInputStream(Enumeration<?extends InputStream> e)
public SequenceInputStream(InputStream s1,InputStream s2)
*/
import java.io.*;
import java.util.*;
class Test3
{
publicstatic void main(String[] args)throws IOException
{
//创建一个Vector集合
Vector<FileInputStream>v = new Vector<FileInputStream>();
//添加数据
v.add(newFileInputStream("1.txt"));
v.add(newFileInputStream("2.txt"));
v.add(newFileInputStream("3.txt"));
//创建Enumeration对象
Enumeration<FileInputStream>en = v.elements();
//创建一个序列流对象
SequenceInputStreamsis = new SequenceInputStream(en);
//创建一个输出流对象
FileOutputStreamfos = new FileOutputStream("4.txt");
//读取字节流
byte[]buf = new byte[1024];
intlen=0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
IO流(切割文件)
import java.io.*;
class Test4
{
publicstatic void main(String[] args)throws IOException
{
splitFile();
}
publicstatic void splitFile()throws IOException
{
//将指定的文件相关联
FileInputStreamfis = new FileInputStream("F:\\1.mp3");
//存储
FileOutputStreamfos = null;
byte[]buf = new byte[1024*1024]; //创建一个要切割大小的数组
intlen=0;
intcount=1;
while((len=fis.read())!=-1)
{
fos=newFileOutputStream("F:\\split\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
//合并
publicstatic void merge()
{
//因为Vector创建的集合低效,所以采用ArrayList
ArrayList<FileInputStream>al = new ArrayList<FileInputStream>();
for(intx=1;x<3;x++)
{
al.add(newFileInputStream("F:\\"+x+".part"))
}
finalIterator<FileInputStream> it = al.iterato();
Enumeration<FileInputStream>en =new Enumeration<FileInputStream>()
{
publicboolean hasMoreElements()
{
returnit.hasNext();
}
publicFileInputStream nextElement()
{
returnit.next();
}
};
SequenceInputStreamsis = new SequenceInputStream(en);
FileOutputStreamfos = new FileOutputStream("F:\\split\\0.mp3");
byte[]buf =new byte[1024];
intlen =0;
while((len=sis.read())!=-1)
{
fos.write(buf,0,len);
}
sis.close();
}
}