20200805_容器类HashMap(相当于python字典)以及IO流（读写操作）

1、作业题参考

一.新建一个类ArrayListDemo，使用今天上课讲解api完成下面需求。 

 1、定义老师类Teacher，私有属性：name，age，提供空参有参构造，提供get/set方法

 2、创建老师对象t1，name：张三，age：25 

 3、创建老师对象t2，name：李四，age：35 

 4、创建老师对象t3，name：老王，age：19 

 5、创建老师对象t4，name：赵六，age：29

 6、创建ArrayList集合对象存储t1，t2，t3，t4 

 7、通过普通for循环和增强for循环打印所有老师数据。打印出对应的name和age属性。 

 8、请求出集合中的老师平均年龄。 

import java.util.ArrayList;

public class ArrayListDemo {

    public static void main(String[] args) {
        //  2、创建老师对象t1，name：张三，age：25
        //    3、创建老师对象t2，name：李四，age：35
        //    4、创建老师对象t3，name：老王，age：19
        //    5、创建老师对象t3，name：赵六，age：29
        Teacher t1 = new Teacher("张三", 25);
        Teacher t2 = new Teacher("李四", 35);
        Teacher t3 = new Teacher("老王", 19);
        Teacher t4 = new Teacher("赵六", 29);
        //    6、创建ArrayList集合对象存储t1，t2，t3，t4
        ArrayList<Teacher> arraylist = new ArrayList<Teacher>();
        arraylist.add(t1);
        arraylist.add(t2);
        arraylist.add(t3);
        arraylist.add(t4);

        //通过普通for循环和增强for循环打印所有学生数据。打印出对应的name和age属性。
        System.out.println("9.通过普通for循环和增强for循环打印所有学生数据。打印出对应的name和age属性");
        for (int i = 0; i < arraylist.size(); i++) {
            System.out.println(arraylist.get(i).getName());
            System.out.println(arraylist.get(i).getAge());
        }
        for (Teacher teacher : arraylist) {
            System.out.println(teacher.getName());
            System.out.println(teacher.getAge());
        }

        //请求出集合中的老师平均年龄。
        //count存储老师数量
        int count = 0;
        //sum存储老师总成绩
        int sum = 0;
        for (Teacher teacher : arraylist) {
            sum += teacher.getAge();
            count++;
        }
        int result = sum / count;
        System.out.println("求出集合中的老师平均年龄:" + result);
    }

}

 二.新建一个类HashSetDemo，使用今天上课讲到的api完成下面的要求。 

 1、往这个HashSet对象里添加如下String类型的数据：“张三”，“李四”，“王五”，“张三”，”赵六” 

 2、判断这个集合是否为空，并打印判断的结果。 

 3、打印这个集合的大小。 

 4、判断这个集合是否包含数据"王五"。 

 5、将”张三”这条数据删掉。 

 6、利用迭代器迭代获取set集合中的每个元素，并打印。 

import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
    public static void main(String[] args) {
        HashSet<String> hashSet = new HashSet<String>();
        //1、往这个HashSet对象里添加如下String类型的数据：“张三”，“李四”，“王五”，“张三”，”赵六”
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("王五");
        hashSet.add("张三");
        hashSet.add("赵六");
        //2、判断这个集合是否为空，并打印判断的结果。
        System.out.println(hashSet.isEmpty());
        //3、打印这个集合的大小。
        System.out.println(hashSet.size());
        //4、判断这个集合是否包含数据"王五"。
        System.out.println(hashSet.contains("王五"));
        //5、将”张三”这条数据删掉。
        hashSet.remove("张三");
        //6、利用迭代器迭代获取set集合中的每个元素，并打印。
        Iterator<String> ite = hashSet.iterator();
        while (ite.hasNext()) {
            System.out.println(ite.next());
        }

    }
}

2、HashMap特点

• 以键值对的形式来保存数据 ~~Json
• 键名不可以重复，重复时，后者键值对覆盖前者 --HashSet
• 键和值支持的数据类型-引用类型

3、HashMap常用Api

• 添加数据-put(…)
• 取值-get(…)
• 移除-remove(…)
• 获取所有的键名-keyset(…)
• 获取所有的键值-values(…)
• 获取集合大小-size()
• 包含指定的键-containsKey(…)
• 包含指定的值-containsValue(…)

import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

ublic class HashMapTest {
    public static void main(String[] args) {
        //1、创建hashMap对象 -- 指定键名数据类型 键值得数据类型
        HashMap<String,String> hashMap = new HashMap<String,String>();
        //2、添加数据 put
        hashMap.put("name","张三");
        hashMap.put("age","20");
        hashMap.put("address","长沙");
        hashMap.put("height","180");
        hashMap.put("age","25");
        //3、获取数据 get --根据键名获取键值
        //System.out.println(hashMap.get("name"));
        //System.out.println(hashMap.get("age"));
        //4、移除数据remove
        //hashMap.remove("height");
        //5、获取到集合得大小
        //System.out.println(hashMap.size());
        //6、获取到所有的键名 keySet()
        /*Set<String> allkeys = hashMap.keySet();
        for (String key : allkeys){
            System.out.println(key);
        }*/
        //7、获取所有的键值 values()
        //Collection<String> allValues = hashMap.values();
        /*for(String value : allValues){
            System.out.println(value);
        }*/

        //用自定义类型作为hashMap的键名存储类型
        /*HashMap<Teacher,String> hashMap1 = new HashMap<Teacher,String>();
        Teacher teacher = new Teacher("张三",20);
        hashMap1.put(teacher,"长沙");*/

        //8、包含指定的键名 containsKey
       //System.out.println( hashMap.containsKey("name"));
       //9、包含指定的键值 containsValue
        //System.out.println(hashMap.containsValue("180"));

        //10、对HashMap进行循环遍历 entrySet--获取到所有键值对的组合
        Set<Entry<String,String>> allKeyValues =  hashMap.entrySet();
        for (Entry<String,String> keyValue : allKeyValues){
            //键值对对应的键名
            System.out.println("键名："+keyValue.getKey());
            System.out.println("键值："+keyValue.getValue());
        }
    }
}

4、迭代HashMap

4.1迭代获取所有的键

Set<String> keySet = hashMap.keySet();
for(String key : keySet){
System.out.println(key);
}

4.2 迭代获取所有的值

Collection<String> values = hashMap.values();
for(String value : values){
　　System.out.println(value);
}

4.3 迭代获取所有的键值对

Set<Entry<String,String>> entries = hashMap.entrySet();
for(Entry<String,String> entry : entries){
　　System.out.println("键:"+entry.getKey()+",值:"+entry.getValue());
}

5、IO流是Java操作文件读写的技术

• I：input（输入流，读取文件内容到流对象）
• O：output（输出流，写文件内容到文件）按照流向划分：

输入流

• InputStream
• FileInputStream
• FileReader

输出流

• OutputStream
• FileOutputStream
• FileWriter

按照类型划分：

• 字符流（只能读写纯文本文件）

1. FileReader
2. FileWriter

• 字节流（读写任意文件） 字节的类型的数据 -- 比如说图片

1. FileInputStream
2. FileOutputStream

6、读写操作，以及复制操作示例代码

import java.io.*;
public class IOTest {
    public static void main(String[] args) throws Exception {
        //普通文本文件读写
        //readFile("C:\Users\Administrator\Desktop\test.txt");
        //writeFile("C:\Users\Administrator\Desktop\testWrite.txt");
        //图片/视频文件 -二进制文件 复制粘贴 先去读-》写到一个新的文件中
        copyFile("C:\Users\Administrator\Desktop\testInputStream.png"
                ,"C:\Users\Administrator\Desktop\testAfter.png");
    }

    public static void copyFile(String srcFilePath,String targetFilePath) throws IOException {

        File srcFile = new File(srcFilePath);
        File targetFile = new File(targetFilePath);
        //创建FileInputStream对象
        FileInputStream fileInputStream = new FileInputStream(srcFile);
        //创建FileOutputStream对象
        FileOutputStream fileOutputStream = new FileOutputStream(targetFile);
        //缓冲流-字节读取
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        //缓冲流-字节写入
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        while(true){
            //规定每一次读取的字节长度 1MB=1024KB=1024*1024字节
            byte[] arr = new byte[1024];
            //read返回值不是用来保存读取的结果，读取的状态 为-1 已经读到文件末尾
            int status = bufferedInputStream.read(arr);
            //写入
            bufferedOutputStream.write(arr);
            //没有意义
            /*for (byte data:arr){
                System.out.println(data);
            }*/
            if(status == -1){
                break;
            }
        }
        //读取结束，关闭流
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }

    public static void writeFile(String filePath) throws Exception {
        File file = new File(filePath);
        //创建FileWriter对象
        FileWriter fileWriter = new FileWriter(file);
        //缓冲流 -写
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.write("hello");
        //换一行 写换行符
        bufferedWriter.newLine();
        bufferedWriter.write("java");
        bufferedWriter.newLine();
        bufferedWriter.write("python");
        //bufferedWriter.newLine();
        //关闭流
        bufferedWriter.close();
    }

    public static void readFile(String filepath) throws IOException {
        //1、普通文本文件的读取 --字符流 FileReader
        //创建file文件对象 参数传入文件的路径
        File file = new File(filepath);
        //创建fileReader对象  参数传入File文件对象
        //（1）异常处理的方式，try catch
        /*try {
            FileReader fileReader = new FileReader(file);
        }catch (FileNotFoundException e){
            //捕捉异常
            //e.printStackTrace(); //StackTrace  方法调用栈,顺序
            System.out.println("文件找不到，检查文件路径是否正确");
        }*/
        //（2）异常的处理方式：不在当前处理，而是把异常抛给上一级调用者
        // eg:方法名后面加throws FileNotFoundException
        //fileReader读取一次性把文件的全部内容读取到内存中
        FileReader fileReader = new FileReader(file);
        // 缓冲流  每一次读取一行，内存中的空间只有这一行  减少内存压力/提高效率
        //BufferedReader参数是为Reader类型 ，传fileReader对象
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String line = "";
        while((line=bufferedReader.readLine()) != null){
            //每一次读取一行
            System.out.println(line);
        }
        //关闭流
        bufferedReader.close();
    }
}

7、 读写的一般步骤--为什么能接收不一样的类，因为多态(ctrl+h快捷键)

• 1、创建file文件对象，一般是string类型的路径参数filepath传入，做为文件的路径-- File file = new File(filepath);
• 2、创建fileReader对象或者 参数传入File文件对象-- FileReader fileReader = new FileReader(file);
• 3、fileReader读取一次性把文件的全部内容读取到内存中--FileReader fileReader = new FileReader(file);
• 4、缓存流，每一次读取一行，内存中的空间只有这一行 减少内存压力/提高效率BufferedReader参数是为Reader类型 ，传fileReader对象--BufferedReader bufferedReader = new BufferedReader(fileReader);
• 5、关闭流--bufferedReader.close();

第4步注意：加上：while(bufferedReader.readLine()!= null) 会输入跳行的数据
BufferedReader bufferedReader = new BufferedReader(fileReader);
String line = "";
while((line=bufferedReader.readLine()) != null){
//每一次读取一行
System.out.println(line);
}

8、异常处理

方式1：
通过try...catch来捕捉异常并进行处理，语法如下：

try{
//可能出现异常的语句
}catch(XXException e){ //异常类 异常对象
//异常处理
}

方式2：

异常直接抛出，给上一级调用者去处理，直到被处理，如果所有上级调用者都不处理就会由java虚拟机处理
使用throws关键字抛出异常

如下图所示：