Sha256Hash (bitcoinj 0.14 API)

java.lang.Object
- org.bitcoinj.core.Sha256Hash

All Implemented Interfaces:

Serializable, Comparable<Sha256Hash>
```
public class Sha256Hash
extends Object
implements Serializable, Comparable<Sha256Hash>
```
A Sha256Hash just wraps a byte[] so that equals and hashcode work correctly, allowing it to be used as keys in a map. It also checks that the length is correct and provides a bit more type safety.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static int LENGTH

static Sha256Hash ZERO_HASH

Fields
Modifier and Type	Field and Description
`static int`	`LENGTH`
`static Sha256Hash`	`ZERO_HASH`

Constructor Summary

Constructors
Constructor and Description

Sha256Hash(byte[] rawHashBytes)
Deprecated.

Sha256Hash(String hexString)
Deprecated.

Constructors
Constructor and Description
`Sha256Hash(byte[] rawHashBytes)` Deprecated.
`Sha256Hash(String hexString)` Deprecated.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`int`	`compareTo(Sha256Hash other)`
`static Sha256Hash`	`create(byte[] contents)` Deprecated.
`static Sha256Hash`	`createDouble(byte[] contents)` Deprecated.
`boolean`	`equals(Object o)`
`byte[]`	`getBytes()` Returns the internal byte array, without defensively copying.
`byte[]`	`getReversedBytes()` Returns a reversed copy of the internal byte array.
`static byte[]`	`hash(byte[] input)` Calculates the SHA-256 hash of the given bytes.
`static byte[]`	`hash(byte[] input, int offset, int length)` Calculates the SHA-256 hash of the given byte range.
`int`	`hashCode()` Returns the last four bytes of the wrapped hash.
`static byte[]`	`hashTwice(byte[] input)` Calculates the SHA-256 hash of the given bytes, and then hashes the resulting hash again.
`static byte[]`	`hashTwice(byte[] input, int offset, int length)` Calculates the SHA-256 hash of the given byte range, and then hashes the resulting hash again.
`static byte[]`	`hashTwice(byte[] input1, int offset1, int length1, byte[] input2, int offset2, int length2)` Calculates the hash of hash on the given byte ranges.
`static MessageDigest`	`newDigest()` Returns a new SHA-256 MessageDigest instance.
`static Sha256Hash`	`of(byte[] contents)` Creates a new instance containing the calculated (one-time) hash of the given bytes.
`static Sha256Hash`	`of(File file)` Creates a new instance containing the calculated (one-time) hash of the given file's contents.
`BigInteger`	`toBigInteger()` Returns the bytes interpreted as a positive integer.
`String`	`toString()`
`static Sha256Hash`	`twiceOf(byte[] contents)` Creates a new instance containing the hash of the calculated hash of the given bytes.
`static Sha256Hash`	`wrap(byte[] rawHashBytes)` Creates a new instance that wraps the given hash value.
`static Sha256Hash`	`wrap(String hexString)` Creates a new instance that wraps the given hash value (represented as a hex string).
`static Sha256Hash`	`wrapReversed(byte[] rawHashBytes)` Creates a new instance that wraps the given hash value, but with byte order reversed.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - LENGTH
```
public static final int LENGTH
```
    See Also:
    
    Constant Field Values
  - ZERO_HASH
```
public static final Sha256Hash ZERO_HASH
```
- Constructor Detail
  - Sha256Hash
```
@Deprecated
public Sha256Hash(byte[] rawHashBytes)
```
    Deprecated.
    
    Use wrap(byte[]) instead.
  - Sha256Hash
```
@Deprecated
public Sha256Hash(String hexString)
```
    Deprecated.
    
    Use wrap(String) instead.
- Method Detail
  - wrap
```
public static Sha256Hash wrap(byte[] rawHashBytes)
```
    Creates a new instance that wraps the given hash value.
    
    Parameters:
    
    rawHashBytes - the raw hash bytes to wrap
    
    Returns:
    
    a new instance
    
    Throws:
    
    IllegalArgumentException - if the given array length is not exactly 32
  - wrap
```
public static Sha256Hash wrap(String hexString)
```
    Creates a new instance that wraps the given hash value (represented as a hex string).
    
    Parameters:
    
    hexString - a hash value represented as a hex string
    
    Returns:
    
    a new instance
    
    Throws:
    
    IllegalArgumentException - if the given string is not a valid hex string, or if it does not represent exactly 32 bytes
  - wrapReversed
```
public static Sha256Hash wrapReversed(byte[] rawHashBytes)
```
    Creates a new instance that wraps the given hash value, but with byte order reversed.
    
    Parameters:
    
    rawHashBytes - the raw hash bytes to wrap
    
    Returns:
    
    a new instance
    
    Throws:
    
    IllegalArgumentException - if the given array length is not exactly 32
  - create
```
@Deprecated
public static Sha256Hash create(byte[] contents)
```
    Deprecated.
    
    Use of(byte[]) instead: this old name is ambiguous.
  - of
```
public static Sha256Hash of(byte[] contents)
```
    Creates a new instance containing the calculated (one-time) hash of the given bytes.
    
    Parameters:
    
    contents - the bytes on which the hash value is calculated
    
    Returns:
    
    a new instance containing the calculated (one-time) hash
  - createDouble
```
@Deprecated
public static Sha256Hash createDouble(byte[] contents)
```
    Deprecated.
    
    Use twiceOf(byte[]) instead: this old name is ambiguous.
  - twiceOf
```
public static Sha256Hash twiceOf(byte[] contents)
```
    Creates a new instance containing the hash of the calculated hash of the given bytes.
    
    Parameters:
    
    contents - the bytes on which the hash value is calculated
    
    Returns:
    
    a new instance containing the calculated (two-time) hash
  - of
```
public static Sha256Hash of(File file)
                     throws IOException
```
    Creates a new instance containing the calculated (one-time) hash of the given file's contents. The file contents are read fully into memory, so this method should only be used with small files.
    
    Parameters:
    
    file - the file on which the hash value is calculated
    
    Returns:
    
    a new instance containing the calculated (one-time) hash
    
    Throws:
    
    IOException - if an error occurs while reading the file
  - newDigest
```
public static MessageDigest newDigest()
```
    Returns a new SHA-256 MessageDigest instance. This is a convenience method which wraps the checked exception that can never occur with a RuntimeException.
    
    Returns:
    
    a new SHA-256 MessageDigest instance
  - hash
```
public static byte[] hash(byte[] input)
```
    Calculates the SHA-256 hash of the given bytes.
    
    Parameters:
    
    input - the bytes to hash
    
    Returns:
    
    the hash (in big-endian order)
  - hash
```
public static byte[] hash(byte[] input,
                          int offset,
                          int length)
```
    Calculates the SHA-256 hash of the given byte range.
    
    Parameters:
    
    input - the array containing the bytes to hash
    
    offset - the offset within the array of the bytes to hash
    
    length - the number of bytes to hash
    
    Returns:
    
    the hash (in big-endian order)
  - hashTwice
```
public static byte[] hashTwice(byte[] input)
```
    Calculates the SHA-256 hash of the given bytes, and then hashes the resulting hash again.
    
    Parameters:
    
    input - the bytes to hash
    
    Returns:
    
    the double-hash (in big-endian order)
  - hashTwice
```
public static byte[] hashTwice(byte[] input,
                               int offset,
                               int length)
```
    Calculates the SHA-256 hash of the given byte range, and then hashes the resulting hash again.
    
    Parameters:
    
    input - the array containing the bytes to hash
    
    offset - the offset within the array of the bytes to hash
    
    length - the number of bytes to hash
    
    Returns:
    
    the double-hash (in big-endian order)
  - hashTwice
```
public static byte[] hashTwice(byte[] input1,
                               int offset1,
                               int length1,
                               byte[] input2,
                               int offset2,
                               int length2)
```
    Calculates the hash of hash on the given byte ranges. This is equivalent to concatenating the two ranges and then passing the result to hashTwice(byte[]).
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Returns the last four bytes of the wrapped hash. This should be unique enough to be a suitable hash code even for blocks, where the goal is to try and get the first bytes to be zeros (i.e. the value as a big integer lower than the target value).
    
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toBigInteger
```
public BigInteger toBigInteger()
```
    Returns the bytes interpreted as a positive integer.
  - getBytes
```
public byte[] getBytes()
```
    Returns the internal byte array, without defensively copying. Therefore do NOT modify the returned array.
  - getReversedBytes
```
public byte[] getReversedBytes()
```
    Returns a reversed copy of the internal byte array.
  - compareTo
```
public int compareTo(Sha256Hash other)
```
    Specified by:
    
    compareTo in interface Comparable<Sha256Hash>

Class Sha256Hash

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LENGTH

ZERO_HASH

Constructor Detail

Sha256Hash

Sha256Hash

Method Detail

wrap

wrap

wrapReversed

create

of

createDouble

twiceOf

of

newDigest

hash

hash

hashTwice

hashTwice

hashTwice

equals

hashCode

toString

toBigInteger

getBytes

getReversedBytes

compareTo