fork download
copy 
  1. import java.math.BigInteger;
  2. import java.util.function.LongSupplier;
  3. import java.util.function.Supplier;
  4.  
  5. class Main {
  6.  
  7.     public static void main(String[] args) {
  8.         BigInteger value = new LazyBigInteger(() -> 42L);
  9.         System.out.println("Ok.");
  10.         System.out.println("Value is " + value);
  11.         System.out.println("Value is " + value.multiply(BigInteger.TEN));
  12.     }
  13.  
  14.     static class Lazy<T> {
  15.         private Supplier<T> supplier;
  16.         private volatile T value;
  17.  
  18.         public Lazy(Supplier<T> supplier) {
  19.             this.supplier = supplier;
  20.         }
  21.  
  22.         public T get() {
  23.             T result = value;
  24.             if (result != null) return result;
  25.             synchronized (this) {
  26.                 result = value;
  27.                 if (result != null) return result;
  28.                 System.out.println("Calculate!");
  29.                 result = value = supplier.get(); 
  30.             }
  31.             return result;
  32.         }
  33.     }
  34.  
  35.     static class LazyBigInteger extends BigInteger {
  36.         private final Lazy<BigInteger> delegate;
  37.  
  38.         public LazyBigInteger(LongSupplier loader) {
  39.             super("0");
  40.             delegate = new Lazy<>(() -> new BigInteger(String.valueOf(loader.getAsLong())));
  41.         }
  42.  
  43.         @Override
  44.         public byte[] toByteArray() {
  45.             return delegate.get().toByteArray();
  46.         }
  47.  
  48.         @Override
  49.         public BigInteger abs() {
  50.             return delegate.get().abs();
  51.         }
  52.  
  53.         @Override
  54.         public BigInteger negate() {
  55.             return delegate.get().negate();
  56.         }
  57.  
  58.         @Override
  59.         public BigInteger add(BigInteger value) {
  60.             return delegate.get().add(value);
  61.         }
  62.  
  63.         @Override
  64.         public BigInteger subtract(BigInteger value) {
  65.             return delegate.get().subtract(value);
  66.         }
  67.  
  68.         @Override
  69.         public int signum() {
  70.             return delegate.get().signum();
  71.         }
  72.  
  73.         @Override
  74.         public BigInteger shiftRight(int n) {
  75.             return delegate.get().shiftRight(n);
  76.         }
  77.  
  78.         @Override
  79.         public BigInteger shiftLeft(int n) {
  80.             return delegate.get().shiftLeft(n);
  81.         }
  82.  
  83.         @Override
  84.         public int bitLength() {
  85.             return delegate.get().bitLength();
  86.         }
  87.  
  88.         @Override
  89.         public boolean testBit(int n) {
  90.             return delegate.get().testBit(n);
  91.         }
  92.  
  93.         @Override
  94.         public BigInteger setBit(int n) {
  95.             return delegate.get().setBit(n);
  96.         }
  97.  
  98.         @Override
  99.         public BigInteger clearBit(int n) {
  100.             return delegate.get().clearBit(n);
  101.         }
  102.  
  103.         @Override
  104.         public BigInteger flipBit(int n) {
  105.             return delegate.get().flipBit(n);
  106.         }
  107.  
  108.         @Override
  109.         public int getLowestSetBit() {
  110.             return delegate.get().getLowestSetBit();
  111.         }
  112.  
  113.         @Override
  114.         public int bitCount() {
  115.             return delegate.get().bitCount();
  116.         }
  117.  
  118.         @Override
  119.         public BigInteger not() {
  120.             return delegate.get().not();
  121.         }
  122.  
  123.         @Override
  124.         public BigInteger and(BigInteger value) {
  125.             return delegate.get().and(value);
  126.         }
  127.  
  128.         @Override
  129.         public BigInteger or(BigInteger value) {
  130.             return delegate.get().or(value);
  131.         }
  132.  
  133.         @Override
  134.         public BigInteger xor(BigInteger value) {
  135.             return delegate.get().xor(value);
  136.         }
  137.  
  138.         @Override
  139.         public BigInteger andNot(BigInteger value) {
  140.             return delegate.get().andNot(value);
  141.         }
  142.  
  143.         @Override
  144.         public int intValue() {
  145.             return delegate.get().intValue();
  146.         }
  147.  
  148.         @Override
  149.         public long longValue() {
  150.             return delegate.get().longValue();
  151.         }
  152.  
  153.         @Override
  154.         public float floatValue() {
  155.             return delegate.get().floatValue();
  156.         }
  157.  
  158.         @Override
  159.         public double doubleValue() {
  160.             return delegate.get().doubleValue();
  161.         }
  162.  
  163.         @Override
  164.         public int compareTo(BigInteger value) {
  165.             return delegate.get().compareTo(value);
  166.         }
  167.  
  168.         @Override
  169.         public BigInteger min(BigInteger value) {
  170.             return delegate.get().min(value);
  171.         }
  172.  
  173.         @Override
  174.         public BigInteger max(BigInteger value) {
  175.             return delegate.get().max(value);
  176.         }
  177.  
  178.         @Override
  179.         public int hashCode() {
  180.             return delegate.get().hashCode();
  181.         }
  182.  
  183.         @Override
  184.         public boolean equals(Object x) {
  185.             return delegate.get().equals(x);
  186.         }
  187.  
  188.         @Override
  189.         public String toString() {
  190.             return delegate.get().toString();
  191.         }
  192.  
  193.         @Override
  194.         public String toString(int radix) {
  195.             return delegate.get().toString(radix);
  196.         }
  197.  
  198.         @Override
  199.         public BigInteger gcd(BigInteger value) {
  200.             return delegate.get().gcd(value);
  201.         }
  202.  
  203.         @Override
  204.         public BigInteger multiply(BigInteger value) {
  205.             return delegate.get().multiply(value);
  206.         }
  207.  
  208.         @Override
  209.         public BigInteger pow(int exp) {
  210.             return delegate.get().pow(exp);
  211.         }
  212.  
  213.         @Override
  214.         public BigInteger[] divideAndRemainder(BigInteger divisor) {
  215.             return delegate.get().divideAndRemainder(divisor);
  216.         }
  217.  
  218.         @Override
  219.         public BigInteger divide(BigInteger divisor) {
  220.             return delegate.get().divide(divisor);
  221.         }
  222.  
  223.         @Override
  224.         public BigInteger remainder(BigInteger divisor) {
  225.             return delegate.get().remainder(divisor);
  226.         }
  227.  
  228.         @Override
  229.         public BigInteger modInverse(BigInteger m) {
  230.             return delegate.get().modInverse(m);
  231.         }
  232.  
  233.         @Override
  234.         public BigInteger modPow(BigInteger exponent, BigInteger modulus) {
  235.             return delegate.get().modPow(exponent, modulus);
  236.         }
  237.  
  238.         @Override
  239.         public BigInteger mod(BigInteger m) {
  240.             return delegate.get().mod(m);
  241.         }
  242.  
  243.         @Override
  244.         public boolean isProbablePrime(int certainty) {
  245.             return delegate.get().isProbablePrime(certainty);
  246.         }
  247.  
  248.         @Override
  249.         public BigInteger nextProbablePrime() {
  250.             return delegate.get().nextProbablePrime();
  251.         }
  252.  
  253.         @Override
  254.         public byte byteValue() {
  255.             return delegate.get().byteValue();
  256.         }
  257.  
  258.         @Override
  259.         public short shortValue() {
  260.             return delegate.get().shortValue();
  261.         }
  262.     }
  263.  
  264. }
  265.  
Success #stdin #stdout 0.13s 2184192KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Ok.
Calculate!
Value is 42
Value is 420
https://ideone.com/XK2GOH
language:
Java (HotSpot 12)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!