Java-IO流学习 课堂笔记
JAVA-IO流
1、IO流是什么？
IO：input和output
输入和输出流的意思？
java程序进行数据传输的管道！
流就是管道的意思
流：Stream
现实网络操作中有没有进行数据输入输出的操作？
例如：上网注册信息的时候对图片信息的上传！------上传 —输入程序中的输入流
从网上下载数据的时候，也是数据的传输！ — 下载 —输出的操作
在计算机中所以的数据都是以文件的格式存储的！
在Java中认为文件是一个对象！！！
Java认为所以的东西都是对象！
官方解释：
文件和目录路径名的抽象表示形式 （磁盘上的文件和文件夹都是File的对象）
文件就是磁盘上的文件在Java语言中的表示对象！
Class 类—对象—>**.class 在内存中的表现形式
new 类（）；jvm----class文件 ------>class 对象
File类的对象 就是磁盘上所有的文件 在java语言中对象的表现形式
2、File类的构造方法
File（string pathname）：根据一个路径得到File对象
File（String parent）,String child):根据一个目录和子文件/目录得到File对象
File（File parent，String child）：根据一个父File对象和一个子文件/目录得到File对象
package IO01;
import java.io.File;
/*
java.io.File类
1.凡是与输入、输出相关的类、接口等都定义在java.io包下
2.File是一个类，可以有构造器创建其对象。此对象对应着一个文件(.txt .png .jpg .mp3 .ppt) 或是文件夹(目录)
3.File类对象是与平台无关的。
4.File中的方法，仅涉及到如何创建、删除、重命名等等。
只有涉及文件内容的，File是无能为力的，必须由IO流来完成。
5.File类的对象常作为IO流的具体类的构造器形参。
路径
1.绝对路径：包括盘符在内的完整文件路径
2.相对路径：在当前文件目录下的文件的路径
*/
public class Text {
// File（string pathname）：根据一个路径得到File对象
// Java中一个"\"反斜杠代表的是转义字符的开始标志，你要是想用“\”,就必须用两个“\”来表示，或者一个“/”
File file1 = new File("D:\\桌面\\Java_IO流\\IO\\b.txt");
// File（String parent）,String child):根据一个目录和子文件/目录得到File对象
// java中认为文件夹是一种特殊的文件,只不过文件夹中的内容是其他的文件或文件夹，而文件中是数据
File file2 =new File("D:\\桌面\\Java_IO流\\IO","b.txt");
// File（File parent，String child）：根据一个父File对象和一个子文件/目录得到File对象
File file=new File("D:\\桌面\\Java_IO流\\IO");
File file3=new File(file,"b.txt");
}
3、File类的成员方法
1、创建功能
public boolean createNewFile():创建文件如果存在这样的文件，就不创建了
public boolean mkdir():创建文件夹，如果存在这样的文件夹，就不创建了
public boolean mkdirs():创建文件夹，如果父文件夹不存在，会帮你创建出来
package IO01;
import java.io.File;
import java.io.IOException;
//public boolean createNewFile():创建文件如果存在这样的文件，就不创建了
//public boolean mkdir():创建文件夹，如果存在这样的文件夹，就不创建了
//public boolean mkdirs():创建文件夹，如果父文件夹不存在，会帮你创建出来
public class Text1 {
public static void main(String[] args) throws IOException {
//public boolean createNewFile():创建文件如果存在这样的文件，就不创建了
File file=new File("D:\\桌面\\Java_IO流\\IO\\cc.txt");
boolean newFile = file.createNewFile();//创建一个文件返回一个布尔类型的值
System.out.println(newFile);
//如果没有指明创建文件的路径，那么该文件是在项目路径下创建
File file1=new File("dd.txt");
boolean newFile1 = file1.createNewFile();
System.out.println(newFile1);
//如果路径不存在能不能创建
//如果调用该createNewFile方法的时候路劲必须存在
File file2 = new File("D:\\桌面抹布\\Java_IO流\\IO");
boolean newFile2 = file2.createNewFile();
System.out.println(newFile2);
//答案是不能，会报错IOException，系统找不到指定文件
}
}
package IO01;
import java.io.File;
public class Text2 {
public static void main(String[] args) {
//public boolean mkdir():创建文件夹，如果存在这样的文件夹，就不创建了
File file = new File("D:\\桌面\\Java_IO流\\IO\\cccc");
boolean mkdir = file.mkdir();
System.out.println(mkdir);
//public boolean mkdir():创建文件夹，如果存在这样的文件夹，就不创建了
// 该方法不能创建多重文件夹
File file2 = new File("D:\\桌面\\Java_IO流\\IO\\ccccc\\aaa");
boolean mkdir2 = file2.mkdir();
System.out.println(mkdir2);//false
//public boolean mkdirs():创建文件夹，如果父文件夹不存在，会帮你创建出来
//他是用来创建多重文件夹的
File file3 = new File("D:\\桌面\\Java_IO流\\IO\\ccccc\\aaa");
boolean mkdir3 = file3.mkdirs();
System.out.println(mkdir3);//false
//同一个项目下，文件和文件夹不能重名
File file1 = new File("bbbb");
file1.mkdir();
}
}
2、删除功能
public boolean delete(); 可以用来删除文件和文件夹
package IO01;
import java.io.File;
//删除功能
//public boolean delete(); 可以用来删除文件和文件夹
public class Text3 {
public static void main(String[] args) {
File file = new File("dd.txt");
File file1 = new File("bbbb");
file.delete();
file1.delete();
}
}
3、重命名功能
renameTo
4、判断功能
package IO01;
import java.io.File;
import java.io.IOException;
//删除功能
//public boolean delete(); 可以用来删除文件和文件夹
public class Text3 {
public static void main(String[] args) {
File file = new File("dd.txt");
//判断这个文件是否存在 exists
boolean newFile = file.exists();
if(newFile){
System.out.println("文件已存在");
}else {
try {
boolean newFile1 = file.createNewFile();
System.out.println(newFile1?"创建成功":"创建失败");
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
5、查询文件
package IO01;
import java.io.File;
import java.io.IOException;
//删除功能
//public boolean delete(); 可以用来删除文件和文件夹
public class Text3 {
public static void main(String[] args) {
File file = new File("dd.txt");
boolean newFile = file.exists();
if(newFile){
System.out.println("文件已存在");
}else {
try {
boolean newFile1 = file.createNewFile();
System.out.println(newFile1?"创建成功":"创建失败");
} catch (IOException e) {
e.printStackTrace();
}
}
//获取文件大小
File file1 = new File("dd.txt");
long length = file1.length();
System.out.println("size="+length);
//获取文件名
String name = file1.getName();
System.out.println("filename="+name);
//获取文件的路径
String path = file1.getPath();
System.out.println("path="+path);
}
}
String字符串：length(),返回字符串的个数
数组： 数组名.length ,是属性，获取数组中元素的个数
集合：集合对象名.size() ,返回集合中元素的个数
6、递归*
方法自己调用自己。。
isDirectory():判断文件是否是文件夹
listFiles():查询某个文件夹下的所有文件
遍历 for(数据类型 变量名：数组/集合)
package IO01;
import java.io.File;
//递归：找出某个文件夹下所有的文件
public class Text4 {
public static void showFile(String patname){
File file = new File(patname);
//1、判断文件是否是文件夹
boolean directory = file.isDirectory();
//选择某个文件夹下所有文件
if (directory){
//是文件夹
File[] files = file.listFiles();
for (File tempFile:files){
boolean directory1 = tempFile.isDirectory();
if(directory1){
showFile(tempFile.getPath());
}else{
String path = file.getPath();
System.out.println("普通文件----"+path);
// file.delete(); //删除
}
}
}else{
//不是文件夹
//获取此文件的路径
String path = file.getPath();
System.out.println("普通文件----"+path);
// file.delete(); //删除
}
}
public static void main(String[] args) {
Text4.showFile("D:\\");
}
}
4、File类成员方法—重置版笔记
4.1、访问文件名
-
getName() //获取文件名
-
getPath() //获取文件路径
-
getAbsoluteFile() //绝对文件名
-
getAbsolutePath() //绝对文件路径
-
getParent() //获取上一层文件路径
-
renameTo(File newName) //把一个文件改成另一个文件
package IO01;
import java.io.File;
public class FileMet {
public static void main(String[] args) {
FileMet fileMet = new FileMet();
fileMet.test1();
}
/*
* getName() //获取文件名
* getPath() //获取文件路径
* getAbsoluteFile() //绝对文件名
* getAbsolutePath() //绝对文件路径
* getParent() //获取上一层文件路径
* renameTo(File newName) //把一个文件改成另一个文件
* */
public void test1(){
File file1 = new File("D:\\桌面\\Java工程\\IO\\Hello.txt");
File file2 = new File("Hello.txt");
File file3 = new File("D:\\桌面\\Java工程\\IO");
System.out.println(file1.getName());
System.out.println(file1.getPath());
System.out.println(file1.getAbsoluteFile());
System.out.println(file1.getAbsolutePath());
System.out.println(file1.getParent());
System.out.println();
System.out.println(file2.getName());
System.out.println(file2.getPath());
System.out.println(file2.getAbsoluteFile());
System.out.println(file2.getAbsolutePath());
System.out.println(file2.getParent());
System.out.println();
System.out.println(file3.getName());
System.out.println(file3.getPath());
System.out.println(file3.getAbsoluteFile());
System.out.println(file3.getAbsolutePath());
System.out.println(file3.getParent());
//renameTo(File newName): 重命名
//file1.renameTo(file2): 将file1重命名为file2
//要求file1文件一定存在，file2一定不存在
//同是文件或文件目录
boolean b = file1.renameTo(file2);
System.out.println(b);
}
}
4.2、文件检测&获取常规文件信息
-
exists() //判断这个文件是否存在
-
canWrite() //判断是否可写
-
canRead() //判断是否可读
-
isFile() //判断是否为文件
-
isDirectory() //判断是否为文件目录(文件夹)
-
lastModified() //返回文件最后修改时间
-
length() //返回文件的大小
package IO01;
import java.util.Date;
import java.io.File;
public class FileTest {
public static void main(String[] args) {
FileTest fileTest = new FileTest();
fileTest.test();
}
/*
exists() //判断这个文件是否存在
canWrite() //判断是否可写
canRead() //判断是否可读
isFile() //判断是否为文件
isDirectory() //判断是否为文件目录(文件夹)
lastModified() //返回文件最后修改时间
length() //返回文件的大小
*/
public void test(){
File file1 = new File("D:\\桌面\\Java工程\\IO\\Hello.txt");
File file2 = new File("D:\\桌面\\Java工程\\IO");
System.out.println(file1.exists());
System.out.println(file1.canWrite());
System.out.println(file1.canRead());
System.out.println(file1.isFile());
System.out.println(file1.isDirectory());
System.out.println(new Date(file1.lastModified()));
System.out.println(file1.length());
System.out.println();
System.out.println(file2.exists());
System.out.println(file2.canWrite());
System.out.println(file2.canRead());
System.out.println(file2.isFile());
System.out.println(file2.isDirectory());
System.out.println(new Date(file2.lastModified()));
System.out.println(file2.length());
}
}
4.3、文件操作相关&目录操作相关
package IO01;
import java.io.File;
import java.io.IOException;
public class CreateFile {
public static void main(String[] args) throws IOException {
CreateFile createFile = new CreateFile();
createFile.test();
}
/*
文件相关 createNewFile() :创建一个文件
文件夹相关 |delete() //删除成功返回true
mkDir() :创建一个文件目录，只有在上层文件目录存在的情况下，才能返回true
mkDirs() :创建一个文件目录，若上层文件目录不存在，一并创建
list() : 字符串形式保存
listFiles()
*/
public void test() throws IOException {
File file1 = new File("D:\\桌面\\Java工程\\IO\\Hello.txt");
System.out.println(file1.delete());
if (!file1.exists()){
boolean newFile = file1.createNewFile();
System.out.println(newFile);
}
File file2 = new File("D:\\桌面\\Java工程\\IO\\IO02");
if (!file2.exists()){
boolean mkdir = file2.mkdir();
System.out.println(mkdir);
//上层文件目录不存在，无法创建。如果用mkdirs，上层目录不在，也创建
}
File file3 = new File("D:\\桌面");
String[] list = file3.list();
for (int i = 0; i < list.length; i++) {
System.out.println(list[i]);
}
System.out.println();
File[] files = file3.listFiles();
for (int i = 0; i < files.length; i++) {
System.out.println(files[i].getName());
}
}
}
5、IO流
输入input
输出output
分类：
-
数据单位：字节流(8 bit),字符流(16 bit)
-
流向：输入流，输出流
-
角色：节点流，处理流
| [抽象基类] | 字节流 | 字符流 |
|---|---|---|
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
1、字节流
FileInputStream
输入流：InputStream
package Z$IO;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class TestFileInputOutputStream {
public static void main(String[] args) throws Exception {
TestFileInputOutputStream test = new TestFileInputOutputStream();
// test.testFileInputStream1();
// test.testFileInputStream2();
test.testFileInputStream3();
}
/*
1.流的分类
按照流向的不同，分为输入输出流
按照处理数据的单位不同，字节流，字符流(处理的文本文件)
按照角色不同，节点流(直接作用于文件上)，处理流
1.IO的体系
抽象基类 节点流(文件流)//访问文件//
InputStream FileInputStream
OutputStream FileOutputStream
Reader FileReader
Writer FileWriter
*/
public void testFileInputStream3(){
FileInputStream fis = null;
try {
File file = new File("Hello.txt");
fis = new FileInputStream(file);
byte[] b = new byte[5];//要读取到的数据要写入的数组
int len; //每次读入到byte中的字节的长度
while ((len=fis.read(b))!=-1){
for (int i = 0; i < len; i++) {
System.out.print((char) b[i]);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fis!=null) {
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//使用try-catch的方式处理如下的异常更合理！:保证流的关闭操作一定可以执行
public void testFileInputStream2(){
FileInputStream FIS = null;
try {
//1.创建一个File类的对象
File file = new File("Hello.txt");
//2.创建一个FileInputStream类的对象
FIS = new FileInputStream(file);
//3.调用FileInputStream的方法，实现file文件的读取。
int b;
while ((b=FIS.read())!=-1){
System.out.print((char) b);
}//一次一个字节，想办法一次多送几个字节 详情见方法3
} catch (IOException e) {
e.printStackTrace();
} finally {
System.out.println("123");
try {
if (FIS!=null) {
//4.关闭相应的流
FIS.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//从硬盘存在的一个文件中，读取其内容到程序中。使用FileInputStream
//要读取的文件一定要存在，否则抛FileNoFoundException异常
public void testFileInputStream1() throws Exception {
//1. 创建一个File类的对象。
File file = new File("Hello.txt");
//2. 创建一个FileInputStream类的对象
FileInputStream fileInputStream = new FileInputStream(file);
//3. 调用FileInputStream的方法，实现file文件的读取。
/*
read():读取文件的一个字节。当执行到文件结尾时返回-1
*/
// int b=fileInputStream.read();
// while (b!=-1){
// System.out.print((char)b);
// b=fileInputStream.read();
// } //读取操作
// 简写
int b;
while ((b=fileInputStream.read())!=-1){
System.out.print((char)b);
}
//4.关闭相应的流
fileInputStream.close();
}
}
FileOutputStream
输出流：OutputStream
package Z$IO;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestFileOutputStream {
public static void main(String[] args) {
TestFileOutputStream test = new TestFileOutputStream();
test.testFileOutputStream();
}
/*
1.流的分类
按照流向的不同，分为输入输出流
按照处理数据的单位不同，字节流，字符流(处理的文本文件)
按照角色不同，节点流(直接作用于文件上)，处理流
1.IO的体系
抽象基类 节点流(文件流)//访问文件//
InputStream FileInputStream
OutputStream FileOutputStream
Reader FileReader
Writer FileWriter
*/
public void testFileOutputStream(){
//1.创建一个File对象，表明要写入的文件位置
//输出的物理文件可以不存在，当执行过程中，若不存在，会自动创建
File file = new File("HelloWord.txt");
//2.创建一个FileOutputStream的对象，将file的对象作为形参传递给FileOutputStream的构造器中
FileOutputStream fos=null;
try {
fos = new FileOutputStream(file);
//3.写入的操作
fos.write(new String("I love China").getBytes());
//将一个字符串转换成字符数组
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.关闭输出流
if(fos!=null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2、字符流
输入流：Reader
输出流：Writer
Reader&Writer
package Z$IO;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class TestFileReader {
public static void main(String[] args) {
TestFileReader testFileReader = new TestFileReader();
// testFileReader.testFileReader();
testFileReader.testFileReaderWriter();
}
/*
使用FileReader FileWriter 可以实现文本文件的复制
对于非文本文件(视频文件，音频，图片等)，只能使用字节流！
*/
public void testFileReaderWriter(){
//1.输入流对应的文件src一定要存在，否则抛异常
//输出流对应的文件file可以不存在，执行过程中会自动创建
FileReader fr=null;
FileWriter fw=null;
try{
File src = new File("ABC.txt");
File file = new File("ABCD.txt");
//2.
fr=new FileReader(src);
fw = new FileWriter(file);
//3.
char[] chars = new char[24];
int len;
while ((len=fr.read(chars))!=-1){
fw.write(chars,0,len);
}
}catch(Exception e){
e.printStackTrace();
}finally {
if(fw!=null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fr!=null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public void testFileReader(){
FileReader fr = null;
try {
File file = new File("ABC.txt");
fr = new FileReader(file);
char[] chars = new char[24];//每次读24个
int len;//记录长度
while ((len=fr.read(chars))!=-1){
String s = new String(chars, 0, len);
System.out.println(s);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fr!=null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3、RandomAccessFile类
-
RandomAccessFile类支持“随机访问”的方式，程序可以直接跳到文件的任意地方来读、写文件
- 支持只访问文件的部分内容
- 可以向已存在的文件后追加内容
-
RandomAccessFile对象包含一个记录指针，用以标示当前读写处的位置。RandomAccessFile类对象可以自由移动记录指针：
- long getFilePointer():获取文件记录指针的当前位置
- void seek(long pos):将文件记录指针定位到pos位置
-
构造器
- public RandomAccessFile(File file,String mode)
- public RandomAccessFile(String name,String mode)
-
创建RandomAccessFile类实例需要指定一个mode参数，该参数指定RandomAccessFile的访问模式：
- r:以只读方式打开
- rw：打开以便读取和写入
- rwd：打开以便读取和写入：同步文件内容的更新
- rws：打开以便读取和写入：同步文件内容和元数据的更新
package Z$IO;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
/*
* RandomAccessFile：支持随机访问
*
* 特点：
* 1. 既可以充当一个输入流，又可以充当一个输出流
* 2. 支持从文件的开头读取、写入
* 3. 支持从任意位置的读取、写入(插入)
* */
public class TestRandomAccessFile {
public void test4(){
//相比于test3更通用
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile(new File("HelloWord.txt"),"rw");
raf.seek(4);
byte[] bytes = new byte[10];
int len;
StringBuffer sb = new StringBuffer();
while ((len=raf.read(bytes))!=-1){
sb.append(new String(bytes,0,len));
}
raf.seek(4);
raf.write("xy".getBytes());
raf.write(sb.toString().getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (raf!=null) {
try {
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//实现插入的效果，在D字符后面插入"XY" //文本只有一行的时候
public void test3(){
//long getFilePointer():获取文件记录指针的当前位置
//void seek(long pos):将文件记录指针定位到pos位置
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile(new File("HelloWord.txt"),"rw");
raf.seek(4);
//把D后边的取出来
String s = raf.readLine();//读一行 EFJGhina
// long filePointer = raf.getFilePointer();//获取当前指针位置
// System.out.println(filePointer);
raf.seek(4);
raf.write("XY".getBytes());
raf.write(s.getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (raf!=null) {
try {
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//实现了实际上是覆盖效果
public void test2(){
//long getFilePointer():获取文件记录指针的当前位置
//void seek(long pos):将文件记录指针定位到pos位置
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile(new File("HelloWord.txt"),"rw");
raf.seek(3);
raf.write("XY".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (raf!=null) {
try {
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//进行文件的读、写
public void test1(){
RandomAccessFile raf1 = null;//r 只读
RandomAccessFile raf2 = null;
try {
raf1 = new RandomAccessFile(new File("Hello.txt"),"r");
raf2 = new RandomAccessFile(new File("HelloWord.txt"),"rw");
byte[] bytes = new byte[20];
int len;
while ((len=raf1.read(bytes))!=-1){
raf2.write(bytes,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (raf2!=null) {
try {
raf2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (raf1!=null) {
try {
raf1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
TestRandomAccessFile tRAF = new TestRandomAccessFile();
// tRAF.test1();
// tRAF.test2();
// tRAF.test3();
tRAF.test4();
}
}
//部分图片来自网络，若有侵犯了您的合法权益，请联系我删除