java基础整理二十（IO流二）

 
第二十天
File类:
创建File类对象的方法:将文件或文件夹封装成File对象
File f1 = new File("a.txt"); File f2 = new File("c:\\abc","b.txt");
File d = new File("c:\\abc"); File f3 = new File(d,"c.txt");
File.separator路径分割符即"c:"+File.separator+"abc"

File类的常见方法:
1,创建
 boolean createNewFile():在指定位置创建文件,如果该文件已经存在,则不创建,返回false
 和输出流不一样,输出流对象创建文件,当文件已存在时会覆盖.
 boolean mkdir();创建目录 boolean mkdirs();创建多级目录
2,删除
 boolean delete():删除失败返回false
 void deleteOnExit():在程序退出时删除指定文件
3,判断
 boolean exidts():文件是否存在 isFile():是否为文件 isDirectory():是否为文件夹
 isHidden():是否为隐藏文件 isAbsolute():是否为绝对目录
4,获取
 getName();获取名称 getPath();获取路径 getParent()返回绝对路径中的父目录,如果是相对路径返回null有上层目录时返回上层目录
 getAbsolutePath():获取绝对路径 lastModified():最后修改时间 length():返回文件大小 f1.rennameTo(f2);f1替换为f2

list():列出目录下文件列表 调用list方法的file对象必须是封装了一个目录.且必须存在
listRoots():列出盘符 listFiles():返回为对象可以具体操作

过滤指定类型文件:
import java.io.*;
class Demo
{
 public static void main(String[]args)
 {
  File f = new File("e:\\abc");
  String[] name = f.list(new FilenameFilter()
  {
   public boolean accept(File e,String name)
   {
    return name.endsWith(".java");
   }
  });
  for (String n:name)
  {
   System.out.println(n);
  }
 }
}

列出指定目录下文件或者文件夹包含子目录中的内容递归手法
递归注意:1,限定条件 2,注意递归次数防止内存溢出
import java.io.*;
class Demo
{
 public static void main(String[]args)
 {
  File f = new File("e:\\");
  show(f);
 }
 public static void show(File f)
 {
  System.out.println(f);
  File[] files = f.listFiles();打印目录名称
  for (int x = 0;x<files.length ;x++ )
  {
   if (files[x].isDirectory())判断是否还为目录
   show(files[x]);
   else
    System.out.println(files[x]);
  }
 }
}

删除原理:
在window中,删除目录运用递归从里往外删的
import 将ava.io.*;
class RemoveDir
{
 public static void main(String[]args)
 {
  File dir = new File("e:\\qq");
  removeDir(dir);
 }
 public static void removeDir(File dir)
 {
  File[]files = dir.listFiles();
  for (int x = 0;x<files.length ;x++ )
  {
   if(files[x].isDirectory())
    removerDir(files[x]);
   System.out.print(files[x].toString()+"--"+files[x].delete());
  }
  System.out.println(dir+"::"+dir.delete());
 }
}

练习:将一个指定目录下的java文件的绝对路径存储到一个文本文件中建立一个java文件列表
思路:
1,对指定的目录进行递归
2,获取递归过程所得的java文件路径
3,将这些路径存储到集合中
import java.io.*;
import java.util.*;
class JavaFileList
{
 public static void main(String[]args)
 {
  File dir = new File("e:\\abc");
  List<File> list = new ArrayList<File>();
  fileToList(dir,list);
  System.out.println(list.size());
  File f = new File("e:\\java.txt");
  writeToFile(list,f.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 filess)
 {
  BufferedWriter buw = null;
  try
  {
   buw = new BufferedWriter(new FileWriter(filess));
   for(File fs:list)
   {
    String path = fs.getAbsolutePath();
    buw.write(path);
    buw.newLine();
    buw.flush();
   }
  }
  catch (IOException e)
  {
   throw new RuntimeException("错误");
  }
  finally
  {
   try
   {
    if(buw!=null)
     buw.close();
   }
   catch (IOException e)
   {
    throw new RuntimeException("失败");
   }
  }
 }
}

Properties是Hashtable的子类具备Map集合的特点里面键值对都为字符串无泛型,
是集合中和IO技术结合的集合容器 对象特点:可以用键值对形式配置文件
import java.io.*;
import java.util.*;
class PropertiesDemo
{
 public static void main(String[]args)
 {
   setAndGet();
 }
 public static void setAndGet()
 {
  Properties prop = new Properties();
  prop.setProperty("lise","24");存值
  prop.setProperty("xiao","27");
  prop.setProperty("lise","29");修改
  Set<String> names = prop.stringPropertyNames();将键存入Set集合中
  for(String name:names)
  {
   System.out.println(name+"--"+prop.getProperty(name));获取键所对应的值
  }
  System.out.println(value);
 }
}
将info.txt中的键值数据存入到集合中
思路:1,用一个流和info.txt文件关联 2,读取一行数据,将该行数据用"="切割 3,"="左右键值存入集合
Properties提供的load(流对象file);可以直接将文件中的数据加载进集合中.list(System.out);打印出集合元素列表 
prop.store(fos,"haha");方法应用:FileOutputStream fos = new FileOutputStream("info.txt");此时store方法将集合内容重新存入文件"haha"为一个标记
import java.util.*;
import java.io.*;
class Demo
{
 public static void main(String[]args)throws IOException
 {
  jianzhi();
 }
 public static void jianzhi()throws IOException
 {
  BufferedReader buf = new BufferedReader(new FileReader("info.txt"));
  String line = null;
  Properties prop = new Properties();
  while((line=buf.readLine())!=null)
  {
   String[]str = line.split("=");
   prop.setProperty(str[0],str[1]);
  }
  System.out.println(prop);
  buf.close();
 }
}
记录应用程序运行次数,次数到达时给出提示
运用计数器,程序结束计数器的值依然存在,下次启动继续存值
建立一个配置文件记录该软件运行次数
以键值对的形式便于阅读与操作,用Map集合承装,以文件形式存储使用到io技术即Properties
import java.io,*;
import java.util.*;
class Demo
{
 public static void main(String[]args)throws IOException
 {
  Properties prop = new Properties();
  File file = new File("info.ini");
  if(!file.exists())
   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)
   {
    System.out.println("次数已到!");
    return;
   }
  }
  count++;
  prop.setProperty("time",count+"");
  FileOutputStream fos = new FileOutputStream(file);
  prop.store(fos,"");
  fos.close();
  fis.close();
 }
}

打印流:提供打印方法,可以将各种数据类型的数据都原样打印
字节打印流:PrintSream 构造函数可以接收的参数类型:
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 buf = new BufferedReader(new InputStreamReader(System.in));
  PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);自动刷新功能为ture 自能刷新流对象
  String line = null;
  while ((line = buf.readLine())!=null)
  {
   if("over".equals(line))
    break;
   out.println(line.toUpperCase());println自持上面的自动刷新
  }
   out.close();
   buf.close();
 }
}
合并流:将多个文件进行关联
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 fis = 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();
  heliu();
 }
 public static void splitFile()throws IOException 切割
 {
  FileInputStream fis = new FileInputStream("ppq.jpg");
  FileOutputStream fos = null;
  byte[]buf = new byte[1024*1024];
  int len = 0;
  int count=1;
  while ((len=fis.read(buf))!=-1)
  {
   fos=new FileOutputStream("e:\\abc\\a\\"+(count++)+".part");
   fos.write(buf,0,len);
   fos.close();
  }
  fis.close();
 }
 public static void heliu()throws IOException 合并
 {
  ArrayList<FileInputStream> v = new ArrayList<FileInputStream>();
  for(int x=1;x<=3;x++)
  {
   v.add(new FileInputStream("e:\\abc\\a\\"+x+".part"));
  }
  final Iterator<FileInputStream> it = v.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:\\abc\\a\\po.jpg");
  byte[]buf = new byte[1024];
  int len = 0;
  while ((len=sis.read(buf))!=-1)
  {
   fos.write(buf,0,len);
  }
  sis.close();
  fos.close();
 }
}