Java输入输出流
File类的使用
- 什么是文件?
- 文件可认为是相关记录或放在一起的数据的集合
- 在Java中，使用java.io.File类对文件进行操作。
package may10;
import java.io.File;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
// 创建File对象(3中方式)
/**
* c:\\JavaTest\\IO 绝对路径
* IO\1 相对路径
* File file1=new File("IO\\1");表示当前目录开始
* “。。\\”表示跳上一级目录
*/
//File file=new File("c:\\JavaTest\\IO\\1.txt");
//File file=new File("c:\\JavaTest","IO\\1.txt");
File file=new File("c:\\JavaTest");
File file1=new File(file,"IO\\1");
/**
* 判断是文件还是目录
*/
System.out.println("content:"+file1.isDirectory());
System.out.println("File:"+file1.isFile());
// 创建目录
File file2=new File("c:\\JavaTest\\Set","HashSet");
if (!file2.exists()){
// 创建单目录 mkdir 多级目录mkdirs
//file2.mkdir();
file2.mkdirs();
}
// 创建文件
if (!file1.exists()){
try {
file1.createNewFile();
/**
* 判断是否是绝对路径isAbsolute()
* 获取相对路径：getPath()
* 获取绝对路径：getAbsolutePath（）
* 获取文件名：getName（）
*/
System.out.println(file1.isAbsolute());
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(file1.getAbsolutePath());
System.out.println(file1.getPath());
}
}
字节流
package may10;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Test2 {
/**
* 字节流
* 字节输入流：InputStream
* FileInputStream
* BufferedInputStream
* 字节输出流：OutputStream
* FileOutputStream
* BufferedOutputStream 缓冲
*/
public static void main(String[] args) {
/**
* FileInputStream.
* 从文件中获取字节
* 用于读取图像原始字节流
*/
// // 创建FileInputStream对象
// try {
// FileInputStream fis=new FileInputStream("src\\may10\\imooc.txt");
// //int n=fis.read();
// // read -1:end
int n=0;
while (n!=-1){
System.out.print((char) n);
n= fis.read();
}
// int n=0;
// while ((n=fis.read())!=-1){
// System.out.print((char) n);
// }
// fis.close();
// System.out.println((char) n);
// } catch (FileNotFoundException e) {
// e.printStackTrace();
// }catch (IOException e){
// e.printStackTrace();
// }
// 创建FileInputStream对象
try {
FileInputStream fis = new FileInputStream("src\\may10\\imooc.txt");
byte[] b=new byte[100];
// fis.read(b);
// System.out.println(new String(b));
fis.read(b,0,5);
System.out.println(new String(b));
// read 读取过后在读取不会在从头开始
int n=fis.read();
System.out.println((char) n);
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 文件写入 拷贝
package may10;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test3 {
/* public static void main(String[] args) {
// FileOutputSream
FileOutputStream fos;
FileInputStream fis;
try {
// append:true 不覆盖源文件
fos=new FileOutputStream("src\\may10\\imooc.txt",true);
fis=new FileInputStream("src\\may10\\imooc.txt");
fos.write(50);
fos.write('a');
System.out.println(fis.read());
System.out.println((char) fis.read());
fos.close();
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
}*/
public static void main(String[] args) {
// 文件拷贝
FileInputStream fis;
FileOutputStream fos;
try {
fis=new FileInputStream("src\\image\\happy.gif");
fos=new FileOutputStream("src\\image\\happycopy.gif");
int n=0;
byte[] b=new byte[1024];
while ((n=fis.read(b))!=-1){
fos.write(b,0,n);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
}
}
缓冲流
package may10;
import java.io.*;
/**
* 缓冲流
*/
public class Test4 {
public static void main(String[] args) {
FileOutputStream fos;
FileInputStream fis;
BufferedOutputStream bos;
BufferedInputStream bis;
try {
// 加入缓冲流速度更快
fos = new FileOutputStream("src\\may10\\imooc.txt");
bos = new BufferedOutputStream(fos);
fis = new FileInputStream("src\\may10\\imooc.txt");
bis = new BufferedInputStream(fis);
long startTime=System.currentTimeMillis();
bos.write(50);
bos.write('a');
bos.flush(); //强制清空，写入
System.out.println(bis.read());
System.out.println((char) bis.read());
long endTime=System.currentTimeMillis();
System.out.println(endTime-startTime);
bos.close(); //数据也写进去了
bis.close();
fis.close();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
字符流
package may10;
import java.io.*;
/**
* 字符流 不是二进制流
* Reader
* writer
* 字节字符转换流
* InputStreamReader
*/
public class Test5 {
public static void main(String[] args) {
FileInputStream fis;
InputStreamReader isr;
FileOutputStream fos;
OutputStreamWriter osw;
// 加入缓冲区提高转换效率
BufferedReader br;
BufferedWriter bw;
try {
// 读写要保持编码一致
fis = new FileInputStream("src\\may10\\imooc.txt");
isr = new InputStreamReader(fis,"GBK");
fos = new FileOutputStream("src\\may10\\imooc1.txt");
osw = new OutputStreamWriter(fos,"GBK");
br=new BufferedReader(isr);
bw=new BufferedWriter(osw);
int n = 0;
char[] cbuf = new char[10];
//1
// while ((n=isr.read())!=-1){
// System.out.print((char) n);
}
// 2
while ((n = br.read(cbuf)) != -1) {
//String s=new String(cbuf,0,n);
// System.out.print(s);
bw.write(cbuf, 0, n);
bw.flush();
}
fis.close();
fos.close();
isr.close();
osw.close();
br.close();
bw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
对象序列化
package may10;
import java.io.*;
/**
* 对象序列化:将Java对象转换成字节序列化的过程 反序列化：就是转成Java对象
* 创建一个类，继承Serializable接口
* 创建对象
* 将对象写入文件
* 从文件读取对象信息
*
* 对象输入流与输出流
*/
public class Test6 {
public static void main(String[] args) {
// 定义Goods对象
Goods goods=new Goods("s01","电脑",3000);
try {
FileOutputStream fos=new FileOutputStream("src\\may10\\imooc.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
FileInputStream fis=new FileInputStream("src\\may10\\imooc.txt");
ObjectInputStream ois=new ObjectInputStream(fis);
// 将对象信息写入文件
oos.writeObject(goods);
oos.writeBoolean(true);
oos.flush();
// 读取文件信息
Goods goods1=(Goods) ois.readObject();
System.out.println(goods1);
System.out.println(ois.readBoolean());
oos.close();
fos.close();
fis.close();
ois.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}catch (ClassNotFoundException e){
e.printStackTrace();
}
}
}
作业 01
-
创建一个File类对象，判断指定文件或目录是否存在，若存在判断其是文件还是目录，是否可读、可写。
-
效果图:
-
任务要求:
-
1、先在File文件下创建一个Monday.docx的文件。 判断文件是否创建成功，若成功返回文件名称和父目录。
-
2、先判断文件是否存在，若存在就先获取其路径或名称。
-
3、再判断其是文件还是目录;判断文件是否可读、可写:
方法:请用适当的方法创建文件，判断是文件还是目录;以及判断文件的可读性。
package homework.File;
import java.io.File;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
// 创建文件
File file=new File("src\\homework\\file\\Monday.docx");
if (!file.exists()){
try {
file.createNewFile();
System.out.println("文件创建成功！");
System.out.println("文件名称："+file.getName());
System.out.println("文件上一级目录："+file.getParent());
} catch (IOException e) {
e.printStackTrace();
}
}
if (file.exists()){
System.out.println("文件绝对路径"+file.getAbsolutePath());
}
System.out.print("文件/目录：");
if (file.isFile()){
System.out.println("这是文件");
}else if (file.isDirectory()){
System.out.println("这是目录");
}
if (file.canRead() && file.canWrite()){
System.out.println("文件是可读、可写");
}else if (file.canRead()){
System.out.println("文件是可读");
}else if (file.canWrite()){
System.out.println("文件是可写");
}
}
}
- 效果图
作业 02
- 老师让程序员小马统计英文演讲稿speech.txt文件中共有多少个字符，并显示所有内容以便在演讲开始前
有个准备，假如你是小马，请完成老师教给你的任务。 - 文本内容: abcdefghijklmnopqrst
- 统计结果: speech. txt文件中共有20个字节。
- 任务要求:
- 1、实例化FileInputStream对象
- 2、设置while循环读取speech.txt文件内容
- 3、在循环中设置计数器count, 每读取一个字节，count加1
package homework.File;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class test02 {
public static void main(String[] args) {
FileInputStream fis ;
try {
fis =new FileInputStream("src\\homework\\file\\speech.txt");
int n,count=0;
System.out.print("文件内容：");
while ((n=fis.read())!=-1){
count++;
System.out.print((char) n);
}
System.out.println();
System.out.print("统计结果：speech有多少"+count+"字节");
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
}
}
- 效果图
作业 03
- 编写一个Java程序，将100000个字符分别写入文件one.txt和文件two.txt, one用不加缓冲的文件输出流
来写，two用缓冲文件输出流来写，比较用时的多少。 - 效果图:
- one . txt不使用缓冲流来写
- 用时为: 98
- two. txt使用缓冲流来写
- 用时为: 2
- 节省时间: 96ms
- 任务要求:
- 1、用FileOutputStream写one;
- 2、用BufferedOutputStream写two;
- 3、写100000个字符，可以使用for循环一次写入一 个。
package homework.File;
import java.io.*;
public class test03 {
public static void main(String[] args) {
int i=0;
FileOutputStream fos;
BufferedOutputStream bos;
System.out.println("one.txt不使用缓冲流来写");
try {
long startTime=System.currentTimeMillis();
fos =new FileOutputStream("src\\homework\\file\\1.txt");
while (i<10000){
fos.write(i++);
}
long endTime=System.currentTimeMillis();
System.out.println("用时："+(endTime-startTime));
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
System.out.println("one.txt使用缓冲流来写");
try {
long startTime=System.currentTimeMillis();
fos=new FileOutputStream("src\\homework\\file\\1.txt");
bos=new BufferedOutputStream(fos);
while (i<10000){
bos.write(i++);
}
bos.flush();
long endTime=System.currentTimeMillis();
System.out.println("用时："+(endTime-startTime));
fos.close();
bos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
}
}
1323
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
