脚踏实地

InputStream inputStream = new FileInputStream("file.txt");
int data;
while ((data = inputStream.read()) != -1) {
    // 处理读取的字节数据
}
inputStream.close();

Reader reader = new FileReader("file.txt");
int data;
while ((data = reader.read()) != -1) {
    // 处理读取的字符数据
}
reader.close();

// 字节输入流转换为字符输入流
public class ByteToCharStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fileInputStream = new FileInputStream("example.txt");
             InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
             BufferedReader bufferedReader = new BufferedReader(inputStreamReader)) {

            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 字节输出流转换为字符输出流
public class CharToByteStreamExample {
    public static void main(String[] args) {
        try (FileOutputStream fileOutputStream = new FileOutputStream("output.txt");
             OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
             BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter)) {

            bufferedWriter.write("这是一个字符流到字节流的示例。");
            bufferedWriter.newLine();
            bufferedWriter.write("Hello, world!");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class MainTest {
    public static void main(String[] args) {
//       serialUser();
        System.out.println("----------反序列化对象----------");
        unSerialUser();
    }

    private static void serialUser (){
        User user = new User();
        user.setName("Jane");
        user.setAge("100");
        System.out.println(user);
        try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./user.txt"));) {
            oos.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void unSerialUser() {
        File file = new File("./user.txt");
        try(ObjectInputStream ois  = new ObjectInputStream(new FileInputStream(file))) {
            User newUser = (User) ois.readObject();
            System.out.println(newUser);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

class User implements Serializable {
    private String name;
    private String age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("stringlist"));
objectOutputStream.writeObject(stringList);
IOUtils.close(objectOutputStream);

writeObject
    --->writeObject0
    --->writeOrdinaryObject
    --->writeSerialData
    --->invokeWriteObject

/**
 * Underlying writeObject/writeUnshared implementation.
 */
private void writeObject0(Object obj, boolean unshared) throws IOException {
    boolean oldMode = bout.setBlockDataMode(false);
    depth++;
    try {
       // ... 

        // remaining cases
        if (obj instanceof String) {
            writeString((String) obj, unshared);
        } else if (cl.isArray()) {
            writeArray(obj, desc, unshared);
        } else if (obj instanceof Enum) {
            writeEnum((Enum<?>) obj, desc, unshared);
        // =============================
        } else if (obj instanceof Serializable) {
            writeOrdinaryObject(obj, desc, unshared);
        } else {
            if (extendedDebugInfo) {
                throw new NotSerializableException(
                    cl.getName() + "\n" + debugInfoStack.toString());
            } else {
                throw new NotSerializableException(cl.getName());
            }
        }
        // =============================
    } finally {
        // ... 
    }
}

java.io.InvalidClassException: content.posts.rookie.User; no valid constructor

public class MainTest {
    public static void main(String[] args) {
//       serialUser();
        System.out.println("----------反序列化对象----------");
        unSerialUser();
    }

    private static void serialUser ()  {
        User user = new User();
        user.setName("Jane");
        user.setAge("100");
        System.out.println(user);
        // /将对象序列化到文件
        try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./user.txt"));) {
            oos.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void unSerialUser() {
        File file = new File("./user.txt");
        try(ObjectInputStream ois  = new ObjectInputStream(new FileInputStream(file))) {
            User newUser = (User) ois.readObject();
            System.out.println(newUser);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

class User implements Externalizable {

    public User() {
    }

    private String name;
    private String age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeObject(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String) in.readObject();
        age = (String) in.readObject();
    }
}

// 该字段不会被序列化
private transient String name;
private static String address;

public class MainTest {
    public static void main(String[] args) {
        System.out.println("----------序列化对象----------");
        serialUser();
        System.out.println("----------反序列化对象----------");
        unSerialUser();
    }

    private static void serialUser (){
        User user = new User();
        user.setName("Jane");
        user.setAge("100");
        System.out.println(user);
        try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./user.txt"));) {
            oos.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void unSerialUser() {
        File file = new File("./user.txt");
        try(ObjectInputStream ois  = new ObjectInputStream(new FileInputStream(file))) {
            User newUser = (User) ois.readObject();
            System.out.println(newUser);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

class User implements Serializable {

    private String name;
    private String age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

java.io.InvalidClassException: com.test.User; local class incompatible: stream classdesc serialVersionUID = -2986778152837257883, local class serialVersionUID = 7961728318907695402

ObjectInputStream.readObject 
    -> readObject0
    -> readOrdinaryObject
    -> readClassDesc
    -> readNonProxyDesc
    -> ObjectStreamClass.initNonProxy

void initNonProxy(ObjectStreamClass model,
                  Class<?> cl,
                  ClassNotFoundException resolveEx,
                  ObjectStreamClass superDesc)
    throws InvalidClassException {
    long suid = Long.valueOf(model.getSerialVersionUID());
    ObjectStreamClass osc = null;
    if (cl != null) {
        osc = lookup(cl, true);
        if (osc.isProxy) {
            throw new InvalidClassException(
                    "cannot bind non-proxy descriptor to a proxy class");
        }
        if (model.isEnum != osc.isEnum) {
            throw new InvalidClassException(model.isEnum ?
                    "cannot bind enum descriptor to a non-enum class" :
                    "cannot bind non-enum descriptor to an enum class");
        }

        // ========== 判断反序列化 serializableUID 是否一致 ========== start//
        if (model.serializable == osc.serializable &&
                !cl.isArray() &&
                suid != osc.getSerialVersionUID()) {
            throw new InvalidClassException(osc.name,
                    "local class incompatible: " +
                            "stream classdesc serialVersionUID = " + suid +
                            ", local class serialVersionUID = " +
                            osc.getSerialVersionUID());
        }
        // ========== 判断反序列化 serializableUID 是否一致 ========== end//
        
        // 在反序列化过程中，对serialVersionUID做了比较，如果发现不相等，则直接抛出异常
        if (!classNamesEqual(model.name, osc.name)) {
            throw new InvalidClassException(osc.name,
                    "local class name incompatible with stream class " +
                            "name \"" + model.name + "\"");
        }

        // ...
    }
}

public long getSerialVersionUID() {
    // REMIND: synchronize instead of relying on volatile?
    if (suid == null) {
        suid = AccessController.doPrivileged(
            new PrivilegedAction<Long>() {
                public Long run() {
                    // 生成一个默认的serialVersionUID
                    return computeDefaultSUID(cl);
                }
            }
        );
    }
    return suid.longValue();
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    private static final long serialVersionUID = 8683452581122892189L;
    transient Object[] elementData; // non-private to simplify nested class access
    private int size;
}

public static void main(String[] args) throws IOException, ClassNotFoundException {
        List<String> stringList = new ArrayList<String>();
        stringList.add("hello");
        stringList.add("world");
        stringList.add("123");
        stringList.add("456");
        System.out.println("init StringList" + stringList);
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("stringlist"));
        objectOutputStream.writeObject(stringList);

        IOUtils.close(objectOutputStream);
        File file = new File("stringlist");
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
        List<String> newStringList = (List<String>)objectInputStream.readObject();
        IOUtils.close(objectInputStream);
        if(file.exists()){
            file.delete();
        }
        System.out.println("new StringList" + newStringList);
    }

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("stringlist"));
objectOutputStream.writeObject(stringList);
IOUtils.close(objectOutputStream);

writeObject
    --->writeObject0
    --->writeOrdinaryObject
    --->writeSerialData
    --->invokeWriteObject

/** class-defined writeObject method, or null if none */
private Method writeObjectMethod;

/**
 * Invokes the writeObject method of the represented serializable class.
 * Throws UnsupportedOperationException if this class descriptor is not
 * associated with a class, or if the class is externalizable,
 * non-serializable or does not define writeObject.
 */
void invokeWriteObject(Object obj, ObjectOutputStream out)
    throws IOException, UnsupportedOperationException {
    requireInitialized();
    if (writeObjectMethod != null) {
        try {

            // ========== 调用writeObject 方法 start========== //
            writeObjectMethod.invoke(obj, new Object[]{ out });
            // ========== 调用writeObject 方法 end========== //

        } catch (InvocationTargetException ex) {
            Throwable th = ex.getTargetException();
            if (th instanceof IOException) {
                throw (IOException) th;
            } else {
                throwMiscException(th);
            }
        } catch (IllegalAccessException ex) {
            // should not occur, as access checks have been suppressed
            throw new InternalError(ex);
        }
    } else {
        throw new UnsupportedOperationException();
    }
}

public class MainTest {
    public static void main(String[] args) throws Exception {
        String path = "/Users/whitepure/github/iblog/blog-site/content/posts/rookie/singleton.txt";

        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path));
        oos.writeObject(Singleton.getSingleton());

        //Read Obj from file
        File file = new File(path);
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        Singleton newInstance = (Singleton) ois.readObject();

        //判断是否是同一个对象
        System.out.println(newInstance == Singleton.getSingleton());
    }
}

class Singleton implements Serializable {
    private static final long serialVersionUID = 6377402142849822126L;

    private volatile static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (MainTest.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("stringlist"));
objectOutputStream.writeObject(stringList);
IOUtils.close(objectOutputStream);

readObject
    ---> readObject0
    ---> readOrdinary
    ---> checkResolve

/**
 * Reads and returns "ordinary" (i.e., not a String, Class,
 * ObjectStreamClass, array, or enum constant) object, or null if object's
 * class is unresolvable (in which case a ClassNotFoundException will be
 * associated with object's handle).  Sets passHandle to object's assigned
 * handle.
 */
private Object readOrdinaryObject(boolean unshared)
    throws IOException {

    // ...

    Object obj;
    try {
        // `desc.isInstantiable()`: 如果一个 `serializable/externalizable` 的类可以在运行时被实例化，那么该方法就返回true
        // `desc.newInstance`：该方法通过反射的方式调用无参构造方法新建一个对象
        obj = desc.isInstantiable() ? desc.newInstance() : null;
    } catch (Exception ex) {
        throw (IOException) new InvalidClassException(
            desc.forClass().getName(),
            "unable to create instance").initCause(ex);
    }

    // ...

    // hasReadResolveMethod:如果实现了serializable 或者 externalizable接口的类中包含readResolve则返回true
    if (obj != null &&
        handles.lookupException(passHandle) == null &&
        desc.hasReadResolveMethod())
    {
        // invokeReadResolve:通过反射的方式调用要被反序列化的类的readResolve方法。
        Object rep = desc.invokeReadResolve(obj);
        if (unshared && rep.getClass().isArray()) {
            rep = cloneArray(rep);
        }
        // ...
    }

    return obj;
}

class Singleton implements Serializable {
    private static final long serialVersionUID = 6377402142849822126L;

    private volatile static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (MainTest.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    public Object readResolve() {
        return singleton;
    }
}

try (Socket socket = new Socket("example.com", 80);
     InputStream input = socket.getInputStream();
     OutputStream output = socket.getOutputStream()) {

    output.write("GET / HTTP/1.1\r\n\r\n".getBytes());
    int data;
    while ((data = input.read()) != -1) {
        System.out.print((char) data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

try (SocketChannel socketChannel = SocketChannel.open()) {
    socketChannel.configureBlocking(false);
    socketChannel.connect(new InetSocketAddress("example.com", 80));

    while (!socketChannel.finishConnect()) {
        // 做其他事情
    }

    ByteBuffer buffer = ByteBuffer.allocate(1024);
    int bytesRead = socketChannel.read(buffer);
} catch (IOException e) {
    e.printStackTrace();
}

try (Selector selector = Selector.open();
     ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
    
    serverChannel.bind(new InetSocketAddress(8080));
    serverChannel.configureBlocking(false);
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);

    while (true) {
        selector.select();
        Set<SelectionKey> selectedKeys = selector.selectedKeys();
        Iterator<SelectionKey> iter = selectedKeys.iterator();

        while (iter.hasNext()) {
            SelectionKey key = iter.next();
            if (key.isAcceptable()) {
                // 处理接受事件
            } else if (key.isReadable()) {
                // 处理读取事件
            }
            iter.remove();
        }
    }
} catch (IOException e) {
    e.printStackTrace();
}

try (AsynchronousSocketChannel client = AsynchronousSocketChannel.open()) {
    Future<Void> connectFuture = client.connect(new InetSocketAddress("example.com", 80));
    connectFuture.get();

    ByteBuffer buffer = ByteBuffer.allocate(1024);
    Future<Integer> readFuture = client.read(buffer);
    readFuture.get();
} catch (IOException | InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

public class MainTest {
    /**
     * 使用非直接缓冲区完成读写操作
     * @param args args
     */
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        try (
                // 获取通道
                FileChannel inChannel = new FileInputStream("1.jpg").getChannel();
                FileChannel outChannel = new FileOutputStream("2.jpg").getChannel();
        ) {
            // 分配指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);

            // 将通道中的数据存入缓冲区中
            while (inChannel.read(buf) != -1) {

                // 切换读取数据的模式
                buf.flip();

                // 将缓冲区中的数据写入通道中
                outChannel.write(buf);

                // 清空缓冲区
                buf.clear();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            long end = System.currentTimeMillis();
            System.out.println("耗费的时间为：" + (end - start));
        }
    }
}

ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put((byte) 1);
buffer.put((byte) 2);
buffer.put((byte) 3);
// 此时，位置 position = 3，容量 capacity = 10，限制 limit = 10

buffer.flip();
// 此时，位置 position = 0，限制 limit = 3，容量 capacity = 10

while (buffer.hasRemaining()) {
    // 输出：1, 2, 3
    System.out.println(buffer.get());
}

buffer.clear();
// 此时，位置 position = 0，限制 limit = 10，容量 capacity = 10

buffer.compact();
// 此时，未读的数据被移到缓冲区的开始位置，位置 position 设置为未读数据的数量

public class BufferExample {
    public static void main(String[] args) {
        // 创建一个容量为10的ByteBuffer
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // 写入数据到缓冲区
        buffer.put((byte) 1);
        buffer.put((byte) 2);
        buffer.put((byte) 3);

        // 写入数据后的缓冲区状态:
        // 位置 (Position): 3
        // 限制 (Limit): 10
        // 容量 (Capacity): 10
        System.out.println("写入数据后的缓冲区状态:");
        printBufferStatus(buffer);

        // 翻转缓冲区，准备读取
        buffer.flip();

        // 翻转缓冲区后的状态:
        // 位置 (Position): 0
        // 限制 (Limit): 3
        // 容量 (Capacity): 10
        System.out.println("翻转缓冲区后的状态:");
        printBufferStatus(buffer);

        // 读取数据
        System.out.println("读取数据:");
        while (buffer.hasRemaining()) {
            System.out.println(buffer.get());
        }

        // 读取数据后的缓冲区状态:
        // 位置 (Position): 3
        // 限制 (Limit): 3
        // 容量 (Capacity): 10
        System.out.println("读取数据后的缓冲区状态:");
        printBufferStatus(buffer);

        // 清空缓冲区，准备再次写入
        buffer.clear();

        // 清空缓冲区后的状态:
        // 位置 (Position): 0
        // 限制 (Limit): 10
        // 容量 (Capacity): 10
        System.out.println("清空缓冲区后的状态:");
        printBufferStatus(buffer);
    }

    private static void printBufferStatus(ByteBuffer buffer) {
        System.out.println("位置 (Position): " + buffer.position());
        System.out.println("限制 (Limit): " + buffer.limit());
        System.out.println("容量 (Capacity): " + buffer.capacity());
        System.out.println();
    }
}

public class BufferMarkResetExample {
    public static void main(String[] args) {
        // 创建一个容量为10的ByteBuffer
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // 写入数据到缓冲区
        buffer.put((byte) 1);
        buffer.put((byte) 2);
        buffer.put((byte) 3);

        // 标记当前位置
        buffer.mark();
        System.out.println("标记位置 (Position)：" + buffer.position());

        // 继续写入数据
        buffer.put((byte) 4);
        buffer.put((byte) 5);

        System.out.println("当前缓冲区位置 (Position)：" + buffer.position());

        // 调用reset()方法恢复到标记的位置
        buffer.reset();
        System.out.println("重置后的位置 (Position)：" + buffer.position());

        // 从标记的位置继续写入数据
        buffer.put((byte) 6);

        // 翻转缓冲区，准备读取
        buffer.flip();

        // 读取数据
        System.out.println("读取数据：");
        while (buffer.hasRemaining()) {
            System.out.print(buffer.get() + " ");
        }
    }
}

Selector selector = Selector.open();

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false); // 非阻塞模式
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

selector.select(); // 阻塞直到有通道发生了注册的事件

Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

while (keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    keyIterator.remove();

    if (key.isAcceptable()) {
        // 处理接受连接事件
        handleAccept(key, selector);
    } else if (key.isReadable()) {
        // 处理读事件
        handleRead(key);
    }
}

private static void handleAccept(SelectionKey key, Selector selector) throws IOException {
    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
    SocketChannel clientChannel = serverChannel.accept();
    clientChannel.configureBlocking(false);
    clientChannel.register(selector, SelectionKey.OP_READ); // 注册读事件
    System.out.println("Accepted connection from " + clientChannel.getRemoteAddress());
}

private static void handleRead(SelectionKey key) throws IOException {
    SocketChannel channel = (SocketChannel) key.channel();
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    int bytesRead = channel.read(buffer);
    if (bytesRead == -1) {
        // 客户端关闭连接
        channel.close();
        key.cancel();
        System.out.println("Closed connection: " + channel.getRemoteAddress());
        return;
    }
    buffer.flip();
    byte[] data = new byte[buffer.remaining()];
    buffer.get(data);
    System.out.println("Received: " + new String(data));
    buffer.clear();
}