Lesson_for_java_day17--java中的IO流(IO基本流、键盘输入、管道流、文件及文件夹操作、Properties类、切割文件、记录软件运行次数)

本文主要是介绍Lesson_for_java_day17--java中的IO流(IO基本流、键盘输入、管道流、文件及文件夹操作、Properties类、切割文件、记录软件运行次数)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

IO基本流：

字符流：读操作：Reader 字符输入流  抽象类Reader r = new FileReader(File f);构造方法：FileReader(File file) ；FileReader(String fileName) ；方法：//读取一个字符并以整数的形式返回(0~255),//如果返回-1已到输入流的末尾。int read() throws IOException//读取一系列字符并存储到一个数组buffer，//返回实际读取的字符数，如果读取前已到输入流的末尾返回-1int read(char[] cbuf) throws IOException//关闭流释放内存资源void close() throws IOException写操作：Writer 字符输出流  抽象类构造方法：FileWriter(File file) 根据给定的 File 对象构造一个 FileWriter 对象。 FileWriter(File file, boolean append) 根据给定的 File 对象构造一个 FileWriter 对象。 FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象。 FileWriter(String fileName, boolean append) 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造FileWriter 对象。 基本方法//向输出流中写入一个字符数据,该字节数据为参数b的低16位void write(int c) throws IOException//将一个字符类型的数组中的数据写入输出流，void write(char[] cbuf) throws IOException//将一个字符串中的字符写入到输出流void write(String string) throws IOException//关闭流释放内存资源void close() throws IOException //将输出流中缓冲的数据全部写出到目的地void flush() throws IOException处理流：缓存区--内存当中的一小块区域（直接从文件读取快还是从缓存区读取快？）字节缓存流   BufferedInputStream  BufferedOutputStream字符缓存流   BufferedReader  BufferedWriterBufferedInputStream 字节输入缓存流 构造方法BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。基本方法read() int read(byte[] b) BufferedOutputStream 字节输出缓存流 从程序写到缓存区，如果要写到文件里面需要有一个动作flush()构造方法BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。基本方法write(int b) 将指定的字节写入此缓冲的输出流。write(byte[] b) 将指定的字节数组写入此缓冲的输出流。flush() 刷新此缓冲的输出流。BufferedReader 字符输入缓存流构造方法BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流基本方法int read();   读取单个字符。int read(char[] cbuf);  将字符读入数组String readLine();  读取一个文本行。BufferedWriter 字符输出缓存流构造方法BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。基本方法write(int c) 写入单个字符。write(char[] c) 写入字符数组。write(String s) 写入字符串。 newLine() 写入一个行分隔符。转换流：InputStreamReader  是字节流通向字符流的桥梁构造方法InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。InputStreamReader(InputStream in, String charsetName) 创建使用指定字符集的 InputStreamReader。基本方法int read();  读取单个字符。int read(char[] cbuf);  读取字符数组，返回的是长度。OutputStreamWriter构造方法OutputStreamWriter(OutputStream out) 创建使用默认字符编码的 OutputStreamWriter。OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的 OutputStreamWriter。基本方法write(int c) 写入单个字符。write(char[] cbuf) 写入字符数组。write(String str) 写入字符串。--------------------------------------------------
数据流：DataInputStream构造方法：DataInputStream(InputStream in) ；基本方法boolean readBoolean() byte readByte() double readDouble() float readFloat() int readInt() long readLong() short readShort() String readUTF() DataOutputStream构造方法：DataOutputStream(OutputStream out) 基本方法boolean writeBoolean() byte writeByte() double writeDouble() float writeFloat() int writeInt() long writeLong() short writeShort() String writeUTF() 

一、键盘输入输出流：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;/*读取键盘录入System.out:对应的是标准的输出设备，控制台System.in:对应的是标准输入设备，键盘需求：通过键盘录入数据，当录入一行数据后，就将该行数据进行打印，如果录入的数据是over，那么停止录入流操作的基本规律：最痛苦的就是流对象很多，不知道该用哪一个。通过三个明确来完成：1、明确源和目的。源：输入流。InputStream   Reader目的：输出流。 OutputStream   Writer.2、操作的数据是否是纯文本。是：字符流不是：字节流3、当体系明确后，在明确要使用哪个具体的对象通过设备来进行区分：源设备：内存，键盘，硬盘目的设备：内存，硬盘，控制台*/
public class ReaderIn {public static void main(String[] args) {BufferedReader br = null;BufferedWriter bw = null;	try {//键盘的最常见写法br = new BufferedReader(new InputStreamReader(System.in));bw = new BufferedWriter(new OutputStreamWriter(System.out));String line = null;while ((line = br.readLine()) != null) {if("over".equals(line))break;bw.write(line.toUpperCase());bw.newLine();bw.flush();}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{try {if(br != null)br.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {if(bw != null)bw.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
}

二、管道流

package io;
//管道流：可以将输入流和输出流连接在一起，形成一个管道
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;public class PipedStreamDemo {public static void main(String[] args) {// TODO Auto-generated method stubPipedInputStream in = null;PipedOutputStream out = null;try {in = new PipedInputStream();out = new PipedOutputStream();in.connect(out);      //将输入流和输出流连接Read r = new Read(in);Write w = new Write(out);new Thread(r).start();new Thread(w).start();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}		}
}//输入流
class Read implements Runnable{private PipedInputStream in = null;public Read(PipedInputStream in) {// TODO Auto-generated constructor stubthis.in = in;}public void run() {// TODO Auto-generated method stubtry {byte[] buf = new byte[1024];System.out.println("读取前。。。。没有数据阻塞");int len = in.read(buf);System.out.println("读到数据。。。。阻塞结束");String s = new String(buf,0,len);System.out.println(s);} catch (Exception e) {// TODO: handle exceptione.printStackTrace();}finally{try {if(in != null)in.close();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
}//输出流
class Write implements Runnable{private PipedOutputStream out = null;public Write(PipedOutputStream out) {// TODO Auto-generated constructor stubthis.out = out;}public void run() {// TODO Auto-generated method stubtry {System.out.println("休眠5秒");Thread.sleep(5000);byte[] b = "piped lai le".getBytes();out.write(b,0,b.length);} catch (Exception e) {// TODO: handle exceptione.printStackTrace();}finally{try {if(out != null)out.close();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}			}}
}

三、文件及文件夹操作：

查询：

package file;import java.io.File;/*目的：列出指定目录下文件或者文件夹，包含子目录中的内容思路：也就是列出指定目录下所有内容，因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。在列出过程中出现的还是目录的话，还可以再次调用本功能，也就是函数自身调用自身。这种表现形式，或者编程手法成为递归。递归要注意：1、限定条件2、要注意递归的次数，尽量避免内存溢出。*/
public class FileDemo3 {public static void main(String[] args) {// TODO Auto-generated method stubFile dir = new File("E:/eclipseWorkspace/github/java");showDir(dir);}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]);elseSystem.out.println(files[x]);//打印文件名称}}}

建立文件列表：

package file;import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;/*目的：建立一个java文件列表文件思路：1、对指定的目录进行递归2、获取递归过程所有的java文件的路径3、将这些路径存储到集合中4、将集合中的数据写入到一个文件中*/
public class JavaFileList {public static void main(String[] args) {// TODO Auto-generated method stubFile dir = new File("E:/eclipseWorkspace/github/java");List<File> list = new ArrayList<File>();fileToList(dir, list);System.out.println(list.size());File file = new File("E:/eclipseWorkspace/github/java/sonyi_20/javaListFile.txt");writeToFile(list,file.toString());}public static void fileToList(File dir, List<File> list){//System.out.println(dir.getName());File[] files = dir.listFiles();for(File file: files){if(file.isDirectory()){fileToList(file, list);}else {if(file.getName().endsWith(".java"))//System.out.println(file.getName());list.add(file);}}}public static void writeToFile(List<File> list,String javaListFile){BufferedWriter bw = null;try {bw = new BufferedWriter(new FileWriter(javaListFile));for(File f : list){String path = f.getAbsolutePath();//System.out.println(path);bw.write(path);bw.newLine();bw.flush();}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{try {if(bw != null)bw.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
}

删除：

package file;import java.io.File;/*目的：删除一个带内容的目录：删除原理：在windows中，删除目录从里面往外面删除的既然是从里往外删除，就需要用到递归。*/
public class RemoveDir {public static void main(String[] args) {File dir = new File("e:/delete");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() + "::" + files[x].delete());		}System.out.println(dir + ":: dir ::" + dir.delete());}}

四、Properties类：

package file;import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;/*Properties是hashtable的子类。也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。Properties是集合和IO技术相结合的集合容器。该对象的特点：可以用于键值对形式的配置文件，那么在加载数据时，需要数据有固定格式:键-值*/
public class PropertiesDemo {public static void main(String[] args) {//setAndGet();//method_1();loadDemo();}public static void loadDemo(){Properties prop = new Properties();FileInputStream fis = null;FileOutputStream fos = null;try {fis = new FileInputStream("info.txt");prop.load(fis);//将流中的数据加载到集合中//System.out.println(prop);prop.setProperty("wangwu", "15");//只在内存中修改prop.list(System.out);//将在内存中修改后的信息存储到硬盘的文件内fos = new FileOutputStream("info.txt");prop.store(fos, "heheh");} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}//演示：如何将流中的数据存储到集合中//想要将info.txt中键值对数据存储到集合中进行操作/*思路：1、用一个流和info.txt文件相关联2、读取一行数据，将该行数据用"="进行切割3、等号左边作为键，右边作为值，存入到properties集合中即可。*/public static void method_1(){BufferedReader br = null;try {br = new BufferedReader(new FileReader("info.txt"));String line = null;Properties prop = new Properties();while((line = br.readLine()) != null){//System.out.println(line);String[] arr = line.split("=");prop.setProperty(arr[0], arr[1]);}System.out.println(prop);} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{try {if(br != null)br.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}	}//设置和获取元素public static 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> name = prop.stringPropertyNames();for(String s : name){System.out.println(s + ": " + prop.getProperty(s));}}}

练习一：记录软件运行次数

package file;import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;/*目的：记录一个软件的运行次数，并达到一定次数后，给出相应的提示信息思路：用于记录应用程序运行次数。如果使用次数已经达到，那么给出注册提示很容易想到的是计数器，可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行了自增。可是随着该应用程序的退出，该计数器也在内存中消失了。下一次再启动该程序，又重新开始从0计数。这样不是我们想要的。程序即使结束，该计数器的值也存在，下一次程序启动会先加载该计数器的值，并加1后重新存储起来。所以要建立一个配置文件，用于记录该软件的使用次数。该配置文件使用键值对的形式。这样便于阅读数据并操作数据。键值对数据是map集合。数据是以文件的形式存储，使用IO技术。那么map+io就是properties，配置文件可以实现应用程序的共享。*/
public class RunCount {public static void main(String[] args) {Properties prop = new Properties();FileInputStream fis = null;FileOutputStream fos = null;File file = new File("count.ini");	try {if(!file.exists())file.createNewFile();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 + "");fos = new FileOutputStream(file);prop.store(fos, "记录程序使用次数");} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{try {if(fis != null)fis.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {if(fos != null)fos.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
}

练习二：切割文件

package file;import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
//目的：将一mp3文件切割成几份存储，然后再将这几份文件合并成一个mp3文件。
public class SplitFile {public static void main(String[] args) {// TODO Auto-generated method stub//splitFile();merge();}//合并文件public static void merge(){ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();int count = 1;try {for(int x = 0; x < 6; x++){al.add(new FileInputStream("切割" + (count++) + ".part"));}} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}final Iterator<FileInputStream> it = al.iterator();Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {public boolean hasMoreElements() {// TODO Auto-generated method stubreturn it.hasNext();}public FileInputStream nextElement() {// TODO Auto-generated method stubreturn it.next();}		};SequenceInputStream sis = null;FileOutputStream fos = null;try {sis = new SequenceInputStream(en);fos = new FileOutputStream("复制1.mp3");byte[] buf = new byte[1024];int len = 0;while ((len = sis.read(buf)) != -1) {fos.write(buf,0,len);}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{try {if(sis != null)sis.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {if(fos != null)fos.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}		}}//切割文件public static void splitFile(){FileInputStream fis = null;FileOutputStream fos = null;File f = null;try {f = new File("1.mp3");System.out.println(f.exists());fis = new FileInputStream(f);byte[] buf = new byte[1024*1024];int len = 0;int count = 1;while((len = fis.read(buf)) != -1){System.out.println(buf.toString());fos = new FileOutputStream("切割" + (count++) + ".part");fos.write(buf,0,len);fos.close();}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{try {if(fis != null)fis.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {if(fos != null)fos.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
}

这篇关于Lesson_for_java_day17--java中的IO流(IO基本流、键盘输入、管道流、文件及文件夹操作、Properties类、切割文件、记录软件运行次数)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---