public class Sha256Hash extends SimpleHash {}

public class SimpleHash extends AbstrachHash {}

public class Sha256Hash extends SimpleHash {
  public static final String ALGORITHM_NAME = "SHA-256";

  public Sha256Hash () {super("SHA-256");}

  public Sha256Hash (Object source) { super("SHA-256", source) }

  public Sha256Hash (Object source, Object salt) {
    super("SHA-256", source, salt);
  }

  public Sha256Hash(Object source, Object salt, int hashIterations) {
    super("SHA-256", source, salt, hashIterations);
  }

  public static Sha256Hash fromHexString(String hex) {
    Sha256Hash hash = new Sha256Hash();
    hash.setBytes(Hex.decode(hex));
    return hash;
  }

  public static Sha256Hash fromBase64String(String base64) {
    Sha256Hash has = new Sha256Hash();
    hash.setBytes(Base64.decode(base64));
    return hash;
  }
}

public SimpleHash(String algorithmName, Object source, Object salt, int hashIterations) throws CodeException, UnknownAlgorithmException {
  this.hexEncoded = null;
  this.base64Encoded = null;
  if (!StringUtils.hasText(algorithmName)) {
    throw new NullPointerException("algorithmName argument cannot be null or empty.");
  } else {
    this.algorithmName = algorithmName;
    this.iterations =Math.max(1, hashIterations);

    ByteSource saltBytes = null;
    if (salt != null) {
      saltBytes = this.convertSaltToBytes(salt);
      this.salt = saltBytes;
    }

    ByteSource sourceBytes = this.convertSourceToBytes(source);
    this.hsah(sourceBytes, saltBytes, hashIterations);
  }
}

public interface ByteSource {
  byte[] getBytes();

  String toHex();

  String toBase64();

  boolean isEmpty();

  public static final class Util {
    //...
    //用于从各种类型的实例中中构造SimpleByteSource实例
  }
}

protected ByteSource convertSaltToBytes (Object salt) {
  return this.toByteSource(salt);
}

protected ByteSource convertSourceToBytes (Object source) {
  return this.toByteSource(source);
}

protected ByteSource toByteSource(Object o) {
  if (o == null) {
    return null;
  } else if (o instanceof ByteSource) {
    return (ByteSource)o;
  } else {
    byte[] bytes = this.toBytes(o);
    return Util.bytes(bytes);
  }
}

private void hash(ByteSource source, ByteSource salt, int hashIterations) throws CodeException, UnknownAlgorithmException {
  byte[] saltBytes = salt != null ? salt.getBytes() : null;
  byte[] hashedBytes = this.hash(source.getBytes()， saltBytes, hashIterations);
  this.setBytes(hashedBytes);
}

protected byte[] hash(byte[] bytes, byte[] salt, int hashIterations) throws UnknownAlgorithmException {
  MessageDigest digest = this.getDigest(this.getAlgorithmName());
  if (salt != null) {
    digest.reset();
    digest.update(salt);
  }

  byte[] hashed = digest.digest(bytes);
  int iterations = hashIterations -1;

  for(int i =0; i < iterations; ++i) {
    digest.reset();
    hashed = digest.digest(hashed);
  }

  return hashed;
}

public void setBytes(byte[] alreadyHashedBytes) {
  this.bytes = alreadyHashedBytes;
  this.hexEncoded = null;
  this.base64Encoded = null;
}

protected MessageDigest getDigest(String algorithmName) throws UnknownAlgorithmException {
  try {
    return MessageDigest.getInstance(algorithmName);
  } catch (...) {
    ...
  }
}

public static void main(String args) {
  Sha256Hash sha256Hsah = new Sha256Hash();
  MessageDigest MessageDigest = sha256Hsah.getDigest(sha256Hsah.getAlgorithmName());
  //这里输出的也不是具体的实现结果
  System.out.println(digest.getClass().getName())
}
//最终找到当AlgorithmName=SHA-256时，加载了sun.security.provider.SHA2$SHA256这个类

abstract class SHA2 extends DigestBase {


  public static class SHA256 extends SHA2 {
    private static final int[] INITIAL_HASHES = new int[]{....};

    public SHA256() { super("SHA-256", 32, INITIAL_HASHES)}
  }
}

abstract class DigestBase extends MessageDigestSpi implements Cloneable {
  private byte[] oneByte;
  private final String algorithm;
  private final int digestLength;
  private final int blockSize;
  byte[] buffer;
  private int bufOfs;
  long bytesProcessed;
  static final byte[] padding = new byte[136];

  DigestBase (String var1, int var2, int var3) {
    this.algorithm = var1;
    this.digestLength = var2;
    this.blockSize = var3;
    this.buffer = new byte[var3];
  }

  protected final int engineGetDigestLength() { return this.digestLength;}

  protected final void engineUpdate(byte var1) {
    if(this.oneByte == null) {
      this.oneByte = new Byte[1];
    }

    this.oneByte[0] = var1;
    this.engineUpdate(this.oneByte, 0,1);
  }

  protected final void engineUpdate(byte[] var1, int var2, int var3) {
    if (var3 != 0) {
      if (var2 >= 0, && var3 >= 0 && var2 <= var1.length - var3) {

      }
    }
  }
}

// 求两个单链表是否有交叉节点，找出交叉点
import java.util.Scanner;

//{1} -> {2} -> {3} -> {4} -> {5} -> null
// {7} ->  {4} ->  {5} -> null

// 1 7;
// 2 4;
// 3 6;
// 4 1;
// 5 2;
// 7 3;
// 4 4;
// 6 5;
// null null;
// 7 1;
// 4 2;
// 6 3;
// null 4;
// 7

class Node {
    int val;
    Node next;


}



public class Main {
    public static void main(String[] args) {


    }

    public Node findX(Node l1, Node l2) {
        Node cl1 = l1;
        Node cl2 = l2;
        boolean hasChange1 = false;
        boolean hasChange2 = false;

        while(cl1 != null
              && cl2 != null
              && cl1.equals(cl2)) {
            cl1 = cl1.next;
            cl2 = cl2.next;

            if (cl1 == null && !hasChange11) {
                cl1 = l2;
                hasChange1 = !hasChange11;
            }

            if (cl2 == null  && !hasCange2) {
                cl2 = l1;
                hasChange2 = !hasChange2;
            }
        }

        return cl1;
    }
}