黑马程序员--java基础9--File类

------- android培训、java培训、期待与您交流！ ---------
day20File类**************************************************************
public static void consMethod()//创建File对象
{
//将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象。
//不创建新的文件！
File f1 = new File("a.txt");
File f2 = new File("e:+"File.separator()"+abc","b.txt");
//File.separator()跨平台的目录分隔符 \\
File d = new File("c:\\abc");
File f3 = new File(d,"c.txt");


sop("f1:"+f1);//f1:a.txt
sop("f2:"+f2);//f2:e:\abc\b.txt
sop("f3:"+f3);//f3:e:\abc\c.txt
}


File类常见基本方法：
1，创建。
boolean createNewFile():
在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。
2，删除。
boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
void deleteOnExit();在程序退出时删除指定文件。
3，判断。
boolean exists() :先判断文件是否存在.*********************
isFile():先判断文件是否存在，再判断文件对象是否是File对象
isDirectory();先判断文件是否存在，再判断文件对象是否是Directory对象
isHidden();隐藏的文件尽量不去访问，可能访问不了
isAbsolute();文件不存在也可以判断，是否是绝对路径
 boolean canExecute() 
          测试应用程序是否可以执行此抽象路径名表示的文件。 
 boolean canRead() 
          测试应用程序是否可以读取此抽象路径名表示的文件。 
 boolean canWrite() 
          测试应用程序是否可以修改此抽象路径名表示的文件。 
4，获取信息。
getName()://返回 最后一级的名字
getPath()://返回 封装的原样
getParent()://该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
//如果相对路径中有上一层目录那么该目录就是返回结果。
getAbsolutePath() //返回绝对路径E:\\abc\file.txt
long lastModified() 先判断文件是否存在,最后修改时间
long length() 先判断文件是否存在,文件长度
boolean renameTo(File dest) 先判断文件是否存在，再移动文件。相当于剪贴并改名字和后缀名！ 


@@基本的方法
public static void m5()
{
File f1 = new File("c:\\Test.jpg");
File f2 = new File("c:\\aaa.txt");
File f3 = new File("e:\\ssss.txt");


sop("rename:"+f3.renameTo(f1));
}
public static void m4()throws IOException
{
File f = new File("abc\\file.txt");

sop(f.getName());//返回最后一级的名字 file.txt
sop("path:"+f.getPath());//返回 封装的原样 abc\file.txt
sop("abspath:"+f.getAbsolutePath());//E:\\abc\file.txt
sop("parent:"+f.getParent());//abc
//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
//如果相对路径中有上一层目录那么该目录就是返回结果。
}
public static void m3()throws IOException
{
File f = new File("file.txt");

//在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在。
//通过f.exists()判断。
sop(f.isDirectory());
sop(f.isFile());
sop(f.isAbsolute());
}
public static void m2()throws IOException
{
File f = new File("file2.txt");
f.createNewFile();
sop(f.exists());
sop(f.canExecute());
File dir = new File("abc\\f\\d\\s\\a");
sop(dir.mkdirs());
sop(dir.delete());//只删除了最后的一个文件夹\\a,且a必须为空才能删除成功
//dir.deleteOnExit();
}
public static void m1()throws IOException
{
File f = new File("file1.txt");
sop(f.createNewFile());
//sop(File.createTempFile("wzq","tmp").createNewFile());
sop(f.delete());
//f.deleteOnExit();
}
public static void consMethod()//创建File对象
{
//将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象。
//不创建新的文件！
File f1 = new File("a.txt");
File f2 = new File("e:+"+File.separator+"+abc","b.txt");
//File.separator()跨平台的目录分隔符 \\
File d = new File("c:\\abc");
File f3 = new File(d,"c.txt");


sop("f1:"+f1);//f1:a.txt
sop("f2:"+f2);//f2:e:\abc\b.txt
sop("f3:"+f3);//f3:e:\abc\c.txt
}


@@重要方法
static File[] listRoots();返回电脑上的所有盘符！
String[] list();返回目录下的所有文件和目录！包含隐藏的文件。
String[] list(FilenameFilter filter) 
 
************调用list方法的file对象必须是一个目录，而且该目录还必须存在。
File dir = new File("E:\\HeiMa\\my25code\\day18");
String[] arr = dir.list(new FilenameFilter(){
public boolean accept(File dir,String name)
{
return name.endsWith(".java");
}
});
sop("len:"+arr.length);
for(String name : arr)
{sop(name);}
File[] listFiles();
public static void showDir(File dir)
{
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]);
}
}
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。


因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。


递归要注意：
1，限定条件。
2，要注意递归的次数(不要大于几千)。尽量避免内存溢出。
public static int getSum(int n)
{
if(n==1)
return 1;
else
return n+getSum(n-1);
}
public static void toBin(int num)
{
if(num>0)
{
toBin(num/2);
sop(num%2);
}
}
@@列出文件夹下的内容
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)
{
sop(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
sop(getLevel(level)+dir.getName());
}
}
@@删除带内容的目录。
删除一个带内容的目录。
删除原理：
在windows中，删除目录是从里往外删除的。
既然是从里往外删除，就需要用到递归。
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
sop(files[x].toString()+":文件:"+files[x].delete());
}
sop(dir.toString()+"-文件夹-"+dir.delete());
}
@@创建java文件列表
import java.io.*;//文件 ，流
import java.util.*;//集合
class JavaFileList 
{
public static void main(String[] args) throws IOException
{
File dir = new File("E:\\day19");

List<File> list = new ArrayList<File>();
fileToList(dir,list);
File file = new File(dir,"javalist.txt");
writeToFile(list,file);
}
public static void fileToList(File dir,List<File> list)
{
File[] files = dir.listFiles();
b 
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,File 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;
}
}
}
}
@@Properties(配置文件)是hashtable的子类、
 void list(PrintStream out) 
          将属性列表输出到指定的输出流。 
 void list(PrintWriter out) 
          将属性列表输出到指定的输出流。 
 void load(InputStream inStream) 
          从输入流中读取属性列表（键和元素对）。 
 void load(Reader reader) 
          按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。 
 Object setProperty(String key, String value) 
          调用 Hashtable 的方法 put。 
 void store(OutputStream out, String comments) 
          以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。 
 void store(Writer writer, String comments) 
          以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符 
 Set<String> stringPropertyNames() 
          返回此属性列表中的键集，其中该键及其对应值是字符串，
 如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。 
也就是说它具备map集合的特点，而且它里面存储的键值对 都是字符串！
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件！
在加载数据时，需要数据有固定的格式，键=值 
存取：
public static void setAndGet()
{
Properties prop = new Properties();
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","55");
sop(prop);
sop(prop.getProperty("lisi"));


Set<String> names = prop.stringPropertyNames();
for(String s : names)
{
sop(s+":"+prop.getProperty(s));
}
}
将info.txt文件中键值数据存储到集合中进行操作。
public static void method_1() 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]);
}
bufr.close();
System.out.println(prop);
}
将输出流中的数据加载进文件！
public static void loadDemo()throws IOException
{
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("info.txt");


//将流中的数据加载进集合。
prop.load(fis);
//System.out.println(prop);
prop.setProperty("wangwu","39");//改变内存中的结果，而不是硬盘。
FileOutputStream fos = new FileOutputStream("info.txt");
prop.store(fos,"haha");//改变了硬盘中的结果！
//haha前面有#,表示注释信息，不是配置信息。不加载！
prop.list(System.out);
fis.close();
fos.close();
}
/*
用于记录应用程序的运行次数。
如果使用次数已到，那么给出注册提示。


很容易想到：计数器、
可是该计数器定义在程序中，随着程序的运行，而在内存中存在，并进行自增。
可是随着该应用程序的推出，该计数器也在内存中消失了、
下次再启动该程序，又重新开始从0计数。不是想要的效果。


程序即使结束，该计数器的值也存在。
下次程序启动会 先加载计数器的值，并加1后再重新存储起来。


所以要建立一个配置文件，用于记录该软件的使用次数。


该配置文件使用键值对的形式，
这样便于阅读和操作数据。


键值对数据是map集合。
数据是以文件形式存储，使用IO技术。
那么map+io-->properties.


配置文件可以实现应用程序数据的共享！
配置文件后缀名一般是，properties、xml、ini
*/
public static void main(String[] args)throws IOException
{
Properties prop = new Properties();
File file = new File("info.ini");
if(!(file.isFile()))
file.createNewFile();
FileInputStream fis = new FileInputStream(file);
prop.load(fis);
int count = 0;
String value = prop.getProperty("time");
if(value!=null)
{
count = Integer.parseInt(value);
if(count>=5)
sop("你好，次数到了，请交钱！");
}
count++;
prop.setProperty("time",count+"");
FileOutputStream fos = new FileOutputStream("info.ini");
prop.store(fos,"");
fos.close();
fis.close();
}
@@PrintStream
打印流：
该流提供了打印方法，可以将各种数据类型的数据都原样打印。!!!!!!!!!!


字节打印流：
PrintStream
构造函数可以接受的参数类型！  *************
1，file对象   File
2，字符串路径 String
3，字节输出流 OutputStream


字符打印流：
@@PrintWriter(重点掌握)   web开发中常用！
构造函数可以接受的参数类型！  *******************************
1，file对象   File
2，字符串路径 String
3，字节输出流 OutputStream


4, 字符输出流 Writer
*/


1111字节打印流
java.lang.Object
  java.io.OutputStream
      java.io.FilterOutputStream
          java.io.PrintStream
 PrintStream append(char c) 
          将指定字符添加到此输出流。 
 void close() 
          关闭流。 
 void flush() 
          刷新该流的缓冲。 
 PrintStream format(Locale l, String format, Object... args) 
          使用指定格式字符串和参数将格式化字符串写入此输出流中。
 PrintStream printf(Locale l, String format, Object... args) 
          使用指定格式字符串和参数将格式化的字符串写入此输出流的便捷方法。 
 void println(char x) 
          打印字符，然后终止该行。 
 void print(char c) 
          打印字符。
 void write(byte[] buf, int off, int len) 
          将 len 字节从指定的初始偏移量为 off 的 byte 数组写入此流。 
 void write(int b) 
          将指定的字节写入此流。 


22222222222222字符输出流
与 PrintStream 类不同，如果启用了自动刷新，（构造函数的第二个参数为true）
则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作，
而不是每当正好输出换行符时才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。
 void write(String s) 
          写入字符串。 
 void write(String s, int off, int len) 
          写入字符串的某一部分。 
 void write(char[] buf) 
          写入字符数组。 
@@合并流SequenceInputStream
SequenceInputStream(Enumeration<? extends InputStream> e) 
          通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。 
SequenceInputStream(InputStream s1, InputStream s2) 
          通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），以提供从此 SequenceInputStream 读取的字节。 
  方法摘要 
 int available() 
          返回不受阻塞地从当前底层输入流读取（或跳过）的字节数的估计值，方法是通过下一次调用当前底层输入流的方法。 
 void close() 
          关闭此输入流并释放与此流关联的所有系统资源。 
 int read() 
          从此输入流中读取下一个数据字节。 
 int read(byte[] b, int off, int len) 
          将最多 len 个数据字节从此输入流读入 byte 数组。 


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();
}
@@切割文件he合并文件
public static void merge()throws IOException
{
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x =0;x<=1;x++)
{
al.add(new FileInputStream("e:\\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("e:\\e.txt");


byte[] buf = new byte[1024*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("e:\\1.txt");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count = 0;
while((len=fis.read(buf))!=-1)
{
fos = new FileOutputStream("e:\\splitfiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}

-------- android培训、java培训、期待与您交流！ ----------