Java IO与文件操作 第七节
Java基本IO及文件操作PPT教学课件
2020/12/09
12
BufferedReader和BufferedWriter类
♣BufferedReader和BufferedWrite类分别继
承自Reader类和Writer类,BufferedReader 类用来从字符输入流中读取文本,缓冲各 个字符,从而实现字符、数组和行的高效 读取。BufferedWrite类用于将文本写入字 符输出流,缓冲各个字符,从而提供单个 字符、数组和字符串的高效写入。
5
输入输出流
♣InputStream和OutputStream是java.io包中
的两个抽象类,他们分别是其他所有输入、 输出流类的父类。其他所有输入流类都是 继承了InputStream的基本输入功能并根据 自身属性对这些功能加以扩充;同样,其 他所有输出流类也都是继承了 OutputStream类的基本输出功能并加以扩 展的
2020/12/09
14
RandomAccessFile类
♣创建RandomAccessFile对象 ♣RandomAccessFile类的方法
2020/12/09
15
创建RandomAccessFile对象
♣Java定义了RandomAccessFile类,用于实现对 文件的随机读写操作。RandomAccessFile类继承 于ng.Object类,该类提供了以下两个构造 方法:
♣创建File类对象时需指明它所对应的文件或
目录名。File类共提供了4个不同的构造方 法,以不同的参数形式灵活地接收文件和 目录名信息
2020/12/09
9
File类的方法
♣File类提供了许多方法,用于获取文件或目
录的属性以及对文件和目录进行操作
第7章 Java的输入 输出流
第7章 Java的输入/输出流
String dirList[]=f1.list(m); for(int i=0;i<dirList.length;i++) Transcript.println(dirList[i]); } } public MyClass3(File f) { this.f=f; } public boolean accept(File dir, String name){ return name.startsWith("un"); } }
第7章 Java的输入/输出流
该程序的运行结果如图7.3所示。 此程序中,我们为了说明路径分隔符的使用方法, 实例化文件对象的时候给出了全路径,其实由于我们 已经在Java系统中设置好了源路径,只要给出文件名 就行了。 表7.1中,list方法用于列出一个目录中所有的文件 或与某个模式相匹配的文件。下面我们给出两个例子 来讨论带参数或不带参数的list方法的使用。
返回指定格式的目录中的文件名 返回当前目录中的所有文件名 创建目录,成功返回真 创建路径中所有目录,成功则返回真 返回路径分隔符 文件更名,成功返回真 返回文件分隔符 返回对象的字符串表示
第7章 Java的输入/输出流
下面我们给出几个File类的应用实例。通过例题的 使用,希望读者对File类有更清楚的认识。 例7.1 import java.io.*; public class MyClass1 { public static void main(String args[]){ Filef=new File("c:\\jbuilder3\\myprojects\\untitled5\\MyClass1.java"); if(!f.exists())
掌握Java中的IO操作与文件处理
掌握Java中的IO操作与文件处理Java中的IO操作与文件处理是Java中非常重要的一个部分,它们可以帮助我们读取和写入文件、处理流数据等操作。
在本文中,我将详细介绍Java中的IO操作和文件处理的基本概念、常用类以及一些实际应用中的技巧。
让我们一起来深入了解吧。
一、IO操作的概念在Java中,IO(Input/Output)操作是指程序与外部设备(如磁盘、网络)之间的数据传输。
Java提供了丰富的类库来支持IO操作,其中最核心的类是java.io包下的类。
在IO操作中,主要涉及到输入流(InputStream)、输出流(OutputStream)、读取器(Reader)和写入器(Writer)等基本概念。
1.输入流(InputStream)和输出流(OutputStream):输入流用于从外部设备读取数据,输出流用于向外部设备写入数据。
它们是IO 操作的基础,我们可以通过它们来进行文件的读写操作。
2.读取器(Reader)和写入器(Writer):读取器用于读取字符数据,写入器用于写入字符数据。
它们是输入流和输出流的字符封装版本,更适合于处理文本文件。
二、常用的IO类Java提供了丰富的IO类来支持文件处理,下面是一些常用的IO 类:1. File类:用于表示文件和目录的类,可以对文件和目录进行创建、删除、重命名等操作。
2. FileInputStream和FileOutputStream类:用于文件输入流和文件输出流的类,可以实现对文件的读取和写入操作。
3. FileReader和FileWriter类:用于字符文件的读取器和写入器的类,更适合于处理文本文件。
4. BufferedReader和BufferedWriter类:提供了缓冲区功能的读取器和写入器,可以提高文件读写的效率。
5. InputStreamReader和OutputStreamWriter类:用于字节流与字符流之间的转换,可以处理不同编码格式的文件。
17java语言基础-IO操作
•
Java 本身是具备高的可移植性的,那么这样
一来就要求程序可以适应各个操作系统平台的要
求,则以上的写法就不合适了,因为固定了操作
平台。
•
那么此时,在编写 IO 操作的时候一定要注意,
所有的分隔符需要使用 separator 进行指定。
IO操作
File类的基本使用
import java.io.File; import java.io.IOException; public class FileDemo02 { public static void main(String[] args) { File file = new File("d:" + File.separator + "test.txt"); try { file.createNewFile(); // 创建文件 } catch (IOException e) { e.printStackTrace(); } } }
IO操作
File类的基本使用
2、删除文件
import java.io.File; public class FileDemo03 { public static void main(String[] args) { File file = new File("d:" + File.separator + "test.txt"); file.delete(); // 删除文件 } }
是否是文件
是否是目录 获取文件或目录的名字 获取最后的修改日期 获取文件大小,字节为单位 如果对象是目录,则返回目录下所有文件和目录名字的列表 创建File中的目录 创建File中的目录,如果父目录不存在,还会创建父目录 修改文件的名称,会删除原文件 如果File代表文件,则创建一个空文件 删除文件或目录(如果目录下包含子目录或文件,则不能删除)
java文件操作详细教程
b、delect 方法 public boolean delete()
该方法的作用是删除当前文件或文件夹。如果删除的是文件夹,则 该文件夹必须为空。如果需要删除一个非空的文件夹,则需要首先删除 该文件夹内部的每个文件和文件夹,然后在可以删除,这个需要书写一 定的逻辑代码实现。
这里的 f1 和 f2 对象分别代表一个文件,f1 是绝对路径,而 f2 是相 对路径,f3 则代表一个文件夹,文件夹也是文件路径的一种。
public File(String parent, String child)
也可以使用父路径和子路径结合,实现代表文件路径,例如:
File f4 = new File(“d:\\test\\”,”1.txt”);
文件的存储介质有很多,例如硬盘、光盘和 U 盘等,由于 IO 类设计时, 从数据源转换为流对象的操作由 API 实现了,所以存储介质的不同对于程序员 来说是透明的,和实际编写代码无关。
11.3.1.1 文件的概念
文件是计算机中一种基本的数据存储形式,在实际存储数据时,如果对于 数据的读写速度要求不是很高,存储的数据量不是很大时,使用文件作为一种 持久数据存储的方式是比较好的选择。
相对路径是指书写文件的部分路径,例如\test\Hello.java,该路径中只包含 文件的部分路径\test 和文件的全名 Hello.java,部分路径是指当前路径下的子路 径,例如当前程序在 d:\abc 下运行,则该文件的完整路径就是 d:\abc\test。使 用这种形式,可以更加通用的代表文件的位置,使得文件路径产生一定的灵活 性。
11.3.1.1.1 绝对路径和相对路径
7IO知识点
本章和集合很象,可能接触到的类很多,但是重点还是只需要通过掌握常用的几个类的使用来熟悉IO操作。
在学习过程中也要和集合一样,首先了解JA V A的整个IO包的结构,然后在具体的类的学习中总结常用通用方法,找到相同的规律减少学习时间和难度。
1.什么是IO?I:input 输入通常做读取操作(将不同数据源的数据读入到内存中,也叫读取流)O:output 输出通常做写入操作(将内存中的数据写入到不同的数据源,也叫写入流)2.理解流的概念。
想像一下自来水公司要把水输到用户家里,应该先把自来水公司到用户家里的连接水管建好,再将水输出去。
管道里输送的是水,但IO里输送的是字节。
◆流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接.◆类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。
这时候你就可以想象数据好像在这其中“流”动一样我们使用JAV A的IO操作,必须要使用java.io里的类,所以在使用之前先要导入这个包3.了解java.io包下的整体结构层次按层次高低划分由低---高3-1.字节流•抽象父类是InputStream 和OutputStream3-2.字符流抽象父类是Reader 和Writer3-3.对象流流的命名很有规律,一般是数据源加上流的名字,如:文件读取流就是FileInputStream,对象流就是ObjectInputStream。
需要注意的是字节流和字符流的区别3-4..字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串(比如对图片文件的操作就只能用字节流)3-5.一个字符可以是1个字节,也可以是2个或多个字节一个字节就是8个位,也就是对同一数据源的操作用字符流可能效率更高3-6.字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以(使用用字节流来传输字符文件会产生乱码)注意,不管是哪一种流,在数据传输的底层,还是以字节方式传输。
OOP 07章 流式输入输出及文件处理
7.3 Java的字节流处理
• Java字节流处理类集
7.3.1 字节输入流InputStream InputStream抽象类从输入设备或文件中读 取数据使用的字节流 提供下面几个用于读取数据的成员方法:
read() read(byte[] buffer) read(byte buffer[], int offset, int length) skip(long n) close()
2. 检测File对象
File类提供了一整套应用于File对象的成员方法。 exists() 检测File对象所描述的文件或目录是否存 在。 isDirectory() 检测File对象所描述的是否为目录。 isFile() 检测File对象所描述的是否为文件。 isHidden() 检测File对象所描述的是否为一个隐藏 文件。 canRead() 检测File对象所描述的文件是否可读。 canWrite() 检测File对象所描述的文件是否可写。 equals(Object obj) 检测File对象描述的绝对路径 与obj的绝对路径是否相等。
程序ቤተ መጻሕፍቲ ባይዱ
数据
输出设备
数据源
数据目标
当试图将外部的数据输入到程序中时,流中的 数据源是输入设备,数据目标是程序,这个流 被称为输入流(input stream)。
输入设备
数据源
数据
程序
数据目标
用流机制处理I/O的主要好处是:程序
中有关I/O的代码与设备无关,
程序不需知道(/处理)每一种设备的细 节,使程序能够适应各种设备的输入 输出。
从标准输入流读取数据
System.in是原始InputStream对象,需要经过包装才能有效地 读取数据。常用的方法: Import java.io.*; public class TypeInString{ public static void main(String[] args){ BuferedReader in = new Buffered Reader( new InputStreamReader( System.in ) ); String s;
Java中的IO操作和文件处理篇
Java中的IO操作和文件处理篇Java是一门功能强大的编程语言,提供了丰富的IO操作和文件处理功能,使开发者能够轻松地读取、写入和处理文件。
本篇文章将介绍Java中的IO操作和文件处理相关知识,帮助读者更好地理解和应用这些功能。
一、概述Java中的IO操作是指程序与外部设备(如硬盘、网络等)进行数据交换的过程。
文件处理是指对文件进行读取、写入、创建、删除等操作。
IO操作和文件处理是Java程序开发中必不可少的部分,也是掌握Java编程的基础知识。
二、IO操作Java提供了两种IO操作方式:字节流和字符流。
1. 字节流字节流是以字节为单位进行读写操作的方式,适用于处理二进制文件或者非文本文件。
Java中的字节流有输入字节流和输出字节流。
- 输入字节流(InputStream):用于从外部设备读取数据。
常用的输入字节流类有FileInputStream和BufferedInputStream等。
开发者可以通过输入字节流将文件中的数据读取到程序中进行处理。
- 输出字节流(OutputStream):用于向外部设备写入数据。
常用的输出字节流类有FileOutputStream和BufferedOutputStream等。
开发者可以通过输出字节流将程序中的数据写入到文件中。
2. 字符流字符流是以字符为单位进行读写操作的方式,适用于处理文本文件。
Java中的字符流有读字符流和写字符流。
- 读字符流(Reader):用于从外部设备读取字符数据。
常用的读字符流类有FileReader和BufferedReader等。
开发者可以通过读字符流将文件中的字符数据读取到程序中进行处理。
- 写字符流(Writer):用于向外部设备写入字符数据。
常用的写字符流类有FileWriter和BufferedWriter等。
开发者可以通过写字符流将程序中的字符数据写入到文件中。
三、文件处理文件处理是对文件进行读取、写入、创建、删除等操作的过程,可以通过Java中的File类来实现。
Java中的文件操作与IO处理
Java中的文件操作与IO处理文件操作和IO处理在Java编程中扮演着重要的角色。
通过文件操作,我们可以读取、写入和处理文件;而IO处理则涉及到了输入和输出流的操作。
本文将探讨Java中的文件操作和IO处理的基本知识、常用类和方法,并提供一些示例代码。
一、文件操作文件操作是指对文件进行创建、读取、写入、删除等操作的过程。
在Java中,我们可以使用File类和相关的方法来进行文件操作。
1. 创建文件要创建一个文件,我们可以使用File类的createNewFile()方法。
以下是一个创建文件的例子:```javaFile file = new File("example.txt");try {if (file.createNewFile()) {System.out.println("文件创建成功!");} else {System.out.println("文件已存在!");}} catch (IOException e) {e.printStackTrace();}```上述代码中,我们通过调用createNewFile()方法创建了一个名为"example.txt"的文件。
如果文件创建成功,将会打印"文件创建成功!",否则打印"文件已存在!"。
2. 读取文件要读取一个文件的内容,我们可以使用FileReader和BufferedReader类。
以下是一个读取文件的例子:```javaFile file = new File("example.txt");try (BufferedReader reader = new BufferedReader(new FileReader(file))) {String line;while ((line = reader.readLine()) != null) {System.out.println(line);}} catch (IOException e) {e.printStackTrace();}```上述代码中,我们通过创建一个FileReader对象和一个BufferedReader对象,逐行读取文件内容并打印出来。
java IO 系统-java 文件操作大全
<body>
<%
String path=request.getRealPath("/");
out.println(path);
FileReader fr=new FileReader(path + "}
fr.close();
%>
</body>
</html>
<html>
<head>
<title>读取所有的文件数据</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileReader fr=new FileReader(path + "<%@ page import="java.io.*"%>
}
}
%>
</body>
</html>
判断是否为空白文件
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>判断是否为空白文件</title>
if(f.exists()){
%>
JAVA IO流及文件操作
Writer类层次
InputStream & OutputStream
InputStream有3中方式从流中读入数据:
int read() //读一个字节并返回,至流末尾时返回-1 int read(byte[ ] ) // 将数据读入byte[], 返回读的 字节数 int read( byte[], int offset, int length )
“输入”与“输出”是站在“程序”的角度 看的:
Java程序 input类 读输入流 输入流 数据源 数据
Java程序 input类 读输入流
输入流
数据源 数据
I/O流
通过流直接进行输入与输出,一般只适用于 数据量很少的情况。当传输数据量大的时候, Java提供了“缓冲流”:数据与外设进行交 互时,先集中到内存中的一块缓冲区。 Java中提供了大量的类(60多个)以完成 输入输出,它们形成了一个合理的自顶向下 的逻辑结构。参见:
input and output stream Reader and Writer
字节流与字符流
java.io包支持两种流:“字节流”和“字 符流”。当向字节流中写入数据时,数据是 以字节(byte)为单位的序列,与内存中形 式相同,不发生任何转换。而字符流则是以 字符为单位的数据序列。 Java中实现字节流的基类是InputStream 和OutputStream,它们均直接继承自 Object类。 InputStream和OutputStream均是抽象 类,定义了输入和输出字节的基本操作。它 们派生出了大量的具体功能的类。
标准数据流
在Java应用程序开始执行时,会自动创建3 个标准数据流,供System类使用: System.in、System.out和System.err
Java IO技术PPT课件
1
1. Java I/O技术
1.1 JavaI/O技术简介 在Java中,数据的输入和输出都是以流(Stream)的方式来处理。JDK中
与输入输出相关的包和类都集中存放在java.io包中,涉及12个接口、51个类、 17个异常。我们用不用逐个研究学习呢?显然不用,API帮助文档相当于一本 字典,我们只需迅速查找到自己要的信息即可。
Java中的流按单位可分为字节流和字符流。按Java的命名惯例,凡是以 InputStream结尾的类均为字节输入流,以OutputStream结尾的类均为字节输 出流,凡是以Reader结尾的类均为字符输入流,以Writer结尾的类均为字符 输出流。
3
1. Java I/O技术
1.2 I/O流的分类
File类可以用来获取或处理与磁盘文件和文件夹相关等信息和操作,但 不提供文件内容的存取 。文件内容的存取功能 一般由FileInputStream 、 FileOutputStream、FileReader、FileWriter等类实现。
File类是对文件和文件夹的一种抽象表示(引用或指针)。File类的对 象可能指向一个存在的文件或文件夹,也可能指向一个不存在的文件或文件 夹。
9
2. 常见I/O应用一
2.1 File类的应用 查阅API帮助文档,掌握File类的常用构造方法和常用方法:
❖ public File(String pathname) ❖ public boolean exists() ❖ public boolean isDirectory() ❖ public long lastModified():返回毫秒数 ❖ public long length() ❖ public String getName()、getParent()、getPath():
javaIo流教程[最终定稿]
javaIo流教程[最终定稿]第一篇:java Io流教程java InputStream读取数据问题1. 关于InputStream.read()在从数据流里读取数据时,为图简单,经常用InputStream.read()方法。
这个方法是从流里每次只读取读取一个字节,效率会非常低。
更好的方法是用InputStream.read(byte[] b)或者InputStream.read(byte[] b,int off,int len)方法,一次读取多个字节。
2. 关于InputStream类的available()方法要一次读取多个字节时,经常用到InputStream.available()方法,这个方法可以在读写操作前先得知数据流里有多少个字节可以读取。
需要注意的是,如果这个方法用在从本地文件读取数据时,一般不会遇到问题,但如果是用于网络操作,就经常会遇到一些麻烦。
比如,Socket通讯时,对方明明发来了1000个字节,但是自己的程序调用available()方法却只得到900,或者100,甚至是0,感觉有点莫名其妙,怎么也找不到原因。
其实,这是因为网络通讯往往是间断性的,一串字节往往分几批进行发送。
本地程序调用available()方法有时得到0,这可能是对方还没有响应,也可能是对方已经响应了,但是数据还没有送达本地。
对方发送了1000个字节给你,也许分成3批到达,这你就要调用3次available()方法才能将数据总数全部得到。
如果这样写代码:int count = in.available();byte[] b = new byte[count];in.read(b);在进行网络操作时往往出错,因为你调用available()方法时,对发发送的数据可能还没有到达,你得到的count是0。
需要改成这样:int count = 0;while (count == 0) {count = in.available();}byte[] b = new byte[count];in.read(b);3. 关于InputStream.read(byte[] b)和InputStream.read(byte[] b,int off,int len)这两个方法都是用来从流里读取多个字节的,有经验的程序员就会发现,这两个方法经常读取不到自己想要读取的个数的字节。
Java文件操作与IO编程详解
Java文件操作与IO编程详解第一章:Java文件操作基础1.1 文件和目录的概念及区别1.2 Java中的文件路径表示方式1.3 文件的创建、删除、重命名和复制等基本操作 1.4 目录的创建、删除和遍历等基本操作1.5 文件属性信息的获取第二章:Java输入输出流2.1 输入输出流的概念和作用2.2 字节流与字符流的区别与选择2.3 输入流的常用类和方法2.4 输出流的常用类和方法2.5 缓冲流的使用及优势第三章:Java文件读取与写入3.1 文件读取的基本方式和使用场景3.2 字节流读取文件的方法和注意事项3.3 字符流读取文件的方法和注意事项 3.4 文件写入的基本方式和使用场景 3.5 写入文件时的编码问题和解决方案第四章:Java序列化与反序列化4.1 序列化的概念和作用4.2 Java对象的序列化和反序列化4.3 实现Serializable接口的注意事项 4.4 序列化和反序列化的性能优化4.5 序列化和反序列化的扩展应用第五章:Java NIO编程5.1 NIO概述和与IO比较5.2 缓冲区(Buffer)的概念和使用5.3 通道(Channel)的概念和使用5.4 文件操作的NIO实现5.5 NIO的选择器(Selector)机制第六章:Java压缩与解压缩6.1 压缩与解压缩的概念和作用6.2 Java中的压缩解压缩工具类6.3 压缩格式的选择和应用场景6.4 压缩和解压缩性能的优化6.5 压缩和解压缩的安全性问题第七章:Java网络编程与文件传输7.1 网络编程的基本概念和工作原理7.2 Java中的网络编程类和接口7.3 基于TCP协议的文件传输实现7.4 基于UDP协议的文件传输实现7.5 文件传输过程中的断点续传和传输效率优化总结:Java文件操作和IO编程是Java开发中非常重要的一部分,能够让开发者方便地读取和写入文件数据,并对文件进行各种操作。
本文从文件操作基础开始介绍,涵盖了文件的创建、删除、重命名、复制,目录的创建、删除、遍历,文件属性信息的获取等内容。
Java面向对象程序设计案例教程课件:Java中的文件操作
文件处理(File类) I/O 流概述 掌握Java流类的分类 常见的字节流:InputStream、OutputStream、FileInputStream、FileOutputStream、DataInputStream、DataOutputStream、BufferedInputStream、BufferedOutputStream、System.in 、 System.out等 字符流 :Reader、Writer、InputStreamReader、OutputStreamWriter、FileReader、FileWriter CharArrayReader、CharArrayWriter、BufferedReader、BufferedWriter 对象流:ObjectInputStream、ObjectOutputStream。
利用缓冲流从一个文件中读出,然后写入另一个文件。
20
DataInputStream 和 DataOutputStream 不仅能读/写数据流,而且能读/写各种的java语言的基本类型,如:boolean,int,float等。
字节流--DataInputStream 和DataOutputStream
字节流
字符流
输入流
InputStream
Reader
输出流
OutputStream
Writer
12
输入输出流分类
节点流:为可以从一个特定的数据源(节点)读写数据(如:文件,内存)
数据源
程序
处理流:是“连接”在已存在的流(节点流或处理流)之上,通过对数据的处理为程序提供更为强大的读写功能。
节点流
数据源
8
一、如果某文件如E:\doc\测试文件.txt存在件名,绝对路径,读写权限)
java中对IO文件的操作(读,写,增加一行,删除一行,删除文件
java中对IO文件的操作(读,写,增加一行,删除一行,删除文件java中对IO文件的操作(读,写,增加一行,删除一行,删除文件)2011-02-27 23:42import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileReader;import java.io.FileWriter;import java.util.ArrayList;import java.util.List;public class testFile {public static void main(String[] args) {//调用方法(对文件的操作)operateFile("F:/test/test1/test.txt");// System.out.println(time);}public static void operateFile(String strPath) {try {File file = new File(strPath);//判断文件是否存在if (file.exists()) {System.out.println("exit " + file.getPath());} else {System.out.println("不存在");}//判断是否为目录if (file.isDirectory()) {System.out.println("首次判断,该文件是目录且存在!" + file.getPath());File[] fileList = file.listFiles();for (int i = 0; i < fileList.length; i++) {if (fileList[i].isDirectory()) {System.out.println("子目录名:" + fileList[i].getName());System.out.print("子目录" + i + ":");operateFile(fileList[i].getPath());} /*else if (fileList[i].isFile()) {System.out.println("目录下该文件是文件且存在!" + file.getName());} else {// 不存在,创建文件//FileOutputStream fos = new FileOutputStream(strPath,true);// System.out.println("文件创建成功!");//System.out.println("全路径:"+file.getAbsolutePath());//System.out.println("文件不存在:"+fileList[i].getName());}*/}//判断是否为文件} else if (file.isFile()) {System.out.println("首次判断,该文件是文件且存在!" + file.getName());//追加文件内容,每次追加一条,/*BufferedWriter bw = new BufferedWriter(newFileWriter(file.getAbsolutePath(),true));bw.write("序号1|姓名|金额|备注1|备注2|");bw.newLine();bw.flush();bw.close();System.out.println("追加内容成功");*///读文件内容/*int num = 0;BufferedReader br = new BufferedReader(new FileReader(file.getAbsolutePath()));String str = null;while( (str=br.readLine()) != null ){System.out.println(str);num++;}System.out.println("读取文件总行数:"+num);*///修改文件内容(可以先删除,在增加)//删除一行内容(java本身没有删除的方法,本方法通过先读取文件的内容(需删除的行数除外),放到list中,在重新写入)/*int line = 2;int num = 0;BufferedReader br = new BufferedReader(new FileReader(file.getAbsolutePath()));String str = null;List list = new ArrayList();while( (str=br.readLine()) != null ){++num;System.out.println(num+"行:"+str);if( num == line )continue;list.add(str);}System.out.println("list size:"+list.size());BufferedWriter bw = new BufferedWriter(new FileWriter(file.getAbsolutePath()));for( int i=0;i<list.size();i++ ){System.out.println("list["+i+"]"+list.get(i));bw.write(list.get(i).toString());bw.newLine();}bw.flush();bw.close();System.out.println("删除成功");*///删除文件//file.delete();//System.out.println("文件删除成功!");} else {//当文件不存在时,新建System.out.println("该文件不存在");String name = file.getName();System.out.println("name:" + name);if (name.trim().toLowerCase().endsWith(".txt")) {System.out.println(".txt文件");// 不存在,创建文件 (先创建目录, file.mkdirs();)//System.out.println("父路径:"+file.getParent());//按照父路径创建目录,然后在该目录下创建文件File file1 = new File(file.getParent());file1.mkdirs();//System.out.println("根据父目录创建目录成功!");//创建文件FileOutputStream fos = new FileOutputStream(strPath, true);System.out.println("文件创建成功!");}else{System.out.println("非.txt文件");//创建多级目录(根据参数的路径格式)file.mkdirs();}}}catch(FileNotFoundException e) {System.out.println("找不到指定文件");System.exit(-1);}catch (Exception e1) {System.out.println("error:" + e1);}}}。
Java流(Stream)、文件(File)和IO菜鸟教程
Java流(Stream)、文件(File)和IO菜鸟教程Java 流(Stream)、文件(File)和IOJava.io 包几乎包含了所有操作输入、输出需要的类。
所有这些流类代表了输入源和输出目标。
Java.io 包中的流支持很多种格式,比如:基本类型、对象、本地化字符集等等。
一个流可以理解为一个数据的序列。
输入流表示从一个源读取数据,输出流表示向一个目标写数据。
Java 为 I/O 提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中。
但本节讲述最基本的和流与I/O 相关的功能。
我们将通过一个个例子来学习这些功能。
读取控制台输入Java 的控制台输入由 System.in 完成。
为了获得一个绑定到控制台的字符流,你可以把System.in 包装在一个 BufferedReader 对象中来创建一个字符流。
下面是创建 BufferedReader 的基本语法:BufferedReader br = new BufferedReader(new InputStreamReader(System.in));BufferedReader 对象创建后,我们便可以使用read() 方法从控制台读取一个字符,或者用 readLine() 方法读取一个字符串。
从控制台读取多字符输入从 BufferedReader 对象读取一个字符要使用 read() 方法,它的语法如下:int read( ) throws IOException每次调用read() 方法,它从输入流读取一个字符并把该字符作为整数值返回。
当流结束的时候返回 -1。
该方法抛出 IOException。
下面的程序示范了用read() 方法从控制台不断读取字符直到用户输入 "q"。
BRRead.java 文件代码:// 使用BufferedReader 在控制台读取字符import java.io.*; public class BRRead { public static void main(String args[]) throws IOException { char c; // 使用System.in 创建BufferedReader BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); System.out.println("输入字符, 按下'q' 键退出。
java输入输出流和文件操作
Java IO流和文件操作Java流操作有关的类或接口:Java流类图结构:1、File类File类是对文件系统中文件以及文件夹进行封装的对象,可以通过对象的思想来操作文件和文件夹。
File类保存文件或目录的各种元数据信息,包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名,判断指定文件是否存在、获得当前目录中的文件列表,创建、删除文件和目录等方法。
构造方法摘要File(File parent, String child)File(String pathname)File(String parent, String child)构造函数创建方法1.boolean createNewFile() 不存在返回true 存在返回false2.boolean mkdir() 创建目录3.boolean mkdirs() 创建多级目录删除方法1.boolean delete()2.boolean deleteOnExit() 文件使用完成后删除例子1:列出指定文件夹的文件或文件夹public class FileDemo1 {public static void main(String[] args){File[] files =File.listRoots();for(File file:files){System.out.println(file);if(file.length()>0){String[] filenames =file.list(); for(String filename:filenames){ System.out.println(filename); }}}}}例子2:文件过滤import java.io.File;public class FileTest2{public static void main(String[] args){File file = new File("file");String[] names = file.list();for(String name : names){if(name.endsWith(".java")){System.out.println(name);}}}}例子3:文件过滤import java.io.File;import java.io.FilenameFilter;public class FileTest3{public static void main(String[] args){File file = new File("file");String[] names = file.list(new FilenameFilter(){public boolean accept(File dir, String name){if(name.endsWith(".txt")){return true;}return false;};});for(String name : names){System.out.println(name);}}}例子4:利用递归列出全部文件import java.io.*;public class FileTest4 {public static void showDir(File dir){ System.out.println(dir);File[] files=dir.listFiles();for(File f:files){if(f.isFile()){System.out.println(f);}else{showDir(f);}}}public static void main(String[] args) { File file=new File("file");showDir(file);}}例子5:利用递归删除全部文件import java.io.File;public class FileTest5 {public static void deleteAll(File file){ if(file.isFile()||file.list().length==0){ file.delete();}else{File[] files=file.listFiles();for(File f:files){deleteAll(f);f.delete();}}}public static void main(String[] args) { File file=new File("file");deleteAll(file);}}流的概念和作用流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1. Java输入输出—OutputStream
public void flush():强制清空缓冲区并执行外设写操作。 对缓冲流式输出来说,write()方法所写的数据并没有直接传到与输出 流相连的外设上,而是先暂存在流的缓冲区中,等到缓冲区中的数据 积累到一定的数量,再统一执行一次向外设的写操作把它们全部写到
向输出类写入数据: 顺序写:只有前面的数据已被写入外设时,才能输出后面的数据。 将原始数据以二进制的方式,逐字节地写入输出流所连接的外设中, 不能对所传递的数据完成格式或类型转换。 public void write(int b):将参数b的低位字节写到输出流。 public void write(byte[] b):将字节数组b中的全部字节顺序写到输出 流。
(5)关闭流对象。
其中步骤(2)~(5)要考虑异常处理。
1. Java输入输出
输入输出流序列中的数据既可以是未经加工的原始二进制数据,也可 以是经一定编码处理后符合某种格式规定的特定数据,如字符流序列、 数字流序列等。 根据不同的数据、不同的数据序列方向,输入输出流的属性和处理方
法也不同,在Java的输入输出类库中,有各种不同的输入输出类。
1. Java输入输出—InputStream子类
② public class FileInputStream extends InputStream——文件输入
字节流——以字节为单位对文件顺序读操作
import java.io.*; public class Temp { static FileInputStream fin; static byte[] b; public static void main(String[] args) { int i; try { fin = new FileInputStream("file.txt"); } catch (FileNotFoundException e) { System.out.println("No file.txt"); System.exit(0); } try { i = fin.available(); if (i >0 ) { b = new byte[i]; fin.read(b); System.out.println(new String(b)); } fin.close(); } catch (IOException e) { System.out.println("file.txt read over"); } System.out.println("program over"); } }
1. Java输入输出
Java中最基本的输入输出流类:基本字节输入流InputStream和基本 字节输出流OutputStream。 这两个类是最基本的字节输入输出功能的抽象类: 其他所有字节输入流类都是继承了InputStream的基本输入功能、 并根据自身属性对这些功能加以扩充的InputStream类的子类; 其他所有字节输出流类也都是继承了OutputStream的基本输出功 能并加以扩展的OutputStream的子类。
1. Java输入输出—InputStream子类
③ FilterInputStream(InputStream in)——过滤输入字节流: 以另一个输入流in为数据源,在输入数据的同时能对所传输的数据 进行指定类型或格式的转换,可实现对二进制字节数据的理解和编 码转换。
注:在FilterInputStream的子类中提供了各种转换功能,常用子类
当程序需要从外设中读入数据时: ① 应该创建一个适当的输入流对象来完成与该外设(如键盘、磁盘 文件或网络套接字等)的连接; ② 然后再调用对象的read()等方法来实现对相应外设的输入操作。 InputStream是抽象类,在实际程序中创建的输入流都是InputStream 子类的对象,由子类对象来实现与外设数据源的连接。 InputStream子类的对象可以调用它继承的read()方法,从输入流读入
利用输入输出类,Java程序可以实现多种输入输出操作和复杂的文件
与目录管理。
1. Java输入输出
流:指在计算机的输入与输出之间运动的数据序列。 输入流代表从外设流入计算机的数据序列; 输出流代表从计算机流向外设的数据序列。 流式输入输出——数据的获取和发送均沿数据序列顺序进行: 每一个数据都必须等待排在它前面的数据读入或送出之后才能被 读写; 每次读写操作处理的都是序列中剩余的未读写数据的第一个,不 能随意选择输入输出的位臵。
Reader类和Writer类: 面向字符读写的抽象类,用于对字符数据流的输入输出操作 public abstract class Reader extends Object implements Readable, Closeable
1. Java输入输出—Writer
public abstract class Writer extends Object
1. Java输入输出—OutputStream子类
① ② ByteArrayOutputStream ——字节数组输出流 FileOutputStream ——文件输出字节流
void print(boolean b):打印布尔值。 void print(char c):打印字符。 void print(char[] s):打印字符数组。 void print(double d):打印双精度浮点数。
Output Stream:抽象类,所有字节输出流的父类。 当Java程序需要向某外设(如屏幕、磁盘文件或另一台计 算机)输出数据时,应该创建一个新的输出流对象来完成
与该外设的连接,然后利用OutputStream提供的write()将
数据顺序写入到外设上。 OutputStream是不能实例化的抽象类,创建的输出流对象
implements Appendable, Closeable, Flushable
1. Java输入输出—InputStream子类
① ByteArrayInputStream(byte[] buf)——字节数组输入流 输入流的数据源为字节数组buf(内存中),程序通过输入流从数据源 获取数据。 ② public class FileInputStream extends InputStream——文件输入字 节流——以字节为单位对文件顺序读操作
所有的字节输入输出流类都是Java的基本字节输入输出类的子类。
1. Java输入输出—InputStream
public abstract class InputStream extends Object implements Closeable ——所有字节输入流类的父类
1. Java输入输出—InputStream
第七节Java IO与文件操作
1. Java输入输出 2. Java 文件操作
1. Java输入输出
任何一种计算机程序都需要进行输入输出处理,比如从键盘读取数据、 保存或读入一个文件、在网络连接上读取数据等等。 Java的输入输出处理封装在java.io包中,包含了不同情况下完成流式 输入输出的类。
③
④ ⑤
FilterOutputStream
——过滤输出流 DataOutputStream
void print(float f):打印浮点数。
void print(int i) :打印整数。 void print(long l):打印 long 整数。 void print(Object obj):打印对象。 void print(String s):打印字符串。 void println(…) System.out.println(…);
Java 程序 Java 程序
输出流:与输出端(目的地)连接,调用write方法向输出端输出数据 输出端:终端显示器、文件、内存区域或另一个输出流对象 输出流的输出为另一个输出流的数据时,对输出流的数据进行进 一步的处理或转换——加强输出功能
1. Java输入输出
输入输出流操作的一般步骤: (1)使用引入语句引入java.io包:import java.io.*; (2)根据不同数据源和输入输出任务,建立字节流或字符流对象。 (3)若需要对字节或字符流信息组织加工为数据,在已建字节流或字符 流对象上构建数据流对象。 (4)用输入输出流对象类的成员方法进行读写操作,需要时,设臵读写 位臵指针。
外设上。这样处理可以降低计算机对外设的读写次数,提高系统的效
率。但是在有些情况下,缓冲区中的数据不满时就需要将它写到外设 上,使用flush()方法。
public void close():关闭输出流。当输出操作完毕时,调用close方
法来关闭输出流与外设的连接并释放所占用的系统资源。
1. Java输入输出—Reader和Writer
④ BufferedInputStream(InputStream in)——缓冲输入字节流:增加 了缓冲区,支持了mark和reset方法,提高了输入效率;
⑤
DataInputStream(InputStream in)——数据输入字节流:带格式的
读操作,可以读取不同类型数据,如readByte(), readBoolean(), readShort(), readInt(), readChar()等。
InputStream中用来控制位臵指针的方法有:
public long skip(long n):使位臵指针从当前位臵向后跳过n个字节; public void mark(int readlimit):在当前位臵指针处做一个标记;
readlimit规定了一个上限,当从流中读取的字符数超过这个上限时,
应该是OutputStream的某个子类。