黑马程序员_java_io(中)

最新推荐文章于 2015-12-17 21:20:06 发布

百鑫

最新推荐文章于 2015-12-17 21:20:06 发布

阅读量517

点赞数

分类专栏：黑马程序员

本文链接：https://blog.csdn.net/u010035035/article/details/8878203

版权

黑马程序员专栏收录该内容

18 篇文章 0 订阅

订阅专栏

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

java_io(中)

File:
File类是io包中唯一代表磁盘文件本身的对象,File类定义了一些与平台无关的方法来操作文件,
可以通过调用File类中的方法,实现创建.删除.重命名文件等,File类是对象主要用来获取未文件本身
的一些信息,如文件所在的目录,文件的长度.文件的读写权限等.数据流可以将数据系写入到文件中,
而文件也是数据流最常用的数据媒体.

构造方法:

File(File parent, String child)// parent:子路径字符串 child:父路径字符串
根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

File(String pathname) //pathname指包括文件路径(包文件名)
通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

File(String parent, String child) //
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(URI uri)
通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

---------------------------------------------------------------------------------------------

File类常见方法：

1，创建。

boolean | createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

boolean | mkdir():创建文件夹。

boolean | mkdirs():创建多级文件夹。

   演示:
    File f=new File("file.txt");
    sop("create:"+f.createNewFile());//创建文件
    sop("mkdir:"+f.mkdir());//创建文件夹
    sop("mkdir:"+f.mkdirs());//创建多级的文件夹

    ps:sop代表打印语句.
   ------------------------------------------------
  2，删除。

boolean | delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。

void | deleteOnExit();在程序退出时删除指定文件。

   演示:
    File f=new File("file.txt");
    f.deleteOnExit();//程序退出时删除指定文件
    sop("create:"+f.createNewFile());//创建文件
    sop("delete:"+f.delete());//删除文件

------------------------------------------------
3，判断。

boolean | exists():文件是否存在.

boolean | isFile():判断是否是文件

boolean | isDirectory():是否是一个目录

boolean | isHidden():判断是是否是隐藏的文件

boolean | isAbsolute()::测试此抽象路径名是否为绝对路径名。

   演示:
    File f = new File("d:\\java1223\\day20\\file2.txt");
    sop("dir:"+f.isDirectory());
    sop("file:"+f.isFile());
    sop(f.isAbsolute());
   //记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。
   //通过exists判断。

      -----------------------------------------------
  4，获取信息。
   String | getName():返回由此抽象路径名表示的文件或目录的名称。

String | getPath():将此抽象路径名转换为一个路径名字符串。

String | getParent():返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。如果相对路径中有上一层目录那么该目录就是返回结果。

String | getAbsolutePath():返回此抽象路径名的绝对路径名字符串。

long | lastModified():返回此抽象路径名表示的文件最后一次被修改的时间。

long | length():返回由此抽象路径名表示的文件的长度.

   演示:
    File f = new File("file.txt");
    sop("path:"+f.getPath());
    sop("abspath:"+f.getAbsolutePath());
    sop("parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
           //如果相对路径中有上一层目录那么该目录就是返回结果。

其他:
static File[] | listRoots():列出可用的文件系统根。

File[] | listFiles():返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

String[] | list():返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录

   演示:
    File f=new File("d:\\");
    String[] nums=f.list();//列出文件和目录。
    for(String s:nums)//高级for
    {
     System.out.println(s);
    }

   演示2:
    public static void listRoots()
    {
     File[] files=File.listRoots();//列出可用的文件系统根。

     for(File f:files)//高级for
     {
      System.out.println(f);
     }
    }
    ps:其他类等详情参阅API java.io File类

------------------------------------------------------------------------------
递归:

函数自己调用自己。
注意：递归时一定要明确结束条件。 

应用场景：
  当某一功能要重复使用时。
递归要注意：
  1，限定条件。
  2，要注意递归的次数。尽量避免内存溢出。

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

示例:

import java.io.*;
class FileDemo3
{
 public static void main(String[] args)
 {
  File f=new File("d:\\java0410");//创建File对象,定义一个路径
  showDir(f);//往函数中传递一个路径dir
 }
 public static void showDir(File dir)
 {
  File[] files=dir.listFiles();//调用listFiles()方法.每个数组元素对应目录中的每个文件或目录

  int num=0;//定义一个变量
  
  for(File f:files)//使用高级for遍历
  {  
   if(files[num].isDirectory())//对元素进行判断是否是文件夹.如果是使用递归.
    showDir(files[num]);//递归自己调用自己
   System.out.println(files[num++]);
  }
 }
}

用递归删除文件:
删除一个带内容的目录。
删除原理：
在window中，删除目录从里面往外删除的。
既然是从里往外删除。就需要用到递归。
示例:

import java.io.*;
class  RemoveDir
{
 public static void main(String[] args) 
 {  
  File dir = new File("d:\\testdir");//创建File对象,定义一个路径
  removeDir(dir);//往函数中传递一个路径dir
 }
 public static void removeDir(File dir)
 {
  File[] files = dir.listFiles();//调用listFiles()方法.每个数组元素对应目录中的每个文件或目录
  
  for(int x=0; x<files.length; x++)//遍历File数组
  {
   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) 
 {
  File dir=new File("d:\\java0410");//建立File对象.指定路径
  List<File> list=new ArrayList<File>();//建立list集合存储递归到的文件
  fileToList(dir,list);//往fileToList函数里面传入路径和集合
  
  try
  {
   //创建路径javalist.txt文本文件
   File file=new File(dir,"javalist.txt");
   writeToFile(list,file.toString());//传入到writeToFile函数中
  }
  catch (IOException e)
  {
   throw new RuntimeException("创建失败");
  }
  
 }

 public static void fileToList(File dir,List<File> list)
 {
  File[] files=dir.listFiles();//获取路径的文件和文件夹

  for(File file:files)//高级for循环.File文件类型   file变量名字   files被变量的数组(或集合)
  {
   if(file.isDirectory())//判断是否是文件夹.如果是文件件.就递归,进文件夹里面.
    fileToList(file,list);//递归穿进去刚才判断的文件夹.list集合也穿进去.因为文件都存在一个集合中
   else
   {
    if(file.getName().endsWith(".java"))//如果是文件的话.就判断是否后缀名是.java的文件
     list.add(file);//往集合中存入文件
   }
  }
 }
 //将集合中的数据存入到文本文件中
 public static void writeToFile(List<File> list,String javaListFile)throws IOException
 {
  BufferedWriter bufw=null;//初始化BufferedWrite容器.
  try
  {
   //建立BufferedWriter字符输出流.并指定文件路径javaListFile就是路径
   bufw=new BufferedWriter(new FileWriter(javaListFile));
   for(File f:list)//高级for遍历
   {
    String path=f.getAbsolutePath();//返回此抽象路径名的绝对路径名字符串。
    bufw.write(path);//将字符传输出到文本文件javalist.txt中
    bufw.newLine();//换行
    bufw.flush();//刷新
   }
  }
  catch (IOException e)
  {
   throw e;//抛出异常
  }
  finally
  {
   try
   {
    if(bufw!=null)//判断是否建立失败
     bufw.close();
   }
   catch (IOException e)
   {
    System.out.pritnln("关闭字符输出流失败");
    throw e;
   }
  }
 }
}

//-----------------------------------------------------------------------
Properties:

Properties是hashtable的子类。
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：键=值。

构造方法摘要

Properties():创建一个无默认值的空属性列表。

Properties(Properties defaults):创建一个带有指定默认值的空属性列表。

常用方法:

String | getProperty(String key):用键获取值.

Object | setProperty(String key, String value):设置键值对.调用 Hashtable 的方法 put。

Set<String> | stringPropertyNames():返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

演示:

public static void setAndGet()
   {
    Properties prop=new Properties();//创建Properties属性类
    
    prop.setProperty("zhangsan","22");//设置键值

    prop.setProperty("lise","21");

    Set<String> names=prop.stringPropertyNames();//把Map转成Set取出

    for(String s: names)//高级for
    {
     System.out.println(s+"...."+prop.getProperty(s));//打印键 调用值getProperty打印值
    }
   }

-----------------------------------------------------------------

void | load(InputStream inStream):从输入流中读取属性列表（键和元素对）。

void | store(Writer writer, String comments):以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。

演示:

public static void loadDemo()throws IOException
   {
    FileReader fr=new FileReader("info.txt");//建立字符输入流对象与文件相关联

    Properties prop=new Properties();//建立Properties属性类

    prop.load(fr);//使用Properties的load方法.将字符输入流的数据转入Properties中

    System.out.println(prop);

    prop.setProperty("zhangsan","88");//将info.txt中到底值设置为88

    FileOutputStream fos=new FileOutputStream("info.txt");//建立字节输出流和文件相关联

    prop.store(fos,"haha");//使用Properties的store方法,将流流中的数据存储到指定的文件中

    System.out.println(prop);

    fr.close();//关闭流

    fos.close();
   }

-----------------------------------------------------------------------
练习:
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。

import java.io.*;
import java.util.*;
class RunCountDemo
{
 public static void main(String[] args)
 {
   count();//调用count方法
 }
 public static void count()
 {
  //给对象初始化属性类
  Properties prop=null;
  File file=null;
  FileInputStream fis=null;
  FileOutputStream fos=null;
  try
  {
  
   prop=new Properties(); //创建Properties属性类对象
   
   file=new File("count.ini");//创建File文件对象
   
   if(!(file.exists()))//对file进行判断是否存在.如果不存在创建一个.
    file.createNewFile();
  
   fis=new FileInputStream(file); //建立字节输入流对象.和文件相关联
   
   prop.load(fis);//将流转换成Properties

   int count=0;//计数器

   String value=prop.getProperty("timp"); //获取timp的值.

   if(value!=null)//判断是否为空
   {
    count=Integer.parseInt(value); //如果不等于空的话将值转换成Integet对象进行操作
    if(count>=5)//如果判断等于>=5程序跳出
    {
     System.out.println("使用次数已经到");
     return ;
    }
   }
   count++;//计数器加加

   fos=new FileOutputStream(file);//创建字符输出流.和文件相关联

   prop.setProperty("timp",count+"");//设置键值.

   prop.store(fos,"haha");//将流流中的数据存储到指定的文件中
  
  } 
  catch (IOException e)//异常处理
  {
   throw new RuntimeException("配置文件创建失败"+e.toString());
  }
  finally
  {
   try
   {
    if(fis!=null)
     fis.close();
   }
   catch (IOException e)
   {
    throw new RuntimeException("关闭输入流失败");
   }
   try
   {
    if(fos!=null)
     fos.close();
   }
   catch (IOException e)
   {
    throw new RuntimeException("关闭输出流失败");
   }
  
  }
 }
}

--------------------------------------------------------------

打印流

打印流：
该流提供了打印方法，可以将各种数据类型的数据都原样打印。

字节打印流：
PrintStream

构造函数可以接收的参数类型：
  1，file对象。File
  2，字符串路径。String
  3，字节输出流。OutputStream
  4，PrintStream(OutputStream out, boolean autoFlush)
//autoFlush - boolean 变量；如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区

字符打印流：
PrintWriter

构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream
4，字符输出流，Writer。
5，PrintWriter(OutputStream out, boolean autoFlush)
//autoFlush - boolean 变量；如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区

演示:

import java.io.*;
 class PrintWriterDemo
 {
  public static void main(String[] args) throws IOException
  {
   BufferedReader bufr=//键盘录入
    new BufferedReader(new InputStreamReader(System.in));

   PrintWriter out=new PrintWriter(System.out,true);//打印流对象

   String len=null;

   while((len=bufr.readLine())!=null)
   {
    if("over".equals(len))
     break;
    out.println(len.toUpperCase());//打印.并转成大写
   }
  }
 }

---------------------------------------------------------------------

合并流SequenceInputStream (合并读取流)

构造方法：

SequenceInputStream(Enumeration<? extends InputStream> e) //Enumeration:枚举 SequenceInputStream(InputStream s1, InputStream s2)
通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。

SequenceInputStream(InputStream s1, InputStream s2)
通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），以提供从此 SequenceInputStream 读取的字节。

示例1:

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("d:\\1.txt"));
  v.add(new FileInputStream("d:\\2.txt"));//添加对象
  v.add(new FileInputStream("d:\\3.txt"));

  Enumeration<FileInputStream> en=v.elements();//使用枚举的elements,.返回Enumeration,SequenceInputStream就可以使用了

  SequenceInputStream sis=new SequenceInputStream(en);

  FileOutputStream fos=new FileOutputStream("d:\\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();
 }
}

示例2:

/*
需求:切割一个MP4文件.,并合并

 步骤..
  切割:
  1.建立字符输入流和文件相关联
  2.建立输出流.输出的时候分三个文件存储.

 合并:
  1.使用枚举的elements.返回Enumeration,因为合并流需要
  2.往枚举里添加字节输入流对象.
  3.建立输出流.和文件路径文件名关联.
  4.输出.
  
*/
import java.io.*;

import java.util.*;
class SplitFile
{
 public static void main(String[] args) 
 {
  //split()
  merge();
 }
 public static void merge()//合并文件
 {
  FileOutputStream fos=null;//初始化字节输入流对象
  SequenceInputStream sis=null;//初始化字节输入流对象合并流
  try
  {
   Vector<FileInputStream> v=new Vector<FileInputStream>();//建立枚举
   for(int x=0;x<3;x++)
   {
    v.add(new FileInputStream("d:\\"+x+".mp4"));//for循环添加遍历对象.
   }

   Enumeration<FileInputStream> en=v.elements();使用枚举的elements,.返回Enumeration,SequenceInputStream就可以使用了

   sis=new SequenceInputStream(en);//建立合并流,往合并流中传入

   fos=new FileOutputStream("d:\\4.mp4");//建立字符输出流对象.并指定文件

   byte[] buf=new byte[1024*1024*10];//建立字符数组10M的

   int len=0;
   while((len=sis.read(buf))!=-1)
   {
    fos.write(buf,0,len);//往容器中存数据.
   }
   }
  catch (IOException e)//异常
  {
   throw new RuntimeException("文件合并失败");
  }
  finally
  {
   try
   {
    if(fos!=null)
     fos.close();
   }
   catch (IOException e)
   {
    System.out.println("关闭流资源失败");
   }
   try
   {
    if(sis!=null)
     sis.close();
   }
   catch (IOException e)
   {
    System.out.println("关闭流资源失败");
   }
  }
  //fos.close();
  //sis.close();

 }

 


 public static void split()//切割
 {
  FileInputStream fis=null;//初始化对象
  FileOutputStream fos=null;
  try
  {   
   fis=new FileInputStream("d:\\VID_20130414_181841.mp4");//字符输入流指定文件
   byte[] buf=new byte[1024*1024*10];

   int len=0;
   int count=0;//定义变量来当名字

   while((len=fis.read(buf))!=-1)
   {
    fos=new FileOutputStream("d:\\"+(count++)+".mp4");//指定路径和文件名字
    fos.write(buf,0,len);//开始输出.
    fos.close();
   }
  }
  catch (IOException e)
  {
   throw new RuntimeException("文件切割失败");
  }
  finally
  {
   try
   {
    if(fis!=null)
     fis.close();
   }
   catch (IOException e)
   {
    System.out.println("关闭流资源失败");
   }
  }
 
  
 }
}

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

百鑫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_java_io(中)

------- android培训、java培训、期待与您交流！ ---------- java_io(中)File: File类是io包中唯一代表磁盘文件本身的对象,File类定义了一些与平台无关的方法来操作文件, 可以通过调用File类中的方法,实现创建.删除.重命名文件等,File类是对象主要用来获取
复制链接

扫一扫