夜光：Java成神之路（六）擅长的语言_java.lang.classcastexception: java.lang.string can-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_41987706/article/details/105515048

夜光序言：

染火枫林，琼壶歌月，长歌倚楼。
岁岁年年，花前月下，一樽芳酒。

正文：

以道御术 / 以术识道

4. 字节流和字符流的区别

字节流读取的时候，读到一个字节就返回一个字节；字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在 UTF-8 码表中是 3 个字节）时。

先去查指定的编码表，将查到的字符返回。

字节流可以处理所有类型数据，如：图片，MP3，AVI 视频文件，而字符流只能处理字符数据。只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流。

字节流主要是操作 byte 类型数据，以 byte 数组为准，主要操作类就是 OutputStream、 InputStream

字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节，操作字节和字节数组。

所以字符流是由 Java 虚拟机将字节转化为 2 个字节的 Unicode 字符为单位的字符而成的，所以它对多国语言支持性比较好

如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点。

在程序中一个字符等于两个字节，java 提供了 Reader、Writer 两个专门操作字符流的类。

5. 如何实现对象克隆？

有两种方式。

1). 实现 Cloneable 接口并重写 Object 类中的 clone()方法；

2). 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。

12. import java.io.ByteArrayInputStream;
13. import java.io.ByteArrayOutputStream;
14. import java.io.ObjectInputStream;
15. import java.io.ObjectOutputStream;
16. import java.io.Serializable;
17. public class MyUtil {
18. private MyUtil() {
19. throw new AssertionError();
20. }
21. @SuppressWarnings("unchecked")
22. public static <T extends Serializable> T clone(T obj) throws Exception {
23. ByteArrayOutputStream bout = new ByteArrayOutputStream();
24. ObjectOutputStream oos = new ObjectOutputStream(bout);
25. oos.writeObject(obj);
26. ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
27. ObjectInputStream ois = new ObjectInputStream(bin);
28. return (T) ois.readObject();
29. // 说明：调用 ByteArrayInputStream 或 ByteArrayOutputStream 对象的 close 方法没有任何意义
30. // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放
31. }
32. }

测试代码：

1. import java.io.Serializable;
2. /**
3. * 人类
4. */
5. class Person implements Serializable {
6. private static final long serialVersionUID = -9102017020286042305L;
7. private String name; // 姓名
8. private int age; // 年龄
9. private Car car; // 座驾
10. public Person(String name, int age, Car car) {
11. this.name = name;
12. this.age = age;
13. this.car = car;
14. }
15. public String getName() {
16. return name;
17. }
18. public void setName(String name) {
19. this.name = name;
20. }
21. public int getAge() {
22. return age;
23. }
24. public void setAge(int age) {
25. this.age = age;
26. }
27. public Car getCar() {
28. return car;
29. }
30. public void setCar(Car car) {
31. this.car = car;
32. }
33. @Override
34. public String toString() {
35. return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
36. }
37. }

1. /**
2. * 小汽车类
3. */
4. class Car implements Serializable {
5. private static final long serialVersionUID = -5713945027627603702L;
6. private String brand; // 品牌
7. private int maxSpeed; // 最高时速
8. public Car(String brand, int maxSpeed) {
9. this.brand = brand;
10. this.maxSpeed = maxSpeed;
11. }
12. public String getBrand() {
13. return brand;
14. }
15. public void setBrand(String brand) {
16. this.brand = brand;
17. }
18. public int getMaxSpeed() {
19. return maxSpeed;
20. }
21. public void setMaxSpeed(int maxSpeed) {
22. this.maxSpeed = maxSpeed;
23. }
24. @Override
25. public String toString() {
26. return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
27. }
28. }

1. class CloneTest {
2. public static void main(String[] args) {
3. try {
4. Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));
5. Person p2 = MyUtil.clone(p1); // 深度克隆
6. p2.getCar().setBrand("BYD");
7. // 修改克隆的 Person 对象 p2 关联的汽车对象的品牌属性
8. // 原来的 Person 对象 p1 关联的汽车不会受到任何影响
9. // 因为在克隆 Person 对象时其关联的汽车对象也被克隆了
10. System.out.println(p1);
11. } catch (Exception e) {
12. e.printStackTrace();
13. }
14. }
15. }

注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常

这种是方案明显优于使用 Object 类的 clone 方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。

6. 什么是 java 序列化，如何实现 java 序列化？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。

可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。

序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现 Serializable 接口，该接口没有需要实现的方法， implements Serializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一 ObjectOutputStream(对象流)对象

接着，使用 ObjectOutputStream 对象的 writeObject(Object obj)方法就可以将参数为 obj 的对象写出(即保存其状态)，要恢复的话则用输入流。

八、Java 的集合

1. HashMap 排序题，上机题。

已知一个 HashMap<Integer，User>集合， User 有 name（String）和 age（int）属性。

请写一个方法实现对HashMap 的排序功能，该方法接收 HashMap<Integer，User>为形参，返回类型为 HashMap<Integer，User>

要求对 HashMap 中的 User 的 age 倒序进行排序。

排序时 key=value 键值对不得拆散。

注意：要做出这道题必须对集合的体系结构非常的熟悉。

HashMap 本身就是不可排序的，但是该道题偏偏让给HashMap 排序，那我们就得想在 API 中有没有这样的 Map 结构是有序的，LinkedHashMap，对的，就是他

他是 Map 结构，也是链表结构，有序的，更可喜的是他是 HashMap 的子类，我们返回 LinkedHashMap<Integer,User>即可，还符合面向接口（父类编程的思想）。

但凡是对集合的操作，我们应该保持一个原则就是能用 JDK 中的 API 就有 JDK 中的 API，比如排序算法我们不应该去用冒泡或者选择，而是首先想到用 Collections 集合工具类。

package com.hy.集合;

import com.hy.Test1.User;

import java.util.Collections;
import java.util.HashMap;

public class HashMapTest {
    public static void main(String[] args) {
        HashMap<Integer, User> users = new HashMap<>();
        users.put(1, new User("张三", 25));
        users.put(3, new User("李四", 22));
        users.put(2, new User("王五", 28));
        System.out.println(users);
        HashMap<Integer, User> sortHashMap = sortHashMap(users);
        System.out.println(sortHashMap);
        /**
         11. * 控制台输出内容
         12. * {1=User [name=张三, age=25], 2=User [name=王五, age=28], 3=User [name=李四, age=22]}
         13. {2=User [name=王五, age=28], 1=User [name=张三, age=25], 3=User [name=李四, age=22]}
         14. */
    }

    public static HashMap<Integer, User> sortHashMap(HashMap<Integer, User> map) {
        // 首先拿到 map 的键值对集合
        Set<Entry<Integer, User>> entrySet = map.entrySet();

        // 将 set 集合转为 List 集合，为什么，为了使用工具类的排序方法
        List<Entry<Integer, User>> list = new ArrayList<Entry<Integer, User>>(entrySet);
        // 使用 Collections 集合工具类对 list 进行排序，排序规则使用匿名内部类来实现
        Collections.sort(list, new Comparator<Entry<Integer, User>>() {

            @Override
            public int compare(Entry<Integer, User> o1, Entry<Integer, User> o2) {
                //按照要求根据 User 的 age 的倒序进行排
                return o2.getValue().getAge() - o1.getValue().getAge();
            }
        });
//创建一个新的有序的 HashMap 子类的集合
        LinkedHashMap<Integer, User> linkedHashMap = new LinkedHashMap<Integer, User>();
        //将 List 中的数据存储在 LinkedHashMap 中
        for (Entry<Integer, User> entry : list) {
            linkedHashMap.put(entry.getKey(), entry.getValue());
        }
        //返回结果
        return linkedHashMap;
    }
}