java文件File和IO流（二）-- IO流，递归，数据流，打印流，转换流等等

最新推荐文章于 2024-08-03 16:59:51 发布

牛大圣

最新推荐文章于 2024-08-03 16:59:51 发布

阅读量644

点赞数 30

分类专栏： Java基础文章标签： java 开发语言递归转换流内存操作流输入输出流

本文链接：https://blog.csdn.net/niudasheng/article/details/137202707

版权

Java基础专栏收录该内容

24 篇文章 0 订阅

订阅专栏

IO流

IO流之数据流

在IO流中，可以通过DataInputStream和DataOutputStream字节流直接操作基本数据类型和字符串

DataOutputStream

import java.io.*;

//TODO 数据流，简单的说，就是容许字节流直接操作基本数据类型和字符串。
public class DataInputStream_DataOutputStream {

	public static void main(String[] args) throws IOException {
		String dataPath = "D:\\price.data";// 数据源
		DataOutputStream outputStream = null;
		try {//向文件中存数据
		//String[] rosterArray = { "张三", "李四", "王五", "薛六" };			double[] priceArray = { 5.2, 7.3, 1.5, 6.7, 8.0 };// 单价
			outputStream = new DataOutputStream(
							new BufferedOutputStream(
							 new FileOutputStream(dataPath)));
			for (int i = 0; i < priceArray.length; i++) {
// 以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入数据输出流。
				//outputStream.writeUTF(rosterArray[i]);
				outputStream.writeDouble(priceArray[i]);   //字符变成字节存进去；
				System.out.println("单价为："+outputStream.toString());
			}
		} finally {
			if(outputStream!=null){
				outputStream.close();
			}
		}

		DataInputStream inputStream = null;
		try {//从文件中读数据
			inputStream = new DataInputStream(
                          new BufferedInputStream(new FileInputStream(dataPath)));
			while (true) {
				//String name = inputStream.readUTF();
				double price = inputStream.readDouble();//字节变成字符输出来
				System.out.println("单价为："+price);
			}
		} catch (EOFException e) {
			System.out.println("数据读取完毕......");
		}finally {
			if(inputStream!=null){
				inputStream.close();
			}
		}
	}
}

IO流之打印流

Java.io.outputstream.PrintStream：

字节打印流，字符打印流

1：提供了更多的功能，比如打印方法。可以直接打印任意类型的数据。

2：它有一个自动刷新机制，创建该对象，指定参数，对于指定方法可以自动刷新。

3：它使用的本机默认的字符编码.

4：该流的print方法不抛出IOException。

该对象的构造函数。

PrintStream(File file)  ：创建具有指定文件且不带自动行刷新的新打印流。 
PrintStream(File file, String csn) ：创建具有指定文件名称和字符集且不带自动行刷新的新打印流。 
PrintStream(OutputStream out) ：创建新的打印流。 
PrintStream(OutputStream out, boolean autoFlush) ：创建新的打印流。 
PrintStream(OutputStream out, boolean autoFlush, String encoding) ：创建新的打印流。 
PrintStream(String fileName) ：创建具有指定文件名称且不带自动行刷新的新打印流。 
PrintStream(String fileName, String csn)

PrintStream可以操作目的：

1：File对象。2：字符串路径。3：字节输出流。

前两个都JDK1.5版本才出现。而且在操作文本文件时，可指定字符编码了。

当目的是一个字节输出流时，如果使用的println方法，可以在printStream对象上加入一个true参数。这样对于println方法可以进行自动的刷新，而不是等待缓冲区满了再刷新。最终print方法都将具体的数据转成字符串，而且都对IO异常进行了内部处理。

既然操作的数据都转成了字符串，那么使用PrintWriter更好一些。因为PrintWrite是字符流的子类，可以直接操作字符数据，同时也可以指定具体的编码。

PrintWriter：具备了PrintStream的特点同时，还有自身特点：

该对象的目的地有四个：

1：File对象。

2：字符串路径。

3：字节输出流。

4：字符输出流。

开发时尽量使用PrintWriter。

方法中直接操作文件的第二参数是编码表。

直接操作输出流的，第二参数是自动刷新。

读取键盘录入将数据转成大写显示在控制台.

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//源：键盘输入
//目的：把数据写到文件中，还想自动刷新。设置true后自动刷新
PrintWriter out = new PrintWriter(new FileWriter("out.txt"),true);

String line = null;
while((line=bufr.readLine())!=null){
	if("over".equals(line))
		break;
	out.println(line.toUpperCase());//转大写输出
}
	//注意：System.in，System.out这两个标准的输入输出流，在jvm启动时已经存在了。
    //随时可以使用。当jvm结束了，这两个流就结束了。但是，当使用了显示的close方法关闭时，这两个流在提前结束了。
out.close();
bufr.close();

复制文本文件

BufferedReader br = new BufferedReader(new FileReader("a.txt"));
PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);
String line = null;
while((line=br.readLine())!=null) {
    pw.println(line);
}
pw.close();
br.close();

IO流之转换流

字节流操作中文数据不是特别的方便，所以就出现了转换流. 转换流的作用就是把字节流转换字符流来使用。

转换流特有功能：

转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。

转换流的最强功能就是基于 字节流 + 编码表 。没有转换，没有字符流。

发现转换流有一个子类就是操作文件的字符流对象：

InputStreamReader

|--FileReader

OutputStreamWriter

|--FileWrier

想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。

但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。

FileReader fr = new FileReader("a.txt");

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"gbk");

以上两句代码功能一致，

如果仅仅使用平台默认码表，就使用FileReader fr = new FileReader("a.txt"); //因为简化。

如果需要制定码表，必须用转换流。

转换流 = 字节流+编码表。

转换流的子类File = 字节流 + 默认编码表。

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

InputStreamReader

OutputStreamWriter

IO流中的编码问题

A: OutputStreamWriter

OutputStreamWriter(OutputStream os):默认编码，GBK

OutputStreamWriter(OutputStream os,String charsetName):指定编码。

B: InputStreamReader

InputStreamReader(InputStream is):默认编码，GBK

InputStreamReader(InputStream is,String charsetName):指定编码

C: 编码问题其实很简单

编码只要一致即可

键盘输入

Java使用System.in代表键盘输入，这个输入流是InputStream类的实例,键盘输入的内容一般都是文本内容，能否使用某种方法将其转化成字符输入流？答案是肯定的：InputStreamReader

假设有这样的需求：使用一个输入字符缓冲流读取用户在命令行输入的一行数据。

分析这个需求，首先得知需要用输入字符缓冲流读取数据，我们想到了使用刚才学习的BufferedReader这个类。需要获取的是用户在命令行输入的一行数据，通过之前的学习我们知道，System.in是InputStream类（字节输入流）的静态对象，可以从命令行读取数据字节。现在问题出现了，需要把一个字节流转换成一个字符流，我们可以使用InputStreamReader和OutputStreamWriter这两个类来进行转换

输入一句话到控制台

//记住，只要一读取键盘录入，就用这句话。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));//输出到控制台
String line = null;
while((line=bufr.readLine())!=null){
	if("over".equals(line))
		break;
	bufw.write(line.toUpperCase());//将输入的字符转成大写字符输出
	bufw.newLine();
	bufw.flush();
	}
bufw.close();
bufr.close();
import java.io.*;

public class StreamToReaderTest {
	public static void main(String[] args) {
		//以不变应万变。。。。。。。
		//假设有这样的需求：使用一个输入字符缓冲流读取用户在命令行输入的一行数据。
		//分析这个需求，首先得知需要用输入字符缓冲流读取数据，
		//我们想到了使用刚才学习的BufferedReader这个类。
		//需要获取的是用户在命令行输入的一行数据，通过之前的学习我们知道，
		//System.in是InputStream类（字节输入流）的静态对象，可以从命令行读取数据字节。
		//现在问题出现了，需要把一个字节流转换成一个字符流，我们可以使用InputStreamReader
		//和OutputStreamWriter这两个类来进行转换
		BufferedReader reader = null;
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			System.out.print("请输入你今天最想说的话：");
			String words = reader.readLine();
			System.err.println(words);
		} catch (IOException e) {
			System.out.println(e.getMessage());
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}
输入一句话存到一个文档里
import java.io.*;

public class InputStreamReader1 {
	public static void main(String[] args) {
		//TODO 输入一句话存到一个文档里
		BufferedReader Reader = null;
		BufferedWriter Writer = null;
		try {
			Reader = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("请输入一句话");
			FileWriter fileWriter=new FileWriter("F:/ 情人.txt");
			Writer = new BufferedWriter(fileWriter);
			String validBufferLength  = Reader.readLine();
			Writer.write(validBufferLength);
			Writer.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (Reader != null) {
				try {
					Reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			if (Writer != null) {
				try {
					Writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

IO流之内存操作流

(1)有些时候我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流。

(2)三种

A: ByteArrayInputStream：源：内存 ByteArrayOutputStream：目的：内存。

这两个流对象不涉及底层资源调用，操作的都是内存中数组，所以不需要关闭。

直接操作字节数组就可以了，为什么还要把数组封装到流对象中呢？因为数组本身没有方法，只有一个length属性。为了便于数组的操作，将数组进行封装，对外提供方法操作数组中的元素。

对于数组元素操作无非两种操作：设置（写）和获取（读），而这两操作正好对应流的读写操作。这两个对象就是使用了流的读写思想来操作数组。

B:CharArrayReader,CharArrayWriter
C:StringReader,StringWriter

IO流之标准输入输出流

(1)System类下面有这样的两个字段

in 标准输入流

out 标准输出流

(2)三种键盘录入方式

A:main方法的args接收参数

B:System.in通过BufferedReader进行包装

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

C:Scanner

Scanner sc = new Scanner(System.in);

(3)输出语句的原理和如何使用字符流输出数据

A:原理

System.out.println("helloworld");
PrintStream ps = System.out;
ps.println("helloworld");

B:把System.out用字符缓冲流包装一下使用

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

IO流之随机访问流RandomAccessFile:

(1)可以按照文件指针的位置写数据和读数据。

特点：

1：该对象即可读取，又可写入。

2：该对象中的定义了一个大型的byte数组，通过定义指针来操作这个数组。

3：可以通过该对象的getFilePointer()获取指针的位置，通过seek()方法设置指针的位置。

4：该对象操作的源和目的必须是文件。

5：其实该对象内部封装了字节读取流和字节写入流。注意：实现随机访问，最好是数据有规律。


class RandomAccessFileDemo{
	public static void main(String[] args) throws IOException{
		write();
		read();
		randomWrite();
	}
	//随机写入数据，可以实现已有数据的修改。
	public static void randomWrite()throws IOException{
		RandomAccessFile raf = new RandomAccessFile("random.txt","rw");
		raf.seek(8*4);
		System.out.println("pos :"+raf.getFilePointer());
		raf.write("王武".getBytes());
		raf.writeInt(102);
		raf.close();
	}
	public static void read()throws IOException{
		RandomAccessFile raf = new RandomAccessFile("random.txt","r");//只读模式。
		//指定指针的位置。
		raf.seek(8*1);//实现随机读取文件中的数据。注意：数据最好有规律。
		System.out.println("pos1 :"+raf.getFilePointer());
		byte[] buf = new byte[4];
		raf.read(buf);
		String name = new String(buf);
		int age = raf.readInt();
		System.out.println(name+"::"+age);
		System.out.println("pos2 :"+raf.getFilePointer());
		raf.close();
	}
	public static void write()throws IOException{
		//rw：当这个文件不存在，会创建该文件。当文件已存在，不会创建。所以不会像输出流一样覆盖。
		RandomAccessFile raf = new RandomAccessFile("random.txt","rw");//rw读写模式
		//往文件中写入人的基本信息，姓名，年龄。
		raf.write("张三".getBytes());
		raf.writeInt(97);
		raf.close();
	}
}

IO流之合并流SequenceInputStream：

作用就是将多个读取流合并成一个读取流。实现数据合并。

表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

这样做，可以更方便的操作多个读取流，其实这个序列流内部会有一个有序的集合容器，用于存储多个读取流对象。

该对象的构造函数参数是枚举，想要获取枚举，需要有Vector集合，但不高效。需用ArrayList，但ArrayList中没有枚举，只有自己去创建枚举对象。

但是方法怎么实现呢？因为枚举操作的是具体集合中的元素，所以无法具体实现，但是枚举和迭代器是功能一样的，所以，可以用迭代替代枚举。

合并原理：多个读取流对应一个输出流。

切割原理：一个读取流对应多个输出流。

import java.io.*;
import java.util.*;
class  SplitFileDemo{
	private static final String CFG = ".properties";
	private static final String SP = ".part";
	public static void main(String[] args) throws IOException{
		File file = new File("c:\\0.bmp");
		File dir = new File("c:\\partfiles");
		meger(dir);
	}
	//数据的合并。
	public static void meger(File dir)throws IOException{
		if(!(dir.exists() && dir.isDirectory()))
			throw new RuntimeException("指定的目录不存在，或者不是正确的目录");
		File[] files = dir.listFiles(new SuffixFilter(CFG));
		if(files.length==0)
			throw new RuntimeException("扩展名.proerpties的文件不存在");
		//获取到配置文件
		File config = files[0];
		//获取配置文件的信息。
		Properties prop = new Properties();
		FileInputStream fis = new FileInputStream(config);
		prop.load(fis);
		String fileName = prop.getProperty("filename");
		int partcount = Integer.parseInt(prop.getProperty("partcount"));
		//--------------------------
		File[] partFiles = dir.listFiles(new SuffixFilter(SP));
		if(partFiles.length!=partcount)
			throw new RuntimeException("缺少碎片文件");
		//---------------------
		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
		for(int x=0; x<partcount; x++){
			al.add(new FileInputStream(new File(dir,x+SP)));
		}
		Enumeration<FileInputStream> en = Collections.enumeration(al);
		SequenceInputStream sis = new SequenceInputStream(en);
		File file = new File(dir,fileName);
		FileOutputStream fos = new FileOutputStream(file);
		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(File file)throws IOException{
		//用一个读取流和文件关联。
		FileInputStream fis = new FileInputStream(file);
		//创建目的地。因为有多个。所以先创建引用。
		FileOutputStream fos = null;
		//指定碎片的位置。
		File dir = new File("c:\\partfiles");
		if(!dir.exists())
			dir.mkdir();
		//碎片文件大小引用。
		File f = null;
		byte[] buf = new byte[1024*1024];
		//因为切割完的文件通常都有规律的。为了简单标记规律使用计数器。
		int count = 0;
		int len = 0;
		while((len=fis.read(buf))!=-1){
			f = new File(dir,(count++)+".part");
			fos = new FileOutputStream(f);
			fos.write(buf,0,len);
			fos.close();
		}
		//碎片文件生成后，还需要定义配置文件记录生成的碎片文件个数。以及被切割文件的名称。
		//定义简单的键值信息，可是用Properties。
		String filename = file.getName();
		Properties prop = new Properties();
		prop.setProperty("filename",filename);
		prop.setProperty("partcount",count+"");
		File config = new File(dir,count+".properties");
		fos = new FileOutputStream(config);
		prop.store(fos,"");
		fos.close();
		fis.close();
	}
}
class SuffixFilter implements FileFilter{
	private String suffix;
	SuffixFilter(String suffix){
		this.suffix  = suffix;
	}
	public boolean accept(File file){
		return  file.getName().endsWith(suffix);
	}
}

以下介绍IO包中扩展功能的流对象：基本都是装饰设计模式。

IO流之管道流：管道读取流和管道写入流可以像管道一样对接上，管道读取流就可以读取管道写入流写入的数据。

注意：需要加入多线程技术，因为单线程，先执行read，会发生死锁，因为read方法是阻塞式的，没有数据的read方法会让线程等待

public static void main(String[] args) throws IOException{
	PipedInputStream pipin = new PipedInputStream();
	PipedOutputStream pipout = new PipedOutputStream();
	pipin.connect(pipout);
	new Thread(new Input(pipin)).start();
	new Thread(new Output(pipout)).start();
}

IO流之对象的序列化：

目的：将一个具体的对象进行持久化，写入到硬盘上。

注意：静态数据不能被序列化，因为静态数据不在堆内存中，是存储在静态方法区中。

如何将非静态的数据不进行序列化？用transient 关键字修饰此变量即可。

Serializable：用于启动对象的序列化功能，可以强制让指定类具备序列化功能，该接口中没有成员，这是一个标记接口。这个标记接口用于给序列化类提供UID。这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid，可以在类中，手动指定一个名称为serialVersionUID id号。依据编译器的不同，或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。

import java.io.*;
class ObjectStreamDemo {
	public static void main(String[] args) throws Exception{
		writeObj();
		readObj();
	}
	public static void readObj()throws Exception{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
		Object obj = ois.readObject();//读取一个对象。
		System.out.println(obj.toString());
	}
	public static void writeObj()throws IOException{
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
		oos.writeObject(new Person("lisi",25)); //写入一个对象。
		oos.close();
	}
}
class Person implements Serializable{
	private static final long serialVersionUID = 42L;
	private transient String name;//用transient修饰后name将不会进行序列化
	public int age;
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String toString(){
		return name+"::"+age;
	}
}

IO流之Properties

Java.util.Properties：

一个可以将键值进行持久化存储的对象。Map--Hashtable的子类。

Map

|--Hashtable

|--Properties：用于属性配置文件，键和值都是字符串类型。

特点：1：可以持久化存储数据。2：键值都是字符串。3：一般用于配置文件。

|-- load()：将流中的数据加载进集合。

原理：其实就是将读取流和指定文件相关联，并读取一行数据，因为数据是规则的key=value，所以获取一行后，通过 = 对该行数据进行切割，左边就是键，右边就是值，将键、值存储到properties集合中。

|-- store()：写入各个项后，刷新输出流。

|-- list()：将集合的键值数据列出到指定的目的地。

(1)是一个集合类，Hashtable的子类

(2)特有功能

A:public Object setProperty(String key,String value)
B:public String getProperty(String key)
C:public Set<String> stringPropertyNames()

(3)和IO流结合的方法

把键值对形式的文本文件内容加载到集合中
public void load(Reader reader)
public void load(InputStream inStream)
把集合中的数据存储到文本文件中
public void store(Writer writer,String comments)
public void store(OutputStream out,String comments)

(4)案例：

A:根据给定的文件判断是否有键为"lisi"的，如果有就修改其值为100

B:写一个程序实现控制猜数字小游戏程序不能玩超过5次

.properties配置文件

key-value类型的配置文件:

password=123456

id=dean

读取配置文件

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class LoadSample {  
	private static Properties properties = null;

	static {
		InputStream fis = null;
		properties = new Properties();

		try {
    	  //反射
//        	  fis = LoadSample.class.getClassLoader().getResourceAsStream("app.properties");
      //读取指定文件夹
			fis = new FileInputStream("conf/app.properties");//properties路径
			properties.load(fis);
			properties.list(System.out);  
		} catch (IOException e) {
		} finally {
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
				}
			}
		}
	}

	public static String getProperty(String key) {
		return properties.getProperty(key);
	}
  
	public static void main(String args[]) throws Exception { 
		System.out.println("\nThe foo property: " + LoadSample.getProperty("id")); 
	}
}

内存写入配置文件

//通过list 方法将Properties写入Properties文件,会将文件中的全部覆盖
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.io.PrintStream;
import java.util.Properties;

public class Test {
  public static void main(String[] args) {

      Properties p = new Properties();
      p.setProperty("id","dean");
      p.setProperty("password","123456");

      try{
      	PrintStream fW = new PrintStream(new File("conf/app.properties"));
      	p.list(fW );
      	System.out.println("jieshu");
      } catch (IOException e) {
      	e.printStackTrace();
      }
  }
}

XML方法：

Xml文件

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">  
<properties>  
	<comment>Hi</comment>  
	<entry key="foo">bar</entry>  
	<entry key="fu">baz</entry>  
</properties>

读取配置文件

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class LoadSampleXML {  
	private static Properties properties = null;

	static {
		InputStream fis = null;
		properties = new Properties();

		try {
    	  //反射
//        	  fis = LoadSample.class.getClassLoader().getResourceAsStream("NewFile.xml");
      //读取指定文件夹
			fis = new FileInputStream("conf/NewFile.xml");//properties路径
			properties.load(fis);
			properties.list(System.out);  
		} catch (IOException e) {
		} finally {
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
				}
			}
		}
	}

	public static String getProperty(String key) {
		return properties.getProperty(key);
	}
  
	public static void main(String args[]) throws Exception { 
		System.out.println("\nThe foo property: " + LoadSample.getProperty("id")); 
	}
}

内存写入配置文件

import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.io.PrintStream;
import java.util.Properties;

public class TestXml {
    public static void main(String[] args) {
        Properties p = new Properties();
        p.setProperty("id","dean");
        p.setProperty("password","123456");

        try{
            PrintStream fW = new PrintStream(new File("NewFile.xml"));
            p.storeToXML(fW,"test");
            System.out.println("结束");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

递归：

就是函数自身调用自身。

什么时候用递归呢？

当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。

简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

递归的注意事项：

1：一定要定义递归的条件。

2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。

其实递归就是在栈内存中不断的加载同一个函数。

A:要有出口，否则就是死递归

B:次数不能过多，否则内存溢出

C:构造方法不能递归使用

(3)递归的案例：

A:递归求阶乘

B:兔子问题

C:递归输出指定目录下所有指定后缀名的文件绝对路径

D:递归删除带内容的目录(小心使用)

牛大圣

关注

30
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
java文件File和IO流（二）-- IO流，递归，数据流，打印流，转换流等等

这个uid是依据类中的成员的数字签名进行运行获取的。其实就是将读取流和指定文件相关联，并读取一行数据，因为数据是规则的key=value，所以获取一行后，通过 = 对该行数据进行切割，左边就是键，右边就是值，将键、值存储到properties集合中。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。因为枚举操作的是具体集合中的元素，所以无法具体实现，但是枚举和迭代器是功能一样的，所以，可以用迭代替代枚举。
复制链接

扫一扫

专栏目录