IO（Input Output）输入输出操作。
包：import java.IO.*;
主要针对当前电脑的物理磁盘，进行目录或文件的创建，删除，读写等等操作。
流：Stream
数据在数据源与程序之间，所经历的一个路径。
以程序为主：
程序--->数据源： 输出流 OutputStream
数据源--->程序： 输入流 InputStream
重要的对象：
File类：
针对路径和文件操作的
数据操作对象：
针对文件中数据内容读写操作的。（；流Stream）
分类：
基础流：按照单个字符进行操作，一个个操作。
高层流：会创建缓冲区域，可以一次性操作数据，
必须建立在 基础流之上。
字节：按照字节操作 --- 速度快，不支持特殊字符，比如中文
字符：按照独立字符操作 --- 速度慢，支持所有的特殊字符
输入：程序读取文件
输出：程序写文件
流 Stream：
基础：
FileInputStream 字节-输入流
FileOutputStream 字节-输出流
FileReader 字符-输入流
FileWriter 字符-输出流
高层：
BufferedInputStream 缓冲-字节-输入流
BufferedOutputStream 缓冲-字节-输出流
BufferedReader 缓冲-字符-输入流
BufferedWriter 缓冲-字符-输出流
所有的流对象 Stream，在文件操作完毕后，必须执行：close()，关闭。
输入流不关闭：文件挂起。
输出流不关闭：容易导致文件没有写入结尾，破损文件。
--File_路径与文档操作
package com.xzm.test; //导入IO流操作的依赖包文件 import java.io.*; public class _01_File_路径与文档操作 { public static void main(String[] args) { // File类： // 针对物理磁盘的目录(文件夹)和文件进行创建，删除，重命名等操作的 //实例化创建文档对象 //必须参数化构造方法，指定路径，文件，后缀 //【目录】 File f = new File("C:/aaa"); //判断指定的对象，是否是一个目录(有没有) if( f.isDirectory() ) { System.out.println("是的，存在的。"); } else { System.out.println("不是，不存在。"); } //如果不是目录， if(!f.isDirectory()) { //创建它 if( f.mkdirs() ) { System.out.println("创建成功！"); } else { System.out.println("无法操作或无权限，请联系管理员！"); } } //判断目录或文件是否是存在 if( f.exists() ) { System.out.println("存在的"); } else { System.out.println("不存在"); } //=============================================== //【文件】 // 默认只能读写操作记事本可以操作的文件类型 // 特殊文件格式，需要下载导入特定的扩展包：word File ff = new File("C:/aaa/aaa.txt"); //判断是否存在，是不是文件 if( ff.exists() ) { System.out.println("存在"); } else { System.out.println("不存在"); } if( ff.isFile() ) { System.out.println("是-存在"); } else { System.out.println("不是-不存在"); } //没有就创建 if(!ff.isFile()) { try { ff.createNewFile(); } catch (IOException e) { //写文件失败：【无权限】 e.printStackTrace(); } } //针对文件：重命名+剪切。 //第一步：创建新文档 File newF = new File("C:/aaa/12345.txt"); ff.renameTo(newF); //获取各种参数:【目录】【文件】 System.out.println("名称：" + ff.getName()); System.out.println("相对路径：" + ff.getPath()); System.out.println("路径：" + ff.getAbsolutePath()); System.out.println("大小：" + ff.length()+"kb"); System.out.println("最后修改日期：" + ff.lastModified()+"时间戳"); //========================================================= //删除目录 // f:目录， ff:文件 //要删除目录，目录必须是空的 if( f.delete() ) { System.out.println("删除成功！"); } else { //没有对应的内容才可以删除 System.out.println("失败，目录不是空的！"); } if( ff.delete() ) { System.out.println("删除成功！"); } else { System.out.println("失败 - 文件被挂起！"); } } }
----File遍历目录
package com.xzm.test; import java.io.File; import java.util.Scanner; public class _03_File_遍历目录 { public static void main(String[] args) { //实例化对象，指定目标 File f = new File("C:/aaa"); //调用方法 .listFiles()，返回一个File对象的数组 //就是当前指定目标下的内容 File[] list = f.listFiles(); //循环遍历 for(File item : list) { //目录 if(item.isDirectory()) { System.out.print("目录---"); } //文件 if(item.isFile()) { System.out.print("文件---"); } //名称 System.out.println(item.getName()); } //================================================== //自定义代码，递归遍历整个指定的目录下所有内容 //跨越操作系统，直接操作物理磁盘的 //因此，Windows系统设置的隐藏效果等， //只是Windows的一个标识，不显示而已， //对于这里的代码，无效的。 //第一步：创建File对象，指定目标 // 目标是一个字符串，可以由用户输入的 System.out.print("请输入目标："); File dir = new File(new Scanner(System.in).next()); //第二步：调用递归方法，传入目标源 digui(dir); } //递归函数 public static void digui(File dir) { //获取传入对象下的列表 File[] list = dir.listFiles(); //迭代循环 // 里面的异常处理，是跨过受保护的文件，不允许读取预览的 for(File item : list) { // try { //目录 if(item.isDirectory()) { //输出信息， System.out.println("目录---"+item.getName()); //递归继续找下一级 digui(item); } //文件 if(item.isFile()) { //输出信息， System.out.println("文件---"+item.getName()); } // } // catch(Exception ex) { // continue; // } } } }
----基础-字节流
package com.xzm.test; //导入io需要的依赖包文件 import java.io.*; public class _04_基础_字节流 { public static void main(String[] args) { //基础 - 字节流 // FileInputStream 输入 // FileOutputStream 输出 //基础流是最基本的对象，按照 byte 字节的方式进行操作的 //【不支持特殊字符：中文就是其中之一】 //由于是字节操作： // 1、不能使用String，必须是一个个 独立的 char 去操作 // 2、它可以操作任何文件：rar，jpg，mp3，mp4，..... //【读写速度快，不支持特殊字符，支持任何类型文件】 try { inputFile(); } catch (IOException e) { e.printStackTrace(); } } //=============================================== //自定义方法，实现 基础-字节流写文档 //【禁止方法中处理异常的】 public static void outputFile() throws IOException { //声明文档对象 File f = new File("C:/aaa/myfile.txt"); //判断：创建 // if(!f.isFile()) { // f.createNewFile(); // } //创建基础字节输出流对象 //必须建立在一个指定的File对象上面。 //如果有文件，打开文件 //如果没有文件，自动创建，再打开文件 FileOutputStream fos = new FileOutputStream(f); //定义写入内容:不支持中文 //程序中，换行 //文档中：换行 String str = "abcd ABCD-这里中文。"; //只能使用char类型写入 for(int i=0; i<str.length(); i++) { //从字符串中提取指定字符 char cr = str.charAt(i); //写入文件 fos.write(cr); } //【重点】：关闭流 fos.close(); } //自定义方法，实现 基础-字节流读文档 public static void inputFile() throws IOException { //创建File对象--数据源 File f = new File("C:/aaa/myfile.txt"); //声明基础字节输入流 //【强制异常处理：属于检查异常checkedException】 //【文件不存在】 FileInputStream fis = new FileInputStream(f); //读取文件 //按照字节方式去读取， f.length() 文件大小就是字节的 //方法：.read()，每一次读取一个， // 返回ASCII码，没有：-1 // 每当读取一个之后，自动移动到下一个 while(true) { //读取，获取ascii //【强制异常：无权限】 int ascii = fis.read(); if(ascii == -1) { break;//读取完毕 } else { //把ascii转换成char字符 System.out.print( (char)ascii ); } } //【重点】：关闭流 fis.close(); } }
----基础字符流
package com.xzm.test; import java.io.*; public class _05_基础_字符流 { public static void main(String[] args) { //基础 - 字符流 // FileReader 输入 // FileWriter 输出 //基础流是最基本的对象，按照 独立字符的方式操作的 //【支持特殊字符，是一个个字去操作的】 //由于是字符操作： // 1、不能使用String，必须是一个个 独立的 char 去操作 // 2、只能用于文件中的文本内容 //【读写速度慢，支持特殊字符】 try { readerFile(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //========================================== //基础字符输出流 public static void writerFile() throws IOException { //数据源对象 File f = new File("C:/aaa/myfile.txt"); //可以单独判断然后创建，例子中不用了 //创建字符输出流 //【强制异常处理】 //有：打开， 没有：创建再打开 FileWriter fw = new FileWriter(f); //直接写入内容 - 替换原有的 //支持String fw.write("今天已经是星期三咯， 今天学习IO内容！"); //支持追加写入 //【只能已char类型追加】 fw.append(' '); fw.append(' '); fw.append('好'); fw.append('☺'); //【关闭】 fw.close(); } //基础 字符输入 public static void readerFile() throws IOException { //数据源对象 File f = new File("C:/aaa/myfile.txt"); //输入流对象 FileReader fr = new FileReader(f); //也是一个个文字读取，获取ascii while(true) { //读取，得到ascii int ascii = fr.read(); //判断 if(ascii==-1) { break;//结束 } else { System.out.print( (char)ascii ); } } //关闭 fr.close(); } }
----高层字节流
package com.xzm.test; import java.io.*; public class _06_高层_字节流 { public static void main(String[] args) { //高层流：Buffered：缓冲区域 //默认操作的先至缓冲区，然后由缓冲区一次性操作。 //有点： // 1、减少对物理磁盘的操作次数。 try { bufferedout(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //===================================================== //高层-字节输出 public static void bufferedout() throws IOException { //数据源对象 File f = new File("C:/aaa/111.txt"); //基础流 FileOutputStream fos = new FileOutputStream(f); //创建高层流 BufferedOutputStream bos = new BufferedOutputStream(fos); //输出写内容：字节-不支持中文 String str = "abcdABCD"; for(int i=0; i<str.length(); i++) { bos.write( str.charAt(i) ); } //上面的内容，先写入缓冲区域， //然后由缓冲区去操作文件 //我们可以清空缓冲区，继续使用这个对象的 //清空缓冲 //【注意】： // 在低版本的JVM中，上面的操作不会写入物理文件。 // 必须调用这个方法，清空缓冲，才会写入物理磁盘。 bos.flush(); //关闭：【有顺序的】 bos.close();//高层 fos.close();//基础 } //高层 - 字节输入 public static void bufferedinput() throws IOException { //数据源 File f = new File("C:/aaa/111.txt"); //基础流 FileInputStream fis = new FileInputStream(f); //高层流 BufferedInputStream bis = new BufferedInputStream(fis); //读取 while(true) { //读取 int ascii = bis.read(); //判断 if(ascii==-1) { break;//结束 } //输出 System.out.print( (char)ascii ); } //上面读取操作的内容，先记录到缓冲区 //然后由缓冲区再呈现出来 //关闭：【顺序】 bis.close();//高层 fis.close();//基础 } }
----高层字符流
package com.xzm.test; import java.io.*; public class _07_高层_字符流 { public static void main(String[] args) { //高层流：Buffered：缓冲区域 //默认操作的先至缓冲区，然后由缓冲区一次性操作。 //有点： // 1、减少对物理磁盘的操作次数。 try { bufferedreader(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //================================================ //高层-字符，输出 public static void bufferedwrite() throws IOException { //数据源 File f = new File("C:/aaa/222.txt"); //基础流 FileWriter fw = new FileWriter(f); //高层流 BufferedWriter bw = new BufferedWriter(fw); //直接创建 //BufferedWriter bw2 = new BufferedWriter(new FileWriter(new File("C:/aaa/222.txt"))); //写内容 bw.write("这里是 高层字符输出流写的。"); //追加：只能一个一个字符追加 bw.append('☻'); //清空缓冲区 bw.flush(); //关闭 bw.close(); fw.close(); } //高层 - 字符，输入 public static void bufferedreader() throws IOException { //一次性声明使用 //就是上面三个独立声明的合并 //减少变量操作 BufferedReader br = new BufferedReader(new FileReader(new File("C:/aaa/222.txt"))); //读取 while(true) { //支持一行一行读取的，没有了就是：null //默认是一个个读取，然后放入缓冲区 //通过方法，从缓冲区拿出一行 String str = br.readLine(); //判断 if(str==null) { break;//结束 } //输出 System.out.println(str); } //关闭 // 由于没有基础流指定对象， // 当关闭高层流的时候，基础流也没有了 br.close(); } }
java针对字符串操作，提供了两个对象：
StringBuilder：
单线程程序，非线程安全的，字符串操作对象。
StringBuffer：
多线程程序，线程安全的（锁），字符串操作对象。
创建一个内存对象，通过行为方法去操作内存中的数据。
始终只有这一个对象存在。
----StringBuilder类
package com.xzm.test; public class _09_StringBuilder类 { public static void main(String[] args) { // StringBuilder：字符串操作对象 // 单线程，非线程安全的 //只创建一个对象，一个内存 //都是通过方法去操作内存，不会产生多余的内存对象。 //实例化对象 StringBuilder sb1 = new StringBuilder();//空字符串 StringBuilder sb2 = new StringBuilder("默认值"); //组合内容:追加 sb1.append("aaaaa"); sb2.append("bbbbb"); sb2.append('c'); //String类有的方法，他全部都有。 //多了新的方法 //插入(索引,"内容") sb2.insert(3, "★★★★★"); //删除指定索引的字符 sb2.deleteCharAt(1); //删除一段：(开始索引，结束索引-1) sb2.delete(3, 6); //获取预览 System.out.println(sb1); System.out.println(sb2); } }
----StringBuffer类
package com.xzm.test; public class _10_StringBuffer类 { public static void main(String[] args) { //与StringBuilder是一样的，只是里面的所有方法 //都有锁机制，适合用于多线程 //实例化对象 StringBuffer sb1 = new StringBuffer();//空字符串 StringBuffer sb2 = new StringBuffer("默认值"); //组合内容:追加 sb1.append("aaaaa"); sb2.append("bbbbb"); //String类有的方法，他全部都有。 //多了新的方法 //插入(索引,"内容") sb2.insert(3, "★★★★★"); //删除指定索引的字符 sb2.deleteCharAt(1); //删除一段：(开始索引，结束索引-1) sb2.delete(3, 6); //获取预览 System.out.println(sb1); System.out.println(sb2); } }