From 56e52fe4cbf5d3ce8fbbad9fa1cc4739e2915ce0 Mon Sep 17 00:00:00 2001 From: Hen Date: Thu, 25 Feb 2016 21:15:13 -0800 Subject: [PATCH] newline pain, despite having run the config line --- .../org/apache/commons/lang3/ThreadUtils.java | 920 ++--- .../commons/lang3/math/NumberUtils.java | 3160 ++++++++--------- 2 files changed, 2040 insertions(+), 2040 deletions(-) diff --git a/src/main/java/org/apache/commons/lang3/ThreadUtils.java b/src/main/java/org/apache/commons/lang3/ThreadUtils.java index 15f0c5c05..89a59cea5 100644 --- a/src/main/java/org/apache/commons/lang3/ThreadUtils.java +++ b/src/main/java/org/apache/commons/lang3/ThreadUtils.java @@ -1,460 +1,460 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.lang3; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; - -/** - *

- * Helpers for {@code java.lang.Thread} and {@code java.lang.ThreadGroup}. - *

- *

- * #ThreadSafe# - *

- * - * @see java.lang.Thread - * @see java.lang.ThreadGroup - * @since 3.5 - */ -public class ThreadUtils { - - /** - * Return the active thread with the specified id if it belong's to the specified thread group. - * - * @param threadId The thread id - * @param threadGroup The thread group - * @return The thread which belongs to a specified thread group and the thread's id match the specified id. - * {@code null} is returned if no such thread exists - * @throws IllegalArgumentException if the specified id is zero or negative or the group is null - * @throws SecurityException - * if the current thread cannot access the system thread group - * - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Thread findThreadById(final long threadId, final ThreadGroup threadGroup) { - if (threadGroup == null) { - throw new IllegalArgumentException("The thread group must not be null"); - } - final Thread thread = findThreadById(threadId); - if(thread != null && threadGroup.equals(thread.getThreadGroup())) { - return thread; - } - return null; - } - - /** - * Return the active thread with the specified id if it belong's to a thread group with the specified group name. - * - * @param threadId The thread id - * @param threadGroupName The thread group name - * @return The threads which belongs to a thread group with the specified group name and the thread's id match the specified id. - * {@code null} is returned if no such thread exists - * @throws IllegalArgumentException if the specified id is zero or negative or the group name is null - * @throws SecurityException - * if the current thread cannot access the system thread group - * - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Thread findThreadById(final long threadId, final String threadGroupName) { - if (threadGroupName == null) { - throw new IllegalArgumentException("The thread group name must not be null"); - } - final Thread thread = findThreadById(threadId); - if(thread != null && thread.getThreadGroup() != null && thread.getThreadGroup().getName().equals(threadGroupName)) { - return thread; - } - return null; - } - - /** - * Return active threads with the specified name if they belong to a specified thread group. - * - * @param threadName The thread name - * @param threadGroup The thread group - * @return The threads which belongs to a thread group and the thread's name match the specified name, - * An empty collection is returned if no such thread exists. The collection returned is always unmodifiable. - * @throws IllegalArgumentException if the specified thread name or group is null - * @throws SecurityException - * if the current thread cannot access the system thread group - * - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection findThreadsByName(final String threadName, final ThreadGroup threadGroup) { - return findThreads(threadGroup, false, new NamePredicate(threadName)); - } - - /** - * Return active threads with the specified name if they belong to a thread group with the specified group name. - * - * @param threadName The thread name - * @param threadGroupName The thread group name - * @return The threads which belongs to a thread group with the specified group name and the thread's name match the specified name, - * An empty collection is returned if no such thread exists. The collection returned is always unmodifiable. - * @throws IllegalArgumentException if the specified thread name or group name is null - * @throws SecurityException - * if the current thread cannot access the system thread group - * - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection findThreadsByName(final String threadName, final String threadGroupName) { - if (threadName == null) { - throw new IllegalArgumentException("The thread name must not be null"); - } - if (threadGroupName == null) { - throw new IllegalArgumentException("The thread group name must not be null"); - } - - final Collection threadGroups = findThreadGroups(new NamePredicate(threadGroupName)); - - if(threadGroups.isEmpty()) { - return Collections.emptyList(); - } - - final Collection result = new ArrayList(); - final NamePredicate threadNamePredicate = new NamePredicate(threadName); - for(final ThreadGroup group : threadGroups) { - result.addAll(findThreads(group, false, threadNamePredicate)); - } - return Collections.unmodifiableCollection(result); - } - - /** - * Return active thread groups with the specified group name. - * - * @param threadGroupName The thread group name - * @return the thread groups with the specified group name or an empty collection if no such thread group exists. The collection returned is always unmodifiable. - * @throws IllegalArgumentException if group name is null - * @throws SecurityException - * if the current thread cannot access the system thread group - * - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection findThreadGroupsByName(final String threadGroupName) { - return findThreadGroups(new NamePredicate(threadGroupName)); - } - - /** - * Return all active thread groups excluding the system thread group (A thread group is active if it has been not destroyed). - * - * @return all thread groups excluding the system thread group. The collection returned is always unmodifiable. - * @throws SecurityException - * if the current thread cannot access the system thread group - * - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection getAllThreadGroups() { - return findThreadGroups(ALWAYS_TRUE_PREDICATE); - } - - /** - * Return the system thread group (sometimes also referred as "root thread group"). - * - * @return the system thread group - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static ThreadGroup getSystemThreadGroup() { - ThreadGroup threadGroup = Thread.currentThread().getThreadGroup(); - while(threadGroup.getParent() != null) { - threadGroup = threadGroup.getParent(); - } - return threadGroup; - } - - /** - * Return all active threads (A thread is active if it has been started and has not yet died). - * - * @return all active threads. The collection returned is always unmodifiable. - * @throws SecurityException - * if the current thread cannot access the system thread group - * - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection getAllThreads() { - return findThreads(ALWAYS_TRUE_PREDICATE); - } - - /** - * Return active threads with the specified name. - * - * @param threadName The thread name - * @return The threads with the specified name or an empty collection if no such thread exists. The collection returned is always unmodifiable. - * @throws IllegalArgumentException if the specified name is null - * @throws SecurityException - * if the current thread cannot access the system thread group - * - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection findThreadsByName(final String threadName) { - return findThreads(new NamePredicate(threadName)); - } - - /** - * Return the active thread with the specified id. - * - * @param threadId The thread id - * @return The thread with the specified id or {@code null} if no such thread exists - * @throws IllegalArgumentException if the specified id is zero or negative - * @throws SecurityException - * if the current thread cannot access the system thread group - * - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Thread findThreadById(final long threadId) { - final Collection result = findThreads(new ThreadIdPredicate(threadId)); - return result.isEmpty() ? null : result.iterator().next(); - } - - /** - *

- * ThreadUtils instances should NOT be constructed in standard programming. Instead, the class should be used as - * {@code ThreadUtils.getAllThreads()} - *

- *

- * This constructor is public to permit tools that require a JavaBean instance to operate. - *

- */ - public ThreadUtils() { - super(); - } - - /** - * A predicate for selecting threads. - */ - //if java minimal version for lang becomes 1.8 extend this interface from java.util.function.Predicate - public interface ThreadPredicate /*extends java.util.function.Predicate*/{ - - /** - * Evaluates this predicate on the given thread. - * @param thread the thread - * @return {@code true} if the thread matches the predicate, otherwise {@code false} - */ - boolean test(Thread thread); - } - - /** - * A predicate for selecting threadgroups. - */ - //if java minimal version for lang becomes 1.8 extend this interface from java.util.function.Predicate - public interface ThreadGroupPredicate /*extends java.util.function.Predicate*/{ - - /** - * Evaluates this predicate on the given threadgroup. - * @param threadGroup the threadgroup - * @return {@code true} if the threadGroup matches the predicate, otherwise {@code false} - */ - boolean test(ThreadGroup threadGroup); - } - - /** - * Predicate which always returns true. - */ - public static final AlwaysTruePredicate ALWAYS_TRUE_PREDICATE = new AlwaysTruePredicate(); - - /** - * A predicate implementation which always returns true. - */ - private final static class AlwaysTruePredicate implements ThreadPredicate, ThreadGroupPredicate{ - - private AlwaysTruePredicate() { - } - - @Override - public boolean test(final ThreadGroup threadGroup) { - return true; - } - - @Override - public boolean test(final Thread thread) { - return true; - } - } - - /** - * A predicate implementation which matches a thread or threadgroup name. - */ - public static class NamePredicate implements ThreadPredicate, ThreadGroupPredicate { - - private final String name; - - /** - * Predicate constructor - * - * @param name thread or threadgroup name - * @throws IllegalArgumentException if the name is {@code null} - */ - public NamePredicate(final String name) { - super(); - if (name == null) { - throw new IllegalArgumentException("The name must not be null"); - } - this.name = name; - } - - @Override - public boolean test(final ThreadGroup threadGroup) { - return threadGroup != null && threadGroup.getName().equals(name); - } - - @Override - public boolean test(final Thread thread) { - return thread != null && thread.getName().equals(name); - } - } - - /** - * A predicate implementation which matches a thread id. - */ - public static class ThreadIdPredicate implements ThreadPredicate { - - private final long threadId; - - /** - * Predicate constructor - * - * @param threadId the threadId to match - * @throws IllegalArgumentException if the threadId is zero or negative - */ - public ThreadIdPredicate(final long threadId) { - super(); - if (threadId <= 0) { - throw new IllegalArgumentException("The thread id must be greater than zero"); - } - this.threadId = threadId; - } - - @Override - public boolean test(final Thread thread) { - return thread != null && thread.getId() == threadId; - } - } - - /** - * Select all active threads which match the given predicate. - * - * @param predicate the predicate - * @return An unmodifiable {@code Collection} of active threads matching the given predicate - * - * @throws IllegalArgumentException if the predicate is null - * @throws SecurityException - * if the current thread cannot access the system thread group - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection findThreads(final ThreadPredicate predicate){ - return findThreads(getSystemThreadGroup(), true, predicate); - } - - /** - * Select all active threadgroups which match the given predicate. - * - * @param predicate the predicate - * @return An unmodifiable {@code Collection} of active threadgroups matching the given predicate - * @throws IllegalArgumentException if the predicate is null - * @throws SecurityException - * if the current thread cannot access the system thread group - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection findThreadGroups(final ThreadGroupPredicate predicate){ - return findThreadGroups(getSystemThreadGroup(), true, predicate); - } - - /** - * Select all active threads which match the given predicate and which belongs to the given thread group (or one of its subgroups). - * - * @param group the thread group - * @param recurse if {@code true} then evaluate the predicate recursively on all threads in all subgroups of the given group - * @param predicate the predicate - * @return An unmodifiable {@code Collection} of active threads which match the given predicate and which belongs to the given thread group - * @throws IllegalArgumentException if the given group or predicate is null - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection findThreads(final ThreadGroup group, final boolean recurse, final ThreadPredicate predicate) { - if (group == null) { - throw new IllegalArgumentException("The group must not be null"); - } - if (predicate == null) { - throw new IllegalArgumentException("The predicate must not be null"); - } - - int count = group.activeCount(); - Thread[] threads; - do { - threads = new Thread[count + (count / 2) + 1]; //slightly grow the array size - count = group.enumerate(threads, recurse); - //return value of enumerate() must be strictly less than the array size according to javadoc - } while (count >= threads.length); - - final List result = new ArrayList(count); - for (int i = 0; i < count; ++i) { - if (predicate.test(threads[i])) { - result.add(threads[i]); - } - } - return Collections.unmodifiableCollection(result); - } - - /** - * Select all active threadgroups which match the given predicate and which is a subgroup of the given thread group (or one of its subgroups). - * - * @param group the thread group - * @param recurse if {@code true} then evaluate the predicate recursively on all threadgroups in all subgroups of the given group - * @param predicate the predicate - * @return An unmodifiable {@code Collection} of active threadgroups which match the given predicate and which is a subgroup of the given thread group - * @throws IllegalArgumentException if the given group or predicate is null - * @throws SecurityException if the current thread cannot modify - * thread groups from this thread's thread group up to the system thread group - */ - public static Collection findThreadGroups(final ThreadGroup group, final boolean recurse, final ThreadGroupPredicate predicate){ - if (group == null) { - throw new IllegalArgumentException("The group must not be null"); - } - if (predicate == null) { - throw new IllegalArgumentException("The predicate must not be null"); - } - - int count = group.activeGroupCount(); - ThreadGroup[] threadGroups; - do { - threadGroups = new ThreadGroup[count + (count / 2) + 1]; //slightly grow the array size - count = group.enumerate(threadGroups, recurse); - //return value of enumerate() must be strictly less than the array size according to javadoc - } while(count >= threadGroups.length); - - final List result = new ArrayList(count); - for(int i = 0; i < count; ++i) { - if(predicate.test(threadGroups[i])) { - result.add(threadGroups[i]); - } - } - return Collections.unmodifiableCollection(result); - } -} +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.lang3; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +/** + *

+ * Helpers for {@code java.lang.Thread} and {@code java.lang.ThreadGroup}. + *

+ *

+ * #ThreadSafe# + *

+ * + * @see java.lang.Thread + * @see java.lang.ThreadGroup + * @since 3.5 + */ +public class ThreadUtils { + + /** + * Return the active thread with the specified id if it belong's to the specified thread group. + * + * @param threadId The thread id + * @param threadGroup The thread group + * @return The thread which belongs to a specified thread group and the thread's id match the specified id. + * {@code null} is returned if no such thread exists + * @throws IllegalArgumentException if the specified id is zero or negative or the group is null + * @throws SecurityException + * if the current thread cannot access the system thread group + * + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Thread findThreadById(final long threadId, final ThreadGroup threadGroup) { + if (threadGroup == null) { + throw new IllegalArgumentException("The thread group must not be null"); + } + final Thread thread = findThreadById(threadId); + if(thread != null && threadGroup.equals(thread.getThreadGroup())) { + return thread; + } + return null; + } + + /** + * Return the active thread with the specified id if it belong's to a thread group with the specified group name. + * + * @param threadId The thread id + * @param threadGroupName The thread group name + * @return The threads which belongs to a thread group with the specified group name and the thread's id match the specified id. + * {@code null} is returned if no such thread exists + * @throws IllegalArgumentException if the specified id is zero or negative or the group name is null + * @throws SecurityException + * if the current thread cannot access the system thread group + * + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Thread findThreadById(final long threadId, final String threadGroupName) { + if (threadGroupName == null) { + throw new IllegalArgumentException("The thread group name must not be null"); + } + final Thread thread = findThreadById(threadId); + if(thread != null && thread.getThreadGroup() != null && thread.getThreadGroup().getName().equals(threadGroupName)) { + return thread; + } + return null; + } + + /** + * Return active threads with the specified name if they belong to a specified thread group. + * + * @param threadName The thread name + * @param threadGroup The thread group + * @return The threads which belongs to a thread group and the thread's name match the specified name, + * An empty collection is returned if no such thread exists. The collection returned is always unmodifiable. + * @throws IllegalArgumentException if the specified thread name or group is null + * @throws SecurityException + * if the current thread cannot access the system thread group + * + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection findThreadsByName(final String threadName, final ThreadGroup threadGroup) { + return findThreads(threadGroup, false, new NamePredicate(threadName)); + } + + /** + * Return active threads with the specified name if they belong to a thread group with the specified group name. + * + * @param threadName The thread name + * @param threadGroupName The thread group name + * @return The threads which belongs to a thread group with the specified group name and the thread's name match the specified name, + * An empty collection is returned if no such thread exists. The collection returned is always unmodifiable. + * @throws IllegalArgumentException if the specified thread name or group name is null + * @throws SecurityException + * if the current thread cannot access the system thread group + * + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection findThreadsByName(final String threadName, final String threadGroupName) { + if (threadName == null) { + throw new IllegalArgumentException("The thread name must not be null"); + } + if (threadGroupName == null) { + throw new IllegalArgumentException("The thread group name must not be null"); + } + + final Collection threadGroups = findThreadGroups(new NamePredicate(threadGroupName)); + + if(threadGroups.isEmpty()) { + return Collections.emptyList(); + } + + final Collection result = new ArrayList(); + final NamePredicate threadNamePredicate = new NamePredicate(threadName); + for(final ThreadGroup group : threadGroups) { + result.addAll(findThreads(group, false, threadNamePredicate)); + } + return Collections.unmodifiableCollection(result); + } + + /** + * Return active thread groups with the specified group name. + * + * @param threadGroupName The thread group name + * @return the thread groups with the specified group name or an empty collection if no such thread group exists. The collection returned is always unmodifiable. + * @throws IllegalArgumentException if group name is null + * @throws SecurityException + * if the current thread cannot access the system thread group + * + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection findThreadGroupsByName(final String threadGroupName) { + return findThreadGroups(new NamePredicate(threadGroupName)); + } + + /** + * Return all active thread groups excluding the system thread group (A thread group is active if it has been not destroyed). + * + * @return all thread groups excluding the system thread group. The collection returned is always unmodifiable. + * @throws SecurityException + * if the current thread cannot access the system thread group + * + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection getAllThreadGroups() { + return findThreadGroups(ALWAYS_TRUE_PREDICATE); + } + + /** + * Return the system thread group (sometimes also referred as "root thread group"). + * + * @return the system thread group + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static ThreadGroup getSystemThreadGroup() { + ThreadGroup threadGroup = Thread.currentThread().getThreadGroup(); + while(threadGroup.getParent() != null) { + threadGroup = threadGroup.getParent(); + } + return threadGroup; + } + + /** + * Return all active threads (A thread is active if it has been started and has not yet died). + * + * @return all active threads. The collection returned is always unmodifiable. + * @throws SecurityException + * if the current thread cannot access the system thread group + * + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection getAllThreads() { + return findThreads(ALWAYS_TRUE_PREDICATE); + } + + /** + * Return active threads with the specified name. + * + * @param threadName The thread name + * @return The threads with the specified name or an empty collection if no such thread exists. The collection returned is always unmodifiable. + * @throws IllegalArgumentException if the specified name is null + * @throws SecurityException + * if the current thread cannot access the system thread group + * + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection findThreadsByName(final String threadName) { + return findThreads(new NamePredicate(threadName)); + } + + /** + * Return the active thread with the specified id. + * + * @param threadId The thread id + * @return The thread with the specified id or {@code null} if no such thread exists + * @throws IllegalArgumentException if the specified id is zero or negative + * @throws SecurityException + * if the current thread cannot access the system thread group + * + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Thread findThreadById(final long threadId) { + final Collection result = findThreads(new ThreadIdPredicate(threadId)); + return result.isEmpty() ? null : result.iterator().next(); + } + + /** + *

+ * ThreadUtils instances should NOT be constructed in standard programming. Instead, the class should be used as + * {@code ThreadUtils.getAllThreads()} + *

+ *

+ * This constructor is public to permit tools that require a JavaBean instance to operate. + *

+ */ + public ThreadUtils() { + super(); + } + + /** + * A predicate for selecting threads. + */ + //if java minimal version for lang becomes 1.8 extend this interface from java.util.function.Predicate + public interface ThreadPredicate /*extends java.util.function.Predicate*/{ + + /** + * Evaluates this predicate on the given thread. + * @param thread the thread + * @return {@code true} if the thread matches the predicate, otherwise {@code false} + */ + boolean test(Thread thread); + } + + /** + * A predicate for selecting threadgroups. + */ + //if java minimal version for lang becomes 1.8 extend this interface from java.util.function.Predicate + public interface ThreadGroupPredicate /*extends java.util.function.Predicate*/{ + + /** + * Evaluates this predicate on the given threadgroup. + * @param threadGroup the threadgroup + * @return {@code true} if the threadGroup matches the predicate, otherwise {@code false} + */ + boolean test(ThreadGroup threadGroup); + } + + /** + * Predicate which always returns true. + */ + public static final AlwaysTruePredicate ALWAYS_TRUE_PREDICATE = new AlwaysTruePredicate(); + + /** + * A predicate implementation which always returns true. + */ + private final static class AlwaysTruePredicate implements ThreadPredicate, ThreadGroupPredicate{ + + private AlwaysTruePredicate() { + } + + @Override + public boolean test(final ThreadGroup threadGroup) { + return true; + } + + @Override + public boolean test(final Thread thread) { + return true; + } + } + + /** + * A predicate implementation which matches a thread or threadgroup name. + */ + public static class NamePredicate implements ThreadPredicate, ThreadGroupPredicate { + + private final String name; + + /** + * Predicate constructor + * + * @param name thread or threadgroup name + * @throws IllegalArgumentException if the name is {@code null} + */ + public NamePredicate(final String name) { + super(); + if (name == null) { + throw new IllegalArgumentException("The name must not be null"); + } + this.name = name; + } + + @Override + public boolean test(final ThreadGroup threadGroup) { + return threadGroup != null && threadGroup.getName().equals(name); + } + + @Override + public boolean test(final Thread thread) { + return thread != null && thread.getName().equals(name); + } + } + + /** + * A predicate implementation which matches a thread id. + */ + public static class ThreadIdPredicate implements ThreadPredicate { + + private final long threadId; + + /** + * Predicate constructor + * + * @param threadId the threadId to match + * @throws IllegalArgumentException if the threadId is zero or negative + */ + public ThreadIdPredicate(final long threadId) { + super(); + if (threadId <= 0) { + throw new IllegalArgumentException("The thread id must be greater than zero"); + } + this.threadId = threadId; + } + + @Override + public boolean test(final Thread thread) { + return thread != null && thread.getId() == threadId; + } + } + + /** + * Select all active threads which match the given predicate. + * + * @param predicate the predicate + * @return An unmodifiable {@code Collection} of active threads matching the given predicate + * + * @throws IllegalArgumentException if the predicate is null + * @throws SecurityException + * if the current thread cannot access the system thread group + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection findThreads(final ThreadPredicate predicate){ + return findThreads(getSystemThreadGroup(), true, predicate); + } + + /** + * Select all active threadgroups which match the given predicate. + * + * @param predicate the predicate + * @return An unmodifiable {@code Collection} of active threadgroups matching the given predicate + * @throws IllegalArgumentException if the predicate is null + * @throws SecurityException + * if the current thread cannot access the system thread group + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection findThreadGroups(final ThreadGroupPredicate predicate){ + return findThreadGroups(getSystemThreadGroup(), true, predicate); + } + + /** + * Select all active threads which match the given predicate and which belongs to the given thread group (or one of its subgroups). + * + * @param group the thread group + * @param recurse if {@code true} then evaluate the predicate recursively on all threads in all subgroups of the given group + * @param predicate the predicate + * @return An unmodifiable {@code Collection} of active threads which match the given predicate and which belongs to the given thread group + * @throws IllegalArgumentException if the given group or predicate is null + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection findThreads(final ThreadGroup group, final boolean recurse, final ThreadPredicate predicate) { + if (group == null) { + throw new IllegalArgumentException("The group must not be null"); + } + if (predicate == null) { + throw new IllegalArgumentException("The predicate must not be null"); + } + + int count = group.activeCount(); + Thread[] threads; + do { + threads = new Thread[count + (count / 2) + 1]; //slightly grow the array size + count = group.enumerate(threads, recurse); + //return value of enumerate() must be strictly less than the array size according to javadoc + } while (count >= threads.length); + + final List result = new ArrayList(count); + for (int i = 0; i < count; ++i) { + if (predicate.test(threads[i])) { + result.add(threads[i]); + } + } + return Collections.unmodifiableCollection(result); + } + + /** + * Select all active threadgroups which match the given predicate and which is a subgroup of the given thread group (or one of its subgroups). + * + * @param group the thread group + * @param recurse if {@code true} then evaluate the predicate recursively on all threadgroups in all subgroups of the given group + * @param predicate the predicate + * @return An unmodifiable {@code Collection} of active threadgroups which match the given predicate and which is a subgroup of the given thread group + * @throws IllegalArgumentException if the given group or predicate is null + * @throws SecurityException if the current thread cannot modify + * thread groups from this thread's thread group up to the system thread group + */ + public static Collection findThreadGroups(final ThreadGroup group, final boolean recurse, final ThreadGroupPredicate predicate){ + if (group == null) { + throw new IllegalArgumentException("The group must not be null"); + } + if (predicate == null) { + throw new IllegalArgumentException("The predicate must not be null"); + } + + int count = group.activeGroupCount(); + ThreadGroup[] threadGroups; + do { + threadGroups = new ThreadGroup[count + (count / 2) + 1]; //slightly grow the array size + count = group.enumerate(threadGroups, recurse); + //return value of enumerate() must be strictly less than the array size according to javadoc + } while(count >= threadGroups.length); + + final List result = new ArrayList(count); + for(int i = 0; i < count; ++i) { + if(predicate.test(threadGroups[i])) { + result.add(threadGroups[i]); + } + } + return Collections.unmodifiableCollection(result); + } +} diff --git a/src/main/java/org/apache/commons/lang3/math/NumberUtils.java b/src/main/java/org/apache/commons/lang3/math/NumberUtils.java index 01f276b5b..b53ba98be 100644 --- a/src/main/java/org/apache/commons/lang3/math/NumberUtils.java +++ b/src/main/java/org/apache/commons/lang3/math/NumberUtils.java @@ -1,1580 +1,1580 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.lang3.math; - -import java.lang.reflect.Array; -import java.math.BigDecimal; -import java.math.BigInteger; - -import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.Validate; - -/** - *

Provides extra functionality for Java Number classes.

- * - * @since 2.0 - */ -public class NumberUtils { - - /** Reusable Long constant for zero. */ - public static final Long LONG_ZERO = Long.valueOf(0L); - /** Reusable Long constant for one. */ - public static final Long LONG_ONE = Long.valueOf(1L); - /** Reusable Long constant for minus one. */ - public static final Long LONG_MINUS_ONE = Long.valueOf(-1L); - /** Reusable Integer constant for zero. */ - public static final Integer INTEGER_ZERO = Integer.valueOf(0); - /** Reusable Integer constant for one. */ - public static final Integer INTEGER_ONE = Integer.valueOf(1); - /** Reusable Integer constant for minus one. */ - public static final Integer INTEGER_MINUS_ONE = Integer.valueOf(-1); - /** Reusable Short constant for zero. */ - public static final Short SHORT_ZERO = Short.valueOf((short) 0); - /** Reusable Short constant for one. */ - public static final Short SHORT_ONE = Short.valueOf((short) 1); - /** Reusable Short constant for minus one. */ - public static final Short SHORT_MINUS_ONE = Short.valueOf((short) -1); - /** Reusable Byte constant for zero. */ - public static final Byte BYTE_ZERO = Byte.valueOf((byte) 0); - /** Reusable Byte constant for one. */ - public static final Byte BYTE_ONE = Byte.valueOf((byte) 1); - /** Reusable Byte constant for minus one. */ - public static final Byte BYTE_MINUS_ONE = Byte.valueOf((byte) -1); - /** Reusable Double constant for zero. */ - public static final Double DOUBLE_ZERO = Double.valueOf(0.0d); - /** Reusable Double constant for one. */ - public static final Double DOUBLE_ONE = Double.valueOf(1.0d); - /** Reusable Double constant for minus one. */ - public static final Double DOUBLE_MINUS_ONE = Double.valueOf(-1.0d); - /** Reusable Float constant for zero. */ - public static final Float FLOAT_ZERO = Float.valueOf(0.0f); - /** Reusable Float constant for one. */ - public static final Float FLOAT_ONE = Float.valueOf(1.0f); - /** Reusable Float constant for minus one. */ - public static final Float FLOAT_MINUS_ONE = Float.valueOf(-1.0f); - - /** - *

NumberUtils instances should NOT be constructed in standard programming. - * Instead, the class should be used as NumberUtils.toInt("6");.

- * - *

This constructor is public to permit tools that require a JavaBean instance - * to operate.

- */ - public NumberUtils() { - super(); - } - - //----------------------------------------------------------------------- - /** - *

Convert a String to an int, returning - * zero if the conversion fails.

- * - *

If the string is null, zero is returned.

- * - * 
-     *   NumberUtils.toInt(null) = 0
-     *   NumberUtils.toInt("")   = 0
-     *   NumberUtils.toInt("1")  = 1
-     *
- * - * @param str the string to convert, may be null - * @return the int represented by the string, or zero if - * conversion fails - * @since 2.1 - */ - public static int toInt(final String str) { - return toInt(str, 0); - } - - /** - *

Convert a String to an int, returning a - * default value if the conversion fails.

- * - *

If the string is null, the default value is returned.

- * - * 
-     *   NumberUtils.toInt(null, 1) = 1
-     *   NumberUtils.toInt("", 1)   = 1
-     *   NumberUtils.toInt("1", 0)  = 1
-     *
- * - * @param str the string to convert, may be null - * @param defaultValue the default value - * @return the int represented by the string, or the default if conversion fails - * @since 2.1 - */ - public static int toInt(final String str, final int defaultValue) { - if(str == null) { - return defaultValue; - } - try { - return Integer.parseInt(str); - } catch (final NumberFormatException nfe) { - return defaultValue; - } - } - - /** - *

Convert a String to a long, returning - * zero if the conversion fails.

- * - *

If the string is null, zero is returned.

- * - * 
-     *   NumberUtils.toLong(null) = 0L
-     *   NumberUtils.toLong("")   = 0L
-     *   NumberUtils.toLong("1")  = 1L
-     *
- * - * @param str the string to convert, may be null - * @return the long represented by the string, or 0 if - * conversion fails - * @since 2.1 - */ - public static long toLong(final String str) { - return toLong(str, 0L); - } - - /** - *

Convert a String to a long, returning a - * default value if the conversion fails.

- * - *

If the string is null, the default value is returned.

- * - * 
-     *   NumberUtils.toLong(null, 1L) = 1L
-     *   NumberUtils.toLong("", 1L)   = 1L
-     *   NumberUtils.toLong("1", 0L)  = 1L
-     *
- * - * @param str the string to convert, may be null - * @param defaultValue the default value - * @return the long represented by the string, or the default if conversion fails - * @since 2.1 - */ - public static long toLong(final String str, final long defaultValue) { - if (str == null) { - return defaultValue; - } - try { - return Long.parseLong(str); - } catch (final NumberFormatException nfe) { - return defaultValue; - } - } - - /** - *

Convert a String to a float, returning - * 0.0f if the conversion fails.

- * - *

If the string str is null, - * 0.0f is returned.

- * - * 
-     *   NumberUtils.toFloat(null)   = 0.0f
-     *   NumberUtils.toFloat("")     = 0.0f
-     *   NumberUtils.toFloat("1.5")  = 1.5f
-     *
- * - * @param str the string to convert, may be null - * @return the float represented by the string, or 0.0f - * if conversion fails - * @since 2.1 - */ - public static float toFloat(final String str) { - return toFloat(str, 0.0f); - } - - /** - *

Convert a String to a float, returning a - * default value if the conversion fails.

- * - *

If the string str is null, the default - * value is returned.

- * - * 
-     *   NumberUtils.toFloat(null, 1.1f)   = 1.0f
-     *   NumberUtils.toFloat("", 1.1f)     = 1.1f
-     *   NumberUtils.toFloat("1.5", 0.0f)  = 1.5f
-     *
- * - * @param str the string to convert, may be null - * @param defaultValue the default value - * @return the float represented by the string, or defaultValue - * if conversion fails - * @since 2.1 - */ - public static float toFloat(final String str, final float defaultValue) { - if (str == null) { - return defaultValue; - } - try { - return Float.parseFloat(str); - } catch (final NumberFormatException nfe) { - return defaultValue; - } - } - - /** - *

Convert a String to a double, returning - * 0.0d if the conversion fails.

- * - *

If the string str is null, - * 0.0d is returned.

- * - * 
-     *   NumberUtils.toDouble(null)   = 0.0d
-     *   NumberUtils.toDouble("")     = 0.0d
-     *   NumberUtils.toDouble("1.5")  = 1.5d
-     *
- * - * @param str the string to convert, may be null - * @return the double represented by the string, or 0.0d - * if conversion fails - * @since 2.1 - */ - public static double toDouble(final String str) { - return toDouble(str, 0.0d); - } - - /** - *

Convert a String to a double, returning a - * default value if the conversion fails.

- * - *

If the string str is null, the default - * value is returned.

- * - * 
-     *   NumberUtils.toDouble(null, 1.1d)   = 1.1d
-     *   NumberUtils.toDouble("", 1.1d)     = 1.1d
-     *   NumberUtils.toDouble("1.5", 0.0d)  = 1.5d
-     *
- * - * @param str the string to convert, may be null - * @param defaultValue the default value - * @return the double represented by the string, or defaultValue - * if conversion fails - * @since 2.1 - */ - public static double toDouble(final String str, final double defaultValue) { - if (str == null) { - return defaultValue; - } - try { - return Double.parseDouble(str); - } catch (final NumberFormatException nfe) { - return defaultValue; - } - } - - //----------------------------------------------------------------------- - /** - *

Convert a String to a byte, returning - * zero if the conversion fails.

- * - *

If the string is null, zero is returned.

- * - * 
-     *   NumberUtils.toByte(null) = 0
-     *   NumberUtils.toByte("")   = 0
-     *   NumberUtils.toByte("1")  = 1
-     *
- * - * @param str the string to convert, may be null - * @return the byte represented by the string, or zero if - * conversion fails - * @since 2.5 - */ - public static byte toByte(final String str) { - return toByte(str, (byte) 0); - } - - /** - *

Convert a String to a byte, returning a - * default value if the conversion fails.

- * - *

If the string is null, the default value is returned.

- * - * 
-     *   NumberUtils.toByte(null, 1) = 1
-     *   NumberUtils.toByte("", 1)   = 1
-     *   NumberUtils.toByte("1", 0)  = 1
-     *
- * - * @param str the string to convert, may be null - * @param defaultValue the default value - * @return the byte represented by the string, or the default if conversion fails - * @since 2.5 - */ - public static byte toByte(final String str, final byte defaultValue) { - if(str == null) { - return defaultValue; - } - try { - return Byte.parseByte(str); - } catch (final NumberFormatException nfe) { - return defaultValue; - } - } - - /** - *

Convert a String to a short, returning - * zero if the conversion fails.

- * - *

If the string is null, zero is returned.

- * - * 
-     *   NumberUtils.toShort(null) = 0
-     *   NumberUtils.toShort("")   = 0
-     *   NumberUtils.toShort("1")  = 1
-     *
- * - * @param str the string to convert, may be null - * @return the short represented by the string, or zero if - * conversion fails - * @since 2.5 - */ - public static short toShort(final String str) { - return toShort(str, (short) 0); - } - - /** - *

Convert a String to an short, returning a - * default value if the conversion fails.

- * - *

If the string is null, the default value is returned.

- * - * 
-     *   NumberUtils.toShort(null, 1) = 1
-     *   NumberUtils.toShort("", 1)   = 1
-     *   NumberUtils.toShort("1", 0)  = 1
-     *
- * - * @param str the string to convert, may be null - * @param defaultValue the default value - * @return the short represented by the string, or the default if conversion fails - * @since 2.5 - */ - public static short toShort(final String str, final short defaultValue) { - if(str == null) { - return defaultValue; - } - try { - return Short.parseShort(str); - } catch (final NumberFormatException nfe) { - return defaultValue; - } - } - - //----------------------------------------------------------------------- - // must handle Long, Float, Integer, Float, Short, - // BigDecimal, BigInteger and Byte - // useful methods: - // Byte.decode(String) - // Byte.valueOf(String,int radix) - // Byte.valueOf(String) - // Double.valueOf(String) - // Float.valueOf(String) - // Float.valueOf(String) - // Integer.valueOf(String,int radix) - // Integer.valueOf(String) - // Integer.decode(String) - // Integer.getInteger(String) - // Integer.getInteger(String,int val) - // Integer.getInteger(String,Integer val) - // Integer.valueOf(String) - // Double.valueOf(String) - // new Byte(String) - // Long.valueOf(String) - // Long.getLong(String) - // Long.getLong(String,int) - // Long.getLong(String,Integer) - // Long.valueOf(String,int) - // Long.valueOf(String) - // Short.valueOf(String) - // Short.decode(String) - // Short.valueOf(String,int) - // Short.valueOf(String) - // new BigDecimal(String) - // new BigInteger(String) - // new BigInteger(String,int radix) - // Possible inputs: - // 45 45.5 45E7 4.5E7 Hex Oct Binary xxxF xxxD xxxf xxxd - // plus minus everything. Prolly more. A lot are not separable. - - /** - *

Turns a string value into a java.lang.Number.

- * - *

If the string starts with {@code 0x} or {@code -0x} (lower or upper case) or {@code #} or {@code -#}, it - * will be interpreted as a hexadecimal Integer - or Long, if the number of digits after the - * prefix is more than 8 - or BigInteger if there are more than 16 digits. - *

- *

Then, the value is examined for a type qualifier on the end, i.e. one of - * 'f','F','d','D','l','L'. If it is found, it starts - * trying to create successively larger types from the type specified - * until one is found that can represent the value.

- * - *

If a type specifier is not found, it will check for a decimal point - * and then try successively larger types from Integer to - * BigInteger and from Float to - * BigDecimal.

- * - *

- * Integral values with a leading {@code 0} will be interpreted as octal; the returned number will - * be Integer, Long or BigDecimal as appropriate. - *

- * - *

Returns null if the string is null.

- * - *

This method does not trim the input string, i.e., strings with leading - * or trailing spaces will generate NumberFormatExceptions.

- * - * @param str String containing a number, may be null - * @return Number created from the string (or null if the input is null) - * @throws NumberFormatException if the value cannot be converted - */ - public static Number createNumber(final String str) throws NumberFormatException { - if (str == null) { - return null; - } - if (StringUtils.isBlank(str)) { - throw new NumberFormatException("A blank string is not a valid number"); - } - // Need to deal with all possible hex prefixes here - final String[] hex_prefixes = {"0x", "0X", "-0x", "-0X", "#", "-#"}; - int pfxLen = 0; - for(final String pfx : hex_prefixes) { - if (str.startsWith(pfx)) { - pfxLen += pfx.length(); - break; - } - } - if (pfxLen > 0) { // we have a hex number - char firstSigDigit = 0; // strip leading zeroes - for(int i = pfxLen; i < str.length(); i++) { - firstSigDigit = str.charAt(i); - if (firstSigDigit == '0') { // count leading zeroes - pfxLen++; - } else { - break; - } - } - final int hexDigits = str.length() - pfxLen; - if (hexDigits > 16 || (hexDigits == 16 && firstSigDigit > '7')) { // too many for Long - return createBigInteger(str); - } - if (hexDigits > 8 || (hexDigits == 8 && firstSigDigit > '7')) { // too many for an int - return createLong(str); - } - return createInteger(str); - } - final char lastChar = str.charAt(str.length() - 1); - String mant; - String dec; - String exp; - final int decPos = str.indexOf('.'); - final int expPos = str.indexOf('e') + str.indexOf('E') + 1; // assumes both not present - // if both e and E are present, this is caught by the checks on expPos (which prevent IOOBE) - // and the parsing which will detect if e or E appear in a number due to using the wrong offset - - int numDecimals = 0; // Check required precision (LANG-693) - if (decPos > -1) { // there is a decimal point - - if (expPos > -1) { // there is an exponent - if (expPos < decPos || expPos > str.length()) { // prevents double exponent causing IOOBE - throw new NumberFormatException(str + " is not a valid number."); - } - dec = str.substring(decPos + 1, expPos); - } else { - dec = str.substring(decPos + 1); - } - mant = getMantissa(str, decPos); - numDecimals = dec.length(); // gets number of digits past the decimal to ensure no loss of precision for floating point numbers. - } else { - if (expPos > -1) { - if (expPos > str.length()) { // prevents double exponent causing IOOBE - throw new NumberFormatException(str + " is not a valid number."); - } - mant = getMantissa(str, expPos); - } else { - mant = getMantissa(str); - } - dec = null; - } - if (!Character.isDigit(lastChar) && lastChar != '.') { - if (expPos > -1 && expPos < str.length() - 1) { - exp = str.substring(expPos + 1, str.length() - 1); - } else { - exp = null; - } - //Requesting a specific type.. - final String numeric = str.substring(0, str.length() - 1); - final boolean allZeros = isAllZeros(mant) && isAllZeros(exp); - switch (lastChar) { - case 'l' : - case 'L' : - if (dec == null - && exp == null - && (numeric.charAt(0) == '-' && isDigits(numeric.substring(1)) || isDigits(numeric))) { - try { - return createLong(numeric); - } catch (final NumberFormatException nfe) { // NOPMD - // Too big for a long - } - return createBigInteger(numeric); - - } - throw new NumberFormatException(str + " is not a valid number."); - case 'f' : - case 'F' : - try { - final Float f = NumberUtils.createFloat(numeric); - if (!(f.isInfinite() || (f.floatValue() == 0.0F && !allZeros))) { - //If it's too big for a float or the float value = 0 and the string - //has non-zeros in it, then float does not have the precision we want - return f; - } - - } catch (final NumberFormatException nfe) { // NOPMD - // ignore the bad number - } - //$FALL-THROUGH$ - case 'd' : - case 'D' : - try { - final Double d = NumberUtils.createDouble(numeric); - if (!(d.isInfinite() || (d.floatValue() == 0.0D && !allZeros))) { - return d; - } - } catch (final NumberFormatException nfe) { // NOPMD - // ignore the bad number - } - try { - return createBigDecimal(numeric); - } catch (final NumberFormatException e) { // NOPMD - // ignore the bad number - } - //$FALL-THROUGH$ - default : - throw new NumberFormatException(str + " is not a valid number."); - - } - } - //User doesn't have a preference on the return type, so let's start - //small and go from there... - if (expPos > -1 && expPos < str.length() - 1) { - exp = str.substring(expPos + 1, str.length()); - } else { - exp = null; - } - if (dec == null && exp == null) { // no decimal point and no exponent - //Must be an Integer, Long, Biginteger - try { - return createInteger(str); - } catch (final NumberFormatException nfe) { // NOPMD - // ignore the bad number - } - try { - return createLong(str); - } catch (final NumberFormatException nfe) { // NOPMD - // ignore the bad number - } - return createBigInteger(str); - } - - //Must be a Float, Double, BigDecimal - final boolean allZeros = isAllZeros(mant) && isAllZeros(exp); - try { - if(numDecimals <= 7){// If number has 7 or fewer digits past the decimal point then make it a float - final Float f = createFloat(str); - if (!(f.isInfinite() || (f.floatValue() == 0.0F && !allZeros))) { - return f; - } - } - } catch (final NumberFormatException nfe) { // NOPMD - // ignore the bad number - } - try { - if(numDecimals <= 16){// If number has between 8 and 16 digits past the decimal point then make it a double - final Double d = createDouble(str); - if (!(d.isInfinite() || (d.doubleValue() == 0.0D && !allZeros))) { - return d; - } - } - } catch (final NumberFormatException nfe) { // NOPMD - // ignore the bad number - } - - return createBigDecimal(str); - } - - /** - *

Utility method for {@link #createNumber(java.lang.String)}.

- * - *

Returns mantissa of the given number.

- * - * @param str the string representation of the number - * @return mantissa of the given number - */ - private static String getMantissa(final String str) { - return getMantissa(str, str.length()); - } - - /** - *

Utility method for {@link #createNumber(java.lang.String)}.

- * - *

Returns mantissa of the given number.

- * - * @param str the string representation of the number - * @param stopPos the position of the exponent or decimal point - * @return mantissa of the given number - */ - private static String getMantissa(final String str, final int stopPos) { - final char firstChar = str.charAt(0); - final boolean hasSign = (firstChar == '-' || firstChar == '+'); - - return hasSign ? str.substring(1, stopPos) : str.substring(0, stopPos); - } - - /** - *

Utility method for {@link #createNumber(java.lang.String)}.

- * - *

Returns true if s is null.

- * - * @param str the String to check - * @return if it is all zeros or null - */ - private static boolean isAllZeros(final String str) { - if (str == null) { - return true; - } - for (int i = str.length() - 1; i >= 0; i--) { - if (str.charAt(i) != '0') { - return false; - } - } - return str.length() > 0; - } - - //----------------------------------------------------------------------- - /** - *

Convert a String to a Float.

- * - *

Returns null if the string is null.

- * - * @param str a String to convert, may be null - * @return converted Float (or null if the input is null) - * @throws NumberFormatException if the value cannot be converted - */ - public static Float createFloat(final String str) { - if (str == null) { - return null; - } - return Float.valueOf(str); - } - - /** - *

Convert a String to a Double.

- * - *

Returns null if the string is null.

- * - * @param str a String to convert, may be null - * @return converted Double (or null if the input is null) - * @throws NumberFormatException if the value cannot be converted - */ - public static Double createDouble(final String str) { - if (str == null) { - return null; - } - return Double.valueOf(str); - } - - /** - *

Convert a String to a Integer, handling - * hex (0xhhhh) and octal (0dddd) notations. - * N.B. a leading zero means octal; spaces are not trimmed.

- * - *

Returns null if the string is null.

- * - * @param str a String to convert, may be null - * @return converted Integer (or null if the input is null) - * @throws NumberFormatException if the value cannot be converted - */ - public static Integer createInteger(final String str) { - if (str == null) { - return null; - } - // decode() handles 0xAABD and 0777 (hex and octal) as well. - return Integer.decode(str); - } - - /** - *

Convert a String to a Long; - * since 3.1 it handles hex (0Xhhhh) and octal (0ddd) notations. - * N.B. a leading zero means octal; spaces are not trimmed.

- * - *

Returns null if the string is null.

- * - * @param str a String to convert, may be null - * @return converted Long (or null if the input is null) - * @throws NumberFormatException if the value cannot be converted - */ - public static Long createLong(final String str) { - if (str == null) { - return null; - } - return Long.decode(str); - } - - /** - *

Convert a String to a BigInteger; - * since 3.2 it handles hex (0x or #) and octal (0) notations.

- * - *

Returns null if the string is null.

- * - * @param str a String to convert, may be null - * @return converted BigInteger (or null if the input is null) - * @throws NumberFormatException if the value cannot be converted - */ - public static BigInteger createBigInteger(final String str) { - if (str == null) { - return null; - } - int pos = 0; // offset within string - int radix = 10; - boolean negate = false; // need to negate later? - if (str.startsWith("-")) { - negate = true; - pos = 1; - } - if (str.startsWith("0x", pos) || str.startsWith("0X", pos)) { // hex - radix = 16; - pos += 2; - } else if (str.startsWith("#", pos)) { // alternative hex (allowed by Long/Integer) - radix = 16; - pos ++; - } else if (str.startsWith("0", pos) && str.length() > pos + 1) { // octal; so long as there are additional digits - radix = 8; - pos ++; - } // default is to treat as decimal - - final BigInteger value = new BigInteger(str.substring(pos), radix); - return negate ? value.negate() : value; - } - - /** - *

Convert a String to a BigDecimal.

- * - *

Returns null if the string is null.

- * - * @param str a String to convert, may be null - * @return converted BigDecimal (or null if the input is null) - * @throws NumberFormatException if the value cannot be converted - */ - public static BigDecimal createBigDecimal(final String str) { - if (str == null) { - return null; - } - // handle JDK1.3.1 bug where "" throws IndexOutOfBoundsException - if (StringUtils.isBlank(str)) { - throw new NumberFormatException("A blank string is not a valid number"); - } - if (str.trim().startsWith("--")) { - // this is protection for poorness in java.lang.BigDecimal. - // it accepts this as a legal value, but it does not appear - // to be in specification of class. OS X Java parses it to - // a wrong value. - throw new NumberFormatException(str + " is not a valid number."); - } - return new BigDecimal(str); - } - - // Min in array - //-------------------------------------------------------------------- - /** - *

Returns the minimum value in an array.

- * - * @param array an array, must not be null or empty - * @return the minimum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @since 3.4 Changed signature from min(long[]) to min(long...) - */ - public static long min(final long... array) { - // Validates input - validateArray(array); - - // Finds and returns min - long min = array[0]; - for (int i = 1; i < array.length; i++) { - if (array[i] < min) { - min = array[i]; - } - } - - return min; - } - - /** - *

Returns the minimum value in an array.

- * - * @param array an array, must not be null or empty - * @return the minimum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @since 3.4 Changed signature from min(int[]) to min(int...) - */ - public static int min(final int... array) { - // Validates input - validateArray(array); - - // Finds and returns min - int min = array[0]; - for (int j = 1; j < array.length; j++) { - if (array[j] < min) { - min = array[j]; - } - } - - return min; - } - - /** - *

Returns the minimum value in an array.

- * - * @param array an array, must not be null or empty - * @return the minimum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @since 3.4 Changed signature from min(short[]) to min(short...) - */ - public static short min(final short... array) { - // Validates input - validateArray(array); - - // Finds and returns min - short min = array[0]; - for (int i = 1; i < array.length; i++) { - if (array[i] < min) { - min = array[i]; - } - } - - return min; - } - - /** - *

Returns the minimum value in an array.

- * - * @param array an array, must not be null or empty - * @return the minimum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @since 3.4 Changed signature from min(byte[]) to min(byte...) - */ - public static byte min(final byte... array) { - // Validates input - validateArray(array); - - // Finds and returns min - byte min = array[0]; - for (int i = 1; i < array.length; i++) { - if (array[i] < min) { - min = array[i]; - } - } - - return min; - } - - /** - *

Returns the minimum value in an array.

- * - * @param array an array, must not be null or empty - * @return the minimum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @see IEEE754rUtils#min(double[]) IEEE754rUtils for a version of this method that handles NaN differently - * @since 3.4 Changed signature from min(double[]) to min(double...) - */ - public static double min(final double... array) { - // Validates input - validateArray(array); - - // Finds and returns min - double min = array[0]; - for (int i = 1; i < array.length; i++) { - if (Double.isNaN(array[i])) { - return Double.NaN; - } - if (array[i] < min) { - min = array[i]; - } - } - - return min; - } - - /** - *

Returns the minimum value in an array.

- * - * @param array an array, must not be null or empty - * @return the minimum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @see IEEE754rUtils#min(float[]) IEEE754rUtils for a version of this method that handles NaN differently - * @since 3.4 Changed signature from min(float[]) to min(float...) - */ - public static float min(final float... array) { - // Validates input - validateArray(array); - - // Finds and returns min - float min = array[0]; - for (int i = 1; i < array.length; i++) { - if (Float.isNaN(array[i])) { - return Float.NaN; - } - if (array[i] < min) { - min = array[i]; - } - } - - return min; - } - - // Max in array - //-------------------------------------------------------------------- - /** - *

Returns the maximum value in an array.

- * - * @param array an array, must not be null or empty - * @return the maximum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @since 3.4 Changed signature from max(long[]) to max(long...) - */ - public static long max(final long... array) { - // Validates input - validateArray(array); - - // Finds and returns max - long max = array[0]; - for (int j = 1; j < array.length; j++) { - if (array[j] > max) { - max = array[j]; - } - } - - return max; - } - - /** - *

Returns the maximum value in an array.

- * - * @param array an array, must not be null or empty - * @return the maximum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @since 3.4 Changed signature from max(int[]) to max(int...) - */ - public static int max(final int... array) { - // Validates input - validateArray(array); - - // Finds and returns max - int max = array[0]; - for (int j = 1; j < array.length; j++) { - if (array[j] > max) { - max = array[j]; - } - } - - return max; - } - - /** - *

Returns the maximum value in an array.

- * - * @param array an array, must not be null or empty - * @return the maximum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @since 3.4 Changed signature from max(short[]) to max(short...) - */ - public static short max(final short... array) { - // Validates input - validateArray(array); - - // Finds and returns max - short max = array[0]; - for (int i = 1; i < array.length; i++) { - if (array[i] > max) { - max = array[i]; - } - } - - return max; - } - - /** - *

Returns the maximum value in an array.

- * - * @param array an array, must not be null or empty - * @return the maximum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @since 3.4 Changed signature from max(byte[]) to max(byte...) - */ - public static byte max(final byte... array) { - // Validates input - validateArray(array); - - // Finds and returns max - byte max = array[0]; - for (int i = 1; i < array.length; i++) { - if (array[i] > max) { - max = array[i]; - } - } - - return max; - } - - /** - *

Returns the maximum value in an array.

- * - * @param array an array, must not be null or empty - * @return the maximum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @see IEEE754rUtils#max(double[]) IEEE754rUtils for a version of this method that handles NaN differently - * @since 3.4 Changed signature from max(double[]) to max(double...) - */ - public static double max(final double... array) { - // Validates input - validateArray(array); - - // Finds and returns max - double max = array[0]; - for (int j = 1; j < array.length; j++) { - if (Double.isNaN(array[j])) { - return Double.NaN; - } - if (array[j] > max) { - max = array[j]; - } - } - - return max; - } - - /** - *

Returns the maximum value in an array.

- * - * @param array an array, must not be null or empty - * @return the maximum value in the array - * @throws IllegalArgumentException if array is null - * @throws IllegalArgumentException if array is empty - * @see IEEE754rUtils#max(float[]) IEEE754rUtils for a version of this method that handles NaN differently - * @since 3.4 Changed signature from max(float[]) to max(float...) - */ - public static float max(final float... array) { - // Validates input - validateArray(array); - - // Finds and returns max - float max = array[0]; - for (int j = 1; j < array.length; j++) { - if (Float.isNaN(array[j])) { - return Float.NaN; - } - if (array[j] > max) { - max = array[j]; - } - } - - return max; - } - - /** - * Checks if the specified array is neither null nor empty. - * - * @param array the array to check - * @throws IllegalArgumentException if {@code array} is either {@code null} or empty - */ - private static void validateArray(final Object array) { - if (array == null) { - throw new IllegalArgumentException("The Array must not be null"); - } - Validate.isTrue(Array.getLength(array) != 0, "Array cannot be empty."); - } - - // 3 param min - //----------------------------------------------------------------------- - /** - *

Gets the minimum of three long values.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the smallest of the values - */ - public static long min(long a, final long b, final long c) { - if (b < a) { - a = b; - } - if (c < a) { - a = c; - } - return a; - } - - /** - *

Gets the minimum of three int values.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the smallest of the values - */ - public static int min(int a, final int b, final int c) { - if (b < a) { - a = b; - } - if (c < a) { - a = c; - } - return a; - } - - /** - *

Gets the minimum of three short values.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the smallest of the values - */ - public static short min(short a, final short b, final short c) { - if (b < a) { - a = b; - } - if (c < a) { - a = c; - } - return a; - } - - /** - *

Gets the minimum of three byte values.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the smallest of the values - */ - public static byte min(byte a, final byte b, final byte c) { - if (b < a) { - a = b; - } - if (c < a) { - a = c; - } - return a; - } - - /** - *

Gets the minimum of three double values.

- * - *

If any value is NaN, NaN is - * returned. Infinity is handled.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the smallest of the values - * @see IEEE754rUtils#min(double, double, double) for a version of this method that handles NaN differently - */ - public static double min(final double a, final double b, final double c) { - return Math.min(Math.min(a, b), c); - } - - /** - *

Gets the minimum of three float values.

- * - *

If any value is NaN, NaN is - * returned. Infinity is handled.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the smallest of the values - * @see IEEE754rUtils#min(float, float, float) for a version of this method that handles NaN differently - */ - public static float min(final float a, final float b, final float c) { - return Math.min(Math.min(a, b), c); - } - - // 3 param max - //----------------------------------------------------------------------- - /** - *

Gets the maximum of three long values.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the largest of the values - */ - public static long max(long a, final long b, final long c) { - if (b > a) { - a = b; - } - if (c > a) { - a = c; - } - return a; - } - - /** - *

Gets the maximum of three int values.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the largest of the values - */ - public static int max(int a, final int b, final int c) { - if (b > a) { - a = b; - } - if (c > a) { - a = c; - } - return a; - } - - /** - *

Gets the maximum of three short values.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the largest of the values - */ - public static short max(short a, final short b, final short c) { - if (b > a) { - a = b; - } - if (c > a) { - a = c; - } - return a; - } - - /** - *

Gets the maximum of three byte values.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the largest of the values - */ - public static byte max(byte a, final byte b, final byte c) { - if (b > a) { - a = b; - } - if (c > a) { - a = c; - } - return a; - } - - /** - *

Gets the maximum of three double values.

- * - *

If any value is NaN, NaN is - * returned. Infinity is handled.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the largest of the values - * @see IEEE754rUtils#max(double, double, double) for a version of this method that handles NaN differently - */ - public static double max(final double a, final double b, final double c) { - return Math.max(Math.max(a, b), c); - } - - /** - *

Gets the maximum of three float values.

- * - *

If any value is NaN, NaN is - * returned. Infinity is handled.

- * - * @param a value 1 - * @param b value 2 - * @param c value 3 - * @return the largest of the values - * @see IEEE754rUtils#max(float, float, float) for a version of this method that handles NaN differently - */ - public static float max(final float a, final float b, final float c) { - return Math.max(Math.max(a, b), c); - } - - //----------------------------------------------------------------------- - /** - *

Checks whether the String contains only - * digit characters.

- * - *

Null and empty String will return - * false.

- * - * @param str the String to check - * @return true if str contains only Unicode numeric - */ - public static boolean isDigits(final String str) { - return StringUtils.isNumeric(str); - } - - /** - *

Checks whether the String a valid Java number.

- * - *

Valid numbers include hexadecimal marked with the 0x or - * 0X qualifier, octal numbers, scientific notation and numbers - * marked with a type qualifier (e.g. 123L).

- * - *

Non-hexadecimal strings beginning with a leading zero are - * treated as octal values. Thus the string 09 will return - * false, since 9 is not a valid octal value. - * However, numbers beginning with {@code 0.} are treated as decimal.

- * - *

null and empty/blank {@code String} will return - * false.

- * - * @param str the String to check - * @return true if the string is a correctly formatted number - * @since 3.3 the code supports hex {@code 0Xhhh} and octal {@code 0ddd} validation - */ - public static boolean isNumber(final String str) { - if (StringUtils.isEmpty(str)) { - return false; - } - final char[] chars = str.toCharArray(); - int sz = chars.length; - boolean hasExp = false; - boolean hasDecPoint = false; - boolean allowSigns = false; - boolean foundDigit = false; - // deal with any possible sign up front - final int start = (chars[0] == '-') ? 1 : 0; - if (sz > start + 1 && chars[start] == '0') { // leading 0 - if ( - (chars[start + 1] == 'x') || - (chars[start + 1] == 'X') - ) { // leading 0x/0X - int i = start + 2; - if (i == sz) { - return false; // str == "0x" - } - // checking hex (it can't be anything else) - for (; i < chars.length; i++) { - if ((chars[i] < '0' || chars[i] > '9') - && (chars[i] < 'a' || chars[i] > 'f') - && (chars[i] < 'A' || chars[i] > 'F')) { - return false; - } - } - return true; - } else if (Character.isDigit(chars[start + 1])) { - // leading 0, but not hex, must be octal - int i = start + 1; - for (; i < chars.length; i++) { - if (chars[i] < '0' || chars[i] > '7') { - return false; - } - } - return true; - } - } - sz--; // don't want to loop to the last char, check it afterwords - // for type qualifiers - int i = start; - // loop to the next to last char or to the last char if we need another digit to - // make a valid number (e.g. chars[0..5] = "1234E") - while (i < sz || (i < sz + 1 && allowSigns && !foundDigit)) { - if (chars[i] >= '0' && chars[i] <= '9') { - foundDigit = true; - allowSigns = false; - - } else if (chars[i] == '.') { - if (hasDecPoint || hasExp) { - // two decimal points or dec in exponent - return false; - } - hasDecPoint = true; - } else if (chars[i] == 'e' || chars[i] == 'E') { - // we've already taken care of hex. - if (hasExp) { - // two E's - return false; - } - if (!foundDigit) { - return false; - } - hasExp = true; - allowSigns = true; - } else if (chars[i] == '+' || chars[i] == '-') { - if (!allowSigns) { - return false; - } - allowSigns = false; - foundDigit = false; // we need a digit after the E - } else { - return false; - } - i++; - } - if (i < chars.length) { - if (chars[i] >= '0' && chars[i] <= '9') { - // no type qualifier, OK - return true; - } - if (chars[i] == 'e' || chars[i] == 'E') { - // can't have an E at the last byte - return false; - } - if (chars[i] == '.') { - if (hasDecPoint || hasExp) { - // two decimal points or dec in exponent - return false; - } - // single trailing decimal point after non-exponent is ok - return foundDigit; - } - if (!allowSigns - && (chars[i] == 'd' - || chars[i] == 'D' - || chars[i] == 'f' - || chars[i] == 'F')) { - return foundDigit; - } - if (chars[i] == 'l' - || chars[i] == 'L') { - // not allowing L with an exponent or decimal point - return foundDigit && !hasExp && !hasDecPoint; - } - // last character is illegal - return false; - } - // allowSigns is true iff the val ends in 'E' - // found digit it to make sure weird stuff like '.' and '1E-' doesn't pass - return !allowSigns && foundDigit; - } - - /** - *

Checks whether the given String is a parsable number.

- * - *

Parsable numbers include those Strings understood by {@link Integer#parseInt(String)}, - * {@link Long#parseLong(String)}, {@link Float#parseFloat(String)} or - * {@link Double#parseDouble(String)}. This method can be used instead of catching {@link java.text.ParseException} - * when calling one of those methods.

- * - *

Hexadecimal and scientific notations are not considered parsable. - * See {@link #isNumber(String)} on those cases.

- * - *

{@code Null} and empty String will return false.

- * - * @param str the String to check. - * @return {@code true} if the string is a parsable number. - * @since 3.4 - */ - public static boolean isParsable(final String str) { - if( StringUtils.endsWith( str, "." ) ) { - return false; - } - if( StringUtils.startsWith( str, "-" ) ) { - return isDigits( StringUtils.replaceOnce( str.substring(1), ".", StringUtils.EMPTY ) ); - } - return isDigits( StringUtils.replaceOnce( str, ".", StringUtils.EMPTY ) ); - } - - /** - *

Compares two {@code int} values numerically. This is the same functionality as provided in Java 7.

- * - * @param x the first {@code int} to compare - * @param y the second {@code int} to compare - * @return the value {@code 0} if {@code x == y}; - * a value less than {@code 0} if {@code x < y}; and - * a value greater than {@code 0} if {@code x > y} - * @since 3.4 - */ - public static int compare(int x, int y) { - if (x == y) { - return 0; - } - return x < y ? -1 : 1; - } - - /** - *

Compares to {@code long} values numerically. This is the same functionality as provided in Java 7.

- * - * @param x the first {@code long} to compare - * @param y the second {@code long} to compare - * @return the value {@code 0} if {@code x == y}; - * a value less than {@code 0} if {@code x < y}; and - * a value greater than {@code 0} if {@code x > y} - * @since 3.4 - */ - public static int compare(long x, long y) { - if (x == y) { - return 0; - } - return x < y ? -1 : 1; - } - - /** - *

Compares to {@code short} values numerically. This is the same functionality as provided in Java 7.

- * - * @param x the first {@code short} to compare - * @param y the second {@code short} to compare - * @return the value {@code 0} if {@code x == y}; - * a value less than {@code 0} if {@code x < y}; and - * a value greater than {@code 0} if {@code x > y} - * @since 3.4 - */ - public static int compare(short x, short y) { - if (x == y) { - return 0; - } - return x < y ? -1 : 1; - } - - /** - *

Compares two {@code byte} values numerically. This is the same functionality as provided in Java 7.

- * - * @param x the first {@code byte} to compare - * @param y the second {@code byte} to compare - * @return the value {@code 0} if {@code x == y}; - * a value less than {@code 0} if {@code x < y}; and - * a value greater than {@code 0} if {@code x > y} - * @since 3.4 - */ - public static int compare(byte x, byte y) { - return x - y; - } -} +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.lang3.math; + +import java.lang.reflect.Array; +import java.math.BigDecimal; +import java.math.BigInteger; + +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.Validate; + +/** + *

Provides extra functionality for Java Number classes.

+ * + * @since 2.0 + */ +public class NumberUtils { + + /** Reusable Long constant for zero. */ + public static final Long LONG_ZERO = Long.valueOf(0L); + /** Reusable Long constant for one. */ + public static final Long LONG_ONE = Long.valueOf(1L); + /** Reusable Long constant for minus one. */ + public static final Long LONG_MINUS_ONE = Long.valueOf(-1L); + /** Reusable Integer constant for zero. */ + public static final Integer INTEGER_ZERO = Integer.valueOf(0); + /** Reusable Integer constant for one. */ + public static final Integer INTEGER_ONE = Integer.valueOf(1); + /** Reusable Integer constant for minus one. */ + public static final Integer INTEGER_MINUS_ONE = Integer.valueOf(-1); + /** Reusable Short constant for zero. */ + public static final Short SHORT_ZERO = Short.valueOf((short) 0); + /** Reusable Short constant for one. */ + public static final Short SHORT_ONE = Short.valueOf((short) 1); + /** Reusable Short constant for minus one. */ + public static final Short SHORT_MINUS_ONE = Short.valueOf((short) -1); + /** Reusable Byte constant for zero. */ + public static final Byte BYTE_ZERO = Byte.valueOf((byte) 0); + /** Reusable Byte constant for one. */ + public static final Byte BYTE_ONE = Byte.valueOf((byte) 1); + /** Reusable Byte constant for minus one. */ + public static final Byte BYTE_MINUS_ONE = Byte.valueOf((byte) -1); + /** Reusable Double constant for zero. */ + public static final Double DOUBLE_ZERO = Double.valueOf(0.0d); + /** Reusable Double constant for one. */ + public static final Double DOUBLE_ONE = Double.valueOf(1.0d); + /** Reusable Double constant for minus one. */ + public static final Double DOUBLE_MINUS_ONE = Double.valueOf(-1.0d); + /** Reusable Float constant for zero. */ + public static final Float FLOAT_ZERO = Float.valueOf(0.0f); + /** Reusable Float constant for one. */ + public static final Float FLOAT_ONE = Float.valueOf(1.0f); + /** Reusable Float constant for minus one. */ + public static final Float FLOAT_MINUS_ONE = Float.valueOf(-1.0f); + + /** + *

NumberUtils instances should NOT be constructed in standard programming. + * Instead, the class should be used as NumberUtils.toInt("6");.

+ * + *

This constructor is public to permit tools that require a JavaBean instance + * to operate.

+ */ + public NumberUtils() { + super(); + } + + //----------------------------------------------------------------------- + /** + *

Convert a String to an int, returning + * zero if the conversion fails.

+ * + *

If the string is null, zero is returned.

+ * + * 
+     *   NumberUtils.toInt(null) = 0
+     *   NumberUtils.toInt("")   = 0
+     *   NumberUtils.toInt("1")  = 1
+     *
+ * + * @param str the string to convert, may be null + * @return the int represented by the string, or zero if + * conversion fails + * @since 2.1 + */ + public static int toInt(final String str) { + return toInt(str, 0); + } + + /** + *

Convert a String to an int, returning a + * default value if the conversion fails.

+ * + *

If the string is null, the default value is returned.

+ * + * 
+     *   NumberUtils.toInt(null, 1) = 1
+     *   NumberUtils.toInt("", 1)   = 1
+     *   NumberUtils.toInt("1", 0)  = 1
+     *
+ * + * @param str the string to convert, may be null + * @param defaultValue the default value + * @return the int represented by the string, or the default if conversion fails + * @since 2.1 + */ + public static int toInt(final String str, final int defaultValue) { + if(str == null) { + return defaultValue; + } + try { + return Integer.parseInt(str); + } catch (final NumberFormatException nfe) { + return defaultValue; + } + } + + /** + *

Convert a String to a long, returning + * zero if the conversion fails.

+ * + *

If the string is null, zero is returned.

+ * + * 
+     *   NumberUtils.toLong(null) = 0L
+     *   NumberUtils.toLong("")   = 0L
+     *   NumberUtils.toLong("1")  = 1L
+     *
+ * + * @param str the string to convert, may be null + * @return the long represented by the string, or 0 if + * conversion fails + * @since 2.1 + */ + public static long toLong(final String str) { + return toLong(str, 0L); + } + + /** + *

Convert a String to a long, returning a + * default value if the conversion fails.

+ * + *

If the string is null, the default value is returned.

+ * + * 
+     *   NumberUtils.toLong(null, 1L) = 1L
+     *   NumberUtils.toLong("", 1L)   = 1L
+     *   NumberUtils.toLong("1", 0L)  = 1L
+     *
+ * + * @param str the string to convert, may be null + * @param defaultValue the default value + * @return the long represented by the string, or the default if conversion fails + * @since 2.1 + */ + public static long toLong(final String str, final long defaultValue) { + if (str == null) { + return defaultValue; + } + try { + return Long.parseLong(str); + } catch (final NumberFormatException nfe) { + return defaultValue; + } + } + + /** + *

Convert a String to a float, returning + * 0.0f if the conversion fails.

+ * + *

If the string str is null, + * 0.0f is returned.

+ * + * 
+     *   NumberUtils.toFloat(null)   = 0.0f
+     *   NumberUtils.toFloat("")     = 0.0f
+     *   NumberUtils.toFloat("1.5")  = 1.5f
+     *
+ * + * @param str the string to convert, may be null + * @return the float represented by the string, or 0.0f + * if conversion fails + * @since 2.1 + */ + public static float toFloat(final String str) { + return toFloat(str, 0.0f); + } + + /** + *

Convert a String to a float, returning a + * default value if the conversion fails.

+ * + *

If the string str is null, the default + * value is returned.

+ * + * 
+     *   NumberUtils.toFloat(null, 1.1f)   = 1.0f
+     *   NumberUtils.toFloat("", 1.1f)     = 1.1f
+     *   NumberUtils.toFloat("1.5", 0.0f)  = 1.5f
+     *
+ * + * @param str the string to convert, may be null + * @param defaultValue the default value + * @return the float represented by the string, or defaultValue + * if conversion fails + * @since 2.1 + */ + public static float toFloat(final String str, final float defaultValue) { + if (str == null) { + return defaultValue; + } + try { + return Float.parseFloat(str); + } catch (final NumberFormatException nfe) { + return defaultValue; + } + } + + /** + *

Convert a String to a double, returning + * 0.0d if the conversion fails.

+ * + *

If the string str is null, + * 0.0d is returned.

+ * + * 
+     *   NumberUtils.toDouble(null)   = 0.0d
+     *   NumberUtils.toDouble("")     = 0.0d
+     *   NumberUtils.toDouble("1.5")  = 1.5d
+     *
+ * + * @param str the string to convert, may be null + * @return the double represented by the string, or 0.0d + * if conversion fails + * @since 2.1 + */ + public static double toDouble(final String str) { + return toDouble(str, 0.0d); + } + + /** + *

Convert a String to a double, returning a + * default value if the conversion fails.

+ * + *

If the string str is null, the default + * value is returned.

+ * + * 
+     *   NumberUtils.toDouble(null, 1.1d)   = 1.1d
+     *   NumberUtils.toDouble("", 1.1d)     = 1.1d
+     *   NumberUtils.toDouble("1.5", 0.0d)  = 1.5d
+     *
+ * + * @param str the string to convert, may be null + * @param defaultValue the default value + * @return the double represented by the string, or defaultValue + * if conversion fails + * @since 2.1 + */ + public static double toDouble(final String str, final double defaultValue) { + if (str == null) { + return defaultValue; + } + try { + return Double.parseDouble(str); + } catch (final NumberFormatException nfe) { + return defaultValue; + } + } + + //----------------------------------------------------------------------- + /** + *

Convert a String to a byte, returning + * zero if the conversion fails.

+ * + *

If the string is null, zero is returned.

+ * + * 
+     *   NumberUtils.toByte(null) = 0
+     *   NumberUtils.toByte("")   = 0
+     *   NumberUtils.toByte("1")  = 1
+     *
+ * + * @param str the string to convert, may be null + * @return the byte represented by the string, or zero if + * conversion fails + * @since 2.5 + */ + public static byte toByte(final String str) { + return toByte(str, (byte) 0); + } + + /** + *

Convert a String to a byte, returning a + * default value if the conversion fails.

+ * + *

If the string is null, the default value is returned.

+ * + * 
+     *   NumberUtils.toByte(null, 1) = 1
+     *   NumberUtils.toByte("", 1)   = 1
+     *   NumberUtils.toByte("1", 0)  = 1
+     *
+ * + * @param str the string to convert, may be null + * @param defaultValue the default value + * @return the byte represented by the string, or the default if conversion fails + * @since 2.5 + */ + public static byte toByte(final String str, final byte defaultValue) { + if(str == null) { + return defaultValue; + } + try { + return Byte.parseByte(str); + } catch (final NumberFormatException nfe) { + return defaultValue; + } + } + + /** + *

Convert a String to a short, returning + * zero if the conversion fails.

+ * + *

If the string is null, zero is returned.

+ * + * 
+     *   NumberUtils.toShort(null) = 0
+     *   NumberUtils.toShort("")   = 0
+     *   NumberUtils.toShort("1")  = 1
+     *
+ * + * @param str the string to convert, may be null + * @return the short represented by the string, or zero if + * conversion fails + * @since 2.5 + */ + public static short toShort(final String str) { + return toShort(str, (short) 0); + } + + /** + *

Convert a String to an short, returning a + * default value if the conversion fails.

+ * + *

If the string is null, the default value is returned.

+ * + * 
+     *   NumberUtils.toShort(null, 1) = 1
+     *   NumberUtils.toShort("", 1)   = 1
+     *   NumberUtils.toShort("1", 0)  = 1
+     *
+ * + * @param str the string to convert, may be null + * @param defaultValue the default value + * @return the short represented by the string, or the default if conversion fails + * @since 2.5 + */ + public static short toShort(final String str, final short defaultValue) { + if(str == null) { + return defaultValue; + } + try { + return Short.parseShort(str); + } catch (final NumberFormatException nfe) { + return defaultValue; + } + } + + //----------------------------------------------------------------------- + // must handle Long, Float, Integer, Float, Short, + // BigDecimal, BigInteger and Byte + // useful methods: + // Byte.decode(String) + // Byte.valueOf(String,int radix) + // Byte.valueOf(String) + // Double.valueOf(String) + // Float.valueOf(String) + // Float.valueOf(String) + // Integer.valueOf(String,int radix) + // Integer.valueOf(String) + // Integer.decode(String) + // Integer.getInteger(String) + // Integer.getInteger(String,int val) + // Integer.getInteger(String,Integer val) + // Integer.valueOf(String) + // Double.valueOf(String) + // new Byte(String) + // Long.valueOf(String) + // Long.getLong(String) + // Long.getLong(String,int) + // Long.getLong(String,Integer) + // Long.valueOf(String,int) + // Long.valueOf(String) + // Short.valueOf(String) + // Short.decode(String) + // Short.valueOf(String,int) + // Short.valueOf(String) + // new BigDecimal(String) + // new BigInteger(String) + // new BigInteger(String,int radix) + // Possible inputs: + // 45 45.5 45E7 4.5E7 Hex Oct Binary xxxF xxxD xxxf xxxd + // plus minus everything. Prolly more. A lot are not separable. + + /** + *

Turns a string value into a java.lang.Number.

+ * + *

If the string starts with {@code 0x} or {@code -0x} (lower or upper case) or {@code #} or {@code -#}, it + * will be interpreted as a hexadecimal Integer - or Long, if the number of digits after the + * prefix is more than 8 - or BigInteger if there are more than 16 digits. + *

+ *

Then, the value is examined for a type qualifier on the end, i.e. one of + * 'f','F','d','D','l','L'. If it is found, it starts + * trying to create successively larger types from the type specified + * until one is found that can represent the value.

+ * + *

If a type specifier is not found, it will check for a decimal point + * and then try successively larger types from Integer to + * BigInteger and from Float to + * BigDecimal.

+ * + *

+ * Integral values with a leading {@code 0} will be interpreted as octal; the returned number will + * be Integer, Long or BigDecimal as appropriate. + *

+ * + *

Returns null if the string is null.

+ * + *

This method does not trim the input string, i.e., strings with leading + * or trailing spaces will generate NumberFormatExceptions.

+ * + * @param str String containing a number, may be null + * @return Number created from the string (or null if the input is null) + * @throws NumberFormatException if the value cannot be converted + */ + public static Number createNumber(final String str) throws NumberFormatException { + if (str == null) { + return null; + } + if (StringUtils.isBlank(str)) { + throw new NumberFormatException("A blank string is not a valid number"); + } + // Need to deal with all possible hex prefixes here + final String[] hex_prefixes = {"0x", "0X", "-0x", "-0X", "#", "-#"}; + int pfxLen = 0; + for(final String pfx : hex_prefixes) { + if (str.startsWith(pfx)) { + pfxLen += pfx.length(); + break; + } + } + if (pfxLen > 0) { // we have a hex number + char firstSigDigit = 0; // strip leading zeroes + for(int i = pfxLen; i < str.length(); i++) { + firstSigDigit = str.charAt(i); + if (firstSigDigit == '0') { // count leading zeroes + pfxLen++; + } else { + break; + } + } + final int hexDigits = str.length() - pfxLen; + if (hexDigits > 16 || (hexDigits == 16 && firstSigDigit > '7')) { // too many for Long + return createBigInteger(str); + } + if (hexDigits > 8 || (hexDigits == 8 && firstSigDigit > '7')) { // too many for an int + return createLong(str); + } + return createInteger(str); + } + final char lastChar = str.charAt(str.length() - 1); + String mant; + String dec; + String exp; + final int decPos = str.indexOf('.'); + final int expPos = str.indexOf('e') + str.indexOf('E') + 1; // assumes both not present + // if both e and E are present, this is caught by the checks on expPos (which prevent IOOBE) + // and the parsing which will detect if e or E appear in a number due to using the wrong offset + + int numDecimals = 0; // Check required precision (LANG-693) + if (decPos > -1) { // there is a decimal point + + if (expPos > -1) { // there is an exponent + if (expPos < decPos || expPos > str.length()) { // prevents double exponent causing IOOBE + throw new NumberFormatException(str + " is not a valid number."); + } + dec = str.substring(decPos + 1, expPos); + } else { + dec = str.substring(decPos + 1); + } + mant = getMantissa(str, decPos); + numDecimals = dec.length(); // gets number of digits past the decimal to ensure no loss of precision for floating point numbers. + } else { + if (expPos > -1) { + if (expPos > str.length()) { // prevents double exponent causing IOOBE + throw new NumberFormatException(str + " is not a valid number."); + } + mant = getMantissa(str, expPos); + } else { + mant = getMantissa(str); + } + dec = null; + } + if (!Character.isDigit(lastChar) && lastChar != '.') { + if (expPos > -1 && expPos < str.length() - 1) { + exp = str.substring(expPos + 1, str.length() - 1); + } else { + exp = null; + } + //Requesting a specific type.. + final String numeric = str.substring(0, str.length() - 1); + final boolean allZeros = isAllZeros(mant) && isAllZeros(exp); + switch (lastChar) { + case 'l' : + case 'L' : + if (dec == null + && exp == null + && (numeric.charAt(0) == '-' && isDigits(numeric.substring(1)) || isDigits(numeric))) { + try { + return createLong(numeric); + } catch (final NumberFormatException nfe) { // NOPMD + // Too big for a long + } + return createBigInteger(numeric); + + } + throw new NumberFormatException(str + " is not a valid number."); + case 'f' : + case 'F' : + try { + final Float f = NumberUtils.createFloat(numeric); + if (!(f.isInfinite() || (f.floatValue() == 0.0F && !allZeros))) { + //If it's too big for a float or the float value = 0 and the string + //has non-zeros in it, then float does not have the precision we want + return f; + } + + } catch (final NumberFormatException nfe) { // NOPMD + // ignore the bad number + } + //$FALL-THROUGH$ + case 'd' : + case 'D' : + try { + final Double d = NumberUtils.createDouble(numeric); + if (!(d.isInfinite() || (d.floatValue() == 0.0D && !allZeros))) { + return d; + } + } catch (final NumberFormatException nfe) { // NOPMD + // ignore the bad number + } + try { + return createBigDecimal(numeric); + } catch (final NumberFormatException e) { // NOPMD + // ignore the bad number + } + //$FALL-THROUGH$ + default : + throw new NumberFormatException(str + " is not a valid number."); + + } + } + //User doesn't have a preference on the return type, so let's start + //small and go from there... + if (expPos > -1 && expPos < str.length() - 1) { + exp = str.substring(expPos + 1, str.length()); + } else { + exp = null; + } + if (dec == null && exp == null) { // no decimal point and no exponent + //Must be an Integer, Long, Biginteger + try { + return createInteger(str); + } catch (final NumberFormatException nfe) { // NOPMD + // ignore the bad number + } + try { + return createLong(str); + } catch (final NumberFormatException nfe) { // NOPMD + // ignore the bad number + } + return createBigInteger(str); + } + + //Must be a Float, Double, BigDecimal + final boolean allZeros = isAllZeros(mant) && isAllZeros(exp); + try { + if(numDecimals <= 7){// If number has 7 or fewer digits past the decimal point then make it a float + final Float f = createFloat(str); + if (!(f.isInfinite() || (f.floatValue() == 0.0F && !allZeros))) { + return f; + } + } + } catch (final NumberFormatException nfe) { // NOPMD + // ignore the bad number + } + try { + if(numDecimals <= 16){// If number has between 8 and 16 digits past the decimal point then make it a double + final Double d = createDouble(str); + if (!(d.isInfinite() || (d.doubleValue() == 0.0D && !allZeros))) { + return d; + } + } + } catch (final NumberFormatException nfe) { // NOPMD + // ignore the bad number + } + + return createBigDecimal(str); + } + + /** + *

Utility method for {@link #createNumber(java.lang.String)}.

+ * + *

Returns mantissa of the given number.

+ * + * @param str the string representation of the number + * @return mantissa of the given number + */ + private static String getMantissa(final String str) { + return getMantissa(str, str.length()); + } + + /** + *

Utility method for {@link #createNumber(java.lang.String)}.

+ * + *

Returns mantissa of the given number.

+ * + * @param str the string representation of the number + * @param stopPos the position of the exponent or decimal point + * @return mantissa of the given number + */ + private static String getMantissa(final String str, final int stopPos) { + final char firstChar = str.charAt(0); + final boolean hasSign = (firstChar == '-' || firstChar == '+'); + + return hasSign ? str.substring(1, stopPos) : str.substring(0, stopPos); + } + + /** + *

Utility method for {@link #createNumber(java.lang.String)}.

+ * + *

Returns true if s is null.

+ * + * @param str the String to check + * @return if it is all zeros or null + */ + private static boolean isAllZeros(final String str) { + if (str == null) { + return true; + } + for (int i = str.length() - 1; i >= 0; i--) { + if (str.charAt(i) != '0') { + return false; + } + } + return str.length() > 0; + } + + //----------------------------------------------------------------------- + /** + *

Convert a String to a Float.

+ * + *

Returns null if the string is null.

+ * + * @param str a String to convert, may be null + * @return converted Float (or null if the input is null) + * @throws NumberFormatException if the value cannot be converted + */ + public static Float createFloat(final String str) { + if (str == null) { + return null; + } + return Float.valueOf(str); + } + + /** + *

Convert a String to a Double.

+ * + *

Returns null if the string is null.

+ * + * @param str a String to convert, may be null + * @return converted Double (or null if the input is null) + * @throws NumberFormatException if the value cannot be converted + */ + public static Double createDouble(final String str) { + if (str == null) { + return null; + } + return Double.valueOf(str); + } + + /** + *

Convert a String to a Integer, handling + * hex (0xhhhh) and octal (0dddd) notations. + * N.B. a leading zero means octal; spaces are not trimmed.

+ * + *

Returns null if the string is null.

+ * + * @param str a String to convert, may be null + * @return converted Integer (or null if the input is null) + * @throws NumberFormatException if the value cannot be converted + */ + public static Integer createInteger(final String str) { + if (str == null) { + return null; + } + // decode() handles 0xAABD and 0777 (hex and octal) as well. + return Integer.decode(str); + } + + /** + *

Convert a String to a Long; + * since 3.1 it handles hex (0Xhhhh) and octal (0ddd) notations. + * N.B. a leading zero means octal; spaces are not trimmed.

+ * + *

Returns null if the string is null.

+ * + * @param str a String to convert, may be null + * @return converted Long (or null if the input is null) + * @throws NumberFormatException if the value cannot be converted + */ + public static Long createLong(final String str) { + if (str == null) { + return null; + } + return Long.decode(str); + } + + /** + *

Convert a String to a BigInteger; + * since 3.2 it handles hex (0x or #) and octal (0) notations.

+ * + *

Returns null if the string is null.

+ * + * @param str a String to convert, may be null + * @return converted BigInteger (or null if the input is null) + * @throws NumberFormatException if the value cannot be converted + */ + public static BigInteger createBigInteger(final String str) { + if (str == null) { + return null; + } + int pos = 0; // offset within string + int radix = 10; + boolean negate = false; // need to negate later? + if (str.startsWith("-")) { + negate = true; + pos = 1; + } + if (str.startsWith("0x", pos) || str.startsWith("0X", pos)) { // hex + radix = 16; + pos += 2; + } else if (str.startsWith("#", pos)) { // alternative hex (allowed by Long/Integer) + radix = 16; + pos ++; + } else if (str.startsWith("0", pos) && str.length() > pos + 1) { // octal; so long as there are additional digits + radix = 8; + pos ++; + } // default is to treat as decimal + + final BigInteger value = new BigInteger(str.substring(pos), radix); + return negate ? value.negate() : value; + } + + /** + *

Convert a String to a BigDecimal.

+ * + *

Returns null if the string is null.

+ * + * @param str a String to convert, may be null + * @return converted BigDecimal (or null if the input is null) + * @throws NumberFormatException if the value cannot be converted + */ + public static BigDecimal createBigDecimal(final String str) { + if (str == null) { + return null; + } + // handle JDK1.3.1 bug where "" throws IndexOutOfBoundsException + if (StringUtils.isBlank(str)) { + throw new NumberFormatException("A blank string is not a valid number"); + } + if (str.trim().startsWith("--")) { + // this is protection for poorness in java.lang.BigDecimal. + // it accepts this as a legal value, but it does not appear + // to be in specification of class. OS X Java parses it to + // a wrong value. + throw new NumberFormatException(str + " is not a valid number."); + } + return new BigDecimal(str); + } + + // Min in array + //-------------------------------------------------------------------- + /** + *

Returns the minimum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the minimum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @since 3.4 Changed signature from min(long[]) to min(long...) + */ + public static long min(final long... array) { + // Validates input + validateArray(array); + + // Finds and returns min + long min = array[0]; + for (int i = 1; i < array.length; i++) { + if (array[i] < min) { + min = array[i]; + } + } + + return min; + } + + /** + *

Returns the minimum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the minimum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @since 3.4 Changed signature from min(int[]) to min(int...) + */ + public static int min(final int... array) { + // Validates input + validateArray(array); + + // Finds and returns min + int min = array[0]; + for (int j = 1; j < array.length; j++) { + if (array[j] < min) { + min = array[j]; + } + } + + return min; + } + + /** + *

Returns the minimum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the minimum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @since 3.4 Changed signature from min(short[]) to min(short...) + */ + public static short min(final short... array) { + // Validates input + validateArray(array); + + // Finds and returns min + short min = array[0]; + for (int i = 1; i < array.length; i++) { + if (array[i] < min) { + min = array[i]; + } + } + + return min; + } + + /** + *

Returns the minimum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the minimum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @since 3.4 Changed signature from min(byte[]) to min(byte...) + */ + public static byte min(final byte... array) { + // Validates input + validateArray(array); + + // Finds and returns min + byte min = array[0]; + for (int i = 1; i < array.length; i++) { + if (array[i] < min) { + min = array[i]; + } + } + + return min; + } + + /** + *

Returns the minimum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the minimum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @see IEEE754rUtils#min(double[]) IEEE754rUtils for a version of this method that handles NaN differently + * @since 3.4 Changed signature from min(double[]) to min(double...) + */ + public static double min(final double... array) { + // Validates input + validateArray(array); + + // Finds and returns min + double min = array[0]; + for (int i = 1; i < array.length; i++) { + if (Double.isNaN(array[i])) { + return Double.NaN; + } + if (array[i] < min) { + min = array[i]; + } + } + + return min; + } + + /** + *

Returns the minimum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the minimum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @see IEEE754rUtils#min(float[]) IEEE754rUtils for a version of this method that handles NaN differently + * @since 3.4 Changed signature from min(float[]) to min(float...) + */ + public static float min(final float... array) { + // Validates input + validateArray(array); + + // Finds and returns min + float min = array[0]; + for (int i = 1; i < array.length; i++) { + if (Float.isNaN(array[i])) { + return Float.NaN; + } + if (array[i] < min) { + min = array[i]; + } + } + + return min; + } + + // Max in array + //-------------------------------------------------------------------- + /** + *

Returns the maximum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the maximum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @since 3.4 Changed signature from max(long[]) to max(long...) + */ + public static long max(final long... array) { + // Validates input + validateArray(array); + + // Finds and returns max + long max = array[0]; + for (int j = 1; j < array.length; j++) { + if (array[j] > max) { + max = array[j]; + } + } + + return max; + } + + /** + *

Returns the maximum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the maximum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @since 3.4 Changed signature from max(int[]) to max(int...) + */ + public static int max(final int... array) { + // Validates input + validateArray(array); + + // Finds and returns max + int max = array[0]; + for (int j = 1; j < array.length; j++) { + if (array[j] > max) { + max = array[j]; + } + } + + return max; + } + + /** + *

Returns the maximum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the maximum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @since 3.4 Changed signature from max(short[]) to max(short...) + */ + public static short max(final short... array) { + // Validates input + validateArray(array); + + // Finds and returns max + short max = array[0]; + for (int i = 1; i < array.length; i++) { + if (array[i] > max) { + max = array[i]; + } + } + + return max; + } + + /** + *

Returns the maximum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the maximum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @since 3.4 Changed signature from max(byte[]) to max(byte...) + */ + public static byte max(final byte... array) { + // Validates input + validateArray(array); + + // Finds and returns max + byte max = array[0]; + for (int i = 1; i < array.length; i++) { + if (array[i] > max) { + max = array[i]; + } + } + + return max; + } + + /** + *

Returns the maximum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the maximum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @see IEEE754rUtils#max(double[]) IEEE754rUtils for a version of this method that handles NaN differently + * @since 3.4 Changed signature from max(double[]) to max(double...) + */ + public static double max(final double... array) { + // Validates input + validateArray(array); + + // Finds and returns max + double max = array[0]; + for (int j = 1; j < array.length; j++) { + if (Double.isNaN(array[j])) { + return Double.NaN; + } + if (array[j] > max) { + max = array[j]; + } + } + + return max; + } + + /** + *

Returns the maximum value in an array.

+ * + * @param array an array, must not be null or empty + * @return the maximum value in the array + * @throws IllegalArgumentException if array is null + * @throws IllegalArgumentException if array is empty + * @see IEEE754rUtils#max(float[]) IEEE754rUtils for a version of this method that handles NaN differently + * @since 3.4 Changed signature from max(float[]) to max(float...) + */ + public static float max(final float... array) { + // Validates input + validateArray(array); + + // Finds and returns max + float max = array[0]; + for (int j = 1; j < array.length; j++) { + if (Float.isNaN(array[j])) { + return Float.NaN; + } + if (array[j] > max) { + max = array[j]; + } + } + + return max; + } + + /** + * Checks if the specified array is neither null nor empty. + * + * @param array the array to check + * @throws IllegalArgumentException if {@code array} is either {@code null} or empty + */ + private static void validateArray(final Object array) { + if (array == null) { + throw new IllegalArgumentException("The Array must not be null"); + } + Validate.isTrue(Array.getLength(array) != 0, "Array cannot be empty."); + } + + // 3 param min + //----------------------------------------------------------------------- + /** + *

Gets the minimum of three long values.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the smallest of the values + */ + public static long min(long a, final long b, final long c) { + if (b < a) { + a = b; + } + if (c < a) { + a = c; + } + return a; + } + + /** + *

Gets the minimum of three int values.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the smallest of the values + */ + public static int min(int a, final int b, final int c) { + if (b < a) { + a = b; + } + if (c < a) { + a = c; + } + return a; + } + + /** + *

Gets the minimum of three short values.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the smallest of the values + */ + public static short min(short a, final short b, final short c) { + if (b < a) { + a = b; + } + if (c < a) { + a = c; + } + return a; + } + + /** + *

Gets the minimum of three byte values.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the smallest of the values + */ + public static byte min(byte a, final byte b, final byte c) { + if (b < a) { + a = b; + } + if (c < a) { + a = c; + } + return a; + } + + /** + *

Gets the minimum of three double values.

+ * + *

If any value is NaN, NaN is + * returned. Infinity is handled.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the smallest of the values + * @see IEEE754rUtils#min(double, double, double) for a version of this method that handles NaN differently + */ + public static double min(final double a, final double b, final double c) { + return Math.min(Math.min(a, b), c); + } + + /** + *

Gets the minimum of three float values.

+ * + *

If any value is NaN, NaN is + * returned. Infinity is handled.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the smallest of the values + * @see IEEE754rUtils#min(float, float, float) for a version of this method that handles NaN differently + */ + public static float min(final float a, final float b, final float c) { + return Math.min(Math.min(a, b), c); + } + + // 3 param max + //----------------------------------------------------------------------- + /** + *

Gets the maximum of three long values.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the largest of the values + */ + public static long max(long a, final long b, final long c) { + if (b > a) { + a = b; + } + if (c > a) { + a = c; + } + return a; + } + + /** + *

Gets the maximum of three int values.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the largest of the values + */ + public static int max(int a, final int b, final int c) { + if (b > a) { + a = b; + } + if (c > a) { + a = c; + } + return a; + } + + /** + *

Gets the maximum of three short values.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the largest of the values + */ + public static short max(short a, final short b, final short c) { + if (b > a) { + a = b; + } + if (c > a) { + a = c; + } + return a; + } + + /** + *

Gets the maximum of three byte values.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the largest of the values + */ + public static byte max(byte a, final byte b, final byte c) { + if (b > a) { + a = b; + } + if (c > a) { + a = c; + } + return a; + } + + /** + *

Gets the maximum of three double values.

+ * + *

If any value is NaN, NaN is + * returned. Infinity is handled.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the largest of the values + * @see IEEE754rUtils#max(double, double, double) for a version of this method that handles NaN differently + */ + public static double max(final double a, final double b, final double c) { + return Math.max(Math.max(a, b), c); + } + + /** + *

Gets the maximum of three float values.

+ * + *

If any value is NaN, NaN is + * returned. Infinity is handled.

+ * + * @param a value 1 + * @param b value 2 + * @param c value 3 + * @return the largest of the values + * @see IEEE754rUtils#max(float, float, float) for a version of this method that handles NaN differently + */ + public static float max(final float a, final float b, final float c) { + return Math.max(Math.max(a, b), c); + } + + //----------------------------------------------------------------------- + /** + *

Checks whether the String contains only + * digit characters.

+ * + *

Null and empty String will return + * false.

+ * + * @param str the String to check + * @return true if str contains only Unicode numeric + */ + public static boolean isDigits(final String str) { + return StringUtils.isNumeric(str); + } + + /** + *

Checks whether the String a valid Java number.

+ * + *

Valid numbers include hexadecimal marked with the 0x or + * 0X qualifier, octal numbers, scientific notation and numbers + * marked with a type qualifier (e.g. 123L).

+ * + *

Non-hexadecimal strings beginning with a leading zero are + * treated as octal values. Thus the string 09 will return + * false, since 9 is not a valid octal value. + * However, numbers beginning with {@code 0.} are treated as decimal.

+ * + *

null and empty/blank {@code String} will return + * false.

+ * + * @param str the String to check + * @return true if the string is a correctly formatted number + * @since 3.3 the code supports hex {@code 0Xhhh} and octal {@code 0ddd} validation + */ + public static boolean isNumber(final String str) { + if (StringUtils.isEmpty(str)) { + return false; + } + final char[] chars = str.toCharArray(); + int sz = chars.length; + boolean hasExp = false; + boolean hasDecPoint = false; + boolean allowSigns = false; + boolean foundDigit = false; + // deal with any possible sign up front + final int start = (chars[0] == '-') ? 1 : 0; + if (sz > start + 1 && chars[start] == '0') { // leading 0 + if ( + (chars[start + 1] == 'x') || + (chars[start + 1] == 'X') + ) { // leading 0x/0X + int i = start + 2; + if (i == sz) { + return false; // str == "0x" + } + // checking hex (it can't be anything else) + for (; i < chars.length; i++) { + if ((chars[i] < '0' || chars[i] > '9') + && (chars[i] < 'a' || chars[i] > 'f') + && (chars[i] < 'A' || chars[i] > 'F')) { + return false; + } + } + return true; + } else if (Character.isDigit(chars[start + 1])) { + // leading 0, but not hex, must be octal + int i = start + 1; + for (; i < chars.length; i++) { + if (chars[i] < '0' || chars[i] > '7') { + return false; + } + } + return true; + } + } + sz--; // don't want to loop to the last char, check it afterwords + // for type qualifiers + int i = start; + // loop to the next to last char or to the last char if we need another digit to + // make a valid number (e.g. chars[0..5] = "1234E") + while (i < sz || (i < sz + 1 && allowSigns && !foundDigit)) { + if (chars[i] >= '0' && chars[i] <= '9') { + foundDigit = true; + allowSigns = false; + + } else if (chars[i] == '.') { + if (hasDecPoint || hasExp) { + // two decimal points or dec in exponent + return false; + } + hasDecPoint = true; + } else if (chars[i] == 'e' || chars[i] == 'E') { + // we've already taken care of hex. + if (hasExp) { + // two E's + return false; + } + if (!foundDigit) { + return false; + } + hasExp = true; + allowSigns = true; + } else if (chars[i] == '+' || chars[i] == '-') { + if (!allowSigns) { + return false; + } + allowSigns = false; + foundDigit = false; // we need a digit after the E + } else { + return false; + } + i++; + } + if (i < chars.length) { + if (chars[i] >= '0' && chars[i] <= '9') { + // no type qualifier, OK + return true; + } + if (chars[i] == 'e' || chars[i] == 'E') { + // can't have an E at the last byte + return false; + } + if (chars[i] == '.') { + if (hasDecPoint || hasExp) { + // two decimal points or dec in exponent + return false; + } + // single trailing decimal point after non-exponent is ok + return foundDigit; + } + if (!allowSigns + && (chars[i] == 'd' + || chars[i] == 'D' + || chars[i] == 'f' + || chars[i] == 'F')) { + return foundDigit; + } + if (chars[i] == 'l' + || chars[i] == 'L') { + // not allowing L with an exponent or decimal point + return foundDigit && !hasExp && !hasDecPoint; + } + // last character is illegal + return false; + } + // allowSigns is true iff the val ends in 'E' + // found digit it to make sure weird stuff like '.' and '1E-' doesn't pass + return !allowSigns && foundDigit; + } + + /** + *

Checks whether the given String is a parsable number.

+ * + *

Parsable numbers include those Strings understood by {@link Integer#parseInt(String)}, + * {@link Long#parseLong(String)}, {@link Float#parseFloat(String)} or + * {@link Double#parseDouble(String)}. This method can be used instead of catching {@link java.text.ParseException} + * when calling one of those methods.

+ * + *

Hexadecimal and scientific notations are not considered parsable. + * See {@link #isNumber(String)} on those cases.

+ * + *

{@code Null} and empty String will return false.

+ * + * @param str the String to check. + * @return {@code true} if the string is a parsable number. + * @since 3.4 + */ + public static boolean isParsable(final String str) { + if( StringUtils.endsWith( str, "." ) ) { + return false; + } + if( StringUtils.startsWith( str, "-" ) ) { + return isDigits( StringUtils.replaceOnce( str.substring(1), ".", StringUtils.EMPTY ) ); + } + return isDigits( StringUtils.replaceOnce( str, ".", StringUtils.EMPTY ) ); + } + + /** + *

Compares two {@code int} values numerically. This is the same functionality as provided in Java 7.

+ * + * @param x the first {@code int} to compare + * @param y the second {@code int} to compare + * @return the value {@code 0} if {@code x == y}; + * a value less than {@code 0} if {@code x < y}; and + * a value greater than {@code 0} if {@code x > y} + * @since 3.4 + */ + public static int compare(int x, int y) { + if (x == y) { + return 0; + } + return x < y ? -1 : 1; + } + + /** + *

Compares to {@code long} values numerically. This is the same functionality as provided in Java 7.

+ * + * @param x the first {@code long} to compare + * @param y the second {@code long} to compare + * @return the value {@code 0} if {@code x == y}; + * a value less than {@code 0} if {@code x < y}; and + * a value greater than {@code 0} if {@code x > y} + * @since 3.4 + */ + public static int compare(long x, long y) { + if (x == y) { + return 0; + } + return x < y ? -1 : 1; + } + + /** + *

Compares to {@code short} values numerically. This is the same functionality as provided in Java 7.

+ * + * @param x the first {@code short} to compare + * @param y the second {@code short} to compare + * @return the value {@code 0} if {@code x == y}; + * a value less than {@code 0} if {@code x < y}; and + * a value greater than {@code 0} if {@code x > y} + * @since 3.4 + */ + public static int compare(short x, short y) { + if (x == y) { + return 0; + } + return x < y ? -1 : 1; + } + + /** + *

Compares two {@code byte} values numerically. This is the same functionality as provided in Java 7.

+ * + * @param x the first {@code byte} to compare + * @param y the second {@code byte} to compare + * @return the value {@code 0} if {@code x == y}; + * a value less than {@code 0} if {@code x < y}; and + * a value greater than {@code 0} if {@code x > y} + * @since 3.4 + */ + public static int compare(byte x, byte y) { + return x - y; + } +}