JAVASE学习笔记第20天

IO流（File概述）

1、File 类

l  用来将文件或者文件夹封装成对象

l  方便对文件与文件夹的属性进行操作

l  File对象可以作为参数传递给流的构造函数

 

2、常用的构造方法和separator

/**

File类中

1，File类的构造方法：

       1， File(Fileparent,String child)

       2， File(Stringparent,String child)

       3， File(Stringpathname)

注意：打印对象的时候，打印的是路径

 

2,字段：public static final String seprator

       实现跨平台的分隔符。

*/

import java.io.*;

 

class Demo1

{

       public static voidmain(String[] args)

       {

              //将指定的文件或者文件夹封装为对象，可以本身没有

              File f1 = newFile("a.txt");

 

              //第二种

              File f2 = newFile("C:\\abc","c.txt");

 

              //第三种

              File d= newFile("C:\\cc");

              File f3 =newFile(d,"a.txt");

 

              System.out.println(f1);

 

              //夸平台的分隔符

              File f4 = newFile("C:"+File.separator+"a.txt");

              System.out.println(f4);

       }

}

 

IO流（File的常见方法）

/**

File类的常见的方法：

crud

1,创建

       booleancreateNewFile()  :

              在指定的位置创建一个文件，如果该文件已经存在，

              则不会被创建

      

       booleanmkdir() :创建一个一级文件

       booleanmkdirs():创建多级文件

 

2，删除

              booleandelete(): 删除文件

 

              voiddeleteOnExit():

              在程序退出时，删除文件，这样的好处是防止文件正在被操作，而不能被删除

                                                                                      

3，判断

              booleanexists(): 判断文件是否存在

              isFile():判断是否为文件

              isDirectory():判断是否是文件夹（目录）

              isHidden():判断是否为隐藏文件

              isAbsolute():判断路径是否为绝对路径名

              canExecute():判断文件是否可以执行

 

              注意：

              在用isFile和isDirectory的时候，首先要判断是否存在

              即使用exists()

 

4，获取

             

              getName():获取文件名

              getPath():获取文件路径

              getParent():获取父目录名（这个是创建File对象的时候，

                                                               我们写在里面那个）

 

              getAbsolutePath():获取相对路径

              lastModified()：获取最后一次修改的时间

              length()：获取文件的大小

*/

 

import java.io.*;

      

class Demo2

{

       //调用者

       publicstatic void main(String[] args)throws IOException

       {

              //creat();

              //delete();

              //panDuan();

              get();

       }

 

       //创建

       publicstatic void creat()throws IOException

       {

              //创建一个文件

              Filef =new File("a.txt");

              sop("create:"+f.createNewFile());

 

              //创建一个目录

              Filef1= new File("F:"+File.separator+"abc");

              sop("mkdir:"+f1.mkdir());

       }

 

       //删除

       publicstatic void delete()

       {

              Filef =new File("a.txt");

              sop("delete:"+f.delete());

       }

      

       //判断：

       publicstatic void panDuan()throws IOException

       {

              Filef = new File("a.txt");

              f.createNewFile();

              //判断文件是否存在

              sop("exists:"+f.exists());

              //判断是否为文件

              sop("isFiel:"+f.isFile());     

              //判断是否为文件夹

              sop("isDirectory："+f.isDirectory());    

              //判断是否为隐藏文件

              sop("isHidden:"+f.isHidden());

              //判断是否为绝对路径名

              sop("isAbsolute:"+f.isAbsolute());

              //判断是否为可执行文件

              sop("canExecute:"+f.canExecute());

       }

 

       //获取

       publicstatic void get()throws IOException

       {

              Filef = new File("F:"+File.separator+"b.txt");

              sop("create:"+f.createNewFile());

              //获取文件名称

              sop("name:"+f.getName());

              //获取父目录名

              sop("parent:"+f.getParent());

              //获取文件路径

              sop("path:"+f.getPath());

              //获取文件的绝对路径

              sop("absolutePath:"+f.getAbsolutePath());

              //获取最后一次修改的时间

              sop("lastModify:"+f.lastModified());

              //获取文件大小

              sop("length:"+f.length());

       }

      

       publicstatic void sop(Object obj)

       {

              System.out.println(obj);

       }

}

IO流（文件列表）

/**

文件列表：

1，列出可用的文件系统根

       publicstatic File[] listRoots()

 

2, 列出指定目录中的文件和目录

       publicString[] list();

       注意：这个方法在实际的开发中一般使用的是ListFiles()

                 因为它返回的是对象，可以进行操作

 

3，列出指定路径的文件

       publicFile[] listFiles();

       注意：列出的是文件，不包含目录

 

4，文件或者目录过滤器，返回的是指定路径下满足条件的

       文件或者目录

       publicString[] list(FilenameFilter filter)

 

关于FilenameFilter的介绍：

       FilenameFilter是一个接口

       就有一个抽象的方法;

       publicabstract boolean accept(File dir,String name)

       其中：dir 是指定目录， name：是对文件的要求

*/

import java .io.*;

 

class Demo3

{

       publicstatic void main(String[] args)

       {

              //listRootMethod();

              //listMethod();

              //listFilesMethod();

              fileFilterMethod();

       }

 

       publicstatic void listRootMethod()

       {

              File[]files = File.listRoots();

             

              //高级for循环

              for(File file :files )

              {

                     System.out.println(file);

              }

       }

 

       publicstatic void listMethod()

       {

              //将指定的目录封装成对象

              Filedir = new File("C:"+File.separator);

              //sop(dir);

 

              String[]str = dir.list();

 

              for(Strings : str)

              {

                     sop(s);

              }

       }

 

       publicstatic void listFilesMethod()

       {

              Filedir = new File("F:\\")  ;

              //返回的是对象

              File[]files = dir.listFiles();

 

              for(Filefile : files)

              {

                     sop(file);

              }

       }

 

       //使用文件过滤器，打印F:\盘下以.jpg结尾的文件

       publicstatic void fileFilterMethod()

       {

              //将指定的目录封装成对象

              Filedir = new File("F:\\");

             

              //sop(dir);

 

              //使用匿名内部类创建FilenameFileter对象

              String[]names = dir.list(new FilenameFilter()

              {

                     publicboolean accept(File dir,String name)

                     {

                     //    sop(dir);

                     //    sop(name.endsWith(".jpg")     );

                            returnname.endsWith(".jpg") ;

                     }     

              });

 

              for(String name : names)

              {

                     sop(name);

              }

       }

 

       publicstatic void sop(Object obj)

       {

              System.out.println(obj);

       }

}

 

IO流（列出目录下的所有的内容—递归）（很重要的思想）

1、思想：

递归：就是自己调用自己

使用递归的时候注意的事情：

1，限定条件

2，注意递归次数，防止内存溢出

 

2、例子：

使用递归方法，求和。

/**

使用递归求和：

*/

 

class Demo4

{

      public static voidmain(String[] args)

      {

            

      }

 

      //定义一个求和的方法

      public static intgetSum(int num)

      {

             if (num==1)

             {

                    return 1;

             }

             returnnum+getSum(num-1);

      }

}

 

 

/**

使用递归列出指定目录下的所有的内容

思路：

1，将指定的目录封装成File对象

2，遍历指定目录下的文件

3，在遍历的过程中，如果文件是文件夹，那么调用这个方法

*/

import java.io.*;

 

class Demo5

{

       public static voidmain(String[] args)

       {

              File dir = newFile("F:"+File.separator+"2014java");

              showDir(dir);

       }

 

       //定义列出目录的方法

       public static voidshowDir(File dir)

       {

              System.out.println(dir);

              File[]files=dir.listFiles();

              for(File file :files)

              {

                     if(file.isDirectory())

                            showDir(file);

                     else

                            System.out.println(file);

              }

       }

}

 

IO流（删除带内容的目录）

1、在windows中，删除目录从里面向外删除

2、在java中delete删的是里面没有内容的文件，

3、在java中一般都不用这种方法

4、在做这个删除操作的时候，为了验证自己是否出错，那么可以再删除的时候打印一下。

 

5、例子：

 

/**

需求：删除带内容的目录

思路：用到了遍历

*/

import java.io.*;

 

class Demo6

{

       public static voidmain(String[] args)

       {

              File dir = newFile("F:\\ab");

              deleteDir(dir);

       }

 

       //删除目录

       public static voiddeleteDir(File dir)

       {

              File[]files=dir.listFiles();

              for(File file :files)

              {

                     if(file.isDirectory())

                            deleteDir(file);

                     else

                            System.out.println(file.getName()+"jjjjjj"+file.delete());  //删除文件

              }

              //删除目录

              System.out.println("dd"+dir.delete());

       }

}

 

IO流（创建java文件列表）

/**

练习：

将一个指定目录下的java文件的绝对路径，存储到一个文本文件中

建立一个java文件的列表文件。

 

思路：

1，将指定的目录封装为File对象

11，创建一个集合，用来存储路径

2，遍历该目录，找到绝对路径

3，在遍历的过程中加上判断条件，如果是java文件，存在集合中

4，将集合中的路径，存在一个文件中

*/

import java.io.*;

import java.util.*;

 

class Demo7

{

       publicstatic void main(String[] args)

       {

              Filedir =new File("F:"+File.separator+"2014java\\day05");

              List<File>list = new ArrayList<File>();

              FilejavaListFile = new File("f:\\javalist.txt");

 

              FileToList(dir,list);

       //    System.out.println(list.size());

              ListToFile(list,javaListFile);          

       }

 

       //将指定目录中java文件存到一个集合中

       publicstatic void FileToList(File dir,List<File> list)  //void??? //有集合就别忘了加泛型

       {

              //列出路径下的文件

              File[]files=dir.listFiles();

              //遍历

              for(Filefile :files )

              {

                     //判断是否为目录

                     if(file.isDirectory())

                            //递归

                            FileToList(file,list);

                     else

                     {

                            //判断是否为.java文件

                            if(file.getName().endsWith(".java"))

                                   list.add(file);

                     }

              }

       }

 

       //将集合中的内容存到一个文件中

       publicstatic void ListToFile(List<File> list,File javaListFile)

       {

              BufferedWriterbufw = null;

              //1,确定操作的是目的，是文本的，设备是硬盘，提高效率

              try

              {

                      bufw =

                            newBufferedWriter(new FileWriter (javaListFile));

 

                     //遍历集合

                     for(Filef : list)

                     {

                            Stringname = f.getAbsolutePath();

                            bufw.write(name);

                            bufw.newLine();

                            bufw.flush();

                     }                          

              }

              catch(IOException e)

              {

                     thrownew RuntimeException("存储到文件中失败");

              }

              finally

              {

                     try

                     {

                            if(bufw!=null)

                                   bufw.close();

                     }

                     catch(IOException e)

                     {

                            thrownew RuntimeException();

                     }

              }

       }

}

                               IO流（Properties简述）

1，Properties是hashtable的子类，也就是说它具备了map集合的特点，

而且在它里面存放的键值对都是字符串。

2，特点：是集合和io技术相结合的集合容器

3，该对象的特点：可以用于键值对形式的配置文件

 

                             IO流（Properties存取）

1、Properties在util包中

2、示例：

import java.util.*;

 

class Demo8

{

       public static voidmain(String[] args)

       {

              //创建对象

              Properties pro =new Properties();

 

              //set方法存入数据

              pro.setProperty("李华","23");

              pro.setProperty("王芳","34");

             

              //使用set方法改变数据

              pro.setProperty("李华","09");

 

              //使用getProperty方法获得单个的属性的值

              String value =pro.getProperty("李华");

              System.out.println(value);

 

              //使用publicSet<String> stringPropertyNames() 方法获得键值

              Set<String>set = pro.stringPropertyNames();

              for (String str :set )

              {

                     System.out.println(str+",,,"+pro.getProperty(str));

              }

       }

}

IO流（Properties练习）（挺好的）

/**

需求：做一个注册提示：

         用于记录应用程序运行次数，如果次数已经到了，那么给出注册提示。

分析：

       1，想到了计数器，用来记录次数

       2，这个记录以键值对的形式保存起来，而键值对是map集合，

            数据是以文件的形式保存起来的，使用到了io技术，

               map+io=====properties

 

总结：配置文件可以实现程序数据的共享。

*/

import java.util.*;

import java.io.*;

 

class Test

{

       publicstatic void main(String[] args)throws IOException

       {     

              demo();

       }

 

       //

       publicstatic void demo()throws IOException

       {

              //有一个properties对象

              Propertiespro = new Properties();

 

              //一般操作文件，先把文件封装

              Filefile = new File("conf.ini");

 

              //判断文件是否存在

              if(!file.exists())

                     file.createNewFile();

      

              //加载，注意是流

              FileReaderfr = new FileReader(file);

              pro.load(fr);

             

              intcount =0;

              Stringvalue=pro.getProperty("time");

 

              if(value!=null)

              {

                     count=Integer.parseInt(value);

                     if(count>=5)

                     {

                            System.out.println("您的使用期限已到，请交钱");

                            return;

                     }

              }                   

              count++;             

              //修改

              pro.setProperty("time",count+"");

 

              //保存

              FileWriterfw = new FileWriter(file);

              pro.store(fw,"");

 

              //关流

              fr.close();

              fw.close();

       }

}

IO流（PrintWriter）(记住)

 

/**

打印流：

PrintWriter 和 PrintStream 可以直接操作输入流和文件

 

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

            数据原样打印。

 

字节打印流：

PrintStream

构造函数可以接收的参数类型：

1，file对象

2，字符串路径

3，字节输出流。 OutputStream

 

字符打印流：

PrintWriter

构造函数可以接收的参数类型：

1，file对象

2，字符串路径

3，字节输出流

4，字符输出流。

 

以上的要记住了，还有在流中和文件有关的都很重要。

记住：

PrintWriter(OutputStream out, booleanautoFlush)

中autoFlus 为true的时候，会对println自动刷新。

                 

*/

 

import java.io.*;

 

class Test2

{

       publicstatic void main(String[] args)throws IOException

       {

              //键盘录入

              BufferedReaderbufr =

                     newBufferedReader(new InputStreamReader(System.in));

 

              //创建打印流对象

              PrintWriterout  = new PrintWriter(System.out,true);//自动刷新

 

              Stringline =null;

 

              while((line=bufr.readLine())!=null)

              {

                     if("over".equals(line))

                            break;

                     out.println(line);  //可以换行了

              }

             

              bufr.close();

       }

}

 

 

IO流（序列流（合并流））

/**

序列流：

SequenceInputStream:将多个读取流合并为一个读取流

构造函数：

public SequenceInputStream(Enumeration<?extends InputStream> e)

 

public SequenceInputStream(InputStream s1,InputStream s2)                         

*/

import java.io.*;

import java.util.*;

 

class Test3

{

       publicstatic void main(String[] args)throws IOException

       {

              //创建一个Vector集合

              Vector<FileInputStream>v = new Vector<FileInputStream>();

             

              //添加数据

              v.add(newFileInputStream("1.txt"));

              v.add(newFileInputStream("2.txt"));

              v.add(newFileInputStream("3.txt"));

 

              //创建Enumeration对象

              Enumeration<FileInputStream>en = v.elements();

 

              //创建一个序列流对象

              SequenceInputStreamsis = new SequenceInputStream(en);

 

              //创建一个输出流对象

              FileOutputStreamfos = new FileOutputStream("4.txt");

 

              //读取字节流

              byte[]buf = new byte[1024];

             

              intlen=0;

              while((len=sis.read(buf))!=-1)

              {

                     fos.write(buf,0,len);                 

              }

             

              fos.close();

              sis.close();

       }

}

IO流（切割文件）

 

import java.io.*;

 

class Test4

{

       publicstatic void main(String[] args)throws IOException

       {

              splitFile();

       }

 

       publicstatic void splitFile()throws IOException

       {

              //将指定的文件相关联

              FileInputStreamfis = new FileInputStream("F:\\1.mp3");

             

              //存储

              FileOutputStreamfos = null;

 

              byte[]buf =  new byte[1024*1024]; //创建一个要切割大小的数组

              intlen=0;

              intcount=1;

              while((len=fis.read())!=-1)

              {

                     fos=newFileOutputStream("F:\\split\\"+(count++)+".part");

                     fos.write(buf,0,len);

                     fos.close();

              }

             

              fis.close();

       }

 

       //合并

       publicstatic void merge()

       {

              //因为Vector创建的集合低效，所以采用ArrayList

              ArrayList<FileInputStream>al = new ArrayList<FileInputStream>();

 

              for(intx=1;x<3;x++)

              {

                     al.add(newFileInputStream("F:\\"+x+".part"))

              }

 

              finalIterator<FileInputStream> it = al.iterato();

 

              Enumeration<FileInputStream>en =new Enumeration<FileInputStream>()

              {

                     publicboolean hasMoreElements()

                     {

                            returnit.hasNext();

                     }

 

                     publicFileInputStream nextElement()

                     {

                            returnit.next();

                     }                   

              };

 

              SequenceInputStreamsis = new SequenceInputStream(en);

             

              FileOutputStreamfos = new FileOutputStream("F:\\split\\0.mp3");

 

              byte[]buf =new byte[1024];

              intlen =0;

 

              while((len=sis.read())!=-1)

              {

                     fos.write(buf,0,len);

              }

 

              sis.close();

       }

}