1、昨日复习

1.如何遍历Map的key集，value集,key-value集，使用上泛型

Map map = new HashMap();
map.put();….
//遍历key
Set keySet = map.keySet();
for(String key : keySet){
System.out.println(key);
}

//遍历value
Collection values = map.values();
Iterator iterator = values.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

//遍历key-value
Set> entrySet = map.entrySet();
Iterator> iterator = entrySet.iterator();
while(iterator.hasNext()){
Map.Entry entry = iterator.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + “—->” + value);
}

  1. 写出使用Iterator 和 增强for 循环遍历List的代码,使用上泛型
  1. 提供一个方法，用于遍历获取HashMap中的所有value，并存放在List中返回。考虑上集合中泛型的使用。

public List getValueList(HashMap map){
ArrayList valueList = new ArrayList<>():
Collection values = map.values();
for(String value : values){
valueList.add(value);
}
return valueList;
}

  1. 创建一个与a.txt文件同目录下的另外一个文件b.txt

File file1 = new File(“d:\a\a.txt”);
File file2 = new File(file1.getParent(),”b.txt”);

  1. Map接口中的常用方法有哪些
    增：put(K k,V v)
    删: V remove(K k)
    改: put(K k,V v)
    查: V get(K k)
    长度:int size()
    遍历

2、File类的使用

  1. package com.atguigu.java1;
  3. import org.junit.Test;
  5. import java.io.File;
  6. import java.io.IOException;
  8. /**
  9.  * File类的使用
  10.  *
  11.  * 1、File类的一个对象，代表一个文件或一个文件目录（俗称：文件夹）
  12.  * 2、File类声明在java.io包下
  13.  * 3、File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，
  14.  *    并未涉及到写入或读取文件内容的操作。如果需要读取或写入问文件内容，必须使用IO流来完成。
  15.  * 4、后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的“终点”。
  16.  *
  17.  */
  18. public class FileTest {
  19.     /*
  20.     1、如何创建File类的实例
  21.         public File(String pathname)
  22.         public File(String parent,String child)
  23.         public File(File parent,String child)
  24.     2、
  25.     相对路径：相较于某个路径下，指明的路径
  26.     绝对路径：包含盘符在内的文件或文件目录的路径
  27.     3、路径分隔符：
  28.     Windows：\\
  29.     Unix：/
  31.      */
  32.     @Test
  33.     public void test1(){
  34.         //构造器1
  35.         File file1 = new File("hello.text");//相对于当前的module
  36.         File file2 = new File("D:\\IdeaProjects\\StudyJava\\Day25\\he.txt");
  37.         System.out.println(file1);
  38.         System.out.println(file2);
  40.         //构造器2
  41.         File file3 = new File("D:\\IdeaProjects\\StudyJava","JavaSenior");
  42.         System.out.println(file3);
  44.         //构造器3
  45.         File file4 = new File(file3,"hi.txt");
  46.         System.out.println(file4);
  47.     }
  49.     /*
  50.  public String getAbsolutePath()：获取绝对路径
  51.  public String getPath() ：获取路径
  52.  public String getName() ：获取名称
  53.  public String getParent()：获取上层文件目录路径。若无，返回null
  54.  public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
  55.  public long lastModified() ：获取最后一次的修改时间，毫秒值
  57. 如下的两个方法适用于文件目录
  58.  public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
  59.  public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组
  60.      */
  61.     @Test
  62.     public void test2(){
  63.         File file1 = new File("hello.txt");
  64.         File file2 = new File("D:\\io\\hi.txt");
  66.         System.out.println(file1.getAbsolutePath());
  67.         System.out.println(file1.getPath());
  68.         System.out.println(file1.getName());
  69.         System.out.println(file1.getParent());
  70.         System.out.println(file1.length());
  71.         System.out.println(file1.lastModified());
  72.         System.out.println("***********************");
  73.         System.out.println(file2.getAbsolutePath());
  74.         System.out.println(file2.getPath());
  75.         System.out.println(file2.getName());
  76.         System.out.println(file2.getParent());
  77.         System.out.println(file2.length());
  78.         System.out.println(file2.lastModified());
  79.     }
  81.     @Test
  82.     public void test3(){
  83.         File file = new File("D:\\IdeaProjects\\StudyJava");
  84.         String[] list = file.list();
  85.         for (String s : list){
  86.             System.out.println(s);
  87.         }
  89.         File[] files = file.listFiles();
  90.         for (File f:files){
  91.             System.out.println(f);
  92.         }
  93.     }
  94.     /*
  95.     public boolean renameTo(File dest):把文件重命名为指定的文件路径
  96.     比如file1.renameTo(file2)为例：
  97.         要想保证返回true，需要file1在硬盘中是存在的，且file2不能再硬盘中存在
  98.      */
  99.     @Test
  100.     public void test4(){
  101.         File file1 = new File("hello.txt");
  102.         File file2 = new File("D:\\io\\hi.txt");
  103.         boolean renameTo = file2.renameTo(file1);
  104.         System.out.println(renameTo);
  105.     }
  107.     /*
  108.  public boolean isDirectory()：判断是否是文件目录
  109.  public boolean isFile() ：判断是否是文件
  110.  public boolean exists() ：判断是否存在
  111.  public boolean canRead() ：判断是否可读
  112.  public boolean canWrite() ：判断是否可写
  113.  public boolean isHidden() ：判断是否隐藏
  114.      */
  115.     @Test
  116.     public void test5(){
  117.         File file1 = new File("hello.txt");
  118.         System.out.println(file1.isDirectory());
  119.         System.out.println(file1.isFile());
  120.         System.out.println(file1.exists());
  121.         System.out.println(file1.canRead());
  122.         System.out.println(file1.canWrite());
  123.         System.out.println(file1.isHidden());
  125.     }
  126.     /*
  127.     创建硬盘中对应的文件或文件目录
  128.  public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
  129.  public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
  130.  public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建
  132. public boolean delete()：删除文件或者文件夹
  133. Java中的删除不走回收站。 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录
  134.      */
  135.     @Test
  136.     public void test6() throws IOException {
  137.         //文件的创建
  138.         File file1 = new File("hi.txt");
  139.         if (!file1.exists()){
  140.             file1.createNewFile();
  141.             System.out.println("创建成功");
  142.         }else {
  143.             file1.delete();
  144.             System.out.println("删除成功");
  145.         }
  147.     }
  149.     @Test
  150.     public void test7(){
  151.         //文件目录的创建
  152.         File file1 = new File("D:\\io\\io1");
  153.         boolean mkdir = file1.mkdir();
  154.         if (mkdir){
  155.             System.out.println("创建成功");
  156.         }
  158.         File file2 = new File("D:\\io\\io2");
  159.         boolean mkdir1 = file2.mkdirs();
  160.         if (mkdir1){
  161.             System.out.println("创建成功2");
  162.         }
  163.     }
  164. }

3、IO流原理及流的分类

I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。
输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

QQ截图20220124205601.png
文本数据：字符流；非文本数据：字节流
QQ截图20220124210220.png
QQ截图20220124210249.png
QQ截图20220125093122.png

  1. package com.atguigu.java1;
  3. import org.junit.Test;
  5. import java.io.*;
  7. /*
  8. 一、流的分类：
  9. 1、操作数据单位：字节流、字符流
  10. 2、数据的流向：输入流、输出流
  11. 3、流的角色：节点流、处理流
  12. 二、流的体系结构
  13. 抽象基类                    节点流                          缓冲流
  14. InputStream                 FileInputStream                 BufferedInputStream
  15. OutputStream                FileOutputStream                BufferedOutputStream
  16. Reader                      FileReader                      BufferedReader
  17. Writer                      FileWriter                      BufferedWriter
  18.  */
  19. public class FileReadWriterTest {
  20.     /*
  21.     说明点：
  22.     1、read()的理解：返回读入的一个字符，如果达到文件末尾，返回-1
  23.     2、异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
  24.     3、读入的文件一定要存在，否则就会报异常
  25.      */
  26.     @Test
  27.     public void test1() {
  28.         FileReader fr = null;
  29.         try {
  30.             //1、实例化File类的对象，指明要操作的对象
  31.             File file = new File("hello.txt");
  32.             //2、提供具体的流
  33.             fr = new FileReader(file);
  34.             //3、数据的读入
  35.             //read():返回读入的一个字符。如果达到文件末尾，返回-1
  36.             //方式一
  37.         /*int data = fr.read();
  38.         while (data!=-1){
  39.             System.out.print((char) data);
  40.             data = fr.read();
  41.         }*/
  42.             //方式二
  43.             int data;
  44.             while ((data = fr.read()) != -1) {
  45.                 System.out.print((char) data);
  46.             }
  47.         } catch (IOException e) {
  48.             e.printStackTrace();
  49.         } finally {
  50.             //4、流的关闭操作
  51.             try {
  52.                 fr.close();
  53.             } catch (IOException e) {
  54.                 e.printStackTrace();
  55.             }
  56.         }
  57.     }
  59.     //对read()操作升级，使用read重载方法
  60.     @Test
  61.     public void test2() {
  62.         FileReader fr = null;
  63.         try {
  64.             //1、File类的实例化
  65.             File file = new File("hello.txt");
  66.             //2、FileReader流的实例化
  67.             fr = new FileReader(file);
  68.             //3、读入的操作
  69.             //read(char[] cbuf)：返回每次读入cbuf数组中的字符的个数，如果达到文件末尾，返回-1
  70.             char[] ch = new char[5];
  71.             int len;
  72.             while ((len = fr.read(ch)) != -1) {
  73.                 for (int i = 0; i < len; i++) {
  74.                     System.out.print(ch[i]);
  75.                 }
  76.             }
  77.         } catch (IOException e) {
  78.             e.printStackTrace();
  79.         } finally {
  80.             //4、资源的关闭
  81.             try {
  82.                 fr.close();
  83.             } catch (IOException e) {
  84.                 e.printStackTrace();
  85.             }
  86.         }
  88.     }
  90.     /*
  91.     从内存中写出数据到硬盘的文件里。
  92.     说明：
  93.     1、输出操作，对应的File可以不存在的。并不会报异常
  94.     2、
  95.         File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件
  96.         File对应的硬盘中的文件如果存在：
  97.             如果流使用的构造器是FileWriter(file,false)/FileWriter(file)：对原有的文件的覆盖
  98.             如果流使用的构造器是FileWriter(file,true)：不会对原有的文件的覆盖，而是在原有文件基础上追加的内容
  99.      */
  100.     @Test
  101.     public void test3() throws IOException {
  102.         //1、提供File类的对象，指明写出到的文件
  103.         File file = new File("hello1.txt");
  104.         //2、提供FileWriter的对象，用于数据的写出
  105.         FileWriter fw = new FileWriter(file, false);
  106.         //3、写出的操作
  107.         fw.write("I have a dream!\n");
  108.         fw.write("you need to have a dream!");
  109.         //4、流的关闭
  110.         fw.close();
  111.     }
  113.     @Test
  114.     public void test4() {
  115.         FileReader fr = null;
  116.         FileWriter fw = null;
  117.         try {
  118. //        1、创建File类的对象，指明读入和写出的文件
  119.             File srcFile = new File("hello.txt");
  120.             File destFile = new File("hello2.txt");
  121. //        2、创建输入流和输出流的对象
  122.             fr = new FileReader(srcFile);
  123.             fw = new FileWriter(destFile);
  124. //        3、数据的读入和写出操作
  125.             char[] cbuf = new char[5];
  126.             int len;
  127.             while ((len = fr.read(cbuf)) != -1) {
  128.                 fw.write(cbuf, 0, len);
  129.             }
  130.         } catch (IOException e) {
  131.             e.printStackTrace();
  132.         }finally {
  133. //        4、关闭流资源
  134.             try {
  135.                 fw.close();
  136.             } catch (IOException e) {
  137.                 e.printStackTrace();
  138.             }
  139.             try {
  140.                 fr.close();
  141.             } catch (IOException e) {
  142.                 e.printStackTrace();
  143.             }
  144.         }
  145.     }
  146. }

结论：
1、对于文本文件（.txt,.java，.c,.cpp）,使用字符流处理，也可以用字节流来处理（但最好不要在控制输出台看）
2、对于非文本文件（.jpg,.mp3,.mp4,.avi,.doc,.ppt,…），使用字节流处理

处理流之一：缓冲流的使用
1、缓冲流：
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
2、作用：提供流的读取、写入的速度
提高读写速度的原因：内部提供了一个缓冲区
3、处理流，就是“套接”在已有的流的基础上。

 为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类
时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
 缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：
BufferedInputStream 和 BufferedOutputStream
BufferedReader 和 BufferedWriter

 当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区
 当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。
 向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法flush()可以强制将缓冲区的内容全部写入输出流
 关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流
 flush()方法的使用：手动将buffer中内容写入文件
 如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出

  2.     BufferedReader br = null;
  3.     BufferedWriter bw = null;
  4. try
  6.     {
  7.         // 创建缓冲流对象：它是处理流，是对节点流的包装
  8.         br = new BufferedReader(new FileReader("d:\\IOTest\\source.txt"));
  9.         bw = new BufferedWriter(new FileWriter("d:\\IOTest\\dest.txt"));
  10.         String str;
  11.         while ((str = br.readLine()) != null) { // 一次读取字符文本文件的一行字符
  12.             bw.write(str); // 一次写入一行字符串
  13.             bw.newLine(); // 写入行分隔符
  14.         }
  15.         bw.flush(); // 刷新缓冲区
  16.     } catch(
  17.     IOException e)
  19.     {
  20.         e.printStackTrace();
  21.     } finally
  23.     {
  24.         // 关闭IO流对象
  25.         try {
  26.             if (bw != null) {
  27.                 bw.close(); // 关闭过滤流时,会自动关闭它所包装的底层节点流
  28.             }
  29.         } catch (IOException e) {
  30.             e.printStackTrace();
  31.         }
  32.         try {
  33.             if (br != null) {
  34.                 br.close();
  35.             }
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         }
  39.     }

QQ截图20220125162802.png

  1. package com.atguigu.java2;
  2. /*
  3. 处理流之二：转换流的使用
  4. 1、转换流：
  5.     InputStreamReader：将一个字节的输入流转换为字符的输入流
  6.     OutputStreamWriter：将一个字符的输出流转换为字节的输出流
  7. 2、作用：提供字节流与字符流之间的转换
  9. 3、解码：字节、字节数组---->字符数组、字符串
  10.    编码：字符数组、字符串---->字节、字节数组
  12. 4、字符集
  13.  ASCII：美国标准信息交换码。
  14.  用一个字节的7位可以表示。
  15.  ISO8859-1：拉丁码表。欧洲码表
  16.  用一个字节的8位表示。
  17.  GB2312：中国的中文编码表。最多两个字节编码所有字符
  18.  GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
  19.  Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
  20.  UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
  21.  */
  23. import org.junit.Test;
  25. import java.io.*;
  26. import java.util.HashMap;
  27. import java.util.Map;
  29. public class InputStreamReaderTest {
  30.     @Test
  31.     public void test1() throws IOException {
  32.         FileInputStream fis = new FileInputStream("dbcp.txt");
  33.         //参数2指明字符集，具体使用哪个字符集取决于文件保存时使用的字符集
  34.         InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
  36.         char[] cbuf = new char[20];
  37.         int len;
  38.         while ((len = isr.read(cbuf)) !=-1){
  39.             String str = new String(cbuf,0,len);
  40.             System.out.print(str);
  41.         }
  43.         isr.close();
  44.         fis.close();
  45.     }
  47.     @Test
  48.     public void test2(){
  49.         File file1 = new File("dbcp.txt");
  50.         File file2 = new File("dbcp_gbk.txt");
  52.         InputStreamReader isr = null;
  53.         OutputStreamWriter osw = null;
  54.         try {
  55.             FileInputStream fis = new FileInputStream(file1);
  56.             FileOutputStream fos = new FileOutputStream(file2);
  58.             isr = new InputStreamReader(fis,"UTF-8");
  59.             osw = new OutputStreamWriter(fos,"gbk");
  61.             char[] ch = new char[20];
  62.             int len;
  63.             while ((len = isr.read(ch))!=-1){
  64.                 osw.write(ch,0,len);
  65.             }
  66.         } catch (IOException e) {
  67.             e.printStackTrace();
  68.         }finally {
  69.             try {
  70.                 isr.close();
  71.             } catch (IOException e) {
  72.                 e.printStackTrace();
  73.             }
  74.             try {
  75.                 osw.close();
  76.             } catch (IOException e) {
  77.                 e.printStackTrace();
  78.             }
  79.         }
  80.     }
  81. }
  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. import java.io.*;
  6. import java.util.Locale;
  7. import java.util.Scanner;
  9. /*
  10. 其他流的使用：
  11. 1、标准的输入、输出流
  12. 2、打印流
  13. 3、数据流
  14.  */
  15. public class OtherStreamTest {
  16.     /*
  17.     1、标准的输入、输出流
  18.     1.1
  19.     System.in:标准的输入流，默认从键盘输入
  20.     System.out:标准的输出流，默认从控制台输出
  21.     1.2
  22.     System类的setIn(InputStream is)/setOut(PrintStream out) 方式重新指定输入和输出的流。
  23.     1.3练习
  24.     从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，
  25.     直至当输入“e”或者“exit”时，退出程序。
  26.     方法一：使用Scanner实现，调用next()返回一个字符串
  27.     方法二：使用System.in实现。System.in--->转换流--->BufferedReader的readLine()方法
  28.      */
  30.     public static void main(String[] args) {
  32.         BufferedReader br = null;
  33.         try {
  34.             InputStreamReader isr = new InputStreamReader(System.in);
  35.             br = new BufferedReader(isr);
  37.             while (true){
  38.                 System.out.println("请输入字符串：");
  39.                 String data = br.readLine();
  40.                 if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)){
  41.                     System.out.println("程序结束");
  42.                     break;
  43.                 }
  44.                 String upperCase = data.toUpperCase();
  45.                 System.out.println(upperCase);
  46.             }
  47.         } catch (IOException e) {
  48.             e.printStackTrace();
  49.         }finally {
  50.             try {
  51.                 br.close();
  52.             } catch (IOException e) {
  53.                 e.printStackTrace();
  54.             }
  55.         }
  57.     }
  59.     /*
  60.     2、打印流：PrintStream和PrintWriter实现将基本数据类型的数据格式转化为字符串输出
  61.     2.1、提供了一系列重载的print()和println()
  62.     2.2、练习：
  63.      */
  64.     @Test
  65.     public void test2(){
  66.         PrintStream ps = null;
  67.         try {
  68.             FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
  69. // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
  70.             ps = new PrintStream(fos, true);
  71.             if (ps != null) {// 把标准输出流(控制台输出)改成文件
  72.                 System.setOut(ps);
  73.             }
  74.             for (int i = 0; i <= 255; i++) { // 输出ASCII字符
  75.                 System.out.print((char) i);
  76.                 if (i % 50 == 0) { // 每50个数据一行
  77.                     System.out.println(); // 换行
  78.                 } }
  79.         } catch (FileNotFoundException e) {
  80.             e.printStackTrace();
  81.         } finally {
  82.             if (ps != null) {
  83.                 ps.close();
  84.             } }
  85.     }
  87.     /*
  88.     3、数据流
  89.     3.1 DataInputStream 和 DataOutputStream
  90.     3.2 用于读取和写出基本数据类型、String类的数据
  91.      */
  92. }

尚硅谷宋红康第13章_IO流.pdf
尚硅谷宋红康计算机字符编码.pdf
拓展：装饰设计模式.pdf