JAVA IO实例(经典)
java之IO技术
java之IO技术java的输出功能来自java.io包的InputStream类,OutputStream类,read 类和writer类,以及继承他们的各种子类,这些类以流的形式处理数据。
1.Inputstream类Inputstream类是字节输入流的抽象类,是所有字节输入的父类。
2.Outputstream类Outputstream类是字节输出流的抽象类,是所有字节输入的父类。
3.Reader类该类是字符输入流的抽象类,定义了操作字符输入流的各种方法4.Writer类用于解决字符输出流的类下面是使用上述类的例子代码public class ShuRuShuChu {public static void main(String [] args){ /*InputStream is=System.in;byte[] b=new byte[50];try {System.out.println("请输入内容 ");is.read(b);is.read(b,1,3);System.out.println(new String(b).trim());System.out.println(is.available());is.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}*/ShuRuShuChu ac=new ShuRuShuChu();//ac.intPut();//ac.outPut();//ac.intPutread();ac.outPutwriter();}void outPut(){OutputStream out=System.out;try{String ass="456789";byte[] s=ass.getBytes();//byte[] s="ssyssyss".getBytes();out.write(s);out.close();}catch(IOException e){System.out.println("写入有误");}}void intPut(){InputStream is=System.in;byte[] b=new byte[50];try {System.out.println("请输入内容 ");is.read(b);//is.read(b,1,3);System.out.println(new String(b).trim());System.out.println(is.available());is.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}void intPutread(){InputStreamReader ri=new InputStreamReader(System.in);char[] sd=new char[50];try{System.out.println("duru");ri.read(sd);ri.markSupported();System.out.println(ri.markSupported());String str=new String(sd);System.out.println(str);ri.close();}catch(IOException e){System.out.println("读入错误");}}void outPutwriter(){Writer writer=new PrintWriter(System.out);try{char ar[]="nisdshidfa".toCharArray();writer.write(ar);writer.flush();writer.close();}catch(IOException e){}}}5.文件字节输入/输出流文件字节输入流可以从指定路径的文件中读取字节数据。
iogame java 案例
iogame java 案例摘要:1.IO游戏简介2.Java编程语言简介3.IO游戏Java案例解析4.案例分析:游戏架构与核心玩法5.技术实现:网络通信与数据处理6.总结与拓展正文:IO游戏在近年来逐渐成为了一种热门的游戏类型,其特点是简单易懂、竞技性强,深受玩家喜爱。
而Java作为一种广泛应用于游戏开发的编程语言,更是开发者们的首选。
本文将为大家详细解析一个IO游戏的Java案例,分析其游戏架构、核心玩法,并探讨技术实现方面的问题。
1.IO游戏简介IO游戏,顾名思义,是指以互联网为基础,支持多人在线对战的游戏。
这类游戏通常具有快速响应、实时互动的特点,能够让玩家在短时间内体验到竞技的快感。
代表性的IO游戏有《Agario》、《Botzilla》等。
2.Java编程语言简介Java是一种面向对象的编程语言,具有跨平台、高效、安全等特点。
在游戏开发领域,Java有着广泛的应用。
许多知名的游戏引擎,如Unity3D,都支持使用Java进行编程。
此外,Java的生态系统丰富,有许多优秀的游戏开发库和框架,如Spike、LWJGL等。
3.IO游戏Java案例解析在这个案例中,我们以一款简单的多人在线贪吃蛇游戏为例,进行分析。
游戏的规则如下:玩家控制一个蛇形角色,通过吞食地图上的食物来增长身体,同时避免与其他玩家或自身碰撞。
游戏中,玩家需要争夺地图上的资源,竞争排名。
4.案例分析:游戏架构与核心玩法这款游戏的架构分为客户端和服务器端两部分。
客户端主要负责渲染画面、接收用户输入和发送游戏状态给服务器。
服务器端负责处理玩家间的互动、游戏状态同步和排行榜更新。
核心玩法包括:- 蛇形角色的移动和增长:玩家通过键盘或触摸屏控制蛇头方向,蛇头碰到食物后,尾部加入新食物,身体长度增加。
- 碰撞检测:蛇头碰到墙壁或自身、其他玩家时,游戏结束。
- 排行榜:根据玩家吞食食物的数量和游戏时长,实时更新排行榜。
5.技术实现:网络通信与数据处理游戏中,客户端与服务器之间的通信采用TCP/IP协议。
PPT26JavaIOJava程序设计实战案例教程
I/O流的分类
按照操作数据类型的不同,可以分为 字节流和字符流
按照数据传输方向的不同可分为输入 流和输出流,程序从输入流中读取数 据,向输出流中写入数据
public class BISDemo{ public static void main(String[]args)throws IOException{ // 创建一个缓冲输入流 BufferedInputStream bis=new BufferedInputStream(new FileInputStream("壁纸.jpg")); // 创建一个缓冲输出流 BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("壁纸副本.jpg")); int len=0; long bt=System.currentTimeMillis();//获取文件复制前的系统时间 while((len=bis.read())!= -1){ bos.write(len); } long et=System.currentTimeMillis();//获取文件复制后的系统时间 System.out.println("文件复制用时:"+(et-bt)+"毫秒"); bis.close(); bos.close();
在代码实现前,准备好要复制的文件,如在当前项 目目录下存放一个“壁纸.jpg“文件。复制的代码如示 例8-6所示。
字节缓冲流
java io流的用法
Java I/O(Input/Output)流用于处理输入和输出数据。
在 Java 中,I/O 操作主要通过流(Stream)来完成。
流是一个有序的数据序列,它通过连接输入和输出设备来实现数据传输。
Java 中的 I/O 流可以分为两类:1. 字节流(Byte Streams):以字节为单位进行操作,适用于处理二进制数据,比如图像、音频、视频等。
- InputStream:用于从输入流读取字节数据。
- OutputStream:用于向输出流写入字节数据。
```java// 例子:使用 FileInputStream 读取文件import java.io.FileInputStream;import java.io.IOException;public class ReadFileExample {public static void main(String[] args) {try (FileInputStream fis = new FileInputStream("example.txt")) {int data;while ((data = fis.read()) != -1) {System.out.print((char) data);}} catch (IOException e) {e.printStackTrace();}}}```2. 字符流(Character Streams):以字符为单位进行操作,适用于处理文本数据。
- Reader:用于从输入流读取字符数据。
- Writer:用于向输出流写入字符数据。
```java// 例子:使用 FileReader 读取文件import java.io.FileReader;import java.io.IOException;public class ReadFileExample {public static void main(String[] args) {try (FileReader reader = new FileReader("example.txt")) {int data;while ((data = reader.read()) != -1) {System.out.print((char) data);}} catch (IOException e) {e.printStackTrace();}}}```注意:- 在 Java 7 及以上版本,可以使用 try-with-resources 语句自动关闭资源,无需显式调用 `close` 方法。
JAVA_20
第二十课Java流式I/O编程案例:2001 节点流应用举例案例文件:Test1.java目标:通过节点流实现文件复制功能,体会JavaI/O机制代码:/ * 范例名称:节点流应用举例* 源文件名称:Test1.java* 要点:* 1. Java I/O机制* 2. FileReader/FileWriter字节流类型的使用* 3. IOException的捕获和处理*/import java.io.*;public class Test1 {public static void main(String[] args) {try {FileReader input = new FileReader("Test1.java");FileWriter output = new FileWriter("temp.txt");int read = input.read();while ( read != -1 ) {output.write(read);read = input.read();}input.close();output.close();} catch (IOException e) {System.out.println(e);}}}Java辅助案例集案例:2002 缓冲功能处理流应用举例案例文件:Test2.java目标:通过处理流实现文件复制功能,体会JavaI/O流的封装/连接机制代码:/ * 范例名称:缓冲功能处理流应用举例* 源文件名称:Test2.java* 要点:* 1. Java I/O机制* 2. FileReader-BufferedReader/FileWriter-BufferedWriter的使用* 3. I/O流的封装和连接*/import java.io.*;public class Test2 {public static void main(String[] args) {try {FileReader input = new FileReader("Test2.java");BufferedReader br = new BufferedReader(input);FileWriter output = new FileWriter("temp.txt");BufferedWriter bw = new BufferedWriter(output);String s = br.readLine();while ( s!=null ) {bw.write(s);bw.newLine();s = br.readLine();}br.close();bw.close();} catch (IOException e) {e.printStackTrace();}}}案例:2003 ByteArrayInputStream应用举例案例文件:ByteArrayInputStreamTest.java目标:使用ByteArrayInputStream类型、掌握其用法代码:/ * 范例名称:ByteArrayInputStream应用举例* 源文件名称:ByteArrayInputStreamTest* 要点:* 1. ByteArrayInputStream类型功能及用法* 2. 字节流read()方法的返回值为int型*/import java.io.*;public class ByteArrayInputStreamTest{public static void main(String args[]){int ch;String str="Create a ByteArrayInputStream";byte buf[]=str.getBytes();ByteArrayInputStream bais=new ByteArrayInputStream(buf,7,7);System.out.println("可读取的字符数:"+bais.available());while((ch=bais.read())!=-1){System.out.print((char)ch);}System.out.println();}}案例:2004 临时文件的创建及使用案例文件:CreateTemp.java目标:掌握临时文件的创建及使用方法代码:/ * 范例名称:临时文件的创建及应用举例* 源文件名称:CreateTemp.java* 要点:* 1. File类对象既可对应文件,也可对应目录* 2. File类static方法createTempFile()用法* 3. 使用完毕后关闭输入/输出流对象与数据源间连接*/Java辅助案例集import java.io.*;public class CreateTemp{public static void main(String args[]){try{//创建File对象path,使之对应temp相对目录File path=new File("temp");//在path路径下创建临时文件"myfileXXXX.tmp"//XXXX 是系统自动产生的随机数, path对应的路径temp应事先存在File tempFile=File.createTempFile("myfile",".tmp",path);FileOutputStream fout=new FileOutputStream(tempFile);PrintStream out=new PrintStream(fout);out.println("安静劳动法立刻犯得上");out.close(); //注意:如无此关闭语句,文件将不能删除tempFile.delete();}catch(IOException e){System.out.println(e);}}}案例:2005 LineNumberReader类应用举例案例文件:PrintLines.java目标:掌握LineNumberXXX 类型使用方法代码:/* 范例名称:LineNumberReader类应用举例* 源文件名称:PrintLines.java* 要点:* 1. LineNumberReader类的使用* 2. 通过键盘输入终止程序运行*/import java.io.*;public class PrintLines {public static void main(String args[]) {InputStreamReader is = new InputStreamReader(System.in);LineNumberReader lineCounter=new LineNumberReader(is);String nextLine=null;System.out.println("输入任意字符串后回车,空回车或输入'exit'退出:");try {nextLine=lineCounter.readLine();while(!nextLine.equals("exit")){if(nextLine.length()==0) {//if(nextLine == null) {//if(nextLine == "") {break;}System.out.print(lineCounter.getLineNumber());System.out.print(":");System.out.println(nextLine);nextLine=lineCounter.readLine();}}catch(Exception e){e.printStackTrace();}}}。
Java IO编程
java i/o原理基本概念:∙I/O(Input/Output)∙数据源(Data Source)∙数据宿(Data Sink)Java中把不同的数据源与程序间的数据传输都抽象表述为"流"(Stream),java.io包中定义了多种I/O流类型实现数据I/O功能。
I/O流分类:∙输入流(Input Stream)和输出流(Output Stream)∙节点流(Node Stream)和处理流(Processing Stream)∙字符流(Character Stream)和字节流(Byte Stream)输入流和输出流按照数据流动的方向,java流可分为输入流(Input Stream)和输出流(Output Stream)∙输入流只能从中读取数据,而不能向其写出数据;∙输出流则只能向其写出数据,而不能从中读取数据∙特例:java.io.RandomAccessFile类节点流和处理流根据数据流所关联的是数据源还是其他数据流,可分为节点流(Node Stream)和处理流(Proce ssing Stream)∙节点流直接连接到数据源∙处理流是对一个已存在的流的连接和封装,通过封装的流的功能调用实现增强的数据读/写功能,处理流并不直接连接到数据源.字符流和字节流按传输数据的"颗粒大小"划分,可分为字符流(Character Stream)和字节流(Byte Stream)∙字节流以字节为单位进行数据传输,每次传送一个或多个字节;∙字符流以字符为单位进行数据传输,每次传送一个或多个字符.Java命名惯例:凡是以InputStream或OutputStream结尾的类型均为字节流,凡是以Reader或Writer结尾的均为字符流。
InputStream抽象类java.io.InputStream是所有字节输入流类型的父类,该类中定义了以字节为单位读取数据的基本方法,并在其子类中进行了分化和实现.三个基本的read方法:∙int read()∙int read(byte[] buffer)∙int read(byte[] buffer,int offset,int length)其他方法:∙void close()∙int available()∙skip(long n)∙boolean markSupported()InputStream类层次OutputStreamjava.io.OutputStream与java.io.InputStream对应,是所有字节输出流类型的抽象父类。
java io流的用法
java io流的用法Java IO流是Java编程中重要的一部分,它提供了丰富的功能,用于处理输入和输出。
本文将介绍Java IO流的基本用法和常见操作。
一、字节流和字符流的区别在Java IO流中,有字节流和字符流两种类型。
字节流用于处理字节数据,而字符流用于处理字符数据。
虽然字符数据可以通过字节流进行处理,但字符流更适合处理文本数据,因为它能够更好地处理字符编码和换行符等特殊字符。
二、字节流的用法字节流主要包括InputStream和OutputStream两个抽象类,分别用于从输入源读取数据和向输出目标写入数据。
常用的字节流有FileInputStream、FileOutputStream和ByteArrayInputStream、ByteArrayOutputStream等。
以文件操作为例,使用字节流读取文件的基本步骤如下:1. 创建一个File对象,指定要读取的文件路径。
2. 创建一个FileInputStream对象,将File对象作为参数传入构造方法。
3. 创建一个字节数组用于存储读取到的数据。
4. 使用read()方法读取字节数据,并将读取到的数据存入字节数组中。
使用字节流写入文件的基本步骤如下:1. 创建一个File对象,指定要写入的文件路径。
2. 创建一个FileOutputStream对象,将File对象作为参数传入构造方法。
3. 创建一个字节数组,将要写入的数据转换为字节数组。
4. 使用write()方法将字节数组写入输出流。
5. 写入结束后,关闭输出流。
三、字符流的用法字符流主要包括Reader和Writer两个抽象类,用于读取和写入字符数据。
常用的字符流有FileReader、FileWriter和BufferedReader、BufferedWriter等。
使用字符流读取文件的基本步骤如下:1. 创建一个File对象,指定要读取的文件路径。
2. 创建一个FileReader对象,将File对象作为参数传入构造方法。
java中的IO整理
【案例1】创建一个新文件 ?1 2 3 4 5 6 7 8 9 10 11 import java.io.*;class hello{public static void main(String[] args) {File f=new File("D:\\hello.txt");try{f.createNewFile();}catch (Exception e) {e.printStackTrace();}}}【运行结果】:程序运行之后,在d 盘下会有一个名字为hello.txt 的文件。
【案例2】File 类的两个常量 ?1 2 3 4 5 6 7 import java.io.*;class hello{public static void main(String[] args) {System.out.println(File.separator);System.out.println(File.pathSeparator);}}【运行结果】:\;此处多说几句:有些同学可能认为,我直接在windows 下使用\进行分割不行吗?当然是可以的。
但是在linux 下就不是\了。
所以,要想使得我们的代码跨平台,更加健壮,所以,大家都采用这两个常量吧,其实也多写不了几行。
呵呵、现在我们使用File 类中的常量改写上面的代码: ?1 2 3 4 5 6 7 8 9 10 11 12 import java.io.*;class hello{public static void main(String[] args) {String fileName="D:"+File.separator+"hello.txt";File f=new File(fileName);try{f.createNewFile();}catch (Exception e) {e.printStackTrace();}}}你看,没有多写多少吧,呵呵。
java IO流讲解博客 (3)
所谓IO ,也就是Input 与Output 的缩写。
在java 中,IO 涉及的范围比较大,这里主要讨论针对文件内容的读写其他知识点将放置后续章节(我想,文章太长了,谁都没耐心翻到最后)对于文件内容的操作主要分为两大类分别是:字符流字节流其中,字符流有两个抽象类:Writer Reader其对应子类FileWriter 和FileReader 可实现文件的读写操作BufferedWriter 和BufferedReader 能够提供缓冲区功能,用以提高效率同样,字节流也有两个抽象类:InputStream OutputStream其对应子类有FileInputStream 和FileOutputStream 实现文件读写BufferedInputStream 和BufferedOutputStream 提供缓冲区功能俺当初学IO 的时候犯了不少迷糊,网上有些代码也无法通过编译,甚至风格都很大不同,所以新手请注意:1.本文代码较长,不该省略的都没省略,主要是因为作为一个新手需要养成良好的代码编写习惯2.本文在linux 下编译,类似于File.pathSeparator 和File.separator 这种表示方法是出于跨平台性和健壮性考虑3.代码中有些操作有多种执行方式,我采用了方式1...方式2...的表述,只需轻轻解开注释便可编译4.代码中并没有在主方法上抛出异常,而是分别捕捉,造成代码过长,如果仅是测试,或者不想有好的编程习惯,那你就随便抛吧……5.功能类似的地方就没有重复写注释了,如果新手看不懂下面的代码,那肯定是上面的没有理解清楚字符流实例1:字符流的写入1 2 3 4 5 6 7 8 9 10 11 12 importjava.io.File; importjava.io.FileWriter; importjava.io.IOException;publicclass Demo {public static void main(String[] args ) {//创建要操作的文件路径和名称//其中,File.separator 表示系统相关的分隔符,Linux 下为:/ Window 为:\\String path = File.separator + "home" + File.separator + "siu" File.separator + "work" + File.separ编译之后的效果:编译之后,产生life目录下的lrc.txt文件,复制成功编译之后产生的文件,以上在字符串中加\r\n就是为了便于终端显示其实在linux下面换行仅用\n即可读取文件到终端两个目录都有“一个人生活.mp3”文件,顺便说一下,这歌挺好听的初学者在学会使用字符流和字节流之后未免会产生疑问:什么时候该使用字符流,什么时候又该使用字节流呢?其实仔细想想就应该知道,所谓字符流,肯定是用于操作类似文本文件或者带有字符文件的场合比较多而字节流则是操作那些无法直接获取文本信息的二进制文件,比如图片,mp3,视频文件等说白了在硬盘上都是以字节存储的,只不过字符流在操作文本上面更方便一点而已此外,为什么要利用缓冲区呢?我们知道,像迅雷等下载软件都有个缓存的功能,硬盘本身也有缓冲区试想一下,如果一有数据,不论大小就开始读写,势必会给硬盘造成很大负担,它会感觉很不爽人不也一样,一顿饭不让你一次吃完,每分钟喂一勺,你怎么想?因此,采用缓冲区能够在读写大文件的时候有效提高效率分类: Java标签: io流。
Java编程语言中的IO编程与实际应用
Java编程语言中的IO编程与实际应用在计算机编程中,IO(Input/Output)编程是必不可少的一部分,它涉及到计算机内部的输入输出操作。
Java编程语言也提供了一套完善的IO编程体系,可以更加方便地进行文件的读写和网络通信。
本文将就Java编程语言中的IO编程进行详细介绍,并结合实际应用讲解其具体用法。
I. Java IO编程体系Java的IO编程体系由四个流(stream)类别组成:字节流(byte streams)、字符流(character streams)、标准IO流(Standard I/O streams)以及对象流(Object streams)。
其中,字节流操作的是原始的8位数据,而字符流则操作Unicode字符。
标准IO流包括了Java系统所提供的三个流对象:System.in、System.out和System.err。
而对象流则用于对Java对象进行序列化和反序列化操作。
字节流由InputStream和OutputStream两个抽象类组成,它们可以用于读写字节数据,比如音频、视频、图像等二进制文件。
字符流由Reader和Writer两个抽象类组成,它们可以用于读写Unicode字符,比如文本文件和XML文件。
标准IO流则包括了System.in、System.out和System.err三个类,它们分别代表标准输入、标准输出和标准错误输出。
对象流则分别由ObjectInputStream和ObjectOutputStream两个类组成,它们可以用于序列化和反序列化Java对象。
通过对象流,我们可以将Java对象保存到磁盘中,也可以从磁盘中读取Java对象。
II. Java IO编程实例以下是一些Java IO编程的实例,这些实例主要包括了文件读写、网络通信以及序列化操作。
1. 文件读写Java IO编程可以使用字节流和字符流来读写文件。
下面的代码演示了如何使用字符流来读取文本文件:```javaFileReader reader = new FileReader("filename.txt");BufferedReader br = new BufferedReader(reader);String line = null;while ((line = br.readLine()) != null) {System.out.println(line);}br.close();reader.close();```上述代码打开文件filename.txt,并逐行读取其中的文本内容,并输出到控制台上。
java io 用法
java io 用法Java的I/O(输入/输出)库提供了处理输入和输出操作的类和方法,用于读取和写入数据。
以下是一些常见的Java I/O用法示例:1. 读取文件内容:```javatry (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {String line;while ((line = reader.readLine()) != null) {System.out.println(line);}} catch (IOException e) {e.printStackTrace();}```上述代码使用`BufferedReader`和`FileReader`来逐行读取文件内容并将其打印到控制台。
2. 写入文件内容:```javatry (BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"))) {writer.write("Hello, World!");} catch (IOException e) {e.printStackTrace();}```上述代码使用`BufferedWriter`和`FileWriter`将字符串"Hello, World!"写入到文件中。
3. 读取用户输入:```javatry (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {System.out.println("Enter your name:");String name = reader.readLine();System.out.println("Hello, " + name + "!");} catch (IOException e) {e.printStackTrace();}```上述代码使用`BufferedReader`和`InputStreamReader`从控制台读取用户输入的名称,并将其与"Hello, "拼接后打印出来。
Java之IO(四)DataInputStream和DataOutputStream
Java之IO(四)DataInputStream和DataOutputStream 转载请注明源出处:1.前⾔ DataInputStream和DataOutputStream分别继承了FilterInputStream和FilterOutputStream,这块内容在第⼆节介绍BufferedInputStream和BufferedOutputStream的时候介绍过了,这⾥不再介绍。
Java中针对于IO有许多现有的封装类可以使⽤,但是每个封装类都有各⾃的特点,使⽤场景不⼀样。
本章介绍的这对IO还实现了其它的接⼝,DataInput和DataOutput。
之前所讲到的流都是字节流,但是实际上对我们⽽⾔,字节流是没有什么太⼤的意义,单个字节⼈是⽆法知道含义的,所以通常需要对字节进⾏解析,获取真正有价值的意义。
⽽这对流就完成了⼀个对基本数据类型(boolean,byte,unsignedByte,short,unsignedShort,char,int,long,float,double)的写⼊和读取和⼀些常⽤的读⼀⾏,读取UTF格式等⽅法,不需要我们⾃⼰重复写。
当然Java的IO体系针对字符流有专门的Reader和Writer进⾏操作字符流。
这在之后的章节进⾏介绍。
2.DataInputStream DataInputStream需要接受⼀个输⼊源流。
这些基础的InputStream的⽅法都是使⽤输⼊源的基本⽅法。
这些⽅法其实也⼗分的简单,都是针对每个类型的特点,将其读取出来,当然写⼊流的时候也要这样才⾏。
// 读取⼀个整形,根据是否为0返回boolean值public final boolean readBoolean() throws IOException {int ch = in.read();if (ch < 0)throw new EOFException();return (ch != 0);}// 读取⼀个整形,转成byte类型(实际上存的就是byte类型)public final byte readByte() throws IOException {int ch = in.read();if (ch < 0)throw new EOFException();return (byte)(ch);}// 读取⼀个整形,直接返回就是⽆符号的byte类型值了public final int readUnsignedByte() throws IOException {int ch = in.read();if (ch < 0)throw new EOFException();return ch;}// 读取两个字节,short是占两个字节,把第⼀读出来的左移8位到⾼8位。
Java文件IO技术应用实例
Java文件IO技术应用实例1.1.1请设计一个能够获得某各文件的属性(比如文件的大小、文件所在目录等方面的信息)的Java程序1、程序的代码实例import java.io.*;public class FileInfo{public static void main(String[] args) {if(args.length!=1){System.out.println("Please enter your file name!");System.exit(1);}File f=new File(args[0]);System.out.println("Absolute path: " + f.getAbsolutePath() +"\n Can read: " + f.canRead() +"\n Can write: " + f.canWrite() +"\n getName: " + f.getName() +"\n getParent: " + f.getParent() +"\n getPath: " + f.getPath() +"\n length: " + f.length() +"\n lastModified: " + stModified());if(f.isFile())System.out.println("It's a file");else if(f.isDirectory())System.out.println("It's a directory");}}2、程序的执行结果1.1.2请设计一个能够实现文件拷贝功能的Java程序1、程序的代码实例import java.io.*;public class CopyFile{public static void main(String[] args){File sour=new File(args[0]);File dest=new File(args[1]);StringBuffer sb = new StringBuffer();if(!sour.exists()){System.out.println("Source file isn't exists!");System.exit(1);}if(!dest.exists()){System.out.println("Destination directory isn't exists,create it?y/n");try{char c;c=(char)System.in.read();if(c=='n') System.exit(1);dest.mkdirs();}catch(IOException e){System.out.println(e.toString());} }try{BufferedReader in = new BufferedReader(new FileReader(sour));String s;while((s = in.readLine()) != null) {sb.append(s);sb.append("\n");}in.close();File f=new File(dest,sour.getName());f.createNewFile();PrintWriter out = new PrintWriter( new BufferedWriter(new FileWriter(f)));out.print(sb.toString());out.close();}catch(IOException e){System.out.println(e.toString());}}}2、程序的执行结果1.1.3请设计一个能够实现打印输出某个文本文件的内容的Java程序1、程序的代码实例import java.io.*;public class OutputFile{public static void main(String[] args ){String s;try {BufferedReader in = new BufferedReader(new FileReader(args[0]));while((s = in.readLine())!= null )System.out.println(s);} catch(EOFException e) {System.err.println("End of stream"); }catch(IOException e) {System.err.println("End of stream"); } }}2、程序的执行结果1.1.4请设计一个能够实现随机读写文件内容的Java程序1、程序的代码实例import java.io.*;public class RandomFile{public static void main(String args[]){try{RandomAccessFile rf =new RandomAccessFile(args[0], "rw");for(int i = 0; i < 10; i++) rf.writeDouble(i*1.414);rf.close();rf = new RandomAccessFile(args[0], "rw");rf.seek(5*8);rf.writeDouble(47.0001);rf.close();rf = new RandomAccessFile(args[0], "r");for(int i = 0; i < 10; i++)System.out.println("Value " + i + ": " +rf.readDouble());rf.close();}catch(IOException e){ System.out.println(e.toString());}}}2、程序的执行结果。
java io处理方式
java io处理方式全文共四篇示例,供读者参考第一篇示例:Java是一种流行的编程语言,广泛用于开发各种类型的应用程序。
在Java编程中,I/O操作是一个非常重要的方面,因为它涉及到应用程序和外部资源(如文件、网络连接等)之间的数据交互。
Java提供了丰富的I/O处理方式,以满足不同场景下的需求。
本文将介绍Java中常用的几种I/O处理方式,并进行详细说明。
1. 输入流和输出流在Java中,I/O操作主要是通过流(stream)来实现的。
流是一个顺序的数据序列,它可以用来读取或写入数据。
Java中的流分为输入流和输出流两种类型。
输入流用于读取数据,输出流用于写入数据。
通过将输入流和输出流进行组合,可以实现数据的双向传输。
Java提供了一系列的输入流和输出流类来支持不同类型的I/O操作。
2. 文件I/O文件I/O是Java中最常见的I/O操作之一。
通过文件I/O,可以读取和写入文件中的数据。
Java提供了FileInputStream和FileOutputStream两个类,用于读取和写入文件中的二进制数据。
Java也提供了FileReader和FileWriter两个类,用于读取和写入文件中的字符数据。
通过这些类,可以轻松实现文件的读取和写入操作。
3. 缓冲流缓冲流是一种性能优化的流处理方式。
在进行大量数据读写时,直接使用输入流或输出流可能会造成性能上的损耗。
为了提高性能,Java提供了BufferedInputStream和BufferedOutputStream两个类,用于对输入流和输出流进行缓冲处理。
通过缓冲流,可以减少I/O操作和系统调用的次数,从而提高数据的读写效率。
4. 字节流和字符流5. 序列化序列化是一种将对象转换为字节流的过程,用于对象的持久化存储或网络传输。
在Java中,可以通过实现Serializable接口来实现对象的序列化。
通过ObjectInputStream和ObjectOutputStream两个类,可以实现对象的序列化和反序列化操作。
java.io.包内常用类及方法
例:String inputLine = scan.nextLine();StringTokenizer wordFinder =new StringTokenizer(inputLine, " \n.,");while(wordFinder.hasMoreTokens()){System.out.println(wordFinder.nextToken());}(2)FileReader注意:可以接文件名。
二、二进制文件(Binary File)1、输出(output)类(to the file)(1)ObjectOutputStream注意:不可以接文件名,可通过套用FileReader来实现。
例如:ObjectOutputStream outputStream=new ObjectOutputStream(new FileOutputStream("numbers.dat"));常用方法:writeInt(int n),writeDouble(double x),writeBoolean(boolean b),writeUTF(String s),writeChar((int) 'A')写入数值,close():保存并关闭文件。
(2)FileOutputStream注意:可以接文件名。
2、输入(input)类(from the file)(1)ObjectInputStream注意:不可以接文件名,可通过套用FileReader来实现。
例如:ObjectInputStream inStream =new ObjectInputStream (new FileInputStream("numbers.dat"));常用方法:readInt(),readDouble(),readBoolean()读取数值,close():保存并关闭文件。
JAVA操作实例大全(完整版)
10.读取文件属性?1 2 3 4 5 6 7 8 910111213141516171819 //import java.io.*;// 文件属性的取得File af = new File(%%1);if(af.exists()) {System.out.println(f.getName() + "的属性如下:文件长度为:"+ f.length()); System.out.println(f.isFile() ? "是文件": "不是文件");System.out.println(f.isDirectory() ? "是目录": "不是目录");System.out.println(f.canRead() ? "可读取": "不");System.out.println(f.canWrite() ? "是隐藏文件": "");System.out.println("文件夹的最后修改日期为:"+ new Date(stModified())); } else{System.out.println(f.getName() + "的属性如下:");System.out.println(f.isFile() ? "是文件": "不是文件");System.out.println(f.isDirectory() ? "是目录": "不是目录");System.out.println(f.canRead() ? "可读取": "不");System.out.println(f.canWrite() ? "是隐藏文件": "");System.out.println("文件的最后修改日期为:"+ new Date(stModified())); }if(f.canRead()){%%2}if(f.canWrite()){%%313.复制文件夹?1 2 3 4 5 6 7 8 9101112131415161718 //import java.io.*;//import java.util.*;LinkedList<String> folderList = new LinkedList<String>();folderList.add(%%1);LinkedList<String> folderList2 = new LinkedList<String>();folderList2.add(%%2+ %%1.substring(%%stIndexOf("//")));while(folderList.size() > 0) {(new File(folderList2.peek())).mkdirs(); // 如果文件夹不存在则建立新文件夹File folders = new File(folderList.peek());String[] file = folders.list();File temp = null;try{for(int i = 0; i < file.length; i++) {if(folderList.peek().endsWith(File.separator)) {temp = new File(folderList.peek() + File.separator+ file[i]);} else{temp = new File(folderList.peek() + File.separator+ file[i]);}if(temp.isFile()) {FileInputStream input = new FileInputStream(temp);1920212223242526272829303132333435363738 FileOutputStream output = new FileOutputStream( folderList2.peek() + File.separator+ (temp.getName()).toString());byte[] b = new byte[5120];int len;while((len = input.read(b)) != -1) {output.write(b, 0, len);}output.flush();output.close();input.close();}if(temp.isDirectory()) {// 如果是子文件夹for(File f : temp.listFiles()) {if(f.isDirectory()) {folderList.add(f.getPath());folderList2.add(folderList2.peek()+ File.separator + f.getName());}}}}} catch(Exception e) {//System.out.println("复制整个文件夹内容操作出错");5 6 7 8 9101112131415161718192021222324 if(copyfoldersList[k].isDirectory()){ArrayList<String>folderList=new ArrayList<String>();folderList.add(copyfoldersList[k].getPath());ArrayList<String>folderList2=new ArrayList<String>();folderList2.add(%%2+"/"+copyfoldersList[k].getName());for(int j=0;j<folderList.length;j++){(new File(folderList2.get(j))).mkdirs(); //如果文件夹不存在则建立新文件夹File folders=new File(folderList.get(j));String[] file=folders.list();File temp=null;try{for(int i = 0; i < file.length; i++) {if(folderList.get(j).endsWith(File.separator)){temp=new File(folderList.get(j)+"/"+file[i]);}else{temp=new File(folderList.get(j)+"/"+File.separator+file[i]);}FileInputStream input = new FileInputStream(temp);if(temp.isFile()){FileInputStream input = new FileInputStream(temp);FileOutputStream output = new FileOutputStream(folderList2.get(j) + "/"+ (temp.getName()).toString());byte[] b = new byte[5120];1213141516171819202122232425262728293031 temp = new File(folderList.peek() + File.separator + file[i]);} else{temp = new File(folderList.peek() + File.separator + file[i]);}if(temp.isFile()) {FileInputStream input = new FileInputStream(temp); FileOutputStream output = new FileOutputStream( folderList2.peek() + File.separator+ (temp.getName()).toString());byte[] b = new byte[5120];int len;while((len = input.read(b)) != -1) {output.write(b, 0, len);}output.flush();output.close();input.close();if(!temp.delete())System.out.println("删除单个文件操作出错!");}if(temp.isDirectory()) {// 如果是子文件夹for(File f : temp.listFiles()) {3233343536373839404142434445464748495051 if(f.isDirectory()) {folderList.add(f.getPath());folderList2.add(folderList2.peek()+ File.separator + f.getName());}}}}} catch(Exception e) {// System.out.println("复制整个文件夹内容操作出错");e.printStackTrace();}folderList.removeFirst();folderList2.removeFirst();}File f = new File(%%1);if(!f.delete()) {for(File file : f.listFiles()) {if(file.list().length == 0) {System.out.println(file.getPath());file.delete();}}}7 8 91011121314151617181920212223242526 ArrayList<String>folderList2=new ArrayList<String>();folderList2.add(%%2+"/"+movefoldersList[k].getName());for(int j=0;j<folderList.length;j++){(new File(folderList2.get(j))).mkdirs(); //如果文件夹不存在则建立新文件夹File folders=new File(folderList.get(j));String[] file=folders.list();File temp=null;try{for(int i = 0; i < file.length; i++) {if(folderList.get(j).endsWith(File.separator)){temp=new File(folderList.get(j)+"/"+file[i]);}else{temp=new File(folderList.get(j)+"/"+File.separator+file[i]);}FileInputStream input = new FileInputStream(temp);if(temp.isFile()){FileInputStream input = new FileInputStream(temp);FileOutputStream output = new FileOutputStream(folderList2.get(j) + "/"+ (temp.getName()).toString());byte[] b = new byte[5120];int len;while( (len = input.read(b)) != -1) {output.write(b, 0, len);20.提取扩展名复制代码代码如下:String %%2=%%1.substring(%%stIndexOf(".")+1);2 3 4 5 6 7 8 9101112131415161718192021 int bytesum = 0;int byteread = 0;File oldfile = new File(%%1);try{if(oldfile.exists()) { //文件存在时InputStream inStream = new FileInputStream(oldfile); //读入原文件FileOutputStream fs = new FileOutputStream(new File(%%2,oldfile.getName())); byte[] buffer = new byte[5120];int length;while( (byteread = inStream.read(buffer)) != -1) {bytesum += byteread; //字节数文件大小//System.out.println(bytesum);fs.write(buffer, 0, byteread);}inStream.close();oldfile.delete();}}catch(Exception e) {System.out.println("复制单个文件操作出错");e.printStackTrace();}26.移动一个文件夹下所有文件到另一个目录?1 2 3 4 5 6 7 8 9101112131415 //import java.io.*;File movefile=new File(%%1);File[] movefiles=movefile.listFiles();for(int i=0;i<movefiles.length;i++){if(movefiles[i].isFile()){int bytesum = 0;int byteread = 0;File oldfile = new File(movefiles[i]);try{if(oldfile.exists()) { //文件存在时InputStream inStream = new FileInputStream(oldfile); //读入原文件FileOutputStream fs = new FileOutputStream(new File(%%2,oldfile.getName())); byte[] buffer = new byte[5120];int length;while( (byteread = inStream.read(buffer)) != -1) {bytesum += byteread; //字节数文件大小//System.out.println(bytesum);fs.write(buffer, 0, byteread);}7 8 91011121314151617181920212223242526 String previousNode = null;Vector<Properties> vec = new Vector<Properties>();int row = 0;FileReader fileReader = null;try{fileReader = new FileReader("Config.ini");} catch(FileNotFoundException e1) {e1.printStackTrace();}BufferedReader bufferedReader = new BufferedReader(fileReader); try{while((strLine = bufferedReader.readLine()) != null) {String oneLine = strLine.trim();if(oneLine.length() >= 1) {Pattern p = pile("//[//s*.*//s*//]");int nodelen = oneLine.split("[;]").length;String[] strArray1 = new String[4];if(nodelen == 1) {oneLine = oneLine.split("[;]")[0].trim();} else if(nodelen == 2) {strArray1[3] = oneLine.split("[;]")[1].trim();oneLine = oneLine.split("[;]")[0].trim();}Matcher m = p.matcher(oneLine);2728293031323334353637383940414243444546 if(m.matches()) {strArray1[0] = "@Node";strArray1[1] = oneLine;strArray1[2] = "";} else{int keylen = oneLine.split("=").length; if(keylen == 1) {strArray1[0] = "@Key";strArray1[1] = oneLine.split("=")[0]; strArray1[2] = "";} else if(keylen == 2) {strArray1[0] = "@Key";strArray1[1] = oneLine.split("=")[0]; strArray1[2] = oneLine.split("=")[1]; } else{strArray1[0] = "@ElementError"; strArray1[1] = "";strArray1[2] = "";strArray1[3] = "";}}if(strArray1[0].equals("@Node")) { previousNode = currentNode; currentNode = strArray1[1];4748495051525354555657585960616263646566 if(row > 0) {configMap.put(previousNode, vec.elementAt(0));vec.clear();row = 0;}WriteBuffer += (oneLine + "/r/n");} else if(strArray1[0].equals("@Key") && row == 0) { Properties ht = new Properties();ht.setProperty(strArray1[1], strArray1[2]);if(strArray1[1].equals(%%1)) {WriteBuffer += (%%1+"="+ %%2+ "/r/n");} elseWriteBuffer += (oneLine + "/r/n");vec.add(0, ht);row++;} else if(strArray1[0].equals("@Key") && row > 0) { Properties ht2 = new Properties();ht2.put(strArray1[1], strArray1[2]);vec.clear();vec.add(0, ht2);WriteBuffer += (oneLine + "/r/n");row++;}}6768697071727374757677787980818283848586 }configMap.put(currentNode, vec.elementAt(0)); } catch(FileNotFoundException e) { configMap = null;e.printStackTrace();} catch(IOException e) {configMap = null;e.printStackTrace();} finally{vec.clear();try{bufferedReader.close();fileReader.close();} catch(IOException e) {e.printStackTrace();}try{FileWriter fw = new FileWriter("Config.ini"); fw.write(WriteBuffer);fw.flush();fw.close();} catch(IOException e) {e.printStackTrace();}34.读取ini文件属性?1 2 3 4 5 6 7 8 9101112131415161718 //import java.io.*;//import java.util.*;//import java.util.regex.*;//private HashMap configMap=null;private Map<String, Serializable> configMap=null;String %%2=null;if(configMap == null) {configMap = new HashMap<String, Serializable>();String strLine = null;String currentNode = null;String previousNode = null;Vector<Properties> vec = new Vector<Properties>();int row = 0;FileReader fileReader = null;try{fileReader = new FileReader("Config.ini");} catch(FileNotFoundException e1) {e1.printStackTrace();}BufferedReader bufferedReader = new BufferedReader(fileReader); try{while((strLine = bufferedReader.readLine()) != null) {1920212223242526272829303132333435363738 String oneLine = strLine.trim();if(oneLine.length() >= 1) {Pattern p = pile("//[//s*.*//s*//]"); int nodelen = oneLine.split("[;]").length;String[] strArray1 = new String[4];if(nodelen == 1) {oneLine = oneLine.split("[;]")[0].trim();} else if(nodelen == 2) {strArray1[3] = oneLine.split("[;]")[1].trim(); oneLine = oneLine.split("[;]")[0].trim();}Matcher m = p.matcher(oneLine);if(m.matches()) {strArray1[0] = "@Node";strArray1[1] = oneLine;strArray1[2] = "";} else{int keylen = oneLine.split("=").length;if(keylen == 1) {strArray1[0] = "@Key";strArray1[1] = oneLine.split("=")[0];strArray1[2] = "";} else if(keylen == 2) {strArray1[0] = "@Key";3940414243444546474849505152535455565758 strArray1[1] = oneLine.split("=")[0];strArray1[2] = oneLine.split("=")[1];} else{strArray1[0] = "@ElementError";strArray1[1] = "";strArray1[2] = "";strArray1[3] = "";}}if(strArray1[0].equals("@Node")) {previousNode = currentNode;currentNode = strArray1[1];if(row > 0) {configMap.put(previousNode, vec.elementAt(0));vec.clear();row = 0;}} else if(strArray1[0].equals("@Key") && row == 0) { Properties ht = new Properties();ht.setProperty(strArray1[1], strArray1[2]);if(strArray1[1].equals(%%1)){%%2=strArray1[2];return;5960616263646566676869707172737475767778 }vec.add(0, ht);row++;} else if(strArray1[0].equals("@Key") && row > 0) { Properties ht2 = new Properties();ht2.put(strArray1[1], strArray1[2]);vec.clear();vec.add(0, ht2);row++;}}}configMap.put(currentNode, vec.elementAt(0));} catch(FileNotFoundException e) {configMap = null;e.printStackTrace();} catch(IOException e) {configMap = null;e.printStackTrace();} finally{vec.clear();try{bufferedReader.close();fileReader.close();35.合并一个文件下所有的文件?1 2 3 4 5 6 7 8 910111213141516 File combinefiles=new File(%%1);File[] files=combinefiles.listFiles(); FileOutputStream fs;try{fs=new FileOutputStream(new File(%%2));}catch(IOException e){e.printStackTrace();}for(int i=0;i<files.length;i++){if(files[i].isFile()){int bytesum=0;int byteread=0;try{FileInputStream inStream=new FileInputStream(files[i]); byte[] buffer = new byte[5120];int length;while((byteread=inStream.read(buffer))!=-1){bytesum+=byteread;fs.write(buffer,0,byteread);36.写入ini文件属性?1 2 3 4 5 6 7 8 9101112131415161718 //import java.io.*;//import java.util.*;//import java.util.regex.*;//private HashMap configMap=null;private Map<String, Serializable> configMap=null;if(configMap==null) {String strLine=null;String currentNode=null;String previousNode=null;Vector<Properties> vec=new Vector<Properties>();int row=0;FileReader fileReader = null;try{fileReader = new FileReader(%%1);} catch(FileNotFoundException e1) {e1.printStackTrace();}BufferedReader bufferedReader=new BufferedReader(fileReader); try{while((strLine=bufferedReader.readLine())!=null) {String oneLine=strLine.trim();if(oneLine.length()>=1) {1920212223242526272829303132333435363738 Pattern p=pile("//[//s*.*//s*//]"); int nodelen=oneLine.split("[;]").length;String[] strArray1=new String[4];if(nodelen==1) {oneLine=oneLine.split("[;]")[0].trim();}else if(nodelen==2) {strArray1[3]=oneLine.split("[;]")[1].trim(); oneLine=oneLine.split("[;]")[0].trim();}Matcher m=p.matcher(oneLine);if(m.matches()) {strArray1[0]="@Node";strArray1[1]=oneLine;strArray1[2]="";} else{int keylen=oneLine.split("=").length;if(keylen==1) {strArray1[0]="@Key";strArray1[1]=oneLine.split("=")[0];strArray1[2]="";} else if(keylen==2) {strArray1[0]="@Key";strArray1[1]=oneLine.split("=")[0];。
Java专题7案例2-IO
相关实践知识6
在Student类中定义变量
// 数据分隔符 为什么要分隔符?为什么字节流里面不需要分隔符? 回答:字节流中都是依靠数据类型来进行读写的,所以可以只要有数据 类型我就知道这个读和写都是要进行多少字节的01码来组成。读写顺序 要对应,要不然就会出错了! public static final String SEPARATOR = ":"; // 学生姓名 private String name; // 学生住址 private String address; // 学生E-mail private String email;
方法说明
在给出 File 对象的情况下构造一个 FileWriter 对象。
在给出 File 对象的情况下构造一个 FileWriter 对象。如果第二个参数为 true,则将字节 写入文件末尾处,而不是写入文件开始处。 在给出文件名的情况下构造一个 FileWriter 对 象。 在给出文件名的情况下构造 FileWriter 对象, 它具有指示是否挂起写入数据的 boolean 值。
Hands-On实训教程系列
字符流-1
用于读取或者写入字符的流是字符流。 java.io包中的字符流分为字符输入流和字符 输出流两类。其中所有的字符输入流都直接或 者间接地继承自Reader,所有的字符输出流 都直接或者间接地继承自Writer。
Hands-On实训教程系列
字符流-2
Writer类图
filereaderstringfilenamethrowsfilenotfoundexception在给定从中读取数据的文件名的情况下创建一个filereaderhandson实训教程系列writer1是一个输出字符流的抽象类我们无法直接将其实例化我们经常直接使用的是一个叫做filewriter的字符输出流handson实训教程系列writer2常用方法方法签名方法说明publicvoidwriteintthrowsioexception写入单个字符
Java-JavaIO示例
Java-JavaIO⽰例1. 概述1. ⾯试偶尔会问到让你写⽂件读写的⾯试官1. 我搞不懂为啥必须会这玩意2. ⾯试官的意思是, 这玩意只要是个开发就得会3. 当然我现在⼜不是开发2. ⼀些概念1. 读与写1. 参照1. 以进⾏读写⾏为的程序作为参照2. 读1. 数据从外部进⼊程序3. 写1. 数据从程序写出到外部2. 流 (stream)1. 传统 IO 是和流(Stream) 做交互2. 流是单向的3. 流对数据操作的单位, 是字节1. inputstream.read() ⼀次读⼊⼀个字节2. outputstream.write(), 有多种参数, 但还是以字节, 或者字节数组, 在做读写3. Reader / Writer1. 但是有时候的读写, 使⽤字符作为单位, 会更加⽅便2. Reader / Writer 也是单向, 根据名字可以得知3. Reader / Writer 操作的单位, 是字符, 这个就不举例⼦了4. 字符编码1. 这是个蛋疼的问题2. Reader / Writer 只能查看, ⽆法指定编码3. 需要⼀个 inputstreamReader / outputStreamWriter 来转换1. 这个真是蛋疼, 为啥 Reader 和 Writer 就⽆法直接指定呢2. 看了 Reader, BufferedReader, FileReader 都没有4. 于是就有了中间类1. InputStreamReader2. OutputStreamWriter3. 思路1. 只操作字节1. inputstream2. outputstream2. 只操作字符, 并且不需要考虑字符集问题1. reader2. writer3. 需要考虑字符集问题1. inputstream, inputstreamreader, reader2. ouputstream, outputstreamwriter, writer3. 后⾯的⽰例代码, 就采⽤这种思路1. 看了看是挺烦的4. 其他1. randomaccessfile2. 环境1. 语⾔1. java 1.83. 准备1. 概述1. 基本概念2. 场景1. ⼀次读⼀⾏2. 读取指定编码3. ⽂件(File 对象)1. 概述1. 读写的⽬标2. 其他1. 要读的⽂件, 需要存在2. 通常不要针对同⼀个⽂件做读写3. 注意⽬录的权限4. 输⼊1. 概述1. 就是读2. 多层嵌套2. FileInputStream1. 概述1. ⽂件输⼊流2. 需要⽂件对象来确定输⼊3. InputStreamReader1. 概述1. 重要参数1. 编码4. BufferedReader1. 概述1. 缓存读取效率较⾼2. 可以使⽤ readline ⽅法读取⼀⾏5. 输出1. 概述1. 写⽂件2. 也是多层嵌套2. FileOutputStream1. 概述1. ⽂件输出流2. 需要⽂件对象3. OutputStreamWriter1. 概述1. 确定编码4. BufferedWriter1. 概述1. 可以缓存写4. ⽰例代码// 注意: 这⾥只给出思路, ⽂件类, 输⼊输出流可能会遇到异常, 需要 try catch 或者 throws, 并且这些东西, 最好在 finally ⾥清空和关闭// 声明变量: 读// inputPath 是 String 类型的变量, 记录着输⼊⽂件在⽂件系统⾥的位置File inputFile = new File(inputPath);FileInputStream fis = new FileInputStream(inputFile);InputStreamReader isr = new InputStreamReader(fis, "UTF-8");BufferedReader br = new BufferedReader(fis);// 下⾯是简化版本// BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile),"UTF-8"));// 如果不需要调整编码, 也可以这么写// BufferedReader br = new BufferedReader(new FileReader(inputFile)));// 声明变量: 写File outputFile = new File(outputPath);FileOutputStream fos = new FileOutputStream(outputFile);OutputStreamWriter osr = new OutputStreamWriter(fos, "UTF-8");BufferedWriter bw = new BufferedWriter(fos);// 下⾯是简化版本// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputFile),"UTF-8"));// 如果不需要调整编码, 也可以这么写// BufferedWriter bw = new BufferedWriter(new FileWriter(outputFile)));//读取数据//循环取出数据String str = null;while ((str = br.readLine()) != null) {System.out.println(str);//写⼊相关⽂件bw.write(str);bw.newLine();}//清楚缓存bw.flush();//关闭流br.close();bw.close();4. 其他1. ref1. 写的很清晰, 很详细https:///ll409546297/p/7197911.html2. 并发编程⽹: Java IO 教程, 是原作是⽼外写的, 他们翻译的不差, ⽐ TIJ 好懂, 循序渐进./java-io/2. 其他的读写场景1. 不需要关注编码的读写2. 每次读写固定字符/字节的场景3. randomaccessfile 场景3. 关于 Java 的 IO1. 这种管道套管道的⽅法, 真的让⼈难受2. 有空可以了解下 python 的 io, 简单的令⼈窒息4. 最后的 shutdown 处理1. bw 需要⼀波输出1. 可能会有剩余内容2. 流的关闭1. 只⽤关闭最顶层的对象即可1. 下⾯的会⾃⼰关闭。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
建立文件路径(Constructing a Filename Path)String path = File.separator + "a" + File.separator + "b";在文件路径和Url之间进行转换(Converting Between a Filename Path and a URL)// Create a file objectFile file = new File("filename");// Convert the file object to a URLURL url = null;try {// The file need not exist. It is made into an absolute path// by prefixing the current working directoryurl = file.toURL(); // file:/d:/almanac1.4/java.io/filename} catch (MalformedURLException e) {}// Convert the URL to a file objectfile = new File(url.getFile()); // d:/almanac1.4/java.io/filename// Read the file contents using the URLtry {// Open an input streamInputStream is = url.openStream();// Read from isis.close();} catch (IOException e) {// Could not open the file}从相对文件路径取得绝对文件路径(Getting an Absolute Filename Path from a Relative Filename Path)File file = new File("filename.txt");file = file.getAbsoluteFile(); // c:\temp\filename.txtfile = new File("dir"+File.separatorChar+"filename.txt");file = file.getAbsoluteFile(); // c:\temp\dir\filename.txtfile = new File(".."+File.separatorChar+"filename.txt");file = file.getAbsoluteFile(); // c:\temp\..\filename.txt// Note that filename.txt does not need to exist判断是否两个文件路径是否指向同一个文件(Determining If Two Filename Paths Refer to the Same File)File file1 = new File("./filename");File file2 = new File("filename");// Filename paths are not equalboolean b = file1.equals(file2); // false// Normalize the pathstry {file1 = file1.getCanonicalFile(); // c:\almanac1.4\filenamefile2 = file2.getCanonicalFile(); // c:\almanac1.4\filename } catch (IOException e) {}// Filename paths are now equalb = file1.equals(file2); // true得到文件所在的文件夹名(Getting the Parents of a Filename Path)// Get the parent of a relative filename pathFile file = new File("Ex1.java");String parentPath = file.getParent(); // nullFile parentDir = file.getParentFile(); // null// Get the parents of an absolute filename pathfile = new File("D:\almanac\Ex1.java");parentPath = file.getParent(); // D:\almanacparentDir = file.getParentFile(); // D:\almanacparentPath = parentDir.getParent(); // D:\parentDir = parentDir.getParentFile(); // D:\parentPath = parentDir.getParent(); // nullparentDir = parentDir.getParentFile(); // null判断路径指向的是文件还是目录(Determining If a Filename Path Is a File or a Directory)File dir = new File("directoryName");boolean isDir = dir.isDirectory();if (isDir) {// dir is a directory} else {// dir is a file}判断文件或者路径是否存在(Determining If a File or Directory Exists)boolean exists = (new File("filename")).exists();if (exists) {// File or directory exists} else {// File or directory does not exist}创建文件(Creating a File)try {File file = new File("filename");// Create file if it does not existboolean success = file.createNewFile();if (success) {// File did not exist and was created} else {// File already exists}} catch (IOException e) {}得到文件的大小(Getting the Size of a File)File file = new File("infilename");// Get the number of bytes in the filelong length = file.length();删除文件(Deleting a File)boolean success = (new File("filename")).delete();if (!success) {// Deletion failed}创建临时文件(Creating a Temporary File)try {// Create temp file.File temp = File.createTempFile("pattern", ".suffix");// Delete temp file when program exits.temp.deleteOnExit();// Write to temp fileBufferedWriter out = new BufferedWriter(new FileWriter(temp));out.write("aString");out.close();} catch (IOException e) {}重命名一个文件或目录(Renaming a File or Directory)// File (or directory) with old nameFile file = new File("oldname");// File (or directory) with new nameFile file2 = new File("newname");// Rename file (or directory)boolean success = file.renameTo(file2);if (!success) {// File was not successfully renamed}移动文件或者目录(Moving a File or Directory to Another Directory)// File (or directory) to be movedFile file = new File("filename");// Destination directoryFile dir = new File("directoryname");// Move file to new directoryboolean success = file.renameTo(new File(dir, file.getName()));if (!success) {// File was not successfully moved}取得和修改文件或目录的修改时间(Getting and Setting the Modification Time of a File or Directory)This example gets the last modified time of a file or directory and then sets it to the current time.File file = new File("filename");// Get the last modified timelong modifiedTime = stModified();// 0L is returned if the file does not exist// Set the last modified timelong newModifiedTime = System.currentTimeMillis();boolean success = file.setLastModified(newModifiedTime);if (!success) {// operation failed.}强制更新硬盘上的文件(Forcing Updates to a File to the Disk)In some applications, such as transaction processing, it is necessary to ensure that an update has been made to the disk. FileDescriptor.sync() blocks until all changes to a file are written to disk.try {// Open or create the output fileFileOutputStream os = new FileOutputStream("outfilename");FileDescriptor fd = os.getFD();// Write some data to the streambyte[] data = new byte[]{(byte)0xCA, (byte)0xFE, (byte)0xBA, (byte)0xBE};os.write(data);// Flush the data from the streams and writers into system buffers.// The data may or may not be written to disk.os.flush();// Block until the system buffers have been written to disk.// After this method returns, the data is guaranteed to have// been written to disk.fd.sync();} catch (IOException e) {}得到当前的工作目录(Getting the Current Working Directory)The working directory is the location in the file system from where the java command was invoked.String curDir = System.getProperty("user.dir");创建目录(Creating a Directory)// Create a directory; all ancestor directories must existboolean success = (new File("directoryName")).mkdir();if (!success) {// Directory creation failed}// Create a directory; all non-existent ancestor directories are // automatically createdsuccess = (new File("directoryName")).mkdirs();if (!success) {// Directory creation failed}删除目录(Deleting a Directory)// Delete an empty directoryboolean success = (new File("directoryName")).delete();if (!success) {// Deletion failed}If the directory is not empty, it is necessary to first recursively delete all files and subdirectories in the directory. Here is a method that will delete a non-empty directory.// Deletes all files and subdirectories under dir.// Returns true if all deletions were successful.// If a deletion fails, the method stops attempting to delete and returns false.public static boolean deleteDir(File dir) {if (dir.isDirectory()) {String[] children = dir.list();for (int i=0; i<children.length; i++) {boolean success = deleteDir(new File(dir, children[i]));if (!success) {return false;}}}// The directory is now empty so delete itreturn dir.delete();}列举文件夹中的文件和子目录(Listing the Files or Subdirectories in a Directory)This example lists the files and subdirectories in a directory. To list all descendant files and subdirectories under a directory, see e33 Traversing the Files and Directories Under a Directory.File dir = new File("directoryName");String[] children = dir.list();if (children == null) {// Either dir does not exist or is not a directory} else {for (int i=0; i<children.length; i++) {// Get filename of file or directoryString filename = children[i];}}// It is also possible to filter the list of returned files.// This example does not return any files that start with `.'.FilenameFilter filter = new FilenameFilter() {public boolean accept(File dir, String name) {return !name.startsWith(".");}};children = dir.list(filter);// The list of files can also be retrieved as File objectsFile[] files = dir.listFiles();// This filter only returns directoriesFileFilter fileFilter = new FileFilter() {public boolean accept(File file) {return file.isDirectory();}};files = dir.listFiles(fileFilter);列举系统根目录下的文件(Listing the File System Roots)UNIX file systems have a single root, `/'. On Windows, each drive is a root. For example the C drive is represented by the root C:\.File[] roots = File.listRoots();for (int i=0; i<roots.length; i++) {process(roots[i]);}遍历目录(Traversing the Files and Directories Under a Directory)This example implements methods that recursively visits all files and directories under a directory.// Process all files and directories under dirpublic static void visitAllDirsAndFiles(File dir) {process(dir);if (dir.isDirectory()) {String[] children = dir.list();for (int i=0; i<children.length; i++) {visitAllDirsAndFiles(new File(dir, children[i]));}}}// Process only directories under dirpublic static void visitAllDirs(File dir) {if (dir.isDirectory()) {process(dir);String[] children = dir.list();for (int i=0; i<children.length; i++) {visitAllDirs(new File(dir, children[i]));}}}// Process only files under dirpublic static void visitAllFiles(File dir) {if (dir.isDirectory()) {String[] children = dir.list();for (int i=0; i<children.length; i++) {visitAllFiles(new File(dir, children[i]));}} else {process(dir);}}从控制台读入文本(Reading Text from Standard Input)try {BufferedReader in = new BufferedReader(new InputStreamReader(System.in));String str = "";while (str != null) {System.out.print("> prompt ");str = in.readLine();process(str);}} catch (IOException e) {}从文件中读入文本(Reading Text from a File)try {BufferedReader in = new BufferedReader(new FileReader("infilename"));String str;while ((str = in.readLine()) != null) {process(str);}in.close();} catch (IOException e) {}将文件内容读入一个Byte型数组(Reading a File into a Byte Array)This example implements a method that reads the entire contents of a file into a byte array.See also e35 Reading Text from a File.// Returns the contents of the file in a byte array.public static byte[] getBytesFromFile(File file) throws IOException {InputStream is = new FileInputStream(file);// Get the size of the filelong length = file.length();// You cannot create an array using a long type.// It needs to be an int type.// Before converting to an int type, check// to ensure that file is not larger than Integer.MAX_V ALUE.if (length > Integer.MAX_V ALUE) {// File is too large}// Create the byte array to hold the databyte[] bytes = new byte[(int)length];// Read in the bytesint offset = 0;int numRead = 0;while (offset < bytes.length&& (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {offset += numRead;}// Ensure all the bytes have been read inif (offset < bytes.length) {throw new IOException("Could not completely read file "+file.getName());}// Close the input stream and return bytesis.close();return bytes;}写文件(Writing to a File)If the file does not already exist, it is automatically created.try {BufferedWriter out = new BufferedWriter(new FileWriter("outfilename"));out.write("aString");out.close();} catch (IOException e) {}向文件中添加内容(Appending to a File)try {BufferedWriter out = new BufferedWriter(new FileWriter("filename", true));out.write("aString");out.close();} catch (IOException e) {}使用随即存取文件(Using a Random Access File)try {File f = new File("filename");RandomAccessFile raf = new RandomAccessFile(f, "rw");// Read a characterchar ch = raf.readChar();// Seek to end of fileraf.seek(f.length());// Append to the endraf.writeChars("aString");raf.close();} catch (IOException e) {}从文件中阅读UTF-8格式的数据(Reading UTF-8 Encoded Data)try {BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("infilename"), "UTF8"));String str = in.readLine();} catch (UnsupportedEncodingException e) {} catch (IOException e) {}向文件中写入UTF-8格式的数据(Writing UTF-8 Encoded Data)try {Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("outfilename"), "UTF8"));out.write(aString);out.close();} catch (UnsupportedEncodingException e) {} catch (IOException e) {}从文件中阅读ISO Latin-1格式的数据(Reading ISO Latin-1 Encoded Data)try {BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("infilename"), "8859_1"));String str = in.readLine();} catch (UnsupportedEncodingException e) {} catch (IOException e) {}向文件中写入ISO Latin-1 格式的数据(Writing ISO Latin-1 Encoded Data)try {Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("outfilename"), "8859_1"));out.write(aString);out.close();} catch (UnsupportedEncodingException e) {} catch (IOException e) {}序列化实体(Serializing an Object)The object to be serialized must implement java.io.Serializable. This example serializes a javax.swing.JButton object.See also e45 Deserializing an Object.Object object = new javax.swing.JButton("push me");try {// Serialize to a fileObjectOutput out = new ObjectOutputStream(new FileOutputStream("filename.ser"));out.writeObject(object);out.close();// Serialize to a byte arrayByteArrayOutputStream bos = new ByteArrayOutputStream() ;out = new ObjectOutputStream(bos) ;out.writeObject(object);out.close();// Get the bytes of the serialized objectbyte[] buf = bos.toByteArray();} catch (IOException e) {}反序列化实体(Deserializing an Object)This example deserializes a javax.swing.JButton object.See also e44 Serializing an Object.try {// Deserialize from a fileFile file = new File("filename.ser");ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));// Deserialize the objectjavax.swing.JButton button = (javax.swing.JButton) in.readObject();in.close();// Get some byte array databyte[] bytes = getBytesFromFile(file);// see e36 Reading a File into a Byte Array for the implementation of this method// Deserialize from a byte arrayin = new ObjectInputStream(newByteArrayInputStream(bytes));button = (javax.swing.JButton) in.readObject();in.close();} catch (ClassNotFoundException e) {} catch (IOException e) {}Implementing a Serializable SingletonBy default, the deserialization process creates new instances of classes. This example demonstrates how to customize the deserialization process of a singleton to avoid creating new instances of the singleton.public class MySingleton implements Serializable {static MySingleton singleton = new MySingleton();private MySingleton() {}// This method is called immediately after an object of this class is deserialized.// This method returns the singleton instance.protected Object readResolve() {return singleton;}}Tokenizing Java Source CodeThe StreamTokenizer can be used for simple parsing of a Java source file into tokens. The tokenizer can be aware of Java-style comments and ignore them. It is also aware of Java quoting and escaping rules.try {// Create the tokenizer to read from a fileFileReader rd = new FileReader("filename.java");StreamTokenizer st = new StreamTokenizer(rd);// Prepare the tokenizer for Java-style tokenizing rulesst.parseNumbers();st.wordChars('_', '_');st.eolIsSignificant(true);// If whitespace is not to be discarded, make this callst.ordinaryChars(0, ' ');// These calls caused comments to be discardedst.slashSlashComments(true);st.slashStarComments(true);// Parse the fileint token = st.nextToken();while (token != StreamTokenizer.TT_EOF) {token = st.nextToken();switch (token) {case StreamTokenizer.TT_NUMBER:// A number was found; the value is in nvaldouble num = st.nval;break;case StreamTokenizer.TT_WORD:// A word was found; the value is in svalString word = st.sval;break;case '"':// A double-quoted string was found; sval contains the contentsString dquoteVal = st.sval;break;case '\'':// A single-quoted string was found; sval contains thecontentsString squoteVal = st.sval;break;case StreamTokenizer.TT_EOL:// End of line character foundbreak;case StreamTokenizer.TT_EOF:// End of file has been reachedbreak;default:// A regular character was found; the value is the token itselfchar ch = (char)st.ttype;break;}}rd.close();} catch (IOException e) {}。