net.sf.javagimmicks.math.NumberCompareUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gimmicks Show documentation
Utility classes, APIs and tools for Java
There is a newer version: 0.99-alpha1
package net.sf.javagimmicks.math;

import java.util.Comparator;

import net.sf.javagimmicks.math.comparator.BooleanComparator;
import net.sf.javagimmicks.math.comparator.ByteComparator;
import net.sf.javagimmicks.math.comparator.DoubleComparator;
import net.sf.javagimmicks.math.comparator.FloatComparator;
import net.sf.javagimmicks.math.comparator.LongComparator;
import net.sf.javagimmicks.math.comparator.ShortComparator;

/**
 * A shortcut helper for comparing non-{@code int}s in a {@link Comparator}
 * style. Internally uses {@link Comparator}s from
 * {@link net.sf.javagimmicks.math.comparator} package.
 */
public class NumberCompareUtils
{
   private NumberCompareUtils()
   {}

   /**
    * Compares two {@code boolean}s in {@link Comparator} style.
    * 
    * @param n1
    *           the first {@code boolean} to compare
    * @param n2
    *           the second {@code boolean} to compare
    * @return the comparison result as {@code int}
    * @see ByteComparator
    */
   public static int compare(final boolean n1, final boolean n2)
   {
      return new BooleanComparator().compare(n1, n2);
   }

   /**
    * Compares two {@code byte}s in {@link Comparator} style.
    * 
    * @param n1
    *           the first {@code byte} to compare
    * @param n2
    *           the second {@code byte} to compare
    * @return the comparison result as {@code int}
    * @see ByteComparator
    */
   public static int compare(final byte n1, final byte n2)
   {
      return new ByteComparator().compare(n1, n2);
   }

   /**
    * Compares two {@code short}s in {@link Comparator} style.
    * 
    * @param n1
    *           the first {@code short} to compare
    * @param n2
    *           the second {@code short} to compare
    * @return the comparison result as {@code int}
    * @see ShortComparator
    */
   public static int compare(final short n1, final short n2)
   {
      return new ShortComparator().compare(n1, n2);
   }

   /**
    * Compares two {@code long}s in {@link Comparator} style.
    * 
    * @param n1
    *           the first {@code long} to compare
    * @param n2
    *           the second {@code long} to compare
    * @return the comparison result as {@code int}
    * @see LongComparator
    */
   public static int compare(final long n1, final long n2)
   {
      return new LongComparator().compare(n1, n2);
   }

   /**
    * Compares two {@code float}s in {@link Comparator} style.
    * 
    * @param n1
    *           the first {@code float} to compare
    * @param n2
    *           the second {@code float} to compare
    * @return the comparison result as {@code int}
    * @see FloatComparator
    */
   public static int compare(final float n1, final float n2)
   {
      return new FloatComparator().compare(n1, n2);
   }

   /**
    * Compares two {@code double}s in {@link Comparator} style.
    * 
    * @param n1
    *           the first {@code double} to compare
    * @param n2
    *           the second {@code double} to compare
    * @return the comparison result as {@code int}
    * @see ShortComparator
    */
   public static int compare(final double n1, final double n2)
   {
      return new DoubleComparator().compare(n1, n2);
   }
}