Java基础(4)
正则表达式
正则表达式其实是由一些特殊的符号组成的，它代表的是某种规则。
正则表达式的作用1：用来校验字符串数据是否合法
正则表达式的作用2：可以从一段文本中查找满足要求的内容
如果不用正则表达式，我们来检验qq号是否正确
public static boolean checkQQ(String qq){ // 1、判断qq号码是否为null if(qq == null || qq.startsWith("0") || qq.length() < 6 || qq.length() > 20){ return false; } // 2、qq至少是不是null,不是以0开头的，满足6-20之间的长度。 // 判断qq号码中是否都是数字。 // qq = 2514ghd234 for (int i = 0; i < qq.length(); i++) { // 根据索引提取当前位置处的字符。 char ch = qq.charAt(i); // 判断ch记住的字符，如果不是数字，qq号码不合法。 if(ch < '0' || ch > '9'){ return false; } } // 3、说明qq号码肯定是合法 return true; }但是用正则表达式:
public static boolean checkQQ1(String qq){ return qq != null && qq.matches("[1-9]\\d{5,19}"); }我们发现，使用正则表达式，大大简化的了代码的写法。
正则表达式书写规则
用到一个方法叫
matches(String regex)。这个方法是属于String类的方法。
/**
* 目标：掌握正则表达式的书写规则
*/
public class RegexTest2 {
public static void main(String[] args) {
// 1、字符类(只能匹配单个字符)
System.out.println("a".matches("[abc]")); // [abc]只能匹配a、b、c
System.out.println("e".matches("[abcd]")); // false
System.out.println("d".matches("[^abc]")); // [^abc] 不能是abc
System.out.println("a".matches("[^abc]")); // false
System.out.println("b".matches("[a-zA-Z]")); // [a-zA-Z] 只能是a-z A-Z的字符
System.out.println("2".matches("[a-zA-Z]")); // false
System.out.println("k".matches("[a-z&&[^bc]]")); // ： a到z，除了b和c
System.out.println("b".matches("[a-z&&[^bc]]")); // false
System.out.println("ab".matches("[a-zA-Z0-9]")); // false 注意：以上带 [内容] 的规则都只能用于匹配单个字符
// 2、预定义字符(只能匹配单个字符) . \d \D \s \S \w \W
System.out.println("徐".matches(".")); // .可以匹配任意字符
System.out.println("徐徐".matches(".")); // false
// \转义
System.out.println("\"");
// \n \t
System.out.println("3".matches("\\d")); // \d: 0-9
System.out.println("a".matches("\\d")); //false
System.out.println(" ".matches("\\s")); // \s: 代表一个空白字符
System.out.println("a".matches("\s")); // false
System.out.println("a".matches("\\S")); // \S: 代表一个非空白字符
System.out.println(" ".matches("\\S")); // false
System.out.println("a".matches("\\w")); // \w: [a-zA-Z_0-9]
System.out.println("_".matches("\\w")); // true
System.out.println("徐".matches("\\w")); // false
System.out.println("徐".matches("\\W")); // [^\w]不能是a-zA-Z_0-9
System.out.println("a".matches("\\W")); // false
System.out.println("23232".matches("\\d")); // false 注意：以上预定义字符都只能匹配单个字符。
// 3、数量词： ? * + {n} {n, } {n, m}
System.out.println("a".matches("\\w?")); // ? 代表0次或1次
System.out.println("".matches("\\w?")); // true
System.out.println("abc".matches("\\w?")); // false
System.out.println("abc12".matches("\\w*")); // * 代表0次或多次
System.out.println("".matches("\\w*")); // true
System.out.println("abc12张".matches("\\w*")); // false
System.out.println("abc12".matches("\\w+")); // + 代表1次或多次
System.out.println("".matches("\\w+")); // false
System.out.println("abc12张".matches("\\w+")); // false
System.out.println("a3c".matches("\\w{3}")); // {3} 代表要正好是n次
System.out.println("abcd".matches("\\w{3}")); // false
System.out.println("abcd".matches("\\w{3,}")); // {3,} 代表是>=3次
System.out.println("ab".matches("\\w{3,}")); // false
System.out.println("abcde徐".matches("\\w{3,}")); // false
System.out.println("abc232d".matches("\\w{3,9}")); // {3, 9} 代表是 大于等于3次，小于等于9次
// 4、其他几个常用的符号：(?i)忽略大小写 、 或：| 、 分组：()
System.out.println("abc".matches("(?i)abc")); // true
System.out.println("ABC".matches("(?i)abc")); // true
System.out.println("aBc".matches("a((?i)b)c")); // true
System.out.println("ABc".matches("a((?i)b)c")); // false
// 需求1：要求要么是3个小写字母，要么是3个数字。
System.out.println("abc".matches("[a-z]{3}|\\d{3}")); // true
System.out.println("ABC".matches("[a-z]{3}|\\d{3}")); // false
System.out.println("123".matches("[a-z]{3}|\\d{3}")); // true
System.out.println("A12".matches("[a-z]{3}|\\d{3}")); // false
// 需求2：必须是”我爱“开头，中间可以是至少一个”编程“，最后至少是1个”666“
System.out.println("我爱编程编程666666".matches("我爱(编程)+(666)+"));
System.out.println("我爱编程编程66666".matches("我爱(编程)+(666)+"));
}
}
案例:校验手机号
public static void checkPhone(){ while (true) { System.out.println("请您输入您的电话号码(手机|座机): "); Scanner sc = new Scanner(System.in); String phone = sc.nextLine(); // 18676769999 010-3424242424 0104644535 if(phone.matches("(1[3-9]\\d{9})|(0\\d{2,7}-?[1-9]\\d{4,19})")){ System.out.println("您输入的号码格式正确~~~"); break; }else { System.out.println("您输入的号码格式不正确~~~"); } } }案例:校验邮箱是否正确
public static void checkEmail(){ while (true) { System.out.println("请您输入您的邮箱： "); Scanner sc = new Scanner(System.in); String email = sc.nextLine(); /** * [email protected] * [email protected] * [email protected] */ if(email.matches("\\w{2,}@\\w{2,20}(\\.\\w{2,10}){1,2}")){ System.out.println("您输入的邮箱格式正确~~~"); break; }else { System.out.println("您输入的邮箱格式不正确~~~"); } } }
查找满足要求的内容
正则表达式的第二个作用：在一段文本中查找满足要求的内容
// 需求1：从以下内容中爬取出，手机，邮箱，座机、400电话等信息。
public static void method1(){
String data = " 来黑马程序员学习Java，\n" +
" 电话：1866668888，18699997777\n" +
" 或者联系邮箱：[email protected]，\n" +
" 座机电话：01036517895，010-98951256\n" +
" 邮箱：[email protected]，\n" +
" 邮箱：[email protected]，\n" +
" 热线电话：400-618-9090 ，400-618-4000，4006184000，4006189090";
// 1、定义爬取规则
String regex = "(1[3-9]\\d{9})|(0\\d{2,7}-?[1-9]\\d{4,19})|(\\w{2,}@\\w{2,20}(\\.\\w{2,10}){1,2})"
+ "|(400-?\\d{3,7}-?\\d{3,7})";
// 2、把正则表达式封装成一个Pattern对象
Pattern pattern = Pattern.compile(regex);
// 3、通过pattern对象去获取查找内容的匹配器对象。
Matcher matcher = pattern.matcher(data);
// 4、定义一个循环开始爬取信息
while (matcher.find()){
String rs = matcher.group(); // 获取到了找到的内容了。
System.out.println(rs);
}
}
替换和分割
public String replaceAll(String regex , String newStr)：按照正则表达式匹配的内容进行替换
需求1：请把下面字符串中的不是汉字的部分替换为 “-”
String s1 = "古力娜扎ai8888迪丽热巴999aa5566马尔扎哈fbbfsfs42425卡尔扎巴"; System.out.println(s1.replaceAll("\\w+", "-"));需求2(拓展)：某语音系统，收到一个口吃的人说的“我我我喜欢编编编编编编编编编编编编程程程！”，需要优化成“我喜欢编程！”。
String s2 = "我我我喜欢编编编编编编编编编编编编程程程"; System.out.println(s2.replaceAll("(.)\\1+", "$1"));
public String[] split(String regex)：按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。
需求1：请把下面字符串中的人名取出来，使用切割来做
String s3 = "古力娜扎ai8888迪丽热巴999aa5566马尔扎哈fbbfsfs42425卡尔扎巴"; String[] names = s3.split("\\w+"); System.out.println(Arrays.toString(names));
异常
认识异常
什么是异常？
我们调用一个方法时，经常一部小心就出异常了，然后在控制台打印一些异常信息。其实打印的这些异常信息，就叫做
异常。
因为写代码时经常会出现问题，Java的设计者们早就为我们写好了
很多个异常类，来描述不同场景下的问题。而有些类是有共性的所以就有了异常的继承体系
先来演示一个运行时异常产生
int[] arr = {11,22,33}; //5是一个不存在的索引，所以此时产生ArrayIndexOutOfBoundsExcpetion System.out.println(arr[5]);
再来演示一个编译时异常
调用
SimpleDateFormat对象的parse方法时，要求传递的参数必须和指定的日期格式一致，否则就会出现异常。 Java比较贴心，它为了更加强烈的提醒方法的调用者，设计了编译时异常，它把异常的提醒提前了，你调用方法是否真的有问题，只要可能有问题就给你报出异常提示（红色波浪线）。编译时异常的目的：意思就是告诉你，你小子注意了！！，这里小心点容易出错，仔细检查一下
- 如果确认代码没问题，为了让它不报错，继续将代码写下去。我们这里有
两种解决方案。
第一种：使用throws在方法上声明，意思就是告诉下一个调用者，这里面可能有异常啊，你调用时注意一下。(懒得管，丢给上一级处理)/** * 目标：认识异常。 */ public class ExceptionTest1 { public static void main(String[] args) throws ParseException{ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date d = sdf.parse("2028-11-11 10:24"); System.out.println(d); } }
第二种：使用try...catch语句块异常进行处理。(自己处理)public class ExceptionTest1 { public static void main(String[] args) throws ParseException{ try { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date d = sdf.parse("2028-11-11 10:24"); System.out.println(d); } catch (ParseException e) { e.printStackTrace(); } } }
自定义异常
无法为这个世界上的
全部问题都提供异常类，如果企业自己的某种问题，想通过异常来表示，那就需要自己来定义异常类了。
- 需求：写一个saveAge(int age)方法，在方法中对参数age进行判断，如果age<0或者>=150就认为年龄不合法，如果年龄不合法，就给调用者抛出一个年龄非法异常。
**Java的API中是没有年龄非常这个异常的，**所以我们可以自定义一个异常类，用来表示年龄非法异常，然后再方法中抛出自定义异常即可。
- 先写一个异常类
AgeIllegalException// 1、必须让这个类继承自Exception，才能成为一个编译时异常类。 public class AgeIllegalException extends Exception{ public AgeIllegalException() { } public AgeIllegalException(String message) { super(message); } }public class ExceptionTest2 { public static void main(String[] args) { // 需求：保存一个合法的年 try { saveAge2(225); System.out.println("saveAge2底层执行是成功的！"); } catch (AgeIllegalException e) { e.printStackTrace(); System.out.println("saveAge2底层执行是出现bug的！"); } } //2、在方法中对age进行判断，不合法则抛出AgeIllegalException public static void saveAge(int age){ if(age > 0 && age < 150){ System.out.println("年龄被成功保存： " + age); }else { // 用一个异常对象封装这个问题 // throw 抛出去这个异常对象 throw new AgeIllegalRuntimeException("/age is illegal, your age is " + age); } } }
- 自定义异常可能是编译时异常，也可以是运行时异常
- 1.如果自定义异常类继承
Excpetion，则是编译时异常。
特
点：方法中抛出的是编译时异常，必须在方法上使用throws声明，强制调用者处理。 - 2.如果自定义异常类继承
RuntimeException，则运行时异常。
特点：方法中抛出的是运行时异常，不需要在方法上用throws声明。
异常处理
出现异常该如何处理?
比如有如下的场景：A调用用B，B调用C；C中有异常产生抛给B，B中有异常产生又抛给A；异常到了A这里就不建议再抛出了，因为最终抛出被JVM处理程序就会异常终止，并且给用户看异常信息，用户也看不懂，体验很不好。
比较好的做法就是：
- 1.将异常捕获，将比较友好的信息显示给用户看；
- 2.尝试重新执行，看是是否能修复这个问题。
main方法调用test1方法，test1方法调用test2方法，test1和test2方法中都有扔异常。
第一种处理方式是，在main方法中对异常进行try…catch捕获处理了，给出友好提示。
public class ExceptionTest3 { public static void main(String[] args) { try { test1(); } catch (FileNotFoundException e) { System.out.println("您要找的文件不存在！！"); e.printStackTrace(); // 打印出这个异常对象的信息。记录下来。 } catch (ParseException e) { System.out.println("您要解析的时间有问题了！"); e.printStackTrace(); // 打印出这个异常对象的信息。记录下来。 } } public static void test1() throws FileNotFoundException, ParseException { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date d = sdf.parse("2028-11-11 10:24:11"); System.out.println(d); test2(); } public static void test2() throws FileNotFoundException { // 读取文件的。 InputStream is = new FileInputStream("D:/meinv.png"); } }
第二种处理方式是：在main方法中对异常进行捕获，并尝试修复
/** * 目标：掌握异常的处理方式：捕获异常，尝试修复。 */ public class ExceptionTest4 { public static void main(String[] args) { // 需求：调用一个方法，让用户输入一个合适的价格返回为止。 // 尝试修复 while (true) { try { System.out.println(getMoney()); break; } catch (Exception e) { System.out.println("请您输入合法的数字！！"); } } } public static double getMoney(){ Scanner sc = new Scanner(System.in); while (true) { System.out.println("请您输入合适的价格："); double money = sc.nextDouble(); if(money >= 0){ return money; }else { System.out.println("您输入的价格是不合适的！"); } } } }
File类
File类，它的就用来表示当前系统下的文件（也可以是文件夹）
通过File类提供的方法可以
获取文件大小、判断文件是否存在、创建文件、创建文件夹等。**但是需要我们注意：**File对象
只能对文件进行操作，不能操作文件中的内容。
File对象的创建
学习File类和其他类一样，第一步是创建File类的对象。 想要创建对象，我们得看File类有哪些构造方法。
/** * 目标：掌握File创建对象，代表具体文件的方案。 */ public class FileTest1 { public static void main(String[] args) { // 1、创建一个File对象，指代某个具体的文件。 // 路径分隔符 // File f1 = new File("D:/resource/ab.txt"); // File f1 = new File("D:\\resource\\ab.txt"); File f1 = new File("D:" + File.separator +"resource" + File.separator + "ab.txt"); System.out.println(f1.length()); // 文件大小 File f2 = new File("D:/resource"); System.out.println(f2.length()); // 注意：File对象可以指代一个不存在的文件路径 File f3 = new File("D:/resource/aaaa.txt"); System.out.println(f3.length()); System.out.println(f3.exists()); // false // 我现在要定位的文件是在模块中，应该怎么定位呢？ // 绝对路径：带盘符的 // File f4 = new File("D:\\code\\javasepromax\\file-io-app\\src\\itheima.txt"); // 相对路径（重点）：不带盘符，默认是直接去工程下寻找文件的。 File f4 = new File("file-io-app\\src\\itheima.txt"); System.out.println(f4.length()); } }
File判断和获取文件信息方法
创建File对象的时候，会传递一个文件路径过来。但是File
对象封装的路径是存在还是不存在，是文件还是文件夹其实是不清楚的。好在File类提供了方法可以帮我们做判断。
/** 目标：掌握File提供的判断文件类型、获取文件信息功能 */ public class FileTest2 { public static void main(String[] args) throws UnsupportedEncodingException { // 1.创建文件对象，指代某个文件 File f1 = new File("D:/resource/ab.txt"); //File f1 = new File("D:/resource/"); // 2、public boolean exists()：判断当前文件对象，对应的文件路径是否存在，存在返回true. System.out.println(f1.exists()); // 3、public boolean isFile() : 判断当前文件对象指代的是否是文件，是文件返回true，反之。 System.out.println(f1.isFile()); // 4、public boolean isDirectory() : 判断当前文件对象指代的是否是文件夹，是文件夹返回true，反之。 System.out.println(f1.isDirectory()); } }除了判断功能还有一些获取功能
File f1 = new File("D:/resource/ab.txt"); // 5.public String getName()：获取文件的名称（包含后缀） System.out.println(f1.getName()); // 6.public long length()：获取文件的大小，返回字节个数 System.out.println(f1.length()); // 7.public long lastModified()：获取文件的最后修改时间。 long time = f1.lastModified(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); System.out.println(sdf.format(time)); // 8.public String getPath()：获取创建文件对象时，使用的路径 File f2 = new File("D:\\resource\\ab.txt"); File f3 = new File("file-io-app\\src\\itheima.txt"); System.out.println(f2.getPath()); System.out.println(f3.getPath()); // 9.public String getAbsolutePath()：获取绝对路径 System.out.println(f2.getAbsolutePath()); System.out.println(f3.getAbsolutePath());
创建和删除文件方法
File类提供了
创建和删除文件的方法
- 1.
mkdir(): 只能创建单级文件夹、- 2.
mkdirs(): 才能创建多级文件夹- 3.
delete(): 文件可以直接删除，但是文件夹只能删除空的文件夹，文件夹有内容删除不了。/** * 目标：掌握File创建和删除文件相关的方法。 */ public class FileTest3 { public static void main(String[] args) throws Exception { // 1、public boolean createNewFile()：创建一个新文件（文件内容为空），创建成功返回true,反之。 File f1 = new File("D:/resource/itheima2.txt"); System.out.println(f1.createNewFile()); // 2、public boolean mkdir()：用于创建文件夹，注意：只能创建一级文件夹 File f2 = new File("D:/resource/aaa"); System.out.println(f2.mkdir()); // 3、public boolean mkdirs()：用于创建文件夹，注意：可以创建多级文件夹 File f3 = new File("D:/resource/bbb/ccc/ddd/eee/fff/ggg"); System.out.println(f3.mkdirs()); // 3、public boolean delete()：删除文件，或者空文件，注意：不能删除非空文件夹。 System.out.println(f1.delete()); System.out.println(f2.delete()); File f4 = new File("D:/resource"); System.out.println(f4.delete()); } }
遍历文件夹方法
/** * 目标：掌握File提供的遍历文件夹的方法。 */ public class FileTest4 { public static void main(String[] args) { // 1、public String[] list()：获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。 File f1 = new File("D:\\course\\待研发内容"); String[] names = f1.list(); for (String name : names) { System.out.println(name); } // 2、public File[] listFiles():（重点）获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点） File[] files = f1.listFiles(); for (File file : files) { System.out.println(file.getAbsolutePath()); } File f = new File("D:/resource/aaa"); File[] files1 = f.listFiles(); System.out.println(Arrays.toString(files1)); } }注意:
1.当主调是文件时，或者路径不存在时，返回null
2.当主调是空文件夹时，返回一个长度为0的数组
3.当主调是一个有内容的文件夹时，将里面所有一级文件和文件夹路径放在File数组中，并把数组返回
4.当主调是一个文件夹，且里面有隐藏文件时，将里面所有文件和文件夹的路径放在FIle数组中，包含隐藏文件
5.当主调是一个文件夹，但是没有权限访问时，返回null
字符集
ASCII字符集：《美国信息交换标准代码》，包含英文字母、数字、标点符号、控制字符
特点：1个字符占1个字节
GBK字符集：中国人自己的字符集，兼容ASCII字符集，还包含2万多个汉字
特点：1个字母占用1个字节；1个汉字占用2个字节
Unicode字符集：包含世界上所有国家的文字，有三种编码方案，最常用的是UTF-8
UTF-8编码方案：英文字母、数字占1个字节兼容(ASCII编码)、汉字字符占3个字节
字符集来历
计算机能够处理的数据只能是0和1组成的二进制数据，为了让计算机能够处理字符，于是美国人就把他们会用到的每一个字符进行了
编码（所谓编码，就是为一个字符编一个二进制数据）美国人常用的字符有英文字母、标点符号、数字以及一些特殊字符，这些字符一共也不到128个，所以他们用
1个字节来存储1字符就够了。 美国人把他们用到的字符和字符对应的编码总结成了一张码表，这张码表叫做ASCII码表（也叫ASCII字符集）
计算机慢慢的普及到全世界，当普及到中国的时候，在计算机中想要存储
中文，那ASCII字符集就不够用了，因为中文太多了，随便数一数也有几万个字符。于是中国人为了在计算机中存储中文，也编了一个中国人用的字符集叫做GBK字符集，这里面包含2万多个汉字字符，GBK中一个汉字采用两个字节来存储，为了能够显示英文字母，GBK字符集也兼容了ASCII字符集，在GBK字符集中一个字母还是采用一个字节来存储。
计算机是怎么识别中文和英文的(GBK)
如果一个文件中既有中文，也有英文，那计算机怎么知道哪几个字节表示一个汉字，哪几个字节表示一个字母呢？
需要我们注意汉字和字母的编码特点：
如果是存储字母，采用1个字节来存储，一共8位，其中
第1位是02.如果是存储汉字，采用2个字节来存储，一共16位，其中
第1位是1
当读取文件中的字符时，通过识别读取到的第1位是0还是1来判断是字母还是汉字
如果读取到第1位是0，就认为是一个字母，此时往后读1个字节。如果读取到第1位是1，就认为是一个汉字，此时往后读2个字节。
Unicode字符集
背景:咱们国家可以用GBK字符集来表示中国人使用的文字，那世界上还有很多其他的国家，他们也有自己的文字，他们也想要自己国家的文字在计算机中处理，于是其他国家也在搞自己的字符集，就这样全世界搞了上百个字符集，而且各个国家的字符集互不兼容。 这样其实很不利于国际化的交流，可能一个文件在我们国家的电脑上打开好好的，但是在其他国家打开就是乱码了。
为了
解决各个国家字符集互不兼容的问题，由国际化标准组织牵头，设计了一套全世界通用的字符集，叫做Unicode字符集。
问题：在Unicode字符集中，采用一个字符4个字节的编码方案，又造成另一个问题：如果是说英语的国家，他们只需要用到26大小写字母，加上一些标点符号就够了，本身一个字节就可以表示完，用4个字节就有点浪费。
于是又对Unicode字符集中的字符进行了重新编码，一共设计了三种编码方案。分别是
UTF-32、UTF-16、UTF-8; 其中比较常用的编码方案是UTF-8
- UTF-8特点
1.
UTF-8是一种可变长的编码方案，工分为4个长度区
2.英文字母、数字占1个字节兼容(ASCII编码)
3.汉字字符占3个字节
4.极少数字符占4个字节
编码与解码
String类类中就提供了相应的方法，可以完成编码和解码的操作。
编码：把字符串按照指定的字符集转换为字节数组解码：把字节数组按照指定的字符集转换为字符串/** * 目标：掌握如何使用Java代码完成对字符的编码和解码。 */ public class Test { public static void main(String[] args) throws Exception { // 1、编码 String data = "a我b"; byte[] bytes = data.getBytes(); // 默认是按照平台字符集（UTF-8）进行编码的。 System.out.println(Arrays.toString(bytes)); // 按照指定字符集进行编码。 byte[] bytes1 = data.getBytes("GBK"); System.out.println(Arrays.toString(bytes1)); // 2、解码 String s1 = new String(bytes); // 按照平台默认编码（UTF-8）解码 System.out.println(s1); String s2 = new String(bytes1, "GBK"); System.out.println(s2); } }
IO流（字节流）
IO流概述
我们知道File类只能操作文件，但是不能操作文件中的内容。
IO流的作用：就是可以对文件或者网络中的数据进行读、写的操作。
-
把数据从磁盘、网络中读取到程序中来，用到的是
输入流。 -
把程序中的数据写入磁盘、网络中，用到的是
输出流。 -
简单记：输入流（读数据）、输出流（写数据）
-
-
IO流在Java中有很多种，
不同的流来干不同的事情。Java把各种流用不同的类来表示
IO流分为
两大派系：
1.字节流：字节流又分为字节输入流、字节输出流
2.字符流：字符流由分为字符输入流、字符输出流
字节流
FileInputStream
接下来我们学习字节流中的字节输入流，用
InputStream来表示。但是InputStream是抽象类，我们用的是它的子类，叫FileInputStream。
构造方法与成员方法
读取文件中的字节数据,一次读取一个字节，步骤如下：
第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read()方法开始读取文件的字节数据。
第三步：调用close()方法释放资源/** * 目标：掌握文件字节输入流，每次读取一个字节。 */ public class FileInputStreamTest1 { public static void main(String[] args) throws Exception { // 1、创建文件字节输入流管道，与源文件接通。 InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt")); // 2、开始读取文件的字节数据。 // public int read():每次读取一个字节返回，如果没有数据了，返回-1. int b; // 用于记住读取的字节。 while ((b = is.read()) != -1){ System.out.print((char) b); } //3、流使用完毕之后，必须关闭！释放系统资源！ is.close(); } }由于一个中文在
UTF-8编码方案中是占3个字节，采用一次读取一个字节的方式，读一个字节就相当于读了1/3个汉字，此时将这个字节转换为字符，是会有乱码的。使用FileInputStream一次读取多个字节
第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read(byte[] bytes)方法开始读取文件的字节数据。(read(byte[] bytes)的重载方法，可以一次读取多个字节，至于一次读多少个字节，就在于你传递的数组有多大。)
第三步：调用close()方法释放资源/** * 目标：掌握使用FileInputStream每次读取多个字节。 */ public class FileInputStreamTest2 { public static void main(String[] args) throws Exception { // 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。 InputStream is = new FileInputStream("file-io-app\\src\\itheima02.txt"); // 2、开始读取文件中的字节数据：每次读取多个字节。 // public int read(byte b[]) throws IOException // 每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1. // 3、使用循环改造。 byte[] buffer = new byte[3]; int len; // 记住每次读取了多少个字节。 abc 66 while ((len = is.read(buffer)) != -1){ // 注意：读取多少，倒出多少。 String rs = new String(buffer, 0 , len); System.out.print(rs); } // 性能得到了明显的提升！！ // 这种方案也不能避免读取汉字输出乱码的问题！！ is.close(); // 关闭流 } }注意的是：read(byte[] bytes)它的返回值，表示当前这一次读取的字节个数。
也就是说，并不是每次读取的时候都把数组装满，比如数组是 byte[] bytes = new byte[3];
第一次调用read(bytes)读取了3个字节(分别是97,98,99)，并且往数组中存，此时返回值就是3
第二次调用read(bytes)读取了2个字节(分别是99,100),并且往数组中存，此时返回值是2
第三次调用read(bytes)文件中后面已经没有数据了，此时返回值为-1使用FileInputStream一次读取全部字节
前面我们到的读取方式，不管是一次读取一个字节，还是一次读取多个字节，都有可能有乱码。那么接下来我们介绍一种，不出现乱码的读取方式。
我们可以
一次性读取文件中的全部字节，然后把全部字节转换为一个字符串，就不会有乱码了。
// 1、一次性读取完文件的全部字节到一个字节数组中去。 // 创建一个字节输入流管道与源文件接通 InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt"); // 2、准备一个字节数组，大小与文件的大小正好一样大。 File f = new File("file-io-app\\src\\itheima03.txt"); long size = f.length(); byte[] buffer = new byte[(int) size]; int len = is.read(buffer); System.out.println(new String(buffer)); //3、关闭流 is.close();
// 1、一次性读取完文件的全部字节到一个字节数组中去。 // 创建一个字节输入流管道与源文件接通 InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt"); //2、调用方法读取所有字节，返回一个存储所有字节的字节数组。 byte[] buffer = is.readAllBytes(); System.out.println(new String(buffer)); //3、关闭流 is.close();注意：一次读取所有字节虽然可以解决乱码问题，但是文件不能过大，如果文件过大，可能导致内存溢出。
FileOutputStream
往文件中写数据需要用到
OutputStream下面的一个子类FileOutputStream。
使用
FileOutputStream往文件中写数据的步骤如下：
第一步：创建FileOutputStream文件字节输出流管道，与目标文件接通。
第二步：调用wirte()方法往文件中写数据
第三步：调用close()方法释放资源/** * 目标：掌握文件字节输出流FileOutputStream的使用。 */ public class FileOutputStreamTest4 { public static void main(String[] args) throws Exception { // 1、创建一个字节输出流管道与目标文件接通。 // 覆盖管道：覆盖之前的数据 // OutputStream os = // new FileOutputStream("file-io-app/src/itheima04out.txt"); // 追加数据的管道 OutputStream os = new FileOutputStream("file-io-app/src/itheima04out.txt", true); // 2、开始写字节数据出去了 os.write(97); // 97就是一个字节，代表a os.write('b'); // 'b'也是一个字节 // os.write('磊'); // [ooo] 默认只能写出去一个字节 byte[] bytes = "我爱你中国abc".getBytes(); os.write(bytes); os.write(bytes, 0, 15); // 换行符 os.write("\r\n".getBytes()); os.close(); // 关闭流 } }
字节流复制文件
场景:我们要复制一张图片，从磁盘
D:/resource/meinv.png的一个位置，复制到C:/data/meinv.png位置。1.需要创建一个
FileInputStream流与源文件接通，创建FileOutputStream与目标文件接通
2.然后创建一个数组，使用FileInputStream每次读取一个字节数组的数据，存如数组中
3.然后再使用FileOutputStream把字节数组中的有效元素，写入到目标文件中
/** * 目标：使用字节流完成对文件的复制操作。 */ public class CopyTest5 { public static void main(String[] args) throws Exception { // 需求：复制照片。 // 1、创建一个字节输入流管道与源文件接通 InputStream is = new FileInputStream("D:/resource/meinv.png"); // 2、创建一个字节输出流管道与目标文件接通。 OutputStream os = new FileOutputStream("C:/data/meinv.png"); System.out.println(10 / 0); // 3、创建一个字节数组，负责转移字节数据。 byte[] buffer = new byte[1024]; // 1KB. // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。 int len; // 记住每次读取了多少个字节。 while ((len = is.read(buffer)) != -1){ os.write(buffer, 0, len); } os.close(); is.close(); System.out.println("复制完成！！"); } }
IO流资源释放
流使用完之后一定要释放资源。但是我们之前的代码并不是很专业。
上图中问题:
在JDK7版本以前，我们可以使用try...catch...finally语句来处理。格式如下:try{ //有可能产生异常的代码 }catch(异常类 e){ //处理异常的代码 }finally{ //释放资源的代码 //finally里面的代码有一个特点，不管异常是否发生，finally里面的代码都会执行。 } -------------------------------------------------------------------------------------------- public class Test2 { public static void main(String[] args) { InputStream is = null; OutputStream os = null; try { System.out.println(10 / 0); // 1、创建一个字节输入流管道与源文件接通 is = new FileInputStream("file-io-app\\src\\itheima03.txt"); // 2、创建一个字节输出流管道与目标文件接通。 os = new FileOutputStream("file-io-app\\src\\itheima03copy.txt"); System.out.println(10 / 0); // 3、创建一个字节数组，负责转移字节数据。 byte[] buffer = new byte[1024]; // 1KB. // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。 int len; // 记住每次读取了多少个字节。 while ((len = is.read(buffer)) != -1){ os.write(buffer, 0, len); } System.out.println("复制完成！！"); } catch (IOException e) { e.printStackTrace(); } finally { // 释放资源的操作 try { if(os != null) os.close(); } catch (IOException e) { e.printStackTrace(); } try { if(is != null) is.close(); } catch (IOException e) { e.printStackTrace(); } } } }本来几行代码就写完了的，加上try…catch…finally之后代码多了十几行，而且阅读性并不高。难受…
**Java在JDK7版本为我们提供了一种简化的是否资源的操作，它会自动是否资源。**代码写起来也非常简单。
try(资源对象1; 资源对象2;){ 使用资源的代码 }catch(异常类 e){ 处理异常的代码 } //注意：注意到没有，这里没有释放资源的代码。它会自动是否资源/** * 目标：掌握释放资源的方式：try-with-resource */ public class Test3 { public static void main(String[] args) { try ( // 1、创建一个字节输入流管道与源文件接通 InputStream is = new FileInputStream("D:/resource/meinv.png"); // 2、创建一个字节输出流管道与目标文件接通。 OutputStream os = new FileOutputStream("C:/data/meinv.png"); ){ // 3、创建一个字节数组，负责转移字节数据。 byte[] buffer = new byte[1024]; // 1KB. // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。 int len; // 记住每次读取了多少个字节。 while ((len = is.read(buffer)) != -1){ os.write(buffer, 0, len); } System.out.println(conn); System.out.println("复制完成！！"); } catch (Exception e) { e.printStackTrace(); } } }
字符流
使用字节流可以读取文件中的字节数据。但是如果文件中有中文，使用字节流来读取，就有可能读到半个汉字的情况，这样会导致乱码。虽然使用读取全部字节的方法不会出现乱码，但是如果文件过大又不太合适。
Java专门为我们提供了另外一种流，叫
字符流，可以说字符流是专门为读取文本数据而生的。
FileReader类
FileReader读取文件的步骤如下：
第一步：创建FileReader对象与要读取的源文件接通
第二步：调用read()方法读取文件中的字符
第三步：调用close()方法关闭流
先通过
构造器创建对象，再通过read方法读取数据（注意：两个read方法的返回值，含义不一样）
/** * 目标：掌握文件字符输入流。 */ public class FileReaderTest1 { public static void main(String[] args) { try ( // 1、创建一个文件字符输入流管道与源文件接通 Reader fr = new FileReader("io-app2\\src\\itheima01.txt"); ){ // 2、一个字符一个字符的读（性能较差） // int c; // 记住每次读取的字符编号。 // while ((c = fr.read()) != -1){ // System.out.print((char) c); // } // 每次读取一个字符的形式，性能肯定是比较差的。 // 3、每次读取多个字符。（性能是比较不错的！） char[] buffer = new char[3]; int len; // 记住每次读取了多少个字符。 while ((len = fr.read(buffer)) != -1){ // 读取多少倒出多少 System.out.print(new String(buffer, 0, len)); } } catch (Exception e) { e.printStackTrace(); } } }
FileWriter类
它可以将程序中的字符数据写入文件。
FileWriter往文件中写字符数据的步骤如下：
第一步：创建FileWirter对象与要读取的目标文件接通
第二步：调用write(字符数据/字符数组/字符串)方法读取文件中的字符
第三步：调用close()方法关闭流
/** * 目标：掌握文件字符输出流：写字符数据出去 */ public class FileWriterTest2 { public static void main(String[] args) { try ( // 0、创建一个文件字符输出流管道与目标文件接通。 // 覆盖管道 // Writer fw = new FileWriter("io-app2/src/itheima02out.txt"); // 追加数据的管道 Writer fw = new FileWriter("io-app2/src/itheima02out.txt", true); ){ // 1、public void write(int c):写一个字符出去 fw.write('a'); fw.write(97); //fw.write('磊'); // 写一个字符出去 fw.write("\r\n"); // 换行 // 2、public void write(String c)写一个字符串出去 fw.write("我爱你中国abc"); fw.write("\r\n"); // 3、public void write(String c ,int pos ,int len):写字符串的一部分出去 fw.write("我爱你中国abc", 0, 5); fw.write("\r\n"); // 4、public void write(char[] buffer):写一个字符数组出去 char[] buffer = {'黑', '马', 'a', 'b', 'c'}; fw.write(buffer); fw.write("\r\n"); // 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去 fw.write(buffer, 0, 2); fw.write("\r\n"); } catch (Exception e) { e.printStackTrace(); } } }
FileWriter写的注意事项
FileWriter写完数据之后，必须刷新或者关闭，写出去的数据才能生效。
比如：下面的代码只调用了写数据的方法，没有关流的方法。当你打开目标文件时，是看不到任何数据的。
//1.创建FileWriter对象 Writer fw = new FileWriter("io-app2/src/itheima03out.txt"); //2.写字符数据出去 fw.write('a'); fw.write('b'); fw.write('c');而下面的代码，加上了flush()方法之后，数据就会立即到目标文件中去。
//1.创建FileWriter对象 Writer fw = new FileWriter("io-app2/src/itheima03out.txt"); //2.写字符数据出去 fw.write('a'); fw.write('b'); fw.write('c'); //3.刷新 fw.flush();调用了
close()方法，数据也会立即到文件中去。因为close()方法在关闭流之前，会将内存中缓存的数据先刷新到文件，再关流。//1.创建FileWriter对象 Writer fw = new FileWriter("io-app2/src/itheima03out.txt"); //2.写字符数据出去 fw.write('a'); fw.write('b'); fw.write('c'); //3.关闭流 fw.close(); //会先刷新，再关流但是需要注意的是，关闭流之后，就不能在对流进行操作了。否则会出异常
缓冲流
缓冲流的作用：可以对原始流进行包装，提高原始流读写数据的性能。
字节缓冲流
字节缓冲流是如何提高读写数据的性能的，原理如下图所示。是因为在
缓冲流的底层自己封装了一个长度为8KB（8129byte）的字节数组，但是缓冲流不能单独使用，它需要依赖于原始流。
- **读数据时：**它先用原始字节输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字节数组中读取一个字节或者多个字节（把消耗屯的货）。
- 写数据时： 它是先把数据写到缓冲流内部的8KB的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字节输出流，一次性写到目标文件中去（把囤好的货，一次性运走）
在创建
缓冲字节流对象时，需要封装一个原始流对象进来。构造方法如下
public class BufferedInputStreamTest1 { public static void main(String[] args) { try ( InputStream is = new FileInputStream("io-app2/src/itheima01.txt"); // 1、定义一个字节缓冲输入流包装原始的字节输入流 InputStream bis = new BufferedInputStream(is); OutputStream os = new FileOutputStream("io-app2/src/itheima01_bak.txt"); // 2、定义一个字节缓冲输出流包装原始的字节输出流 OutputStream bos = new BufferedOutputStream(os); ){ byte[] buffer = new byte[1024]; int len; while ((len = bis.read(buffer)) != -1){ bos.write(buffer, 0, len); } System.out.println("复制完成！！"); } catch (Exception e) { e.printStackTrace(); } } }
字符缓冲流
字符缓冲流,它的原理和字节缓冲流是类似的，它底层也会有一个8KB的数组，但是这里是
字符数组。字符缓冲流也不能单独使用，它需要依赖于原始字符流一起使用。
BufferedReader读数据时：它先原始字符输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字符数组中读取一个字符或者多个字符（把消耗屯的货）。
- 创建BufferedReader对象需要用到BufferedReader的构造方法，内部需要封装一个原始的字符输入流，我们可以传入FileReader.
- BufferedReader还要特有的方法，一次可以读取文本文件中的一行
public class BufferedReaderTest2 { public static void main(String[] args) { try ( Reader fr = new FileReader("io-app2\\src\\itheima04.txt"); // 创建一个字符缓冲输入流包装原始的字符输入流 BufferedReader br = new BufferedReader(fr); ){ // char[] buffer = new char[3]; // int len; // while ((len = br.read(buffer)) != -1){ // System.out.print(new String(buffer, 0, len)); // } // System.out.println(br.readLine()); // System.out.println(br.readLine()); // System.out.println(br.readLine()); // System.out.println(br.readLine()); String line; // 记住每次读取的一行数据 while ((line = br.readLine()) != null){ System.out.println(line); } } catch (Exception e) { e.printStackTrace(); } } }
- BufferedWriter写数据时： 它是先把数据写到字符缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字符输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。如下图所示
- 创建BufferedWriter对象时需要用到BufferedWriter的构造方法，而且内部需要封装一个原始的字符输出流，我们这里可以传递FileWriter。
- 而且BufferedWriter新增了一个功能，可以用来写一个
换行符
public class BufferedWriterTest3 { public static void main(String[] args) { try ( Writer fw = new FileWriter("io-app2/src/itheima05out.txt", true); // 创建一个字符缓冲输出流管道包装原始的字符输出流 BufferedWriter bw = new BufferedWriter(fw); ){ bw.write('a'); bw.write(97); bw.write('磊'); bw.newLine(); bw.write("我爱你中国abc"); bw.newLine(); } catch (Exception e) { e.printStackTrace(); } } }
缓冲流性能分析
**缓冲流的性能不一定比低级流高，其实低级流自己加一个数组，性能其实是不差。**只不过缓冲流帮你加了一个相对而言大小比较合理的数组 。
它和我们使用原始流，自己加一个8BK数组不是一样的吗？ 缓冲流就一定能提高性能吗？先告诉同学们答案，缓冲流不一定能提高性能。
下面我们用一个比较大文件（889MB）复制，做性能测试，分别使用下面四种方式来完成文件复制，并记录文件复制的时间。
① 使用低级流一个字节一个字节的复制
② 使用低级流按照字节数组的形式复制
③ 使用缓冲流一个字节一个字节的复制
④ 使用缓冲流按照字节数组的形式复制
低级流一个字节复制:
慢得简直让人无法忍受
低级流按照字节数组复制(数组长度1024):12.117s
缓冲流一个字节复制:11.058s
缓冲流按照字节数组复制(数组长度1024):2.163s
【注意：这里的测试只能做一个参考，和电脑性能也有直接关系】经过上面的测试，我们可以得出一个结论：默认情况下，采用一次复制1024个字节，缓冲流完胜。
但是，缓冲流就一定性能高吗？我们采用一次复制8192个字节试试
低级流按照字节数组复制(数组长度8192):
2.535s
缓冲流按照字节数组复制(数组长度8192):2.088s经过上面的测试，我们可以得出一个结论：**一次读取8192个字节时，低级流和缓冲流性能相当。**相差的那几毫秒可以忽略不计。
继续把数组变大，看一看缓冲流就一定性能高吗？现在采用一次读取1024*32个字节数据试试
低级流按照字节数组复制(数组长度8192):
1.128s
缓冲流按照字节数组复制(数组长度8192):1.133s经过上面的测试，我们可以得出一个结论：**数组越大性能越高，低级流和缓冲流性能相当。**相差的那几秒可以忽略不计。
继续把数组变大，看一看缓冲流就一定性能高吗？现在采用一次读取1024*6个字节数据试试
低级流按照字节数组复制(数组长度8192):
1.039s
缓冲流按照字节数组复制(数组长度8192):1.151s此时你会发现，当数组大到一定程度，性能已经提高了多少了，甚至
缓冲流的性能还没有低级流高。总结一下：**缓冲流的性能不一定比低级流高，其实低级流自己加一个数组，性能其实是不差。**只不过缓冲流帮你加了一个相对而言大小比较合理的数组 。
转换流
前面我们学习过
FileReader读取文件中的字符，但是同学们注意了，FileReader默认只能读取UTF-8编码格式的文件。如果使用FileReader读取GBK格式的文件，可能存在乱码，因为FileReader它遇到汉字默认是按照3个字节来读取的，而GBK格式的文件一个汉字是占2个字节，这样就会导致乱码。Java给我们提供了另外两种流
InputStreamReader，OutputStreamWriter，这两个流我们把它叫做转换流。它们可以将字节流转换为字符流,并且可以指定编码方案。
InputStreamReader
先学习InputStreamReader类，你看这个类名就比较有意思，前面是InputStream表示字节输入流，后面是Reader表示字符输入流，合在一起意思就是表示可以把InputStream转换为Reader，最终InputStreamReader其实也是Reader的子类，所以也算是
字符输入流。
InputStreamReader也是不能单独使用的，它内部需要封装一个InputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。
需求：我们可以先准备一个GBK格式的文件，然后使用下面的代码进行读取，看是否有乱码
public class InputStreamReaderTest2 { public static void main(String[] args) { try ( // 1、得到文件的原始字节流（GBK的字节流形式） InputStream is = new FileInputStream("io-app2/src/itheima06.txt"); // 2、把原始的字节输入流按照指定的字符集编码转换成字符输入流 Reader isr = new InputStreamReader(is, "GBK"); // 3、把字符输入流包装成缓冲字符输入流 BufferedReader br = new BufferedReader(isr); ){ String line; while ((line = br.readLine()) != null){ System.out.println(line); } } catch (Exception e) { e.printStackTrace(); } } }执行完之后，你会发现没有乱码。
OutputStreamWriter
OutputStreamWriter类，你看这个类名也比较有意思，前面是OutputStream表示字节输出流，后面是Writer表示字符输出流，合在一起意思就是表示可以把OutputStream转换为Writer，最终OutputStreamWriter其实也是Writer的子类，所以也算是字符输出流。
OutputStreamReader也是不能单独使用的，它内部需要封装一个OutputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。
-
需求：我们可以先准备一个GBK格式的文件，使用下面代码往文件中写字符数据。
-
public class OutputStreamWriterTest3 { public static void main(String[] args) { // 指定写出去的字符编码。 try ( // 1、创建一个文件字节输出流 OutputStream os = new FileOutputStream("io-app2/src/itheima07out.txt"); // 2、把原始的字节输出流，按照指定的字符集编码转换成字符输出转换流。 Writer osw = new OutputStreamWriter(os, "GBK"); // 3、把字符输出流包装成缓冲字符输出流 BufferedWriter bw = new BufferedWriter(osw); ){ bw.write("我是中国人abc"); bw.write("我爱你中国123"); } catch (Exception e) { e.printStackTrace(); } } }
打印流
打印流可以实现更加方便，更加高效的写数据的方式。
打印流基本使用
打印流，这里所说的打印其实就是写数据的意思，它和普通的write方法写数据还不太一样，一般会使用打印流特有的方法叫
print(数据)或者println(数据)，它打印啥就输出啥。
- 打印流有两个，一个是
字节打印流PrintStream，一个是字符打印流PrintWriter
PrintStream和PrintWriter的用法是一样的
public class PrintTest1 { public static void main(String[] args) { try ( // 1、创建一个打印流管道 // PrintStream ps = // new PrintStream("io-app2/src/itheima08.txt", Charset.forName("GBK")); // PrintStream ps = // new PrintStream("io-app2/src/itheima08.txt"); PrintWriter ps = new PrintWriter(new FileOutputStream("io-app2/src/itheima08.txt", true)); ){ ps.print(97); //文件中显示的就是:97 ps.print('a'); //文件中显示的就是:a ps.println("我爱你中国abc"); //文件中显示的就是:我爱你中国abc ps.println(true);//文件中显示的就是:true ps.println(99.5);//文件中显示的就是99.5 ps.write(97); //文件中显示a，发现和前面println方法的区别了吗？ } catch (Exception e) { e.printStackTrace(); } } }
重定向输出语句
System.out.println()这句话表示打印输出，但是至于为什么能够输出，其实我们一直不清楚。因为System里面有一个静态变量叫out，out的数据类型就是
PrintStream，它就是一个打印流，而且这个打印流的默认输出目的地是控制台，所以我们调用System.out.pirnln()就可以往控制台打印输出任意类型的数据，而且打印啥就输出啥。
-
System还提供了一个方法，可以修改底层的打印流，这样我们就可以重定向打印语句的输出目的地了。我们玩一下, 直接上代码。
-
public class PrintTest2 { public static void main(String[] args) { System.out.println("老骥伏枥"); System.out.println("志在千里"); try ( PrintStream ps = new PrintStream("io-app2/src/itheima09.txt"); ){ // 把系统默认的打印流对象改成自己设置的打印流 System.setOut(ps); System.out.println("烈士暮年"); System.out.println("壮心不已"); } catch (Exception e) { e.printStackTrace(); } } }此时打印语句，将往文件中打印数据，而不在控制台。
数据流
我们想把数据和数据的类型一并写到文件中去，读取的时候也将数据和数据类型一并读出来。这就可以用到数据流，有两个
DataInputStream和DataOutputStream.
DataOutputStream类
DataOutputStream类，它也是一种包装流，创建
DataOutputStream对象时，底层需要依赖于一个原始的OutputStream流对象。然后调用它的wirteXxx方法，写的是特定类型的数据。
代码如下：往文件中写整数、小数、布尔类型数据、字符串数据
public class DataOutputStreamTest1 { public static void main(String[] args) { try ( // 1、创建一个数据输出流包装低级的字节输出流 DataOutputStream dos = new DataOutputStream(new FileOutputStream("io-app2/src/itheima10out.txt")); ){ dos.writeInt(97); dos.writeDouble(99.5); dos.writeBoolean(true); dos.writeUTF("黑马程序员666！"); } catch (Exception e) { e.printStackTrace(); } } }
DataInputStream类
DataIntputStream类，它也是一种包装流，创建DataInputStream对象时，底层需要依赖于一个原始的InputStream流对象。然后调用它的readXxx()方法就可以读取特定类型的数据。
代码如下：读取文件中特定类型的数据（整数、小数、字符串等）
public class DataInputStreamTest2 { public static void main(String[] args) { try ( DataInputStream dis = new DataInputStream(new FileInputStream("io-app2/src/itheima10out.txt")); ){ int i = dis.readInt(); System.out.println(i); double d = dis.readDouble(); System.out.println(d); boolean b = dis.readBoolean(); System.out.println(b); String rs = dis.readUTF(); System.out.println(rs); } catch (Exception e) { e.printStackTrace(); } } }
序列化流
序列化：意思就是把对象写到文件或者网络中去。（简单记：写对象）
反序列化：意思就是把对象从文件或者网络中读取出来。（简单记：读对象）
序列化流是干什么用的呢？ 我们知道字节流是以字节为单位来读写数据、字符流是按照字符为单位来读写数据、而对象流是以对象为单位来读写数据。也就是把对象当做一个整体，可以写一个对象到文件，也可以从文件中把对象读取出来。
ObjectOutputStream
ObjectOutputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输出流使用。
代码如下：将一个User对象写到文件中去
- 第一步：先准备一个User类，必须让其实现Serializable接口。
// 注意：对象如果需要序列化，必须实现序列化接口。 public class User implements Serializable { private String loginName; private String userName; private int age; // transient 这个成员变量将不参与序列化。 private transient String passWord; public User() { } public User(String loginName, String userName, int age, String passWord) { this.loginName = loginName; this.userName = userName; this.age = age; this.passWord = passWord; } @Override public String toString() { return "User{" + "loginName='" + loginName + '\'' + ", userName='" + userName + '\'' + ", age=" + age + ", passWord='" + passWord + '\'' + '}'; } }
- 第二步：再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。
public class Test1ObjectOutputStream { public static void main(String[] args) { try ( // 2、创建一个对象字节输出流包装原始的字节 输出流。 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("io-app2/src/itheima11out.txt")); ){ // 1、创建一个Java对象。 User u = new User("admin", "张三", 32, "666888xyz"); // 3、序列化对象到文件中去 oos.writeObject(u); System.out.println("序列化对象成功！！"); } catch (Exception e) { e.printStackTrace(); } } }注意：写到文件中的对象，是不能用记事本打开看的。因为对象本身就不是文本数据，打开是乱码
怎样才能读懂文件中的对象是什么呢？
这里必须用反序列化，自己写代码读。
ObjectInputStream类
ObjectInputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输入流使用。
- 假如文件中已经有一个Student对象，现在要使用
ObjectInputStream读取出来。称之为反序列化。
public class Test2ObjectInputStream { public static void main(String[] args) { try ( // 1、创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io-app2/src/itheima11out.txt")); ){ User u = (User) ois.readObject(); System.out.println(u); } catch (Exception e) { e.printStackTrace(); } } }
IO框架
我们只学习了IO流对文件复制，能不能复制文件夹呀？
当然是可以咯，但是如果让我们自己写复制文件夹的代码需要用到递归，还是比较麻烦的。为了简化对IO操作，由apache开源基金组织提供了一组有关IO流小框架，可以提高IO流的开发效率。
这个框架的名字叫
commons-io：其本质是别人写好的一些字节码文件（class文件），打包成了一个jar包。我们只需要把jar包引入到我们的项目中，就可以直接用了。
jar包中提供的工具类叫
FileUtils，它的部分功能如下，很方便，你一看名字就知道怎么用了。
- 在写代码之前，先需要引入jar包，具体步骤如下
- 1.在模块的目录下，新建一个lib文件夹
- 2.把jar包复制粘贴到lib文件夹下
- 3.选择lib下的jar包，右键点击
Add As Library，然后就可以用了。
public class CommonsIOTest1 {
public static void main(String[] args) throws Exception {
//1.复制文件
FileUtils.copyFile(new File("io-app2\\src\\itheima01.txt"), new File("io-app2/src/a.txt"));
//2.复制文件夹
FileUtils.copyDirectory(new File("D:\\resource\\私人珍藏"), new File("D:\\resource\\私人珍藏3"));
//3.删除文件夹
FileUtils.deleteDirectory(new File("D:\\resource\\私人珍藏3"));
// Java提供的原生的一行代码搞定很多事情
Files.copy(Path.of("io-app2\\src\\itheima01.txt"), Path.of("io-app2\\src\\b.txt"));
System.out.println(Files.readString(Path.of("io-app2\\src\\itheima01.txt")));
}
}