Tabnine Logo
RuleBasedCollatorICU.compare
Code IndexAdd Tabnine to your IDE (free)

How to use
compare
method
in
libcore.icu.RuleBasedCollatorICU

Best Java code snippets using libcore.icu.RuleBasedCollatorICU.compare (Showing top 14 results out of 315)

origin: robovm/robovm

public boolean equals(String source, String target) {
  return (compare(source, target) == 0);
}
origin: robovm/robovm

/**
 * Compares the {@code source} text to the {@code target} text according to
 * the collation rules, strength and decomposition mode for this
 * {@code RuleBasedCollator}. See the {@code Collator} class description
 * for an example of use.
 * <p>
 * General recommendation: If comparisons are to be done with the same strings
 * multiple times, it is more efficient to generate {@code CollationKey}
 * objects for the strings and use
 * {@code CollationKey.compareTo(CollationKey)} for the comparisons. If each
 * string is compared to only once, using
 * {@code RuleBasedCollator.compare(String, String)} has better performance.
 *
 * @param source
 *            the source text.
 * @param target
 *            the target text.
 * @return an integer which may be a negative value, zero, or else a
 *         positive value depending on whether {@code source} is less than,
 *         equivalent to, or greater than {@code target}.
 */
@Override
public int compare(String source, String target) {
  if (source == null) {
    throw new NullPointerException("source == null");
  } else if (target == null) {
    throw new NullPointerException("target == null");
  }
  return icuColl.compare(source, target);
}
origin: ibinti/bugvm

public boolean equals(String source, String target) {
  return (compare(source, target) == 0);
}
origin: MobiVM/robovm

public boolean equals(String source, String target) {
  return (compare(source, target) == 0);
}
origin: com.bugvm/bugvm-rt

public boolean equals(String source, String target) {
  return (compare(source, target) == 0);
}
origin: com.mobidevelop.robovm/robovm-rt

public boolean equals(String source, String target) {
  return (compare(source, target) == 0);
}
origin: com.gluonhq/robovm-rt

public boolean equals(String source, String target) {
  return (compare(source, target) == 0);
}
origin: FlexoVM/flexovm

public boolean equals(String source, String target) {
  return (compare(source, target) == 0);
}
origin: ibinti/bugvm

/**
 * Compares the {@code source} text to the {@code target} text according to
 * the collation rules, strength and decomposition mode for this
 * {@code RuleBasedCollator}. See the {@code Collator} class description
 * for an example of use.
 * <p>
 * General recommendation: If comparisons are to be done with the same strings
 * multiple times, it is more efficient to generate {@code CollationKey}
 * objects for the strings and use
 * {@code CollationKey.compareTo(CollationKey)} for the comparisons. If each
 * string is compared to only once, using
 * {@code RuleBasedCollator.compare(String, String)} has better performance.
 *
 * @param source
 *            the source text.
 * @param target
 *            the target text.
 * @return an integer which may be a negative value, zero, or else a
 *         positive value depending on whether {@code source} is less than,
 *         equivalent to, or greater than {@code target}.
 */
@Override
public int compare(String source, String target) {
  if (source == null) {
    throw new NullPointerException("source == null");
  } else if (target == null) {
    throw new NullPointerException("target == null");
  }
  return icuColl.compare(source, target);
}
origin: MobiVM/robovm

/**
 * Compares the {@code source} text to the {@code target} text according to
 * the collation rules, strength and decomposition mode for this
 * {@code RuleBasedCollator}. See the {@code Collator} class description
 * for an example of use.
 * <p>
 * General recommendation: If comparisons are to be done with the same strings
 * multiple times, it is more efficient to generate {@code CollationKey}
 * objects for the strings and use
 * {@code CollationKey.compareTo(CollationKey)} for the comparisons. If each
 * string is compared to only once, using
 * {@code RuleBasedCollator.compare(String, String)} has better performance.
 *
 * @param source
 *            the source text.
 * @param target
 *            the target text.
 * @return an integer which may be a negative value, zero, or else a
 *         positive value depending on whether {@code source} is less than,
 *         equivalent to, or greater than {@code target}.
 */
@Override
public int compare(String source, String target) {
  if (source == null) {
    throw new NullPointerException("source == null");
  } else if (target == null) {
    throw new NullPointerException("target == null");
  }
  return icuColl.compare(source, target);
}
origin: com.mobidevelop.robovm/robovm-rt

/**
 * Compares the {@code source} text to the {@code target} text according to
 * the collation rules, strength and decomposition mode for this
 * {@code RuleBasedCollator}. See the {@code Collator} class description
 * for an example of use.
 * <p>
 * General recommendation: If comparisons are to be done with the same strings
 * multiple times, it is more efficient to generate {@code CollationKey}
 * objects for the strings and use
 * {@code CollationKey.compareTo(CollationKey)} for the comparisons. If each
 * string is compared to only once, using
 * {@code RuleBasedCollator.compare(String, String)} has better performance.
 *
 * @param source
 *            the source text.
 * @param target
 *            the target text.
 * @return an integer which may be a negative value, zero, or else a
 *         positive value depending on whether {@code source} is less than,
 *         equivalent to, or greater than {@code target}.
 */
@Override
public int compare(String source, String target) {
  if (source == null) {
    throw new NullPointerException("source == null");
  } else if (target == null) {
    throw new NullPointerException("target == null");
  }
  return icuColl.compare(source, target);
}
origin: FlexoVM/flexovm

/**
 * Compares the {@code source} text to the {@code target} text according to
 * the collation rules, strength and decomposition mode for this
 * {@code RuleBasedCollator}. See the {@code Collator} class description
 * for an example of use.
 * <p>
 * General recommendation: If comparisons are to be done with the same strings
 * multiple times, it is more efficient to generate {@code CollationKey}
 * objects for the strings and use
 * {@code CollationKey.compareTo(CollationKey)} for the comparisons. If each
 * string is compared to only once, using
 * {@code RuleBasedCollator.compare(String, String)} has better performance.
 *
 * @param source
 *            the source text.
 * @param target
 *            the target text.
 * @return an integer which may be a negative value, zero, or else a
 *         positive value depending on whether {@code source} is less than,
 *         equivalent to, or greater than {@code target}.
 */
@Override
public int compare(String source, String target) {
  if (source == null) {
    throw new NullPointerException("source == null");
  } else if (target == null) {
    throw new NullPointerException("target == null");
  }
  return icuColl.compare(source, target);
}
origin: com.gluonhq/robovm-rt

/**
 * Compares the {@code source} text to the {@code target} text according to
 * the collation rules, strength and decomposition mode for this
 * {@code RuleBasedCollator}. See the {@code Collator} class description
 * for an example of use.
 * <p>
 * General recommendation: If comparisons are to be done with the same strings
 * multiple times, it is more efficient to generate {@code CollationKey}
 * objects for the strings and use
 * {@code CollationKey.compareTo(CollationKey)} for the comparisons. If each
 * string is compared to only once, using
 * {@code RuleBasedCollator.compare(String, String)} has better performance.
 *
 * @param source
 *            the source text.
 * @param target
 *            the target text.
 * @return an integer which may be a negative value, zero, or else a
 *         positive value depending on whether {@code source} is less than,
 *         equivalent to, or greater than {@code target}.
 */
@Override
public int compare(String source, String target) {
  if (source == null) {
    throw new NullPointerException("source == null");
  } else if (target == null) {
    throw new NullPointerException("target == null");
  }
  return icuColl.compare(source, target);
}
origin: com.bugvm/bugvm-rt

/**
 * Compares the {@code source} text to the {@code target} text according to
 * the collation rules, strength and decomposition mode for this
 * {@code RuleBasedCollator}. See the {@code Collator} class description
 * for an example of use.
 * <p>
 * General recommendation: If comparisons are to be done with the same strings
 * multiple times, it is more efficient to generate {@code CollationKey}
 * objects for the strings and use
 * {@code CollationKey.compareTo(CollationKey)} for the comparisons. If each
 * string is compared to only once, using
 * {@code RuleBasedCollator.compare(String, String)} has better performance.
 *
 * @param source
 *            the source text.
 * @param target
 *            the target text.
 * @return an integer which may be a negative value, zero, or else a
 *         positive value depending on whether {@code source} is less than,
 *         equivalent to, or greater than {@code target}.
 */
@Override
public int compare(String source, String target) {
  if (source == null) {
    throw new NullPointerException("source == null");
  } else if (target == null) {
    throw new NullPointerException("target == null");
  }
  return icuColl.compare(source, target);
}
libcore.icuRuleBasedCollatorICUcompare

Popular methods of RuleBasedCollatorICU

  • <init>
  • characterIteratorToString
  • clone
  • equals
  • getCollationElementIterator
  • getCollationKey
  • getDecomposition
  • getRules
  • getStrength
  • setDecomposition
  • setStrength
  • setStrength

Popular in Java

  • Making http post requests using okhttp
  • putExtra (Intent)
  • onRequestPermissionsResult (Fragment)
  • setRequestProperty (URLConnection)
  • BorderLayout (java.awt)
    A border layout lays out a container, arranging and resizing its components to fit in five regions:
  • ByteBuffer (java.nio)
    A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate
  • Random (java.util)
    This class provides methods that return pseudo-random values.It is dangerous to seed Random with the
  • TimeZone (java.util)
    TimeZone represents a time zone offset, and also figures out daylight savings. Typically, you get a
  • Executor (java.util.concurrent)
    An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
  • IsNull (org.hamcrest.core)
    Is the value null?
  • Top plugins for WebStorm
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now