Java IO 学习案例

最新推荐文章于 2024-10-17 10:27:13 发布
最新推荐文章于 2024-10-17 10:27:13 发布
阅读量138 收藏
点赞数
分类专栏： # IO学习案例 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42739776/article/details/107761863
版权

文章目录

1.File类的使用：

public class FileTest {
  public static void main(String[] args) {
//	  testFileCreate();
//   delDir("G:\\test\\myTestFile");
//	  printFile("G:\\test\\mytest",0);//0为当前目录层级；就只是个计数器，用于递归调用而已
	//  changeFile("G:\\test\\mytest\\javabook");
//	  renameNum("G:\\test\\mytest\\javabook");
	  renameDel("G:\\test\\mytest\\orcalbook", "zh2");
  }

  //File类的简单使用
  private static void testFileCreate() {
  //构造器中传的是路径;我这里用的绝对路径
	  File file = new File("G:\\test\\fileTest.txt");
	    File file2 = new File("G:\\test\\myTestFile");
	  if(file2.mkdir()) {
	    	System.out.println("创建成功");
	    }
		if(file.exists()) {
		//获取文件名
			String name = file.getName();
		//获取文件绝对路径	
			String absolutePath = file.getAbsolutePath();
		//获取文件大小long
			long size = file.length();
		//获取最后修改事件long
			long date = file.lastModified();
			System.out.println("文件名："+name);
			System.out.println("绝对路径"+absolutePath);
			System.out.println("大小："+size);
			System.out.println("日期："+new Date(date));
			System.out.println("上级目录："+file.getParent());
			System.out.println("上级File对象"+file.getParentFile());
		}else {
			try {
				if(file.createNewFile())
				{
					System.out.println("Ok");
				}else {
					System.out.println("创建失败");
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	
  }

//删除目录，递归删除
  private static void delDir(String path) {
	  File dir = new File(path);
	  if(dir.exists()) {
		  if(dir.isDirectory()) {
			 File[] files = dir.listFiles();
			 for(File file:files) {
				 String absoultePath = file.getAbsolutePath();
				 delDir(absoultePath);
			 }
		  }
		  dir.delete();
	  }
  }
  //递归分层打印目录信息 其中level为目录层级
  private static void printFile(String path,int level) {
	  File dir = new File(path);
	  if(dir.exists()) {
		  for(int i=0;i<level;i++) {
			  System.out.print("\t");
		  }
		  System.out.println(dir.getName());
		  if(dir.isDirectory()) {
			  File[] files = dir.listFiles();
			  if(files!=null) {
				  level++;
			  }
				 for(File file:files) {
					 String absoultePath = file.getAbsolutePath();
					 printFile(absoultePath,level);
				 }
	
		  }
		
		 
	  }
  }
/**
以下几个功能是为了：
编写程序将如下目录的文件或子文件进行重命名操作。
	books
	  javabook
		1 abczhiliaotang.txt
		2 zhiliaotangbcd.txt
		10 abczhiliaotang.txt
		...
		100 abczhiliaotang.txt
	  dbbook
		1 abczhiliaotang.txt
		2 zhiliaotangbcd.txt
		10 abczhiliaotang.txt
		99 abczhiliaotang.txt
	  1 abc.txt
   books目录下的文件名为：
	books
	  javabook
		001 abc.txt
		002 bcd.txt
		010 abc.txt
		...
		100 abc.txt
	  dbbook
		01 abc.txt
		02 bcd.txt
		10 abc.txt
		99 abc.txt
*/


  //获取文件名编号最大长度
  private static int getCount(String path) {
	  File dir = new File(path);
	  int count = 1;
	  if(dir.exists()) {
		  if(dir.isDirectory()) {
			  File[] files = dir.listFiles();
			  for(File file : files) {
				  String name = file.getName();
//				  System.out.println(name);
				  int temp = 0;
				  for(int i=0;i<name.length();i++) {
					  if(name.charAt(i)>=48&&name.charAt(i)<=57) {
						  temp++;
						  if(count<temp) {
							  count = temp;
						  }
					  }else {
						  break;
					  }
				  }
			  }
		  }
	  }
//	  System.out.println(count);
	  return count;
  }

	//	对文件编号格式化如从1.txt格式化为01.txt,从2.txt格式化为02.txt
  public static void renameNum(String path) {
	  File dir = new File(path);
	  File newFile;
	  int count = getCount(path);
	  System.out.println("上级"+path);
	  if(dir.exists()) {
		  if(dir.isDirectory()) {
			  File[] files = dir.listFiles();
			  for(File file : files) {
				  String name = file.getName();
				  System.out.println(name);
				  int temp = 0;
				  for(int i=0;i<name.length();i++) {
					  if(name.charAt(i)>=48&&name.charAt(i)<=57) {
						  temp++;
					  }else {
						  break;
					  }
				  }
				  for(int i=0;i<count-temp;i++) {
					  name = "0"+name;
				  }
				  String newPath = path+"\\"+name;
				  System.out.println(newPath);
				  newFile = new File(newPath);
				  file.renameTo(newFile);
			  }
		  }
	  } 
  }
  //删除文件名中的指定字符串，对文件进行重命名
  public static void renameDel(String path,String str) {
	  File newFile;
	  File dir = new File(path);
	  if(dir.exists()) {
		  if(dir.isDirectory()) {
			  File[] files = dir.listFiles();
			  for(File file : files) {
				  String newName =path+"\\"+file.getName().replace(str, "");
				  System.out.println("更改后："+newName);
				  newFile = new File(newName);
				  file.renameTo(newFile);
			  }
		  }
	  }
	  
  }
}

2.流的操作：

public static void main(String[] args) {
        System.out.println("OK");
      //copyFile("G:\\test\\mytest\\javabook\\test.png", "G:\\test\\test.png");//文件复制
        //testFileOutStreamAndOutStreamWriter();//OutStreamWriter的使用
            //testFileWriter();//测试使用FileWriter
        //testBufferedWriter();//测试BufferedWriter
       try {
           testBufferedReader();//测试BufferedReader
        testFileReader();测试FileReader
           testInputStreamReader();//测试InputStreamReader
        } catch (IOException e) {
           e.printStackTrace();
        }


    }

//文件复制功能
    private static void copyFile(String org,String des){
        try {
            InputStream in = new FileInputStream(org);
            OutputStream out = new FileOutputStream(des);
            byte[] bytes =new byte[1024];
            int len=-1;
            while ((len=in.read(bytes))!=-1){
                out.write(bytes, 0, len);
            }
            out.close();
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    //OutputStreamWriter的使用
    private static void testFileOutStreamAndOutStreamWriter(){
        try {
            OutputStream outputStream = new FileOutputStream("G:\\test\\mytest\\javabook\\testFileIO.txt");
            Writer writer = new OutputStreamWriter(outputStream);
            writer.write("嘿嘿嘿");
            writer.close();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //FileWriter的使用
    private static void testFileWriter(){
        try{
            //创建类的实例
            Writer writer = new FileWriter("G:\\test\\mytest\\javabook\\book1.txt");
            //写入数据
            writer.write("Hello 中国");
            //关闭流
            writer.close();
        }catch(IOException ex){
            ex.printStackTrace();
        }
    }

   //bufferedWriter的使用
    private static void testBufferedWriter(){
        try{
			/*
			//创建类的实例
			Writer writer = new FileWriter("book.txt");
			//创建BufferedWriter类的实例
			BufferedWriter bufferedWriter = new BufferedWriter(writer);
			*/
            //创建BufferedWriter类的实例
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("G:\\test\\mytest\\javabook\\book2.txt"));
            //写入数据
            bufferedWriter.write("Hello 中国");
            //写入换行符
            bufferedWriter.newLine();
            //写入数据
            bufferedWriter.write("Hello 中国");
            //关闭流
            bufferedWriter.close();
            bufferedWriter.close();
        }catch(IOException ex){
            ex.printStackTrace();
        }
    }
    //BufferedReader的使用
    private static void testBufferedReader()throws IOException{
        //创建字符流类的实例
        Reader reader = new FileReader("G:\\test\\mytest\\javabook\\book2.txt");
        //创建BufferedReader类的实例
        BufferedReader bufferedReader = new BufferedReader(reader);
        //一行内容
        String line = null;
        while((line = bufferedReader.readLine())!=null){
            //打印一行
            System.out.println(line);
        }
        //关闭流
        bufferedReader.close();
        reader.close();
    }
    //FileReader的使用
    private static void testFileReader()throws IOException{
        //创建字符流类的实例
        Reader reader = new FileReader("G:\\test\\mytest\\javabook\\book2.txt");
        //缓冲区
        char[] buffer = new char[1024];
        int len = -1;	//读取字符的长度
        //读取数据
        while((len = reader.read(buffer))!=-1){
            //使用字符数组构造字符串对象
            String content = new String(buffer);
            //打印
            System.out.println(content);
        }
        //关闭流
        reader.close();
    }
    //InputStreamReader的使用
    private static void testInputStreamReader()throws IOException{
        //创建字节流类的实例
        InputStream in = new FileInputStream("G:\\test\\mytest\\javabook\\book2.txt");
        //创建字符流类的实例
        Reader reader = new InputStreamReader(in);
        //缓冲区
        char[] buffer = new char[1024];
        int len = -1;	//读取字符的长度
        //读取数据
        while((len = reader.read(buffer))!=-1){
            //使用字符数组构造字符串对象
            String content = new String(buffer);
            //打印
            System.out.println(content);
        }
        //关闭流
        reader.close();
        in.close();
    }

3.序列化与反序列化案例：

序列化：将对象存入文件的过程。

反序列化：读取文件中存储的对象。

两个类：ObjectInputStream类和ObjectOutoptStream
首先创建一个类，实现Serializable接口

1.普通对象序列化与反序列化

public class Emp implements Serializable{
private int id;
private String name;
public int getId() {
	return id;
}
public void setId(int id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}

public Emp(int id, String name) {
	super();
	this.id = id;
	this.name = name;
}
}

使用ObjectOutputStream（OutStream out）进行序列化
主要使用writeObject（Object obj）方法

//序列化
    private static void testObjectOutputStream(Emp emp) {
   	 try {
   	 //我写死了路径，一般路径是作为参数传入的
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\TestJava\\testObjectIO.txt"));
		oos.writeObject(emp);
		oos.close();
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
    }

使用ObjectInputStream(InputStream in)进行反序列化
使用 readObject().进行读取，强制转换

   //反序列化
    private static void testObjectInputStream() {
    	try {
    	//我写死了路径，一般路径是作为参数传入的
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\TestJava\\testObjectIO.txt"));
				Emp emp = (Emp)ois.readObject();
				System.out.println(emp.getName());
				//修改name属性
				emp.setName("lisi");
				//调用上面的方法，重新序列化
				testObjectOutputStream(emp);
				ois.close();

    	}catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }

2.集合与反序列化：

//准备工作：
public static void main(String[] args) {
//      copyFile("G:\\test\\mytest\\javabook\\test.png", "G:\\test\\test.png");
    //testObjectIO();
    	Emp emp1 = new Emp(1, "张三");
    	Emp emp2 = new Emp(2, "李四");
    	Emp emp3 = new Emp(3, "张5");
    	List<Emp> emps = new ArrayList<Emp>();
    	emps.add(emp1);
    	emps.add(emp2);
    	emps.add(emp3);
//    	testCollectionObjOut(emps);//集合对象序列化存入txt文件
//    	testObjectIO(emp);//对象序列化存入txt文件
 //   	testObjectIn();//对象反序列化
    	testCollectionObjIn();//集合对象反序列化
    }

//反序列化，写入集合
    private static void testCollectionObjOut(List list) {
    	try {
    	//我写死了路径，一般路径是作为参数传入的
			ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\TestJava\\testCollectionObj.txt"));
			out.writeObject(list);
			out.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }

//反序列化，从txt文件中读取集合
    private static void testCollectionObjIn() {
    	try {
    	//我写死了路径，一般路径是作为参数传入的
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\TestJava\\testCollectionObj.txt"));
			List<Emp> emps = (List<Emp>) ois.readObject();
			for(Emp emp:emps) {
				System.out.println(emp);
			}
			ois.close();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
SinceThenLater
关注
专栏目录
java IO 编程实例
12-24
import java.io.FileNotFoundException; import java.io.FileReader; public class TestFileReader { public static void main(String[] args) { int c = 0; FileReader freader = null; try { freader = new FileReader("d:/io/test.txt");//查看API 它的构造函数 int ln = 0; while((c=freader.read())!=-1){ System.out.println((char)c); } freader.close(); } catch (FileNotFoundException e) { System.out.println("找不到指定的文件"); }catch(Exception ee){ System.out.println("文件读取错误"); } } }
java io案例
10-11
本案例将深入探讨Java IO流的基本概念、主要类库及其在实际编程中的应用。 在Java中，IO流分为两大类：字节流（Byte Stream）和字符流（Character Stream）。字节流处理单个字节的数据，而字符流处理Unicode字符。...
java中IO流的学习
xiaotai1234的博客
05-27 319
IO 1.io流的概念 2.IO流的分类 按照流的方向 输入流：把数据从 其他设备 上读取到 内存 中的流。（字节输入流/字符输入流） 输出流：把数据从 内存 中写出到 其他设备 上的流。（字节输出流/字符输出流） 按照操作的内容 字节流：计算机中的一切都是字节，可以操作任意类型的文件，一次可以操作一个/多个字节 字符流：只能操作纯文本文件，用记事本打开可以看得懂的文件，一次可以操作一个/多个字节 .txt,.java,.html,.css 是纯文本文件 .doc,.xls 不是纯文本文件 3.字节输出流
java io学习报告
This is bill的专属博客
07-21 1066
Io概述 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输介质将流抽象为各种类，方便更直观的进行数据操作。说白了这些类就是用来读取和写入数据的，由于可以读取或写入的媒介非常多，针对每一种媒介jdk提供了单独的类来读和写数据。同时根据读写单位又分为读取按字节读写和按字符读取(根据不同的编码方案,一个字符可能按多个
java.io包的学习，彻底搞透！
展翅腾飞
08-23 644
什么是IO 　　 　　IO（Input/Output）是计算机输出/输出的接口。Java的核心库java.io提供了全面的IO接口，包括：文件读写，标准设备输出等等。Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。此外，Java也对块传
Java I/O学习（附实例和详解）
weixin_30364147的博客
03-06 282
一、Java I/O类结构以及流的基本概念 在阅读Java I/O的实例之前我们必须清楚一些概念，我们先看看Java I/O的类结构图： Java I/O主要以流的形式进行读写数据。 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 根据...
Java文件IO操作及案例
trong_ 的烂笔头
02-03 3938
详细介绍常用的文件IO操作, 即针对文件系统的操作和文件内容的读写, 介绍一些IO操作的代码案例.
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java io流学习
hua226的博客
04-12 2万+
Java io 一、File 1.1 File类概述和构造方法 概述： 它是文件和目录路径名的抽象表示 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。 将来是要通过具体的操作把这个路径的内容转换为具体存在的。 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例 File(String parent,String child) 从父路径名字符串
Java：IO流综合案例（大礼包）
weixin_44918667的博客
05-04 1824
1.第一个简单的IO流 当程序需要读取数据源的数据时，就会通过 IO 流对象开启一个通向数据源的流，通过这个 IO 流对象的相关方法可以顺序读取数据源中的数据。
Java IO流详解（史上最全18个案例代码）
Liugx的博客
03-05 2136
Java IO流是Java中用于输入和输出数据的机制，它提供了一种灵活且强大的方式来处理文件、网络连接和其他数据源。IO流主要分为字节流和字符流两种类型，其中字节流适用于处理二进制数据，而字符流则适用于处理文本数据。Java IO流的核心是输入流和输出流，输入流用于从数据源读取数据，输出流用于向数据源写入数据。
java-网络编程-io流-学习案例
02-25
在本学习案例中，我们关注的是Java的IO流和Socket技术，这些是实现客户端-服务器通信的基础。IO流用于数据的输入输出操作，而Socket则是网络通信的桥梁。 首先，让我们深入了解Java的IO流。IO流在Java中被广泛用于...
java io流 案例
11-11
学习Java IO流时，理解各种流之间的关系和用途至关重要。例如，知道何时使用字节流和字符流，如何利用缓冲流提高性能，以及如何通过转换流处理不同字符编码等问题。此外，掌握异常处理策略也是关键，因为IO操作常常...
Java IO（输入输出）案例练习
09-10
在给定的“Java IO（输入输出）案例练习”中，包含两个小练习，分别涉及字节流和字符流的使用。 首先，我们来看第一个练习，"task01"。这个例子中，开发者可能利用Java的字节流（Byte Stream）来模拟保存每日交易...
javaIO案例
01-15
在这个"javaIO案例"中，我们关注的是如何使用核心的Java IO类，如`InputStream`、`OutputStream`、`FileInputStream`、`FileOutputStream`以及`PipedInputStream`和`PipedOutputStream`等管道流。这些类构成了Java ...
JAVA IO的使用实例
an341221的专栏
02-24 5241
package com.soecode.lyf.web.test; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; ...
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 376
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 679
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
最新发布
qq_57340195的博客
10-17 677
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
java非阻塞io案例
09-20
以下是一个简单的Java NIO非阻塞IO案例： ```java import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SinceThenLater

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值