黑马程序员————IO流3（day20）

最新推荐文章于 2024-06-07 08:18:49 发布
最新推荐文章于 2024-06-07 08:18:49 发布
阅读量445 收藏
点赞数
分类专栏： Java笔记 文章标签： 黑马程序员
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010201862/article/details/10725235
版权

----------------------ASP.Net+Android+IOS开发----------------------期待与您交流！

 

 

IO流3

l  File概述

l  File类常见方法

l  列出目录下所有内容-递归

l  删除带内容的目录

l  创建java文件列表

l  Properties简述

l  Properties存取

l  Properties存取配置文件

l  PrintWriter

l  合并流

l  切割文件

 

 

File概述

File类

用来将文件或者文件夹封装成对象，方便对文件与文件夹进行操作。

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

了解File类中的常用方法。

 

File类似乎IO包中唯一代表磁盘文件本身的对象。File类定义了一些与平台无关的方法来操纵文件，通过调用File类提供的各种方法，能够完成创建、删除文件，重命名文件等，判断文件的读写权限及文件是否存在，设置和查询文件的最近修改时间等操作。

 

示例：

import java.io.*;

class FileDemo {
	public static void main(String[] args) {
		consMethod();
	}

	// 创建File对象
	public static void consMethod() {
		// 将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象
		File f1 = new File("a.txt");// 相对路径，输出时就输出相对路径
		File f2 = new File("f:\\abc", "b.txt");// 绝对路径，输出时就输出绝对路径

		File d = new File("d:\\abc");
		File f3 = new File(d, "c.txt");

		System.out.println("f1:" + f1);
		System.out.println("f2:" + f2);
		System.out.println("f3:" + f3);

		// File.separator代表目录分隔符，可以跨平台，相当于\\
		File f4 = new File("f:" + File.separator + "abc" + File.separator
				+ "zzz" + File.separator + "a.txt");
	}
}


 

运行结果：f1:a.txt

f2:f:\abc\b.txt

f3:d:\abc\c.txt

 

Java能正确处理UNIX和Windows/DOS约定路径分隔符。如果在Windows版本的Java下用斜线(/)，路径处理依然正确。记住：如果Windows/DOS使用反斜线(\)的约定，就需要在字符串内使用它的转移序列(\\)。Java约定是用UNIX和URL风格的斜线来作路径分隔符。

 

 

File类常见方法

File类常见方法：

1.      创建

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

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

boolean mkdir():创建文件夹。

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

2.      删除

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

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

3.      判断

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

isFile():

isDirectory();

isHidden();

isAbsolute();

4.      获取信息

getName():

getPath():

         getParent():

getAbsolutePath()

long lastModified()

long length()

 

创建删除示例：

import java.io.*;

class FileDemo {
	public static void main(String[] args) throws IOException {
		method_1();
	}

	public static void method_1() throws IOException {
		File f = new File("file.txt");

		// 在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
		System.out.println("create:" + f.createNewFile());
		// f.deleteOnExit();// 在程序退出时删除指定文件。
		// 删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
		System.out.println("delete:" + f.delete());
	}


 

判断示例：

import java.io.*;

class FileDemo {
	public static void main(String[] args) throws IOException {
		method_2();
	}

	// 判断
	public static void method_2() {
		File f1 = new File("file.txt");
		System.out.println("exists:" + f1.exists());// 判断文件是否存在
		// System.out.println("execute:"+f1.canExecute());

		// 创建文件夹
		// File dir = new File("abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");
		// System.out.println("mkdir:"+dir.mkdirs());

		File f2 = new File("F:\\myjava\\Demo\\src\\day20\\IO\\file2.txt");
		// f.createNewFile();
		// f.mkdir();

		// 记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。
		// 通过exists判断。
		System.out.println("dir:" + f2.isDirectory());// 判断f2是目录吗
		System.out.println("file:" + f2.isFile());// 判断f2是文件吗
		System.out.println(f2.isAbsolute());// 判断f2路径是否为绝对路径
	}


 

运行结果：exists:false

dir:false

file:false

true

 

 

获取示例：

import java.io.*;

class FileDemo {
	public static void main(String[] args) throws IOException {
		method_3();
	}

	// 获取
	public static void method_3() {
		File f1 = new File("file.txt");
		System.out.println("path:" + f1.getPath());// 封装成什么路径就获取什么路径
		System.out.println("abspath:" + f1.getAbsolutePath());// 不管封装成什么，只获取绝对路径
		// 该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null
		// 如果相对路径中有上一层目录那么该目录就是返回结果
		System.out.println("parent:" + f1.getParent());// 把f2重命名为f3，Test.java重命名为haha.java

		File f2 = new File("f:\\Test.java");
		File f3 = new File("f:\\haha.java");
		System.out.println("rename:" + f2.renameTo(f3));
	}


 

运行结果：path:file.txt

abspath:F:\myjava\Demo\file.txt

parent:null

rename:true

 

 

列出目录下所有内容-递归

列出指定目录下文件或者文件夹，包含子目录中的内容，也就是列出指定目录下所有内容。

 

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

 

递归要注意：

1.      限定条件

2.      要注意递归的次数，尽量避免内存溢出。

 

示例：

import java.io.*;

class FileDemo2 {
	public static void main(String[] args) {
		File dir = new File("f:\\myjava");
		showDir(dir);
		//toBin(6);
		//int n = getSum(100);
		//System.out.println("n="+n);
	}
	
	// 累加和
	public static int getSum(int n){
		if(n==1)
			return 1;
		return n+getSum(n-1);// 递归，函数自身调用自身
	}
	
	// 转二进制
	public static void toBin(int num){
		if(num>0){
			toBin(num/2);// 递归，函数自身调用自身
			System.out.println(num%2);
		}
	}
	
	
	// 列出指定目录下文件或者文件夹，包含子目录中的内容
	public static void showDir(File dir){
		System.out.println(dir);
		File[] files = dir.listFiles();
		for(int x=0;x<files.length; x++){
			if(files[x].isDirectory())
				showDir(files[x]);// 递归，函数自身调用自身
			else {
				System.out.println(files[x]);
			}
		}
	}
}


 

删除带内容的目录

删除一个带内容的目录。

 

删除原理：

在window中，删除目录从里面往外删除的，既然是从里往外删除，就需要用到递归。

 

示例：

import java.io.*;

class RemoveDir {
	public static void main(String[] args) {
		File dir = new File("f:\\myjava1");
		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());
	}
}


 

创建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("f:\\myjava");
		List<File> list = new ArrayList<File>();
		fileToList(dir, list);

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

		File file = new File(dir, "javalist.txt");
		writeToFile(list, file.toString());

	}

	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);
			}
		}
	}

	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) {
			throw e;
		} finally {
			try {
				if (bufw != null)
					bufw.close();
			} catch (IOException e) {
				throw e;
			}
		}
	}
}


 

Properties简述

Properties是hashtable的子类，也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串，是集合中和IO技术相结合的集合容器。

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

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

 

 

Properties存取

示例:

import java.io.*;
import java.util.*;

class PropertiesDemo {
	public static void main(String[] args) {
		setAndGet();
	}

	// 设置和获取元素
	public static void setAndGet() {
		Properties prop = new Properties();
		prop.setProperty("zhangsan", "20");
		prop.setProperty("lisi", "30");

		// System.out.println(prop);
		String value = prop.getProperty("lisi");
		// System.out.println(value);

		prop.setProperty("lisi", 89 + "");

		Set<String> names = prop.stringPropertyNames();
		for (String s : names) {
			System.out.println(s + ":" + prop.getProperty(s));
		}
	}
}


 

Properties存取配置文件

示例：

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);
	}
}


 

PrintWriter

打印流：

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

 

字节打印流：PrintStream，构造函数可以接收的参数类型：

1.      file对象。File

2.      字符串路径。String

3.      字节输出流。OutputStream

 

字符打印流：PrintWriter，构造函数可以接收的参数类型：

1.      file对象。File

2.      字符串路径。String

3.      字节输出流。OutputStream

4.      字符输出流，Writer。

 

示例：

import java.io.*;

class PrintStreamDemo {
	public static 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();
	}
}


 

合并流

示例：

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("f:\\1.txt"));
		v.add(new FileInputStream("f:\\2.txt"));
		v.add(new FileInputStream("f:\\3.txt"));

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

		SequenceInputStream sis = new SequenceInputStream(en);

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


 

切割文件

示例：

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(new FileInputStream("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 = new FileInputStream("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 = new FileOutputStream("c:\\splitfiles\\" + (count++) + ".part");
			fos.write(buf, 0, len);
			fos.close();
		}
		fis.close();
	}
}


 

 

 

----------------------ASP.Net+Android+IOS开发----------------------期待与您交流！

详情请查看：http://edu.csdn.net

 

AIxxx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
.NET中的IO操作之文件流用法分析
10-24
主要介绍了.NET中的IO操作之文件流用法,实例分析了.net对文件流的读写操作及编码转换等问题,具有一定参考借鉴价值,需要的朋友可以参考下
IO流——文件操作字节流常用方法一览
12-22
IO流——文件操作字节流常用方法 1. 文件操作字节流 1.1 文件操作输入字节流 ileInputStream 文件操作输入字节流 Constructor 构造方法 FileInputStream(File file); 这里是根据提供的File类对象创建对应的文件...
黑马程序员——JAVA之IO流
hou0201_的博客
09-24 298
------- http://www.itheima.com" target="blank">android培训、http://www.itheima.com" target="blank">java培训、期待与您交流！ 1.如何定义一个类             2.如何使用对象                 3.JAVA中的成员变量和局部变量
黑马程序员————IO流1（day18）
u010201862的专栏
08-31 439
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------     IO流1 l  其它对象（System） l  其它对象（Runtime） l  其它对象（Date） l  其它对象（Calendar） l  其它对象（Math - Random） l
黑马程序员————IO流2（day19）
u010201862的专栏
08-31 430
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------     IO流2 l  BufferedWriter l  BufferedReader l  通过缓冲区复制文本文件 l  装饰设计模式 l  LineNumberReader l  字节流
黑马程序员————IO流4（day21）
u010201862的专栏
08-31 590
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------     IO流4 l  对象的序列化 l  管道流 l  RandomAccessFile l  操作基本数据类型的流对象DataStream l  ByteArrayStream l  转换
黑马程序员————IO流——字节流
lgplf的博客
06-13 432
 ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- IO流——字节流 一.IO流：  1、IO流的类的层次结构    A:字节流： OutputStream: |--FileOutputStream: |--FilterOutputStream:(没学) |--
黑马程序员——Java中IO流下
wanyy的博客
08-13 349
------Java培训、Android培训、期待与您交流！ ------- 一、File类 1、概念： File类用来将文件和路径封装成对象，方便对文件与文件夹的属性信息进行操作。File对象可以作为参数传递给流的构造函数。 2、常用方法 2.1 创建 boolean createNewFile()：//在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不
黑马程序员——Spring框架——day01
qq_56444564的博客
05-24 761
问题导入我们为什么要学习Spring框架？为什么要学Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>==90%==专业角度==简化开发==，降低企业级开发的复杂性==框架整合==，高效整合其他技术，提高企业级应用开发与运行效率生命周期：从创建到消亡的完整过程bean生命周期：bean从创建到销毁的整体过程bean生命周期控制：在bean创建后到销毁前做一些事情。
Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）。
浅谈java IO流——四大抽象类
08-26
java IO流——四大抽象类 java IO流是java语言中用于输入输出操作的基本类库，IO流是Java程序中最基本也最重要的一部分，java IO流主要可以分为两大类：字节流和字符流。在java中，四大抽象类是IO流的基础，它们...
java——IO流技术.pdf
04-03
javaIO流
黑马程序员入学Java知识——精华总结
05-31
含面向对象，异常处理和常用类，线程技术，集合框架，IO操作，网络编程，文件操作，反射机制，
黑马程序员——Java之IO流(一)
Meteor_Come
03-21 555
一、流的概念和定义 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 二、IO流分类 IO流用于处理设备之间的数据传输，Java对数据的操作时通过流的方式。 流按操作数据分为字节流和字符流。按流向分为输入流和输出流。 三、IO流区别 字符流的由来
黑马程序员——Spring框架——day06——SpringBoot基础
最新发布
qq_56444564的博客
06-07 805
SpringMVC的HelloWord程序大家还记得吗？SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程原生开发SpringMVC程序过程入门案例中没有引入spring-webmvc等依赖包，没有配置Tomcat服务器，为什么能正常启动？我们没有配置端口号，为什么端口是8080？
黑马程序员————面向对象1（day5）
u010201862的专栏
08-31 635
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------   面向对象1 l  面向对象概述 l  类与对象的关系 l  成员变量和局部变量 l  匿名对象的应用 l  封装概述 l  构造函数 l  构造代码块 l  this关键字 面向对象的概述  面向对象其
黑马程序员————高新技术————eclipse及IDE开发工具介绍
u010201862的专栏
08-31 624
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------     eclipse及IDE开发工具介绍   Eclipse概述 Eclipse是IBM花巨资开发的IDE集成开发环境（Integrated Development Environment）。其前身是IBM的Visual
黑马程序员io流笔记
07-29
关于黑马程序员的IO流笔记，根据提供的信息，无法得知具体内容。请提供更多细节或具体问题，以便我能够给出更准确的回答。 #### 引用[.reference_title] - *1* *2* *3* [黑马程序员—IO学习笔记]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值