java输入输出流的简单应用

最新推荐文章于 2022-11-29 15:07:24 发布
最新推荐文章于 2022-11-29 15:07:24 发布
阅读量229 收藏
点赞数 1
文章标签： java 输入输出流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bulingbulinging/article/details/98480687
版权

自己写的java程序终于不只是整字符串的了，可以在文件上操作了

1.模仿shell的pwd功能–打印当前目录
java有丰富的库可供我们使用，获取当前文件路径的方法也不用自己写
我们在用File实例化对象的时候，可以利用

File file=new File(this.getClass().getResource("").getPath());

这种方法直接赋予file当前绝对路径，java程序运行时会返回.class文件路径
可是this指针的存在将导致该种方法无法在主方法中使用，我们可以借助

System.getProperty("user.dir")

方法获得当前工作路径，java程序运行时会返回.java文件路径
之后的练习过程中，无法频繁使用this指针方法会使.getAbsolutePath()返回绝对路径的方法使用频率增加，这种方法也需要掌握
下面贴上全部源码

package ezshell;//包名

import java.io.File;

public class pwd {
	public void getpath() {
		File file=new File(this.getClass().getResource("").getPath());
		System.out.println("当前绝对路径"+file.getAbsolutePath());
	}

	public static void main(String[] args){
		// TODO Auto-generated method stub
		pwd p=new pwd();
		System.out.println("当前工作路径"+System.getProperty("user.dir"));
		p.getpath();
	}
}

这是运行结果
在这里插入图片描述

2.模仿shell的ls功能–打印当前目录下的所有文件
先贴上全部源码镇博客

package ezshell;

import java.io.File;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;

public class ls {
	public static void printlist(List <String> list) {//list输出方法
		for(String str:list) {
			System.out.println(str);
		}
	}
	public List<String> dirListrec(String dir){//递归
		List<String> list=new LinkedList<String>();
		File file=new File(dir);
		list.add(file.getAbsolutePath());
		File[] listfile1=file.listFiles();
		if(listfile1!=null&&listfile1.length!=0)
		{
			for(File f:listfile1) {
				if(f.isDirectory()) {
					List<String> dirListrec=dirListrec(f.getAbsolutePath());
					list.addAll(dirListrec);
					continue;
				}
				list.add(f.getAbsolutePath());
			}
		}
		return list;
	}
	public List<String> dirListsta(String dir){//栈
		List<String> list=new LinkedList<String>();
		Stack<File> stack=new Stack<File>();
		File file=new File(dir);
		list.add(file.getAbsolutePath());
		stack.push(file);
		//list.add(file.getAbsolutePath());
		while(!stack.empty()) {
			File popfile=stack.pop();
			File[] listfile2=popfile.listFiles();
			if(listfile2==null||listfile2.length==0) continue;
			for(File f:listfile2) {
				if(f.isDirectory()) {
					stack.push(f);
				}
				list.add(f.getAbsolutePath());
			}
		}
		return list;
		
	}
	public List<String> dirListque(String dir){//队列
		List<String> list=new LinkedList<String>();
		Queue<File> queue=new LinkedBlockingQueue<File>();
		File file=new File(dir);
		list.add(file.getAbsolutePath());
		queue.add(file);
		while(!queue.isEmpty()) {
			File outfile=queue.remove();
			File[] listfile3=outfile.listFiles();
			if(listfile3==null||listfile3.length==0) continue;
			for(File f:listfile3) {
				if(f.isDirectory()) {
					queue.add(f);
				}
				list.add(f.getAbsolutePath());
			}
		}
		return list;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ls l=new ls();
		String dir=System.getProperty("user.dir");
		List<String> reclist=l.dirListrec(dir);
		List<String> stalist=l.dirListsta(dir);
		List<String> quelist=l.dirListque(dir);
		//System.out.println("递归搜索打印当前目录下所有文件");
		//printlist(reclist);
		//System.out.println("栈搜索打印当前目录下所有文件");
		//printlist(stalist);	
		System.out.println("队列搜索打印当前目录下所有文件");
		printlist(quelist);

	}

}

然后我们再慢慢看
---------------------------------------------------------------递归法---------------------------------------------------------------------
因为要打印出所有文件，我们不难想到文件夹里面的文件夹也需要我们进去搜索，这种想法很容易让我们想到递归
先打印一个文件夹下的文件，如果发现一个文件夹，那么就将方法在那个文件夹里再走一遍

如何保存数据呢？因为写C写多了第一反映是数组可丰富的java类连HashMap都有有没有在存储无关联数据上比数组方便一些的类呢？List就是我们要寻找的类

那我们的思路就基本确定了，用递归的方法去搜索，再用集合收集数据并输出
那我们需要写一个递归方法，让这个方法返回一个集合，最终输出集合

为了输出美观一点，我们先写个输出方法来保证集合换行输出

	public static void printlist(List <String> list) {//list输出方法
		for(String str:list) {
			System.out.println(str);
		}

我们结合集合写递归算法

首先当我们的file文件指向正确时要先把file文件夹绝对路径储存在集合list中

list.add(filePath);

此方法得到了使用，此方法可以在集合list中加入一个filePath元素，测试一下，成功后我们以后就可以按照这个模板写代码了

import java.io.File;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;
public List<String> dirListrec(String dir){//递归
		List<String> list=new LinkedList<String>();
		File file=new File(dir);
		list.add(file.getAbsolutePath());
		File[] listfile1=file.listFiles();
		}
public static void main(String[] args) {
		// TODO Auto-generated method stub
		ls l=new ls();
		String dir=System.getProperty("user.dir");
		List<String> reclist=l.dirListrec(dir);
		System.out.println("递归搜索打印当前目录下所有文件");
		printlist(reclist);

在这里插入图片描述
可以正常输出后我们去完善递归方法，当集合list储存下当前目录后，需要我们遍历其他文件，由于file指向的是最最外面的文件夹，所以我们需要实例化一个集合listfile1装下file文件里面的其他文件，利用for循环对listfile1进行遍历，我们就完成了file里面一层文件目录的收集，此时代码如下

	public List<String> dirListrec(String dir){//递归
		List<String> list=new LinkedList<String>();
		File file=new File(dir);
		list.add(file.getAbsolutePath());
		File[] listfile1=file.listFiles();
		if(listfile1!=null&&listfile1.length!=0)
		{
			for(File f:listfile1) {
				list.add(f.getAbsolutePath());
			}
		}

可是如果里面还有文件夹呢？再来一个遍历？可以
可是如果里面的里面还有文件夹呢？手写多层嵌套循环是很不现实的事，所以我们要用到方法递归了

判断file是不是文件夹的方法

if(file.isDirectory())

我们要把这个方法嵌套到我们的for循环里面去，以保证在llistfile1的遍历过程中，如果再次遇到了文件夹，就以该文件夹为形参，调用递归方法，递归结束后我们将集合dirListrec中保存的所有路径合并到list中，这里使用到了

list.addAll(dirListrec)

集合合并方法，这时我们的递归方法就完成了，跑一下程序试一下

	public List<String> dirListrec(String dir){//递归
		List<String> list=new LinkedList<String>();
		File file=new File(dir);
		list.add(file.getAbsolutePath());
		File[] listfile1=file.listFiles();
		if(listfile1!=null&&listfile1.length!=0)
		{
			for(File f:listfile1) {
				if(f.isDirectory()) {
					List<String> dirListrec=dirListrec(f.getAbsolutePath());
					list.addAll(dirListrec);
					continue;
				}
				list.add(f.getAbsolutePath());
			}
		}
		return list;
	}

在这里插入图片描述我没有一个一个数程序个数确定是不是真正全部打印出来啊不过应该是没问题了，如果有问题请指正啊

--------------------------------------------------------------栈方法--------------------------------------------------------------------------
当我们掌握整体思想后，使用其他方法理解起来就并不难了，我们尝试利用栈的方法完成题目要求，毕竟递归与栈都有明确的顺序前后关系，方法几乎一模一样
我们遵循一个原则
出栈存到集合中，遇到文件夹就进栈，栈不空不停
相对于递归方法，栈的使用略微简化了思路，代码量几乎没有得到简化
PS:此时想找个可以看内存使用的工具结果折腾老半天没弄成，成功了后比较下内存使用和时间使用再更新博客

	public List<String> dirListsta(String dir){//栈
		List<String> list=new LinkedList<String>();
		Stack<File> stack=new Stack<File>();
		File file=new File(dir);
		list.add(file.getAbsolutePath());
		stack.push(file);
		//list.add(file.getAbsolutePath());
		while(!stack.empty()) {
			File popfile=stack.pop();
			File[] listfile2=popfile.listFiles();
			if(listfile2==null||listfile2.length==0) continue;
			for(File f:listfile2) {
				if(f.isDirectory()) {
					stack.push(f);
				}
				list.add(f.getAbsolutePath());
			}
		}
		return list;
		
	}

记得写主方法啊

在这里插入图片描述

---------------------------------------------------------------队列-------------------------------------------------------------------------
不多说了直接上源码，思路一致

	public List<String> dirListque(String dir){//队列
		List<String> list=new LinkedList<String>();
		Queue<File> queue=new LinkedBlockingQueue<File>();
		File file=new File(dir);
		list.add(file.getAbsolutePath());
		queue.add(file);
		while(!queue.isEmpty()) {
			File outfile=queue.remove();
			File[] listfile3=outfile.listFiles();
			if(listfile3==null||listfile3.length==0) continue;
			for(File f:listfile3) {
				if(f.isDirectory()) {
					queue.add(f);
				}
				list.add(f.getAbsolutePath());
			}
		}
		return list;
	}

三种方法均可以完成目录下所有文件的打印
在这里插入图片描述

3.模仿shell的cat功能
打印一个文件的内容，我们以前写过grep的java实现，所以我们可以直接搬过来，想个办法从控制台输入绝对路径就可以了
PS：有个朋友在实现grep语句时直接利用相对路径完成了当前目录下文件的查找，很方便，不用找绝对路径了，这里记下
控制台吸收整行字符串为绝对路径，别的照抄grep

package ezshell;

import java.io.BufferedReader；
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class cat {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		System.out.println("请输入你需要打印内容的文件路径:");
		Scanner sc=new Scanner(System.in);
		String str1=sc.nextLine();
		File dir=new File(str1);
		BufferedReader buf=new BufferedReader(new FileReader(dir));
		String strs=null;
		while((strs=buf.readLine())!=null) {
			System.out.println(strs);
		}
		sc.close();
		buf.close();
	}
}

让我们输入路径
在这里插入图片描述回车运行
在这里插入图片描述

4.模仿shell的mkdir

package ezshell;

import java.io.File;
import java.util.Scanner;

public class mkdir {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("请输入创建文件的完整路径：");
		Scanner sc=new Scanner(System.in);
		String str=sc.nextLine();
		File file=new File(str);
		sc.close();
		file.mkdir();
		}
	}

5.模仿shell的cp功能
我这个代码是将file里面的内容复制到copy中，这是新建的file
新建的file和copy
在这里插入图片描述在这里插入图片描述
java的复制方法有很多中，这里只使用了最为常用的一种方法，使用channel类帮助转化
重点方法

outputchan.transferFrom(inputchan, 0, inputchan.size());

该方法的作用是将inputchan从0位置开始复制inputchan.size()长度到outputchan，此特殊情况为全部复制
其他就是频繁的实例化了，代码如下

package ezshell;

import java.io.*;
import java.nio.channels.FileChannel;

public class cp {
	@SuppressWarnings("resource")
	public static void copy(File source,File dest) throws IOException{
		FileChannel inputchan=null;
		FileChannel outputchan=null;
		try {
			inputchan=new FileInputStream(source).getChannel();
			outputchan=new FileOutputStream(dest).getChannel();
			outputchan.transferFrom(inputchan, 0, inputchan.size());
			}
		finally {
			inputchan.close();
		    outputchan.close();
		    }
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File file=new File("/home/victor/eclipse-workspace/ezshell/file");
		File copyfile=new File("/home/victor/eclipse-workspace/ezshell/copy");
		copy(file,copyfile);
	}
}

代码运行后
在这里插入图片描述完成任务啦
2019-08-05

一群哈士奇
关注
java输入输出流总结_Java输入输出流总结(转)
weixin_29847829的博客
02-26 846
Java语言的输入输出功能是十分强大而灵活的，美中不足的是看上去输入输出的代码并不是很简洁，因为你往往需要包装许多不同的对象。在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流....本文的目的是为大家做一个简要的介绍。流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以...
java读取输出流_Java输入输出流
weixin_32677301的博客
02-12 3169
1什么是IOJava中I/O操作主要是指使用Java进行输入，输出操作。Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.n...
Java---输入输出应用编程
aeiou123123123的博客
08-02 272
通过类File中提供的方法，可以得到文件或者目录的描述信息，包括名称、所在路径、可读性等， 还可以生成新的文件、目录、改变文件名、删除文件、列出一个目录中所有的文件或者与某个模式匹配的文件等。在Java程序中，对于数据的输入输出操作以流Stream方式进行，JavaSE提供各种各样的类用于使用相同 的方法获取不同类型的数据，程序中通过标准的方法输入或者输出数据。AIO即异步非阻塞I/O模型，无需一个线程去轮询所有IO操作的状态改变，在相应的状态改变后，系统会通知对应的线程来处理。...
java中输入输出流的简单应用
老孟的技术博客
04-04 928
程序一：
Java之输入输出流
weixin_40645546的博客
10-21 570
demo：将“张三 89 李四 91 王五 83 刘六 100”此条记录写入"C:\\Demo"的"demo1.txt"，再读出此文件，计算这四人的成绩总和。      
Java 输入输出流简介和应用 (Java实现序列化工具类)
trigger的博客
11-29 580
Java 流相关的类都封装在 java.io 包中，而且每个数据流都是一个对象。序列化：将一个实例对象序列化为字节数组并返回，或者将该字节数组保存在本地。 反序列化：将一个字节数组反序列化为对象并返回，或者将本地的文件读取到内存中并且转成对象返回。
Java常见应用（五）：文件输入输出
JohnnyLin
03-16 226
文件的基本操作 File的构造方法 Modifier and Type Method Description boolean createNewFile() Atomically creates a new, empty file named by this abstract pathname if and only if a file with this name does not yet exist. boolean delete() Deletes the file or dir
Java输入输出流Java输入输出流.doc
06-10
Java 输入输出流（I/O 流）是Java编程语言中处理数据传输的核心概念。Java I/O 流系统设计得非常灵活且功能强大，能够处理不同类型的输入和输出，包括文件操作、标准输入输出、网络数据流、字符串流、对象流以及压缩...
Java实验五输入输出流
最新发布
02-19
### Java实验五输入输出流知识点解析 #### 一、实验目的 本次实验旨在帮助学习者深入理解文件和数据流的基本概念及其在Java中的应用。通过实际操作，掌握Java提供的各种字节流类和字符流类的功能与使用方法，具体...
java输入输出流的简单例子
11-11
这个简单的例子展示了Java输入输出流的基本用法，实际应用中，我们可以根据需求选择不同的流类型和操作方式，例如处理网络数据传输、内存缓冲、压缩解压等复杂场景。理解并熟练掌握Java的输入输出流，对于进行任何...
JAVA输入输出流在文件中的应用
商山居士
06-10 236
前面把最基本的输入输出流的概念性东西说过了，今天主要说明一下文件输入输出在文件中最基本的应用，先看文件的创建和基本的方法应用 import java.io.File; /** * 文件的基本操作 * * @author 王伟 * */ public class FileDemo { public static void main(String args...
java的输入输出函数_Java输入输出流的使用详细介绍
weixin_42493325的博客
02-12 581
例子：import java.io.File;import java.io.IOException;public class TestFile {public static void main(String args[]) throws IOException {File dir = new File("\\root");File f1 = new File(dir, "fileOne.txt")...
1,2,3，.....n 的栈的所有输出情况
九术沫的博客
10-25 1384
栈的最鲜明的特征就是 先进后出 判断一个按从小到大输入栈的序列是否为栈的输出 规则为，在数 n 的后面(n > 2), 后1 ，2，3 ，n-1的排列得是降序 数的排列得是降序 例如进栈的顺序是1234 那么 4 2 3 1 是不可能的 因为 在 4 的后面 1，2，3 这三个数只能 排成 3 2 1 还如 3 1 2 4 ，也是不对的 ，在3 的后面 1 2 得按降序的来 按 2 ...
复习一下栈的基本操作
木凡_Denius
11-15 2552
题目描述 对输入整数序列1 2 3 ..执行一组栈操作，输出操作的出栈序列。 输入 每行是一个测试用例，表示一个操作序列。操作序列由P和Q两个符号组成，P表示入栈，Q表示出栈。每个操作序列长度不超过1000。 输出 对每个操作序列，输出出栈序列，若操作序列有错误，如栈空时执行出栈操作，输出error。 样例输入 PQPPQQPPPQ
栈的基本操作（C语言入栈，出栈，打印栈内元素，打印栈顶元素）
qq_60304505的博客
02-09 5544
栈的基本操作（C语言入栈，出栈，打印栈内元素，打印栈顶元素）
从终端输入一组数据进行进栈、出栈操作并将其结果打印出来（采用顺序栈的方式）
jilily的专栏
11-07 2561
利用栈的基本知识进行简单程序的编程，从终端输入数据经压栈、出栈操作。最后将其列印出来。  #include#define MaxSize 10typedef int BOOL;typedef  struct stack{         int Top,MaxStack;         int  Element[MaxSize];        }Stack;void Creat_Sta
（数据结构）建立链栈，将一组数据入栈，然后再分别出栈并输出。
qq_46426180的博客
10-08 1610
#include <stdio.h> #define datatype char #define MAXSIZE 100 #define NULL '\0' typedef struct { datatype data[MAXSIZE]; int top; }SEQSTACK; void initstack(SEQSTACK *s) { s->top=-1;//赋值 } void push(SEQSTACK *s,datatype x)//入栈 { if(s->top
假设栈的输入序列为1、2、3、...、n，求出所有可能的出栈序列
热门推荐
blackfrog_unique的专栏
11-27 1万+
假设栈的输入序列为1、2、3、...、n，设计算法求出所有可能的出栈序列（合法序列）。  比如 n = 4，出栈序列可能有1 2 3 4 ， 1 2 4 3 ， 1 4 3 2 ， 1 3  4 2等等   我使用递归来完成，主要思想：从1到n输入，每一个数只对应两个操作，一个是入栈，一个是出栈（输出），我用一个栈保存入栈元素，一个数组保存出栈元素（这里也可以使用栈，但是输出元素时，需要从
入栈出栈的基本操作
galaxyrt的博客
11-06 6728
入栈和出栈的基本操作 描述 输入一个整数序列a1,a2,a3...,an。当ai不等于-1时将ai进栈；当ai=-1时，输出栈顶元素并将其出栈。 输入 多组数据，每组数据有两行，第一行为序列的长度n，第二行为n个整数，整数之间用空格分隔。当n=0时输入结束。 输出 对于每一组数据输出若干行。每行为相应的出栈元素。当出栈异常时，输出“POP ERROR”并结束本组数据的输出。 输入样例 1 5 1 2 -1 -1 1 5 1 -1 -1 2 2 0 输出样例： 2 1 1 POP E.
Java输入输出流详解与应用
Java输入输出系统的设计非常灵活，允许开发者根据需要选择适当的流类型来处理数据。这些流类的组合和扩展使得Java成为处理各种输入输出任务的强大工具，无论是简单的文件操作还是复杂的网络通信。通过深入理解和熟练...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值