content: package dev.utils.common;
  
  import java.io.ByteArrayOutputStream;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.Map;
  
  import dev.utils.JCLogUtils;
  
  /**
   * detail: 克隆工具类
   * @author Ttt
   */
  public final class CloneUtils {
  
      private CloneUtils() {
      }
  
      // 日志 TAG
      private static final String TAG = CloneUtils.class.getSimpleName();
  
      /**
       * 进行克隆
       * @param data Object implements {@link Serializable}
       * @param <T>  泛型
       * @return 克隆后的对象
       */
      public static <T> T deepClone(final Serializable data) {
          if (data == null) return null;
          return (T) ConvertUtils.bytesToObject(serializableToBytes(data));
      }
  
      /**
       * 通过序列化实体类, 获取对应的 byte[] 数据
       * @param serializable Object implements {@link Serializable}
       * @return 克隆后 byte[]
       */
      public static byte[] serializableToBytes(final Serializable serializable) {
          if (serializable == null) return null;
          ObjectOutputStream oos = null;
          try {
              ByteArrayOutputStream baos = new ByteArrayOutputStream();
              oos = new ObjectOutputStream(baos);
              oos.writeObject(serializable);
              return baos.toByteArray();
          } catch (Exception e) {
              JCLogUtils.eTag(TAG, e, "serializableToBytes");
              return null;
          } finally {
              CloseUtils.closeIOQuietly(oos);
          }
      }
  
      // =
  
      /**
       * 进行克隆
       * @param map    存储集合
       * @param values 需要克隆的数据源
       * @param <K>    key
       * @param <V>    value
       * @return {@code true} success, {@code false} fail
       */
      public static <K, V> boolean deepClone(
              final Map<K, V> map,
              final Map<K, V> values
      ) {
          if (map != null && values != null && values.size() > 0) {
              Iterator<Map.Entry<K, V>> iterator = values.entrySet().iterator();
              while (iterator.hasNext()) {
                  try {
                      Map.Entry<K, V> entry = iterator.next();
                      // 获取 key
                      K key = entry.getKey();
                      // 克隆对象
                      V cloneObj = (V) ConvertUtils.bytesToObject(
                              serializableToBytes((Serializable) entry.getValue())
                      );
                      if (cloneObj != null) {
                          // 保存到集合
                          map.put(key, cloneObj);
                      }
                  } catch (Exception e) {
                      JCLogUtils.eTag(TAG, e, "deepClone");
                  }
              }
              return true;
          }
          return false;
      }
  
      /**
       * 进行克隆
       * @param collection 存储集合
       * @param values     需要克隆的数据源
       * @param <T>        泛型
       * @return {@code true} success, {@code false} fail
       */
      public static <T> boolean deepClone(
              final Collection<T> collection,
              final Collection<T> values
      ) {
          if (collection != null && values != null && values.size() > 0) {
              Iterator<T> iterator = values.iterator();
              while (iterator.hasNext()) {
                  try {
                      // 克隆对象
                      T cloneObj = (T) ConvertUtils.bytesToObject(
                              serializableToBytes((Serializable) iterator.next())
                      );
                      if (cloneObj != null) {
                          collection.add(cloneObj);
                      }
                  } catch (Exception e) {
                      JCLogUtils.eTag(TAG, e, "deepClone");
                  }
              }
              return true;
          }
          return false;
      }
  }