Java上路18-I/O-File

最新推荐文章于 2022-05-09 14:36:17 发布
最新推荐文章于 2022-05-09 14:36:17 发布
阅读量637 收藏
点赞数
分类专栏： Java上路 文章标签： file PrintWriter SequenceInputStream 合并流 打印流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Vigiles/article/details/8250754
版权


一. File：

File对象可以表示文件或者目录，利用它可对文件或目录的属性进行基本操作。也可以查询文件的基本信息，并进行修改。

  构造函数  

  File file = new File (“ Demo.txt ”) ; 

  在默认目录创建文件 

  File file = new File (“ C : \\”，“ Demo.txt ”) ;  

  以字符串形式，在指定目录创建文件   

  File file = new File (  File，“ Demo.txt ”) ;

  以文件形式，在指定目录创建文件 

 

 常用方法

 描述

       增

  file. createNewFile() ;

  创建声明的文件 

  file.mkdir() ;

  创建声明的目录 

       删

  file.delete() ;

  删除文件或目录

  file.deleteOnExit() ;

  程序结束后删除

       改

  renameTo() ;

  重命名

  setReadOnly() ;

  设置只读

       查

  file.exists ( ) ; 

  判断文件或目录是否存在 

  file.isFile ( ) ; 

  判断是否是文件 

  file.isDirectory ( ) ; 

  判断是否是目录 

  file.getName ( ) ;  

  获取文件或目录的名称 

  file.getPath ( ) ; 

  获取文件或目录的路径 

  file.getAbsolutePath ( ) ; 

  获取文件或目录的绝对路径 

  file.lastModified ( ) ; 

  获取文件或目录的最后修改日期 

  file.length ( ) ; 

  获取文件或目录的大小（字节） 

 

1. 例子：

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Date;
 
class FileDemo
{
       public static void main(String[] args) throws IOException
       {
              File file1=new File("Demo.txt"); //创建文件操作器
              file1.createNewFile();
              test("file1is a file : "+file1.isFile());   //判断是否为文件
              test("thename of file1 is : "+file1.getName());      //查询文件名
              file1.renameTo(new File("MyDemo.txt"));       //重命名
              test("thenew name of file1 is : "+file1.getName()+
                     ". File 类的实例是不可变的；一旦创建，File对象表示的抽象路径名将永不改变");
             
              File file2=new File("Demo.java");
              file2.createNewFile();
              test("\nfile2is a directory  :"+file2.isDirectory ());      //判断是否为文件夹
             
              File file3=new File("Demo");      //创建目录
              file3.mkdir();
              test("\nfile3is a exist : "+file3.exists());   //判断是否存在
              test("file3is a directory  :"+file3.isDirectory());
 
              File file4=new File("file.txt");
              FileWriter fw=new FileWriter("file.txt");
              BufferedWriter bw=new BufferedWriter(fw);
              bw.write("thisis a file.");
              bw.flush();
              fw.close();
              test("\nthelength of file4 is : "+file4.length()+" byte");       //判断大小
              test("thepath of file4 is : "+file4.getPath());   //获取路径
              test("theabsolute path of file4 is : "+file4.getAbsolutePath());   //获取绝对路径
              Date date=new Date(file4.lastModified());
              test("thelast modified of file4 is : "+date);     //获取最后编辑时间
             
              String txtfile="new file.txt";
              File file5=new File("c:\\", txtfile);
              file5.createNewFile();
              test("\nfile5is a exist : "+file5.exists());   //判断是否为文件夹
              file5.delete(); //删除文件
 
              File file6=new File(file3, "new demo.java");
              file6.createNewFile();
              test("\nfile6is a exist : "+file6.exists());   //判断是否为文件夹
              file6.deleteOnExit();
       }
 
       publicstatic void test(Object obj)
       {
              System.out.println(obj);
       }
}

 

2. 层级列表：

                          方法

                                          说明

  list ( ) ;

  返回全部的文件夹和文件（不包括子目录）的名称数组  

  list (FilenameFilter filter ) ;

  返回指定类型的文件

  listFiles ( ) ;

  返回全部的文件夹和文件（不包括子目录）的对象数组  

  listFiles ( FilenameFilter filter ) ;  

  返回指定类型的对象

import java.io.File;
import java.io.FilenameFilter;
 
class FileDemo
{
       public static void main(String[] args)
       {
/*
              File[] files=File.listRoots();  //获取所有盘符-驱动器
              for(File f:files)
              {
                     test(f);
              }
 
              File file=new File("e:/javatest");
              String[] names=file.list();    //获取所有文件及目录的名称
              for(String s:names)
              {
                     test(s);
              }
*/
              //filter();
 
              File dir=new File("e:/javatest");
              dir(dir);
       }
 
       publicstatic void dir(File dir)
       {
              test("\n目录："+dir);
              File[] files=dir.listFiles();
              for(int x=0; x<files.length; x++)
              {
                     if(files[x].isDirectory())
                     {
                            dir(files[x]);   //递归，查询子目录
                     }
                     else
                     {
                            test(files[x]);
                     }
              }
       }
 
/*
递归：
       务必有终止条件
       合理设置执行次数
*/
 
       public static void filter()
       {
              File file=new File("e:/javatest");
              String[] names=file.list(
              //匿名内部类
              new FilenameFilter()
              {
                     //此时两个参数是自动装入的
                     public boolean accept(File dir, String name)
                     {
                            return name.endsWith(".txt");   //只返回封装目录下的txt文件
                     }
              }
              );     //获取指定文件对象
              for(String s:names)
              {
                     test(s);
              }
       }
 
       public static void test(Object obj)
       {
              System.out.println(obj);
       }
}


3. 删除文件及文件夹：

import java.io.File;
 
class FileDemo
{
       public static void main(String[] args)
       {
              File dir=newFile("e:/javatest/demo");
              removeDir(dir);
       }
 
       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
                     {
                            System.out.println(files[x].toString()+"--file--"+files[x].delete());
                     }
              }
              System.out.println(dir+"--dir--"+dir.delete()+"\n");
       }
 
       public static void test(Object obj)
       {
              System.out.println(obj);
       }
}

从执行的结果来看，Demo或demo都可以被删除。

 

4. 提取所有的java文件名单到txt文件：

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
 
class FileDemo
{
       public static void main(String[] args) throws IOException
       {
              File dir=new File("e:/javatest");
              List<File> list=new ArrayList<File>();
              fileToList(dir,list);  //提取java文件到集合
 
              File file=new File(dir, "javatest.txt");
              writeToFile(list,file.toString());   //将集合内容保存到文本文件
       }
 
       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)
              {
                     throwe;
              }
              finally
              {
                     try
                     {
                            if(bufw!=null)
                            {
                                   bufw.close();
                            }
                     }
                     catch(IOException e)
                     {
                            throwe;
                     }
              }
       }
 
       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);
                            }
                     }
              }
       }
}


二. Properties：

       java.util.Properties，可将数据保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。可与IO结合的集合容器。

 

方法

说明

  查   

  getProperty(String key)

    用指定的键在此属性列表中搜索属性

  load(InputStream inStream)

    从输入流中读取键和元素对

   list(PrintStream out)

    将属性列表输出到指定的输出流

  stringPropertyNames()

    返回此属性列表中的键集

改

  setProperty(String key, String value)

    调用 Hashtable 的put方法

  store(OutputStream out, String comments)

    将此 Properties 表中的属性列表（键和元素对）写入输出流   

import java.io.*;
import java.util.*;
 
class FileDemo
{
       public static void main(String[] args) throws IOException
       {
              //File file=new File("info.txt");
              //file.createNewFile();
 
              //creat();       //创建集合对象，写入文本文件
              //gets(); //查询（文本文件内容全部是有效的）
              load();    //使用Properties的已有方法查询
       }
 
       public static void load() throws IOException
       {
              Properties prop=new Properties();
              FileInputStream fis=new FileInputStream("info.txt");
              prop.load(fis);      //加载字符流
              prop.list(System.out);
       }
 
       public static void gets() 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 creat() throws IOException
       {
              Properties prop=new Properties();
              prop.setProperty("wangwu","39");  //插入键值对
              prop.setProperty("wangliu","35");
              prop.setProperty("wangqi","49");
              //prop.setProperty("wangwu","50");      //覆盖已有的键
              FileOutputStream fos=new FileOutputStream("info.txt");
              prop.store(fos,"this is a tab");  //将此 Properties 表中的属性列表（键和元素对）写入输出字符
              //prop.list(System.out);      //在控制台打印
              fos.close();    //     关闭前自动flush
       }
}


 例子：

       限制使用次数:

import java.io.*;
import java.util.*;
 
class FileDemo
{
       public static void main(String[] args) throws IOException
       {
              Properties prop=new Properties();
              File file=new File("count.ini");
              if(!file.exists())
              {
                     file.createNewFile();
              }
              FileInputStream fis=new FileInputStream(file);      //读
              prop.load(fis);
              intcount=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+"");
              FileOutputStreamfos=new FileOutputStream(file);
              prop.store(fos,"");
              fos.close();
              fis.close();
       }
}


三. 其它常用IO类：

SequenceInputStream：合并流

PrintWriter：打印流

import java.io.*;
import java.util.*;
 
class FileDemo
{
       public static void main(String[] args) throws IOException
       {
              //cut();   //拆分mp3文件
              //merge();     //合并mp3
              //sequenceInputStreamDemo();      //合并流（文本文件）
              printWriterDemo();     //打印流
       }
 
       public static void cut() throws IOException
       {
              FileInputStream fis=new FileInputStream("demo.mp3");     //字节读取流，封装图片文件
              FileOutputStream fos=null;       //字节写入流
              byte[] buf=new byte[1024*1024];   //1M大的字节数组
              int len=0;
              int count=1;
              //读取1m大的量的字节存入buf，同时存入len
              while ((len=fis.read(buf))!=-1)
              {
                     fos=new FileOutputStream((count++)+".tmp");   //字节写入流封装一个新的tmp文件
                     fos.write(buf, 0, len);   //写入刚才的数据（数据，位置，长度）
                     fos.close();    //刷新缓冲区写入文件，然后关闭
              }
              fis.close();
       }
 
       public static void merge() throws IOException
       {
              ArrayList<FileInputStream> al=new ArrayList<FileInputStream> ();
              for (int x=1; x<=3; x++)
              {
                     al.add(new FileInputStream(x+".tmp")); //将3个tmp文件存入集合
              }
              finalIterator<FileInputStream> it=al.iterator();     //迭代
              Enumeration<FileInputStream> en=new Enumeration<FileInputStream> ()   //枚举
              {
                     public booleanhasMoreElements()
                     {
                            return it.hasNext();
                     }
                     public FileInputStreamnextElement()
                     {
                            return it.next();
                     }
              };
              SequenceInputStream sis=new SequenceInputStream(en); //合并流
              FileOutputStream fos=new FileOutputStream("new demo.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 sequenceInputStreamDemo() throws IOException
       {
              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 printWriterDemo ()throws IOException
       {
              BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
              PrintWriter out=new PrintWriter(System.out, true);     //打印流，自动刷新
              String line=null;
              while((line=bufr.readLine())!=null)
              {
                     if("over".equals(line))
                     {
                            break;
                     }
                     out.println(line.toUpperCase());
                     //out.flush(); //已经启动自动刷新缓冲区
              }
              out.close();
              bufr.close();
       }
}



vigiles
关注
专栏目录
阿里巴巴Java开发手册（华山版）
╱/.独﹄無㈡oоΟ的博客
07-05 7688
这是第二次研读阿里规约，这本书对我们的编码规范影响非常深远，希望大家可以参考哦。 前 言 《Java 开发手册》是阿里巴巴集团技术团队的集体智慧结晶和经验总结， 经历了多次大规模一线实战的检验及不断完善， 公开到业界后，众多社区开发者踊跃参与，共同打磨完善， 系统化地整理成册。现代软件行业的高速发展对开发者的综合素质要求越来越高， 因为不仅是编程知识点，其它维度的知识点也会影响到软件的最终交付质量。比如： 数据库的表结构和索引设计缺陷可能带来软件上的架构缺陷或性能风险； 工程结构混乱导致后续维护艰难；没.
Java学习（下）
Lzdnydppx的博客
08-16 483
web开发、spring开发、spring boot开发、spring cloud开发
JAVA File的创建及相对路径绝对路径
zhouyong0的专栏
11-13 5354
File f = new File("D:/test/mytest.txt");//当执行这句话后在内存的栈空间存在一个f的应用，在堆空间里存在一个mytest.txt对象。注意 这个对象只含有文件的属性(如大小，是否可读，修改时间等)，不包含文件的内容，所以length=0。当我们想执行对文件的操作的时候，这个时 候抽象路径起作用了，比如我们想执行f.createNewFile()命
java file 默认路径_java file的路径?
weixin_29051193的博客
02-16 845
这是File(String parent, String child)的文档，当parent为null时，这个方法才和File(String path)一样; 当parent为空串时，会根据系统的默认目录来和转化后的child组合生成路径。我看着很费劲，你看看吧。你看到的并不是这个方法内部真是的东西，所以以文档为准。Creates a new File instance from a parent...
关于idea中File file = new File(path)；这里的路径问题
Java学习之旅
08-06 4749
再idea中默认的路径是工程的根路径即：E:\IDEA_worksplace=project\ （工程名/） 所以创建文件时这里的路径要写项目名： 例如：这里的students.xml文件是放在项目下的src目录下的 这里的path为图中所示： String path = "09-java_XML-07/src/students.xml"; ...
有关new File中的路径问题
bingwangzi_java的专栏
01-02 1788
<br />默认路径是工程的根目录
new file(file)文件路径设置方法
热门推荐
Perserve In Learning
05-28 2万+
[java] view plaincopyprint? 发现这样一行代码：    File file = new File(".");      起初十分纳闷，不懂这个“.”代表什么意思。    后来经过一番实验返现：    “.”知识代表当前工作目录的意思，它是一个相对路径的写法，一般也就是jvm调用路径，可以通过   System.getPropert
Java上路16-I/O
Vigiles的编程基础
11-28 661
IO流用来处理设备之间的数据传输，Java对数据的操作是通过流的方式，Java用于操作的流的对象都在IO包中。流按操作数据分为字节流和字符流，流按流向分为输入流和输出流。         字符流：FileReader、FileWriter，BufferedReader、BufferedWriter          字节流：InputStream、OutputStream，FileInputS
JAVA I/O流（10）
王小六4ever’s poke
03-07 254
这一讲就是JAVA中的I/O流的一部分内容，当然，跟前面一样，咱们浅尝辄止，需要深入了解的推荐大家看一本JAVA 核心技术 这本书讲的比较深入也很全面。 第一节  I/O流简介 流的本质是数据传输。 流分为两类主要：字符流和字节流 第二节 文件操作File类 先讲两个比较经典的用法就是创建文件和监测文件是否创建成功： public class
新增11条新规约，阿里Java开发手册|黄山版，拥抱规范，远离伤害
QLCZ0809的博客
05-09 388
前言 阿里开发手册是阿里近万名开发同学集体智慧的结晶，以开发视角为中心，详细列举如何开发更加高效、更加容错、更加有协作性，力求知其然，更知其不然，结合正反例，让Java开发者能够提升协作效率、提高代码质量。 全部笔记内容和答案解析都整理成文档了(在文末) 码出高效，码出质量！ 你是否曾因Java代码规范版本纷杂而无所适从？ 你是否想过代码规范能将系统故障率降低20%？ 你是否曾因团队代码风格迥异而协同困难？ 你是否正在review一些原本可以避免的故障？ 你是否无法确定自己的代码足够健壮？ 一、编程
13.深度学习(词嵌入)与自然语言处理--HanLP实现
mantch
02-19 3057
**深度学习**(Deep Leaming, DL )属于表示学习( Representation Learning )的范畴，指的是利用具有一定“深度”的模型来自动学习事物的向量表示(vectorial rpresenation)的一种学习范式。目前，深度学习所采用的模型主要是层数在一层以上的神经网络。
HanLP《自然语言处理入门》笔记--2.词典分词
mantch
02-05 1666
文章目录2. 词典分词2.1 什么是词2.2 词典2.3 切分算法2.4 字典树2.5 基于字典树的其它算法2.6 HanLP的词典分词实现2.7 GitHub项目 2. 词典分词 中文分词：指的是将一段文本拆分为一系列单词的过程，这些单词顺序拼接后等于原文本。 中文分词算法大致分为基于词典规则与基于机器学习这两大派。 2.1 什么是词 在基于词典的中文分词中，词的定义要现实得多：词典中的...
IO-File 文件 目录 基本操作 递归 遍历
weixin_34348174的博客
06-15 131
创建和删除//创建文件File file1 = new File("不存在的文件.txt");//注意，这一步并没有创建文件，只是把磁盘中的文件封装成了一个对象System.out.println(file1.exists() + "--" + file1.createNewFile());//false--true。这一步是将File对象写入到磁盘中的文件中。如果文件不存在，则创建System....
java删除Linux服务器上的文件以及new File(url)路径详解
Qyq0498的博客
08-03 5581
话不多说，先上代码~~ /** * 删除服务上的文件 * @param filePath 路径 * @param fileName 文件名 * @return */ @PostMapping("/deleteServerFile") @ResponseBody public static boolean deleteServerFile(String filePath){ boolean delete_flag = false
Java上路04-流程控制语句
Vigiles的编程基础
11-14 1533
一．条件判断语句： 1. if-else，如果，否则。当if的条件成立时，执行if语句块，忽略else语句块， if (条件) {       执行语句1; } else {       执行语句2; } 例子：   2. if-elseif-else，如果，或者如果，否则当第一个if不成立时，会判断紧跟着的else if语句，如果还不成立，执行else if(
Java上路09-多线程
Vigiles的编程基础
11-19 1350
记得九几年小学课本里有一篇华罗庚的文章写的是统筹学，里面的例子大概是这么说的：我们想喝茶，第一种办法，洗刷茶壶，放上茶叶，烧水，等水开了泡茶；第二种办法，烧水，等待水开的时间里洗刷茶壶，放上茶叶，然后水开了泡茶。        生活中的统筹学也就是编程思想中的算法。在此之前我们写的所有程序都可以说是单线程的。因为都是按部就班的干了一样再干另一样。而多线程达到了事半功倍的效果，一个时刻可以进行多个
Java上路06-面向对象
Vigiles的编程基础
11-15 1152
面向对象（Object Oriented Programming，OOP）是一种思想，Java可以通过这种思想设计程序。最笨的理解就是让别人去干活，自己做管理。 一. 类： class Human { public static void main(String[] args) { System.out.println("HelloWorld!我是
train_pointlk.py: error: the following arguments are required: -o/--outfile, -i/--dataset-path, -c/--categoryfile什么意思
最新发布
04-02
train_pointlk.py是一个Python脚本文件，用于训练PointLK模型。该错误提示说明在运行该脚本时，需要提供三个必填参数，分别是：-o/--outfile，-i/--dataset-path，-c/--categoryfile。 - -o/--outfile：指定输出文件的路径和名称。 - -i/--dataset-path：指定训练数据集的路径。 - -c/--categoryfile：指定标签文件的路径和名称。 因此，需要在运行该脚本时，正确提供以上三个参数的值，方能正常执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值