IO框架
流的概念
内存与存储设备之间传输数据的通道
流的分类
输入流：存储设备==========>内存
输出流：存储设备<==========内存
字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据
节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础上增强功能
字节流
字节流的父类（抽象类）：
FileInputStream：字节输入流
public class Demo01 {
public static void main(String[] args) throws IOException {
//创建文件字节输入流，指定文件路径
FileInputStream fileInputStream = new FileInputStream("E:\\Java学习\\inputexample.txt");
//单个字节读取文件
//int data = 0;
//while ((data = fileInputStream.read()) != -1){
//System.out.print((char) data);
//}
//System.out.println("");
//System.out.println("执行结束");
//一次性读取多个字节
byte[] buf = new byte[2];
int count = 0;
while ((count = fileInputStream.read(buf)) != -1){
System.out.print(new String(buf,0,count));
}
}
}
FileOutputStream：字节输出流
public class Demo02 {
public static void main(String[] args) throws Exception{
//创建文件字节流输出对象
FileOutputStream fileOutputStream = new FileOutputStream("E:\\Java学习\\IO框架\\example.txt",true);
fileOutputStream.write(3);
fileOutputStream.write('9');
fileOutputStream.write(38);
String b = "What are you talking about?";
fileOutputStream.write(b.getBytes());
fileOutputStream.close();
System.out.println("The end.");
}
}
利用字节输入流和字节输出流复制文件（文件类型不受限）
public class Demo03 {
public static void main(String[] args) throws Exception{
//文件字节输入流
FileInputStream fileInputStream = new FileInputStream("E:\\Java学习\\IO框架\\微信截图_20200706105652.png");
//文件字节输出流
FileOutputStream fos = new FileOutputStream("E:\\Java学习\\IO框架\\复制微信截图_20200706105652.png");
byte[] buf = new byte[1024];
int count = 0;
while ((count = fileInputStream.read(buf)) != -1){
fos.write(buf,0,count);//写入一个字节的内容
}
System.out.println("复制结束");
fileInputStream.close();
fos.close();
}
}
BufferInputStream/BufferOutputStream:字节缓冲流
提高I/O效率，减少访问磁盘的次数；数据存储在缓冲区中，flush是将缓存区的内容写入文件，也可以直接close
public class Demo04 {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("E:\\Java学习\\inputexample.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//int data = 0;
//while ((data = bis.read()) != -1){
//System.out.print((char)data);
//}
//bis.close();
byte[] buf =new byte[1024];
int count = 0;
while ((count = bis.read(buf)) != -1){
System.out.print(new String(buf,0,count));
}
bis.close();
}
}
public class Demo05 {
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("E:\\Java学习\\IO框架\\BufferOutputStream.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
for (int i = 0; i < 10; i++) {
bos.write("100100001101010\r\n".getBytes());//写入了8K的缓冲区
bos.flush();//刷新到硬盘里
}
bos.close();
}
}
对象流
ObjectInputStream/ObjectOutpuStream
增强了缓存区功能
增强了八种基本数据类型和字符串功能
增强了读写对象的功能：
readObject() 从流中读取一个对象 反序列化
writeObject() 向流中写入一个对象 序列化
代码实例
public class Star implements Serializable {
//serialVersionUID 序列化版本ID 保证序列化的类和反序列化的类是同一个类
//使用transient来修饰属性，则该属性不能序列化
private int month;
private String name;
public Star() {
}
public Star(int month, String name) {
this.month = month;
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Star{" +
"month=" + month +
", name='" + name + '\'' +
'}';
}
}
public class Demo06 {
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("E:\\Java学习\\IO框架\\Star-oos.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//序列化
Star star1 = new Star(12,"Capricorn");
Star star2 = new Star(1,"Aquarius");
ArrayList<Star> stars = new ArrayList<>();
stars.add(star1);
stars.add(star2);
oos.writeObject(stars);
oos.close();
System.out.println("序列化结束");
}
}
public class Demo07 {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("E:\\Java学习\\IO框架\\Star-oos.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
ArrayList<Star> list = (ArrayList<Star>)ois.readObject();
System.out.println(list.toString());
ois.close();
}
}
字符流
字符编码
ISO-8859-1
UTF-8
GB2312(95年之前)
GBK
BIG5
字符流的父类（抽象类）
reader：字符输入流
writer：字符输出流
文件字符流FileReader/FileWriter
public class Demo09 {
public static void main(String[] args) throws Exception{
FileReader fileReader = new FileReader("E:\\Java学习\\IO框架\\example.txt");
//System.out.println("=====单个字符读取");
//int data = 0;
//while ((data = fileReader.read()) != -1){
//System.out.print((char)data);
//}
//fileReader.close();
char[] buf =new char[1024];
int count = 0;
while ((count = fileReader.read(buf)) != -1){
System.out.print(new String(buf,0,count));
}
fileReader.close();
}
}
public class Demo10 {
public static void main(String[] args) throws Exception{
FileWriter fileWriter = new FileWriter("E:\\Java学习\\IO框架\\输入字符流.txt");
for (int i = 0; i < 100; i++) {
fileWriter.write("在这复杂的世界里\r\n");
}
fileWriter.close();
}
}
复制文件的案例：使用字符流只能复制文本文件，不能复制其他类型的文件（二进制文件、图片音频等）
public class Demo11 {
public static void main(String[] args) throws Exception{
FileWriter fileWriter = new FileWriter("E:\\Java学习\\IO框架\\字符流复制案例.txt");
FileReader fileReader = new FileReader("E:\\Java学习\\IO框架\\example.txt");
int data = 0;
while ((data = fileReader.read()) != -1){
fileWriter.write(data);
}
fileReader.close();
fileWriter.close();
}
}
字符缓冲流
高效读写；支持换行符；可以写一行、读一行
public class Demo12 {
public static void main(String[] args) throws Exception{
FileReader fileReader = new FileReader("E:\\Java学习\\IO框架\\example.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);
//自创缓冲区 一个字符一个字符读取
//char[] buf =new char[1024];
//int count = 0;
//while ((count = bufferedReader.read(buf)) != -1){
//System.out.print(new String(buf,0,count));
//}
//bufferedReader.close();
String line = null;
while ((line = bufferedReader.readLine()) != null){
System.out.println(line);
}
bufferedReader.close();
}
}
public class Demo13 {
public static void main(String[] args) throws Exception{
FileWriter fileWriter = new FileWriter("E:\\Java学习\\IO框架\\字符缓冲输入流.txt");
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
for (int i = 0; i < 10; i++) {
bufferedWriter.write("少吃一点！\r\n");
bufferedWriter.newLine();//写入一个换行符
bufferedWriter.flush();
}
bufferedWriter.close();
System.out.println("the mission is over");
}
}
打印流PrintWriter
public class Demo14 {
public static void main(String[] args) throws Exception{
PrintWriter printWriter = new PrintWriter("E:\\Java学习\\IO框架\\打印流.txt");
printWriter.println(100);
printWriter.println("love");
printWriter.println(100.987);
printWriter.println('b');
printWriter.close();
}
}
转换流InputStreamReader/OutputStreamWriter
可以将字节流转换为字符流inputstreamreader/OutputStreamWriter
public class Demo15 {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("E:\\Java学习\\IO框架\\example.txt");
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
int data = 0;
while ((data = isr.read()) != -1){
System.out.print((char)data);
}
isr.close();
}
}
public class Demo16 {
public static void main(String[] args) throws Exception{
FileOutputStream fileOutputStream = new FileOutputStream("E:\\Java学习\\IO框架\\转换流.txt");
OutputStreamWriter gbk = new OutputStreamWriter(fileOutputStream, "gbk");
for (int i = 0; i < 10; i++) {
gbk.write("我好累啊\r\n");
gbk.flush();
}
gbk.close();
System.out.println("执行结束");
}
}
File类
代表物理盘符中的一个文件或者一个文件夹
public class Demo01 {
public static void main(String[] args) throws Exception{
//separator();
//fileOpe();
directorOpe();
}
public static void separator(){
System.out.println("路径分隔符"+ File.pathSeparator);
System.out.println("名称分隔符"+ File.separator);
}
public static void fileOpe() throws Exception{
//创建文件 createnewFile
File file = new File("E:\\Java学习\\IO框架\\file.txt");//不写路径只写文件名，则会直接在项目里创建文件
System.out.println(file.toString());
if (!file.exists()){
boolean b = file.createNewFile();
System.out.println("创建结果"+b);
}
//删除文件
//1. 直接删除delete
//System.out.println("删除结果"+file.delete());
//2. 使用jvm退出时删除
//file.deleteOnExit();
//Thread.sleep(5000);
//获取文件信息
System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
System.out.println("获取文件路径："+file.getPath());
System.out.println("获取文件名称："+file.getName());
System.out.println("获取文件父目录："+file.getParent());
System.out.println("获取文件长度："+file.length());
System.out.println("获取文件创建时间："+new Date(file.lastModified()).toLocaleString());
//判断
System.out.println("是否可写"+file.canWrite());
System.out.println("是否是文件"+file.isFile());
System.out.println("是否隐藏"+file.isHidden());
}
public static void directorOpe() throws Exception{
//创建文件夹
File dir = new File("E:\\Java学习\\IO框架\\file1\\file2\\file3");
System.out.println(dir.toString());
if (!dir.exists()){
//dir.mkdir();//只能创建单级目录 mkdirs可以创建多级目录
System.out.println("创建结果"+dir.mkdirs());
}
//获取文件夹信息
System.out.println("获取绝对路径："+dir.getAbsolutePath());
System.out.println("获取路径："+dir.getPath());
System.out.println("获取名称："+dir.getName());
System.out.println("获取文件父目录："+dir.getParent());
System.out.println("获取文件创建时间："+new Date(dir.lastModified()).toLocaleString());
//判断
System.out.println("是否是文件夹"+dir.isFile());
System.out.println("是否隐藏"+dir.isHidden());
//遍历文件夹
File file2 = new File("C:\\Users\\Think\\Desktop\\我爱北极熊");
String[] files = file2.list();
System.out.println("---------------");
for (String s : files) {
System.out.println(s);
}
System.out.println("=================FileFilter接口的使用================");
File[] files2 = file2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".jpg")){
return true;
}
return false;
}
});
for (File file : files2) {
System.out.println(file.getName());
}
//删除文件夹
//直接删除
//System.out.println("删除结果"+dir.delete());//只删除最底层的目录，且必须为空目录
//JVM删除
//dir.deleteOnExit();
//Thread.sleep(5000);
}
}
递归遍历/删除文件夹练习
public class ListDemo {
public static void main(String[] args) {
//listdir(new File("E:\\Java学习\\IO框架\\myfiles"));
deleteDir(new File("E:\\Java学习\\IO框架\\myfiles2"));
}
//递归遍历文件夹
public static void listdir(File dir){
File[] files = dir.listFiles();
System.out.println(dir.getAbsolutePath());
if (files != null && files.length>0){
for (File file : files) {
if (file.isDirectory()){
listdir(file);
}else{
System.out.println(file.getAbsolutePath());
}
}
}
}
//递归删除文件夹
public static void deleteDir(File dir){
File[] files = dir.listFiles();
if (files!=null && files.length>0){
for (File file : files) {
if (file.isDirectory()){
deleteDir(file);
}else{
System.out.println(file.getAbsolutePath()+"删除"+file.delete());
}
}
}
System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());
}
}
FileFilter接口
properties
属性集合
特点：
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
public class Demo02 {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
properties.setProperty("username","Faye");
properties.setProperty("userage","20");
System.out.println(properties.toString());
//遍历
//keyset entryset都可以
//stringpropertynames()
Set<String> propertyNames = properties.stringPropertyNames();
for (String propertyName : propertyNames) {
System.out.println(propertyName+"===="+properties.getProperty(propertyName));
}
//和流有关的方法
//list方法
PrintWriter printWriter = new PrintWriter("E:\\Java学习\\IO框架\\打印流properties.txt");
properties.list(printWriter);
printWriter.close();
//store保存
FileOutputStream fos = new FileOutputStream("E:\\Java学习\\IO框架\\store.properties");
properties.store(fos,"注释");
fos.close();
//load加载
Properties properties2 = new Properties();
FileInputStream fis = new FileInputStream("E:\\Java学习\\IO框架\\store.properties");
properties2.load(fis);
System.out.println(properties2.toString());
}
}
浙公网安备 33010602011771号