---------------------- android培训、java培训、期待与您交流！ ----------------------
一、File类
1、用来将文件或者文件夹封装成对象
2、方便对文件与文件夹进行操作
3、File对象可以作为参数传递给流的构造函数。
4、了解File类中的常用方法
static String separator
与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
import java.io.*;
public class Demo{
public static void main(String args[])throws IOException{
consMethod();
}
//创建File对象
public static void consMethod(){
//将a.txt封装成 file 对象，可以将已有的和未出现的文件或者文件夹封装成对象。
File f1 = new File("c:\\java\\demo.txt");
File f2 = new File("c:\\java","demo.txt");//和上面相等
File d = new File("c:\\java");
File f3 = new File(d,"demo.txt");//这样也可以
File f4 = new File("c:"+File.separator+"java"+File.separator+"demo.txt");
sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
sop("f4:"+f4);
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
二、IO流(File对象功能-创建和删除)
1、创建
boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false
和输出流不一样棒，输出流对象一建立就创建文件，而且文件已经存在，会覆盖
boolean mkdir() 创建此抽象路径名指定的目录。
2、删除
boolean delete() 删除此抽象路径名表示的文件或目录。
void deleteOnExit() 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
当被操作时候，删除不了，所以等虚拟机终止时，删除
import java.io.*;
public class Demo{
public static void main(String args[])throws IOException{
method_1();
}
//创建File对象
public static void method_1()throws IOException{
File f = new File("demo_2.txt");
sop("create:"+f.createNewFile());
f.deleteOnExit();
sop("delete:"+f.delete());
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
三、IO流(File对象功能-判断)
/*
File 常见方法
3、判断
boolean canExecute() 测试应用程序是否可以执行此抽象路径名表示的文件。
boolean canRead() 测试应用程序是否可以读取此抽象路径名表示的文件。
boolean canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。
int compareTo(File pathname) 按字母顺序比较两个抽象路径名
boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
boolean isAbsolute() 测试此抽象路径名是否为绝对路径名。
判断类型时候。必须先判断是否存在
boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
*/
import java.io.*;
public class Demo{
public static void main(String args[])throws IOException{
method_1();
}
//创建File对象
public static void method_1()throws IOException{
File f = new File("file.txt");
f.mkdirs();
sop(f.isDirectory());
sop(f.isFile());
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
四、IO流(File对象功能-获取)
/*
File 常见方法
4、获取信息
String getName()
String getPath
String getParent() 此抽象路径名指定父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null
String getAbsolutPath
String getAbsolutFile() 绝对路径对象
long lastModified（）
long length() 返回由此抽象路径名表示的文件的长度。
boolean renameTo(File dest) 重新命名此抽象路径名表示的文件。
*/
import java.io.*;
public class Demo{
public static void main(String args[])throws IOException{
method_1();
}
//创建File对象
public static void method_1()throws IOException{
File f = new File("Demo.java");
File f2 = new File("Demo2.java");
sop(f.renameTo(f2));
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
五、IO流(File对象功能-文件列表)
static File[] listRoots()
列出可用的文件系统根。
String[] list() 包含隐藏文件
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
import java.io.*;
public class Demo{
public static void main(String args[])throws IOException{
method();
}
public static void method()throws IOException{
File files = new File("c:\\java");
String[] names = files.list();//调用list方法的file对象，必须是封装了一个目录，该目录还必须存在
for(String name : names){
sop(name);
}
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
六、IO流(File对象功能-文件列表2) 文件过滤
String[] list(FilenameFilter filter)
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[] listFiles(FilenameFilter filter)
返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
import java.io.*;
public class Demo{
public static void main(String args[])throws IOException{
method();
}
public static void method()throws IOException{
File dir = new File("c:\\java");
File[] subNames = dir.listFiles();
for(File name : subNames){
sop(name.getName()+"::"+name.length());
}
}
public static void method2()throws IOException{
File dir = new File("c:\\java");
String[] subNames = dir.list(new FilenameFilter(){
public boolean accept(File dir,String name){
return name.endsWith(".java");
}
});
for(String name : subNames){
sop(name);
}
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
七、IO流(列出目录下所有内容-递归)
/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现还是目录的话，还可以在此调用本功能
也就是函数自身调用自身，
这种表现形式，或者编程手法，成为递归
递归要注意：
1、制条件
2、要注意递归次数，避免内存溢出
*/
import java.io.*;
public class Demo{
public static void main(String args[])throws IOException{
File dir = new File("c:\\java\\test");
showDir(dir);
}
public static void showDir(File dir)throws IOException{
sop(dir);
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++){
if(files[x].isDirectory()){
showDir(files[x]);
}else{
sop(files[x]);
}
}
}
public static void toBin(int num){
while(num>0){
num = num/2;
toBin(num);
}
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
八、IO流(列出目录下所有内容-带层次)
/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现还是目录的话，还可以在此调用本功能
也就是函数自身调用自身，
这种表现形式，或者编程手法，成为递归
递归要注意：
1、制条件
2、要注意递归次数，避免内存溢出
*/
import java.io.*;
public class Demo{
public static void main(String args[])throws IOException{
File dir = new File("c:\\java\\test");
showDir(dir,0);
}
public static String getLevel(int level){
StringBuilder sb = new StringBuilder();
for(int x=0;x<level;x++){
sb.append("| ");
}
return sb.toString();
}
public static void showDir(File dir,int level)throws IOException{
sop(getLevel(level)+dir);
level++;
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++){
if(files[x].isDirectory()){
showDir(files[x],level);
}else{
sop(files[x]);
}
}
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
九、IO流(删除带内容的目录)
/*
既然是从里往外删除，就需要用到递归。
*/
import java.io.*;
public class Demo{
public static void main(String args[])throws IOException{
File dir = new File("c:\\java\\test");
removeDir(dir);
}
public static void removeDir(File dir)throws IOException{
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++){
if(files[x].isDirectory()){
removeDir(files[x]);
}else{
sop(files[x].toString()+"::"+files[x].delete());
}
}
sop(dir+"::dir::"+dir.delete());
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
十、IO流(创建java文件列表)
/*
练习，
讲一个指定目录下的java文件的绝对路径，存储到一个文本文件中
建立一个java文件列表文件
思路：
1、对指定的目录进行递归
2、获取递归过程中的java文件路径
3、将这些路径存储到集合中
4、将集合中的数据写入到一个文件中
*/
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String args[])throws IOException{
File dir = new File("c:\\java");
List<File> list = new ArrayList<File>();
fileToList(dir,list);
File file = new File(dir,"demo.txt");
writeToFile(list,file.toString());
}
public static void fileToList(File dir,List<File> list)throws IOException{
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){
}
}
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
十一、IO流(Properties简述)
Properties 是 hashtable 的子类
也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串
是集合中和IO技术相结合的集合容器
该对象特点：可以用于键值对形式的配置文件。
那么在加载数据时候，需要数据有固定格式：键=值
十二、IO流(Properties存取)
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String args[])throws IOException{
setAndGet();
}
//设置和获取元素
public static void setAndGet(){
Properties prop = new Properties();
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");
sop(prop.toString());
String value = prop.getProperty("lisi");
sop(value);
prop.setProperty("lisi","98");
Set<String> names = prop.stringPropertyNames();
for(String s : names){
sop(s+":"+prop.getProperty(s));
}
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
十三、IO流(Properties存取配置文件)
String getProperty(String key)
用指定的键在此属性列表中搜索属性。
String getProperty(String key, String defaultValue)
用指定的键在属性列表中搜索属性。
void list(PrintStream out)
将属性列表输出到指定的输出流。
void list(PrintWriter out)
将属性列表输出到指定的输出流。
void load(InputStream inStream)
从输入流中读取属性列表（键和元素对）。
void load(Reader reader)
按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
store(OutputStream out, String comments)
以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
十四、-IO流(Properties练习)
/*
演示，如何将流中的数据存储到集合中
想要将 info.txt 中的键值对数据存到集合中进行操作。
1、用一个流和info.txt文件关联
2、读取一行数据。将改行数据用"="进行切割。
3、等号左边作为键，右边作为值，存入到Properties集合中即可
*/
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String args[])throws IOException{
loadDemo();
}
public static void loadDemo()throws IOException{
FileInputStream fis = new FileInputStream("info.txt");
Properties prop = new Properties();
prop.load(fis);
sop(prop);
FileOutputStream fos = new FileOutputStream("info.txt");
prop.store(fos,"haha");
prop.list(System.out);
fos.close();
fis.close();
}
//设置和获取元素
public static void method()throws IOException{
BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));
String line = null;
Properties prop = new Properties();
while((line=bufr.readLine())!=null){
String[] arr = line.split("=");
prop.setProperty(arr[0],arr[1]);
sop(prop);
}
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
十五、IO流(PrintWriter)
1、打印流
PrintWriter 与 PrintStream
可以直接操作输入流和文件
2、序列流、
SequenceInputStream
对多个流进行合并
3、操作对象
ObjectInputStream 与 ObjectOutputStream
被操作的对象需要实现 Serializale (标记接口);
4、练习：文件分割程序
/*
打印流
该流提供了打印方法，可以将各种数据烈性的数据都原样打印
字节打印流
PrintStream
构造函数可以接受的参数类型
1、file对象。
2、字符串路径。String
3、字节输出流 OutpuStream
字符打印流
PrintWriter
构造函数可以接受的参数类型
1、file对象。
2、字符串路径。String
3、字节输出流 OutpuStream
4、字符输出流 Writer
*/
import java.io.*;
public class Demo{
public static void main(String args[])throws Exception{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
//PrintWriter out = new PrintWriter(System.out,true);
PrintWriter out = new PrintWriter(new FileWriter("demo.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();
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
十六、IO流(合并流)
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String args[])throws Exception{
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));
Enumeration <FileInputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("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();
}
public static void sop(Object obj){
System.out.println(obj.toString());
}
}
十七、IO流(切割文件)
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String args[])throws Exception{
splitFile();
merge();
}
public static void splitFile()throws Exception{
FileInputStream fis = new FileInputStream("Kalimba.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("Kalimba-"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
public static void merge()throws Exception{
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=1;x<10;x++){
al.add(new FileInputStream("Kalimba-"+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("Kalimba_part.mp3");
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 sop(Object obj){
System.out.println(obj.toString());
}
}
----------------------
android培训、java培训、期待与您交流！ ----------------------