黑马程序员_Java基础IO流File流
<一、File流>
用来将文件或者文件夹封装成对象。
方便对文件与文件夹的属性信息进行操作。
File对象可以作为参数传递给流的构造函数。
了解File类中的常用方法。
File.separator:跨平台的目录分隔符
import java.io.*;
class FileDemo
{
public static void main(String[] args)
{
consMethod();
}
//创建File对象
public static void consMethod()
{
//将a.txt封装成file对象。可以将已有的和已出现的文件或者文件夹封装成对象。
File f1=new File("f:\\abc\\a.txt");
File f2=new File("f:\\abc","b.txt");//将目录与文件分开。
//上一行相当于
File d=new File("f:\\abc");
File f3=new File(d,"c.txt");
sop("f1:"+f1);//初始化封装的什么就打印什么：f:\abc\b.txt
sop("f2:"+f2);
sop("f3:"+f3);
/*File f4=new File("f:\\abc\\zz\\a.txt");
//在不同操作系统下分隔符可能不同,为了统一，用File.separator代替。返回一个字符串
*/
File f4=new File("f:"+File.separator+"abc"+File.separator+"zz"+File.separator+"a.txt");
sop("f4:"+f4);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
File类常见方法：
1，创建。
boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不同，输出流对象一建立创建文件，而且文件已存在，会覆盖。
boolean mkdir()：创建文件夹，只能创建一级目录。
boolean mkdirs():创建文件夹，可创建多级目录。
2，删除。
boolean delete()：删除失败返回false
void deleteOnExit()：在程序退出时删除指定对象。
3，判断。
boolean canExecute():是否能执行。
boolean exists():是否存在。
boolean isDirectory():目录是否存在
boolean isFile():文件是否存在
boolean isAbsolute():是否是绝对路径
4，获取信息。
getName():
getPath():
getParent():该方法返回的是绝对路径中的父目录，即上一层目录，如果获取的是相对路径，返回null
如果相对路径中有上一层目录那么该目录就是返回结果。
getAbsolutePath():获取绝对路径
long lastModified():获取最后修改时间。
long length():文件长度
5.
File[] listRoots:列出可用的文件系统根
String [] list()：指定目录下的所有文件或文件夹名称，调用list方法的file对象必须是目录，且该目录必须存在
*/
import java.io.*;
class FileDemo2
{
public static void main(String[] args) throws IOException
{
//method_1();
//method_2();
// method_3();
//method_4();
method_5();
listRootsDemo();
}
public static void method_1()throws IOException
{
File f=new File("file.txt");//创建文件
f.deleteOnExit();//在程序退出时删除指定对象。
sop("create:"+f.createNewFile());//创建新文件
sop("delete"+f.delete());//删除文件
}
public static void method_2()
{
File f=new File("file1.txt");
sop("execute:"+f.canExecute());//是否能执行。
sop("exists:"+f.exists());//是否存在
//创建文件夹,即目录
File dir=new File("abc\\a\\t\\h\\r\\hh\\t");
sop("mkdir:"+dir.mkdirs());//创建目录,能创建多级目录。
}
public static void method_3()throws IOException
{
File f=new File("file.txt");
//f.createNewFile();//创建文件
// f.mkdir();//创建文件夹
//记住在判断文件对象是否是文件或目录时，必须要先判断该文件对象封装的内容是否存在
//通过exists判断
sop("dir:"+f.isDirectory());
sop("file:"+f.isFile());
sop(f.isAbsolute());
}
public static void method_4()
{
File f=new File("f:\\aatxt");
sop("path:"+f.getPath());
sop("abspath:"+f.getAbsolutePath());
sop("parent"+f.getParent());//该方法返回的是绝对路径中的父目录，即上一层目录，如果获取的是相对路径，返回null
//如果相对路径中有上一层目录那么该目录就是返回结果。
}
public static void method_5()
{
File f1=new File("f:\\Test.txt");
File f2=new File("d:\\HHHH.txt");
sop("rename"+f1.renameTo(f2));
}
public static void listRootsDemo()
{
File[] files=File.listRoots(); //列出可用的文件系统根
for(File f :files)
{
sop(f);
}
}
public static void listDemo()
{
File f=new File("c:\\");
String[]names=f.list();//list()：指定目录下的文件或文件夹名称
for(String name:names)
{
sop(name);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*文件列表list,listFile*/
import java.io.*;
class FileDemo2
{
public static void main(String[] args)
{
//list_method();
listFile();
}
public static void list_method()
{
File dir=new File("f:\\Source1");
/* String[] list(FilenameFilter filter)
过滤指定目录下的文件，FilenameFileter为过滤器。
FilenameFileter为一接口，有accept方法。
可采用调用匿名内部类的方法。
*/
String[] arr=dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
/*if(name.endsWith(".java"))
return true;
else
return false;
*/
return name.endsWith(".java");
}
});
for(String str:arr)
{
sop(str);
}
}
public static void listFile()
{
File dir=new File("f:\\Source1");
File[] arr=dir.listFiles();//与list方法相比，返回的是File对象，对象可以调用很多方法
for(File str:arr)
{
sop(str.getName()+"::"+str.length());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
列出目录下所有内容,包含子目录中的内容——递归
因为目录中还有目录，可用递归调用。
递归要注意：
1.限定条件。
2.要注意递归的次数，尽量避免内存的溢出
import java.io.*;
class FileDemo3
{
public static void main(String[] args)
{
File dir=new File("d:\\");
showDir(dir,0);
//toBin(6);
//sop(getSum(11));
}
public static String getLevel(int level)
{
StringBuilder sb=new StringBuilder();
sb.append("|--");
for(int x=0;x<level;x++)
{
sb.insert(0,"| ");
}
return sb.toString();
}
public static void showDir(File dir,int level)//列出目录下所有内容
{
System.out.println(getLevel(level)+dir.getName());
level++;
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x],level);
else
System.out.println(files[x]);
}
}
public static void toBin(int num)//递归求二进制
{
if(num>0)
{
toBin(num/2);
sop(num%2);
}
}
public static int getSum(int n)
{
if(n==1)
return 1;
else
return n+getSum(n-1);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*删除一个带内容的目录
删除原理：
在windows中，删除目录从里往外删除-递归
*/
import java.io.*;
class RemoveDir
{
public static void main(String[] args)
{
File dir=new File("f:\\123");
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()+":-file-:"+files[x].delete());
}
System.out.println(dir+"::dir::"+dir.delete());
}
}
/*练习:
将一个指定目录下的所有java文件的绝对路径，存储到一个文本文件中。建立一个java文件列表文件。
思路：
1，对指定的目录 进行递归。
2.获取递归过程所有的java文件的路径。
3.将这些路径存储到集合中。
4.将集合中的数据写入到一个文件中。
*/
import java.io.*;
import java.util.*;
class JavaFileList
{
public static void main(String[] args)throws IOException
{
File dir=new File("f:\\Source1");
List<File> list=new ArrayList<File>();
fileToList(dir,list);
sop(list);
sop(list.size());
// File file=new File("f:\\Source1\\javalist.txt");相当于下式
File file=new File(dir,"javalist1.txt");
writeToFile(list,file.toString());
}
public static void fileToList(File dir,List<File> list)
{
File[] files=dir.listFiles();
for(File file:files)
{
if(file.isDirectory())
fileToList(file,list);
else
{
if(file.getName().endsWith(".java"))
list.add(file);
}
}
}
public static void writeToFile(List<File>list,String javaListFile)throws IOException//将集合存入文本
{
BufferedWriter bufw=null;
try
{
bufw=new BufferedWriter(new FileWriter(javaListFile));
for(File f:list)
{
String path=f.getAbsolutePath();
bufw.write(path);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw e;
}
finally
{
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw e;
}
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
<二、Properties简介>
Properties是hashtable的子类
也就是说他具备map集合特点，而且他里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：键=值。
*/
import java.io.*;
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args)throws IOException
{
//setAndGet();
//method_1();
loadDemo();
}
//设置和获取元素
public static void setAndGet()
{
Properties prop=new Properties();
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");
sop(prop);
sop(prop.getProperty("lisi"));
prop.setProperty("lisi","99");
Set<String> names=prop.stringPropertyNames();//将键值对存到set集合
for(String s : names)
{
sop(s+":"+prop.getProperty(s));
}
}
//想要将info.txt中键值数据存到集合中进行操作。
/*思路；
1，用一个流和info.txt文件关联。
2，读取一行数据，将改行数据用“=”进行切割。
3，等号左边作为键，右边作为值，存入到Properties集合中即可。
*/
public static void method_1()throws IOException//将info.txt中键值数据存到集合中进行操作
{
BufferedReader bufr=new BufferedReader(new FileReader("info.txt"));
String line=null;
Properties prop=new Properties();
while((line=bufr.readLine())!=null)
{
String[] arr=line.split("=");
//sop(arr[0]+"-----"+arr[1]);
prop.setProperty(arr[0],arr[1]);
}
bufr.close();
sop(prop);
}
public static void loadDemo()throws IOException//演示Properties的load方法。此方法比上方法更方便
{
Properties prop=new Properties();
FileInputStream fis=new FileInputStream("info.txt");
//将流中数据加载进集合
prop.load(fis);
prop.setProperty("lisi","66");//注意此处改的是内存中的数据。但没改变文件中数值。修改的是property中信息
sop(prop);
//利用输出流改变文件info.txt中的值
FileOutputStream fos=new FileOutputStream("info.txt");
prop.store(fos,"zhu shi xin xi");//第二个参数为注释信息。store方法将信息存储到输出流并写到文件中去。
prop.list(System.out);
fos.close();
fis.close();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*Properties小练习：
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示：
很容易想到的是：计数器。
可该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
可是随着该应用程序的退出，该计数器也在内存中消失了。
下一次再启动该程序，又重新开始从0计数。这不是我们想要的。
程序即使结束，该计数器的值，也存在。
下次程序再启动会先加载该计数器的值并加1，再重新存储起来。
所以要建立一个配置文件，用于记录该软件的使用次数。
该配置文件使用键值对的形式。
这样便于阅读数据，并操作数据。
键值对数据时map集合。
数据是以文件形式存储，使用io技术。
那么map+io-->properties
配置文件可以实现应用程序数据的共享。
*/
import java.io.*;
import java.util.*;
class RunCount
{
public static void main(String[] args)throws IOException
{
Properties prop=new Properties();
File file=new File("count.ini");
if(!file.exists())
file.createNewFile();
FileInputStream fis=new FileInputStream(file);//文件变成流
prop.load(fis);//将流加载进pro
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+"");//重新存回去
FileOutputStream fos=new FileOutputStream(file);//重新写到文件infor里
prop.store(fos,"ffffff");
fos.close();
fis.close();
}
}
<三、打印流>
该流提高了打印方法，可以将各种数据类型的数据都原样打印。
字节打印流：
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(System.out,true);//true表示自动刷新，仅当print带ln时才用
/*
当输出到文件时，因为刷新是对流而言的，文件没有刷新，所以可把文件封装到流里
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.flush();
}
out.close();
bufr.close();
}
}
<三、序列流>
SequencelnputStream：将多个流进行合并
import java.io.*;
import java.util.*;
class SequenceDemo
{
public static void main(String[] args)throws IOException
{
Vector<FileInputStream> v=new Vector<FileInputStream>();
v.add(new FileInputStream("c:\\1.txt"));
v.add(new FileInputStream("c:\\2.txt"));
v.add(new FileInputStream("c:\\3.txt"));
Enumeration<FileInputStream> en=v.elements();
SequenceInputStream sis=new SequenceInputStream(en);//三流合一
FileOutputStream fos=new FileOutputStream("c:\\4.txt");
byte[] buf=new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
/*切割文件*/
import java.io.*;
import java.util.*;
class SplitFile
{
public static void main(String[] args)throws IOException
{
splitFile();
merge();
}
public static void splitFile()throws IOException//分割
{
FileInputStream fis=new FileInputStream("c:\\1.mp3");
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:\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
/*下方法为 合并 ，做了解即可*/
public static void merge()throws IOException
{
ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
for(int x=1;x<=3;x++)
{
al.add(new FileInputStream("c:\\"+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);//必须接受Enumeration
FileOutputStream fos=new FileOutputStream("c:\\0.mp3");
byte[] buf=new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
