【20】IO流3_File类，递归，Properties，合并流，切割文件

2024-05-30 14:58
文章标签 递归 file 合并 io 20 properties 切割

本文主要是介绍【20】IO流3_File类，递归，Properties，合并流，切割文件，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！


7.11  File类常见方法：

1，创建。

         booleancreateNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

                                                        和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，

会覆盖。

 

         boolean   mkdir():创建文件夹。

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

2，删除。

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

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

 

 

3，判断。

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

         isFile():判断是否是一个标准文件

         isDirectory();判断是否是一个目录（文件夹）

         isHidden();判断是否是一个隐藏文件

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

 

4，获取信息。

         getName():获取文件名

         getPath():获取文件的相对路径

         getParent():获取文件所在绝对路径的父目录，如果获取的是相对路径，返回null

 

         getAbsolutePath()获取文件的绝对路径

         longlastModified() 返回此抽象路径名表示的文件最后一次修改的时间

         longlength() 返回由此抽象路径名表示的文件长度

 

练习一：File类中方法的应用

import java.io.*;
class FileDemo
{public static void main(String[] args) throws IOException{method_5();}public static void method_5(){File f1 = new File("c:\\Test.java");File f2 = new File("d:\\hahah.java");sop("rename:"+f2.renameTo(f1));//重命名此抽象路径的文件名}public static void method_4(){File f = new File("file.txt");sop("path:"+f.getPath());//返回指定文件的相对路径sop("abspath:"+f.getAbsolutePath());//返回指定文件的绝对路径sop("parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。//如果相对路径中有上一层目录那么该目录就是返回结果。}public static void method_3()throws IOException{File f = new File("d:\\java1223\\day20\\file2.txt");//f.createNewFile();//创建指定路径文件//f.mkdir();//创建指定路径文件夹//记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。//通过exists判断。sop("dir:"+f.isDirectory());sop("file:"+f.isFile());sop(f.isAbsolute());}public static void method_2(){File f = new File("file.txt");//sop("exists:"+f.exists());//sop("execute:"+f.canExecute());//创建文件夹File dir = new File("abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");sop("mkdir:"+dir.mkdirs());}public static void method_1()throws IOException{File f = new File("file.txt");//sop("create:"+f.createNewFile());//sop("delete:"+f.delete());//删除指定文件，如果该文件正在使用，则删除失败}//创建File对象public static void consMethod(){//将a.txt封装成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");sop("f1:"+f1);sop("f2:"+f2);sop("f3:"+f3);File f4 = newFile("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");//separator为跨平台符号\}public static void sop(Object obj){System.out.println(obj);}
}


 

练习二：File类中方法应用二

/*
需求：判断默认路径下是否有重名文件，没有重名文件，则创建A.txt文件如果有count++，直到没有重名文件时，创建A+count.txt文件，并退出运行效果:运行第一次，创建A.txt运行第二次，创建A1.txt运行第三次，创建A2.txt。。。。。
*/
import java.io.*;class FileTest3{public static void main(String[] args) throws IOException{File f = newFile("d:\\A.txt");         int count = 0;while(true){       if(f.exists()){f = newFile("d:\\A"+(count++)+".txt");}                           else{                             f.createNewFile();break;}}}
}


 

练习三：文件里表三

 

import java.io.*;class FileDemo2
{public static void main(String[] args){File dir = new File("c:\\");File[] files = dir.listFiles();for(File f : files){System.out.println(f.getName()+"::"+f.length());}}public static void listDemo_2()//筛选出指定文件{File dir = new File("d:\\java1223\\day18");String[] arr = dir.list(new FilenameFilter(){public boolean accept(File dir,String name){//                                  /System.out.println("dir:"+dir+"....name::"+name);/*if(name.endsWith(".bmp"))return true;elsereturn false;*/returnname.endsWith(".bmp");}});System.out.println("len:"+arr.length);for(Stringname : arr){System.out.println(name);}}public static void listDemo(){File f = new File("c:\\abc.txt");String[] names = f.list();//调用list方法的file对象必须是封装了一个目录。该目录还必须存在。for(Stringname : names){System.out.println(name);}}public static void listRootsDemo(){File[] files = File.listRoots();//列出计算机的所有盘符for(File f : files){System.out.println(f);}}
}


 

练习四：递归的应用一

 

//一个简单的递归应用，求和
class SumDemo
{public static void main(String[] args){System.out.println(getSum(3));}public static int getSum(int num){if(num==1)return1;return num+getSum(num-1);}
}


 

练习五：递归的应用二

 

 

/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。递归要注意：
1，限定条件。2，要注意递归的次数。尽量避免内存溢出。*/import java.io.*;class FileDemo3
{public static void main(String[] args){File dir = new File("d:\\testdir");//showDir(dir,0);//toBin(6);//intn = getSum(8000);//System.out.println("n="+n);System.out.println(dir.delete());}public static String getLevel(int level){StringBuilder sb = new StringBuilder();sb.append("|--");for(intx=0; x<level; x++){//sb.append("|--");sb.insert(0,"|  ");}return sb.toString();}public static void showDir(File dir,int level){System.out.println(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);elseSystem.out.println(getLevel(level)+files[x]);}}public static int getSum(int n){if(n==1)return1;returnn+getSum(n-1);}public static void toBin(int num){if(num>0){toBin(num/2);System.out.println(num%2);}}public static void method(){method();}
}


 

练习六：打印指定路径下所有文件及文件夹（利用递归完成）

 

import java.io.*;
class DirDemo
{public static void main(String[] args){Filedir = new File("d:\\two");dirDemo(dir);}public static void dirDemo(File dir){File[] f = dir.listFiles();for(int x=0; x<f.length; x++){if(f[x].isDirectory())dirDemo(f[x]);elseSystem.out.println(f[x].toString());}System.out.println(dir);}
}


 

练习七：删除指定路径下的所有文件及目录

 

import java.io.*;
class RemoveDemo
{public static void main(String[] args){File dir = new File("D:\\two");removeDir(dir);}public static void removeDir(File dir){File[] f = dir.listFiles();for(int x=0; x<f.length; x++){if(f[x].isDirectory())removeDir(f[x]);elseSystem.out.println(f[x].toString()+"--File--"+f[x].delete());}System.out.println(dir+"--Direcotory--"+dir.delete());}
}


 

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

 

/*
练习
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件。思路：
1，对指定的目录进行递归。
2，获取递归过程所以的java文件的路径。
3，将这些路径存储到集合中。
4，将集合中的数据写入到一个文件中。*/
import java.io.*;
import java.util.*;
class JavaFileList
{public static void main(String[] args) throws IOException{File dir = new File("d:\\java1223");List<File> list = new ArrayList<File>();fileToList(dir,list);//System.out.println(list.size());Filefile = new File(dir,"javalist.txt");writeToFile(list,file.toString());}public static void fileToList(File dir,List<File> list){File[] files = dir.listFiles();for(Filefile : files){if(file.isDirectory())fileToList(file,list);else{if(file.getName().endsWith(".java"))list.add(file);}}}public static void writeToFile(List<File> list,String javaListFile)throwsIOException{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;}}}
}


 

7.12  Properties类

 

Properties是hashtable的子类。

也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。

 

是集合中和IO技术相结合的集合容器。

 

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

 

那么在加载数据时，需要数据有固定格式：键=值。

 

import java.io.*;
import java.util.*;class PropertiesDemo
{public static void main(String[] args) throws IOException{//method_1();loadDemo();}public static void loadDemo()throws IOException{Properties prop = new Properties();FileInputStream fis = new FileInputStream("info.txt");//将流中的数据加载进集合。prop.load(fis);prop.setProperty("wangwu","39");FileOutputStream fos = new FileOutputStream("info.txt");prop.store(fos,"haha");//      System.out.println(prop);prop.list(System.out);fos.close();fis.close();}//演示，如何将流中的数据存储到集合中。//想要将info.txt中键值数据存到集合中进行操作。/*1,用一个流和info.txt文件关联。2，读取一行数据，将该行数据用"="进行切割。3，等号左边作为键，右边作为值。存入到Properties集合中即可。*/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("=");///System.out.println(arr[0]+"...."+arr[1]);prop.setProperty(arr[0],arr[1]);}bufr.close();System.out.println(prop);}//      设置和获取元素。publicstatic void setAndGet(){Properties prop = new Properties();prop.setProperty("zhangsan","30");prop.setProperty("lisi","39");//               System.out.println(prop);String value = prop.getProperty("lisi");//System.out.println(value);prop.setProperty("lisi",89+"");Set<String> names = prop.stringPropertyNames();for(Strings : names){System.out.println(s+":"+prop.getProperty(s));}}}


 

 

练习九：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。

/*
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。很容易想到的是:计数器。
可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
可是随着该应用程序的退出，该计数器也在内存中消失了。下一次在启动该程序，又重新开始从0计数。
这样不是我们想要的。程序即使结束，该计数器的值也存在。
下次程序启动在会先加载该计数器的值并加1后在重新存储起来。所以要建立一个配置文件。用于记录该软件的使用次数。该配置文件使用键值对的形式。
这样便于阅读数据，并操作数据。键值对数据是map集合。
数据是以文件形式存储，使用io技术。
那么map+io -->properties.配置文件可以实现应用程序数据的共享。*/
import java.io.*;
import java.util.*;
class RunCount
{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);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();}
}


 

7.13  Print方法

 

打印流：

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

 

字节打印流：

PrintStream

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

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

 

 

 

字符打印流：

PrintWriter

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

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

 

 

练习十：Print方法的应用

 

 

import java.io.*;class PrintStreamDemo
{publicstatic void main(String[] args) throws IOException{BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);String line = null;while((line=bufr.readLine())!=null){if("over".equals(line))break;out.println(line.toUpperCase());//out.flush();}out.close();bufr.close();}       
}


 

7.13序列流

 

序列流可以将多个流，合并成一个流

 

练习十一：序列流，让多个流，合并成一个流

 

 

import java.io.*;
import java.util.*;
class SequenceDemo
{public static void main(String[] args) throws IOException{Vector<FileInputStream> v = new Vector<FileInputStream>();v.add(newFileInputStream("c:\\1.txt"));v.add(newFileInputStream("c:\\2.txt"));v.add(newFileInputStream("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();}
}


 

7.14切割合并文件

 

练习十二：切割合并文件

 

 

import java.io.*;
import java.util.*;class SplitFile
{public static void main(String[] args) throws IOException{//splitFile();merge();}//合并文件public static void merge()throws IOException{ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();for(int x=1; x<=3; x++){al.add(newFileInputStream("c:\\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("c:\\splitfiles\\0.bmp");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 splitFile()throws IOException{FileInputStream fis =  newFileInputStream("c:\\1.bmp");FileOutputStream fos = null;byte[] buf = new byte[1024*1024];int len = 0;int count = 1;while((len=fis.read(buf))!=-1){fos = newFileOutputStream("c:\\splitfiles\\"+(count++)+".part");fos.write(buf,0,len);fos.close();}fis.close();}
}


这篇关于【20】IO流3_File类，递归，Properties，合并流，切割文件的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1016402。

相关文章

hdu2241（二分+合并数组）

hdu2241（二分+合并数组）

题意：判断是否存在a+b+c = x，a，b，c分别属于集合A,B,C 如果用暴力会超时，所以这里用到了数组合并，将b,c数组合并成d，d数组存的是b，c数组元素的和，然后对d数组进行二分就可以了 代码如下（附注释）： #include<iostream>#include<algorithm>#include<cstring>#include<stack>#include<que
阅读更多...
day-51 合并零之间的节点

day-51 合并零之间的节点

思路 直接遍历链表即可，遇到val=0跳过，val非零则加在一起，最后返回即可 解题过程 返回链表可以有头结点，方便插入，返回head.next Code /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}*
阅读更多...
系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

本章知识考点：         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识
阅读更多...
【每日一题】LeetCode 2181.合并零之间的节点（链表、模拟）

【每日一题】LeetCode 2181.合并零之间的节点（链表、模拟）

【每日一题】LeetCode 2181.合并零之间的节点（链表、模拟） 题目描述 给定一个链表，链表中的每个节点代表一个整数。链表中的整数由 0 分隔开，表示不同的区间。链表的开始和结束节点的值都为 0。任务是将每两个相邻的 0 之间的所有节点合并成一个节点，新节点的值为原区间内所有节点值的和。合并后，需要移除所有的 0，并返回修改后的链表头节点。 思路分析 初始化：创建一个虚拟头节点
阅读更多...
【C++学习笔记 20】C++中的智能指针

【C++学习笔记 20】C++中的智能指针

智能指针的功能 在上一篇笔记提到了在栈和堆上创建变量的区别，使用new关键字创建变量时，需要搭配delete关键字销毁变量。而智能指针的作用就是调用new分配内存时，不必自己去调用delete，甚至不用调用new。 智能指针实际上就是对原始指针的包装。 unique_ptr 最简单的智能指针，是一种作用域指针，意思是当指针超出该作用域时，会自动调用delete。它名为unique的原因是这个
阅读更多...
【JavaScript】LeetCode：16-20

【JavaScript】LeetCode：16-20

文章目录 16 无重复字符的最长字串17 找到字符串中所有字母异位词18 和为K的子数组19 滑动窗口最大值20 最小覆盖字串 16 无重复字符的最长字串 滑动窗口 + 哈希表这里用哈希集合Set()实现。左指针i，右指针j，从头遍历数组，若j指针指向的元素不在set中，则加入该元素，否则更新结果res，删除集合中i指针指向的元素，进入下一轮循环。 /*** @param
阅读更多...
Java IO 操作——个人理解

Java IO 操作——个人理解

之前一直Java的IO操作一知半解。今天看到一个便文章觉得很有道理（ 原文章），记录一下。 首先，理解Java的IO操作到底操作的什么内容，过程又是怎么样子。          数据来源的操作： 来源有文件，网络数据。使用File类和Sockets等。这里操作的是数据本身，1,0结构。    File file = new File("path");   字
阅读更多...
springboot体会BIO（阻塞式IO）

springboot体会BIO（阻塞式IO）

使用springboot体会阻塞式IO 大致的思路为： 创建一个socket服务端，监听socket通道，并打印出socket通道中的内容。 创建两个socket客户端，向socket服务端写入消息。 1.创建服务端 public class RedisServer {public static void main(String[] args) throws IOException {
阅读更多...
Java基础回顾系列-第七天-高级编程之IO

Java基础回顾系列-第七天-高级编程之IO

Java基础回顾系列-第七天-高级编程之IO 文件操作字节流与字符流OutputStream字节输出流FileOutputStream InputStream字节输入流FileInputStream Writer字符输出流FileWriter Reader字符输入流字节流与字符流的区别转换流InputStreamReaderOutputStreamWriter 文件复制 字符编码内存操作流(
阅读更多...
PHP实现二叉树遍历(非递归方式，栈模拟实现)

PHP实现二叉树遍历(非递归方式，栈模拟实现)

二叉树定义是这样的：一棵非空的二叉树由根结点及左、右子树这三个基本部分组成，根据节点的访问位置不同有三种遍历方式： ① NLR：前序遍历(PreorderTraversal亦称(先序遍历)) ——访问结点的操作发生在遍历其左右子树之前。 ② LNR：中序遍历(InorderTraversal) ——访问结点的操作发生在遍历其左右子树之中(间)。 ③ LRN：后序遍历(PostorderT
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2