com.landawn.abacus.util.N Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of abacus-common Show documentation
Show all versions of abacus-common Show documentation
A general programming library in Java/Android. It's easy to learn and simple to use with concise and powerful APIs.
/*
* Copyright (c) 2015, Haiyang Li.
*
* Licensed 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 com.landawn.abacus.util;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.RandomAccess;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;
import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.exception.UncheckedException;
import com.landawn.abacus.parser.DeserializationConfig;
import com.landawn.abacus.parser.JSONDeserializationConfig;
import com.landawn.abacus.parser.JSONDeserializationConfig.JDC;
import com.landawn.abacus.parser.JSONSerializationConfig;
import com.landawn.abacus.parser.XMLDeserializationConfig;
import com.landawn.abacus.parser.XMLDeserializationConfig.XDC;
import com.landawn.abacus.parser.XMLSerializationConfig;
import com.landawn.abacus.type.Type;
import com.landawn.abacus.util.Fn.Factory;
import com.landawn.abacus.util.Fn.IntFunctions;
import com.landawn.abacus.util.Fn.Suppliers;
import com.landawn.abacus.util.Iterables.Slice;
import com.landawn.abacus.util.Tuple.Tuple2;
import com.landawn.abacus.util.Tuple.Tuple3;
import com.landawn.abacus.util.Tuple.Tuple4;
import com.landawn.abacus.util.Tuple.Tuple5;
import com.landawn.abacus.util.u.Nullable;
import com.landawn.abacus.util.function.IntBiFunction;
import com.landawn.abacus.util.stream.ObjIteratorEx;
import com.landawn.abacus.util.stream.Stream;
/**
*
* Note: This class includes codes copied from Apache Commons Lang, Google Guava and other open source projects under the Apache License 2.0.
* The methods copied from other libraries/frameworks/projects may be modified in this class.
*
* Class N is a general java utility class. It provides the most daily used operations for Object/primitive types/String/Array/Collection/Map/Bean...:
*
* When to throw exception? It's designed to avoid throwing any unnecessary
* exception if the contract defined by method is not broken. for example, if
* user tries to reverse a null or empty String. the input String will be
* returned. But exception will be thrown if trying to repeat/swap a null or
* empty string or operate Array/Collection by adding/removing...
*
* @author Haiyang Li
*
* @version $Revision: 0.8 $ 07/03/10
*
* @see com.landawn.abacus.util.Array
* @see com.landawn.abacus.util.Iterables
* @see com.landawn.abacus.util.Iterators
* @see com.landawn.abacus.util.Maps
* @see com.landawn.abacus.util.Strings
* @see com.landawn.abacus.util.IOUtil
*/
@SuppressWarnings("java:S1192")
public final class N extends CommonUtil {
private static final int CPU_CORES = Runtime.getRuntime().availableProcessors();
private static final float LOAD_FACTOR_FOR_FLAT_MAP = 1.75f;
private static final int LOAD_FACTOR_FOR_TWO_FLAT_MAP = 2;
static final AsyncExecutor asyncExecutor = new AsyncExecutor(//
max(64, IOUtil.CPU_CORES * 8), // coreThreadPoolSize
max(128, IOUtil.CPU_CORES * 16), // maxThreadPoolSize
180L, TimeUnit.SECONDS);
static final ScheduledExecutorService SCHEDULED_EXECUTOR;
static {
final ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(Math.max(64, CPU_CORES));
// executor.setKeepAliveTime(180, TimeUnit.SECONDS);
// executor.allowCoreThreadTimeOut(true);
// executor.setRemoveOnCancelPolicy(true);
SCHEDULED_EXECUTOR = MoreExecutors.getExitingScheduledExecutorService(executor);
}
private N() {
// Utility class.
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static int occurrencesOf(final boolean[] a, final boolean valueToFind) {
if (isNullOrEmpty(a)) {
return 0;
}
int occurrences = 0;
for (boolean element : a) {
if (element == valueToFind) {
occurrences++;
}
}
return occurrences;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static int occurrencesOf(final char[] a, final char valueToFind) {
if (isNullOrEmpty(a)) {
return 0;
}
int occurrences = 0;
for (char element : a) {
if (element == valueToFind) {
occurrences++;
}
}
return occurrences;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static int occurrencesOf(final byte[] a, final byte valueToFind) {
if (isNullOrEmpty(a)) {
return 0;
}
int occurrences = 0;
for (byte element : a) {
if (element == valueToFind) {
occurrences++;
}
}
return occurrences;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static int occurrencesOf(final short[] a, final short valueToFind) {
if (isNullOrEmpty(a)) {
return 0;
}
int occurrences = 0;
for (short element : a) {
if (element == valueToFind) {
occurrences++;
}
}
return occurrences;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static int occurrencesOf(final int[] a, final int valueToFind) {
if (isNullOrEmpty(a)) {
return 0;
}
int occurrences = 0;
for (int element : a) {
if (element == valueToFind) {
occurrences++;
}
}
return occurrences;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static int occurrencesOf(final long[] a, final long valueToFind) {
if (isNullOrEmpty(a)) {
return 0;
}
int occurrences = 0;
for (long element : a) {
if (element == valueToFind) {
occurrences++;
}
}
return occurrences;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static int occurrencesOf(final float[] a, final float valueToFind) {
if (isNullOrEmpty(a)) {
return 0;
}
int occurrences = 0;
for (float element : a) {
if (Float.compare(element, valueToFind) == 0) {
occurrences++;
}
}
return occurrences;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static int occurrencesOf(final double[] a, final double valueToFind) {
if (isNullOrEmpty(a)) {
return 0;
}
int occurrences = 0;
for (double element : a) {
if (Double.compare(element, valueToFind) == 0) {
occurrences++;
}
}
return occurrences;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static int occurrencesOf(final Object[] a, final Object valueToFind) {
if (isNullOrEmpty(a)) {
return 0;
}
int occurrences = 0;
if (valueToFind == null) {
for (Object element : a) {
if (element == null) {
occurrences++;
}
}
} else {
for (Object element : a) {
if (valueToFind.equals(element)) {
occurrences++;
}
}
}
return occurrences;
}
/**
*
* @param c
* @param valueToFind
* @return
* @see java.util.Collections#frequency(Collection, Object)
*/
public static int occurrencesOf(final Iterable c, final Object valueToFind) {
if (c == null) {
return 0;
}
long occurrences = 0;
if (valueToFind == null) {
for (Object e : c) {
if (e == null) {
occurrences++;
}
}
} else {
for (Object e : c) {
if (equals(e, valueToFind)) {
occurrences++;
}
}
}
return Numbers.toIntExact(occurrences);
}
/**
*
*
* @param iter
* @param valueToFind
* @return
*/
public static long occurrencesOf(final Iterator iter, final Object valueToFind) {
if (iter == null) {
return 0;
}
long occurrences = 0;
if (valueToFind == null) {
while (iter.hasNext()) {
if (iter.next() == null) {
occurrences++;
}
}
} else {
while (iter.hasNext()) {
if (equals(iter.next(), valueToFind)) {
occurrences++;
}
}
}
return occurrences;
}
/**
*
* @param str
* @param ch
* @return
* @see Strings#occurrencesOf(String, char)
*/
public static int occurrencesOf(final String str, final char ch) {
return Strings.occurrencesOf(str, ch);
}
/**
*
* @param str
* @param substr
* @return
* @see Strings#occurrencesOf(String, String)
*/
public static int occurrencesOf(final String str, final String substr) {
return Strings.occurrencesOf(str, substr);
}
/**
*
* @param
* @param a
* @return
* @see Multiset#from(Collection)
*/
public static Map occurrencesMap(final T[] a) {
return occurrencesMap(a, Suppliers. ofMap());
}
/**
*
* @param
* @param a
* @param mapSupplier
* @return
* @see Multiset#from(Collection)
*/
public static Map occurrencesMap(final T[] a, final Supplier> mapSupplier) {
if (isNullOrEmpty(a)) {
return mapSupplier.get();
}
final Map map = mapSupplier.get();
for (T e : a) {
map.merge(e, 1, (o, n) -> o + n);
}
return map;
}
/**
*
* @param
* @param c
* @return
* @see Multiset#from(Collection)
*/
public static Map occurrencesMap(final Iterable c) {
return occurrencesMap(c, Suppliers. ofMap());
}
/**
*
* @param
* @param c
* @param mapSupplier
* @return
* @see Multiset#from(Collection)
*/
public static Map occurrencesMap(final Iterable c, final Supplier> mapSupplier) {
if (c == null) {
return mapSupplier.get();
}
final Map map = mapSupplier.get();
for (T e : c) {
map.merge(e, 1, (o, n) -> o + n);
}
return map;
}
/**
*
*
* @param
* @param iter
* @return
* @see Multiset#from(Iterator)
*/
public static Map occurrencesMap(final Iterator iter) {
return occurrencesMap(iter, Suppliers. ofMap());
}
/**
*
* @param
* @param iter
* @param mapSupplier
* @return
* @see Multiset#from(Iterator)
*/
public static Map occurrencesMap(final Iterator iter, final Supplier> mapSupplier) {
if (iter == null) {
return mapSupplier.get();
}
final Map map = mapSupplier.get();
while (iter.hasNext()) {
map.merge(iter.next(), 1, (o, n) -> o + n);
}
return map;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static boolean contains(final boolean[] a, final boolean valueToFind) {
return indexOf(a, valueToFind) != INDEX_NOT_FOUND;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static boolean contains(final char[] a, final char valueToFind) {
return indexOf(a, valueToFind) != INDEX_NOT_FOUND;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static boolean contains(final byte[] a, final byte valueToFind) {
return indexOf(a, valueToFind) != INDEX_NOT_FOUND;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static boolean contains(final short[] a, final short valueToFind) {
return indexOf(a, valueToFind) != INDEX_NOT_FOUND;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static boolean contains(final int[] a, final int valueToFind) {
return indexOf(a, valueToFind) != INDEX_NOT_FOUND;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static boolean contains(final long[] a, final long valueToFind) {
return indexOf(a, valueToFind) != INDEX_NOT_FOUND;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static boolean contains(final float[] a, final float valueToFind) {
return indexOf(a, valueToFind) != INDEX_NOT_FOUND;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static boolean contains(final double[] a, final double valueToFind) {
return indexOf(a, valueToFind) != INDEX_NOT_FOUND;
}
/**
*
* @param a
* @param valueToFind
* @return
*/
public static boolean contains(final Object[] a, final Object valueToFind) {
return indexOf(a, valueToFind) != INDEX_NOT_FOUND;
}
/**
*
* @param c
* @param valueToFind
* @return
*/
public static boolean contains(final Collection c, final Object valueToFind) {
if (isNullOrEmpty(c)) {
return false;
}
return c.contains(valueToFind);
}
/**
*
*
* @param iter
* @param valueToFind
* @return
*/
public static boolean contains(final Iterator iter, final Object valueToFind) {
if (iter == null) {
return false;
}
while (iter.hasNext()) {
if (equals(iter.next(), valueToFind)) {
return true;
}
}
return false;
}
/**
*
* @param c
* @param valuesToFind the objs to find
* @return
*/
public static boolean containsAll(final Collection c, final Collection valuesToFind) {
if (isNullOrEmpty(valuesToFind)) {
return true;
} else if (isNullOrEmpty(c)) {
return false;
}
return c.containsAll(valuesToFind);
}
/**
*
* @param c
* @param valuesToFind the objs to find
* @return
*/
@SafeVarargs
public static boolean containsAll(final Collection c, final Object... valuesToFind) {
if (isNullOrEmpty(valuesToFind)) {
return true;
} else if (isNullOrEmpty(c)) {
return false;
}
return c.containsAll(Array.asList(valuesToFind));
}
/**
*
*
* @param iter
* @param valuesToFind
* @return
*/
public static boolean containsAll(final Iterator iter, final Collection valuesToFind) {
if (isNullOrEmpty(valuesToFind)) {
return true;
} else if (iter == null) {
return false;
}
final Set set = new HashSet<>(valuesToFind);
while (iter.hasNext()) {
if (set.remove(iter.next()) && (set.size() == 0)) {
return true;
}
}
return false;
}
/**
*
* @param c
* @param valuesToFind the objs to find
* @return
*/
public static boolean containsAny(final Collection c, final Collection valuesToFind) {
if (isNullOrEmpty(c) || isNullOrEmpty(valuesToFind)) {
return false;
}
return !disjoint(c, valuesToFind);
}
/**
*
* @param c
* @param valuesToFind the objs to find
* @return
*/
@SafeVarargs
public static boolean containsAny(final Collection c, final Object... valuesToFind) {
if (isNullOrEmpty(c) || isNullOrEmpty(valuesToFind)) {
return false;
}
return !disjoint(c, Array.asList(valuesToFind));
}
/**
*
*
* @param iter
* @param valuesToFind
* @return
*/
public static boolean containsAny(final Iterator iter, final Set valuesToFind) {
if (iter == null || isNullOrEmpty(valuesToFind)) {
return false;
}
while (iter.hasNext()) {
if (valuesToFind.contains(iter.next())) {
return true;
}
}
return false;
}
/**
* Returns a read-only Seq.
*
* @param
* @param a
* @param fromIndex
* @param toIndex
* @return the immutable collection
*/
public static ImmutableList slice(final T[] a, final int fromIndex, final int toIndex) {
CommonUtil.checkFromToIndex(fromIndex, toIndex, CommonUtil.len(a));
if (CommonUtil.isNullOrEmpty(a)) {
return ImmutableList.empty();
}
return slice(Array.asList(a), fromIndex, toIndex);
}
/**
* Returns a read-only ImmutableCollection.
*
* @param
* @param c
* @param fromIndex
* @param toIndex
* @return the immutable collection
*/
@SuppressWarnings("deprecation")
public static ImmutableList slice(final List c, final int fromIndex, final int toIndex) {
CommonUtil.checkFromToIndex(fromIndex, toIndex, CommonUtil.size(c));
if (CommonUtil.isNullOrEmpty(c)) {
return ImmutableList.empty();
}
return ImmutableList.wrap(((List) c).subList(fromIndex, toIndex));
}
/**
* Returns a read-only ImmutableCollection.
*
* @param
* @param c
* @param fromIndex
* @param toIndex
* @return the immutable collection
*/
public static ImmutableCollection slice(final Collection c, final int fromIndex, final int toIndex) {
CommonUtil.checkFromToIndex(fromIndex, toIndex, CommonUtil.size(c));
if (CommonUtil.isNullOrEmpty(c)) {
return ImmutableList.empty();
}
if (c instanceof List) {
return slice((List) c, fromIndex, toIndex);
}
return new Slice<>(c, fromIndex, toIndex);
}
/**
*
* @param
* @param iter
* @param fromIndex
* @param toIndex
* @return
*/
public static ObjIterator slice(final Iterator iter, final long fromIndex, final long toIndex) {
if (fromIndex < 0 || fromIndex > toIndex) {
throw new IndexOutOfBoundsException("Index range [" + fromIndex + ", " + toIndex + "] is out-of-bounds");
}
if (iter == null || fromIndex == toIndex) {
return ObjIterator.empty();
}
return Iterators.skipAndLimit(iter, fromIndex, toIndex - fromIndex);
}
/**
* Returns consecutive sub arrays of an array, each of the same size (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final boolean[] a, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize"); //NOSONAR
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
final int len = a.length;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int fromIndex = 0, toIndex = a.length; fromIndex < toIndex; fromIndex += chunkSize) {
res.add(copyOfRange(a, fromIndex, fromIndex <= toIndex - chunkSize ? fromIndex + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final boolean[] a, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(a));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(copyOfRange(a, i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final char[] a, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
final int len = a.length;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int fromIndex = 0, toIndex = a.length; fromIndex < toIndex; fromIndex += chunkSize) {
res.add(copyOfRange(a, fromIndex, fromIndex <= toIndex - chunkSize ? fromIndex + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final char[] a, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(a));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(copyOfRange(a, i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final byte[] a, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
final int len = a.length;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int fromIndex = 0, toIndex = a.length; fromIndex < toIndex; fromIndex += chunkSize) {
res.add(copyOfRange(a, fromIndex, fromIndex <= toIndex - chunkSize ? fromIndex + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final byte[] a, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(a));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(copyOfRange(a, i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final short[] a, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
final int len = a.length;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int fromIndex = 0, toIndex = a.length; fromIndex < toIndex; fromIndex += chunkSize) {
res.add(copyOfRange(a, fromIndex, fromIndex <= toIndex - chunkSize ? fromIndex + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final short[] a, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(a));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(copyOfRange(a, i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final int[] a, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
final int len = a.length;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int fromIndex = 0, toIndex = a.length; fromIndex < toIndex; fromIndex += chunkSize) {
res.add(copyOfRange(a, fromIndex, fromIndex <= toIndex - chunkSize ? fromIndex + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final int[] a, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(a));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(copyOfRange(a, i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final long[] a, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
final int len = a.length;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int fromIndex = 0, toIndex = a.length; fromIndex < toIndex; fromIndex += chunkSize) {
res.add(copyOfRange(a, fromIndex, fromIndex <= toIndex - chunkSize ? fromIndex + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final long[] a, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(a));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(copyOfRange(a, i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final float[] a, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
final int len = a.length;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int fromIndex = 0, toIndex = a.length; fromIndex < toIndex; fromIndex += chunkSize) {
res.add(copyOfRange(a, fromIndex, fromIndex <= toIndex - chunkSize ? fromIndex + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final float[] a, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(a));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(copyOfRange(a, i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final double[] a, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
final int len = a.length;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int fromIndex = 0, toIndex = a.length; fromIndex < toIndex; fromIndex += chunkSize) {
res.add(copyOfRange(a, fromIndex, fromIndex <= toIndex - chunkSize ? fromIndex + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param a
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final double[] a, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(a));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(copyOfRange(a, i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param
* @param a
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final T[] a, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
final int len = a.length;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int fromIndex = 0, toIndex = a.length; fromIndex < toIndex; fromIndex += chunkSize) {
res.add(copyOfRange(a, fromIndex, fromIndex <= toIndex - chunkSize ? fromIndex + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub arrays of an array, each of the same chunkSize (the final list may be smaller),
* or an empty List if the specified array is {@code null} or empty.
*
* @param
* @param a
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub array (the last may be smaller).
* @return
*/
public static List split(final T[] a, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(a));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(a) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(copyOfRange(a, i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
return res;
}
/**
* Returns consecutive sub lists of a collection, each of the same chunkSize (the final list may be smaller).
* or an empty List if the specified collection is {@code null} or empty. The order of elements in the original collection is kept
*
* @param
* @param c
* @param chunkSize the desired size of each sub list (the last may be smaller).
* @return
*/
public static List> split(final Iterable c, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (c == null) {
return new ArrayList<>();
} else if (c instanceof Collection) {
final Collection coll = (Collection) c;
return split(coll, 0, coll.size(), chunkSize);
} else {
return toList(split(c.iterator(), chunkSize));
}
}
/**
* Returns consecutive sub lists of a collection, each of the same chunkSize (the final list may be smaller).
* or an empty List if the specified collection is {@code null} or empty. The order of elements in the original collection is kept
*
* @param
* @param c
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub list (the last may be smaller).
* @return
*/
public static List> split(final Collection c, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, size(c));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(c) || fromIndex == toIndex) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List> res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
if (c instanceof List) {
final List list = (List) c;
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(list.subList(i, i <= toIndex - chunkSize ? i + chunkSize : toIndex));
}
} else {
final Iterator iter = c.iterator();
for (int i = 0; i < toIndex;) {
if (i < fromIndex) {
iter.next();
i++;
continue;
}
final List subList = new ArrayList<>(min(chunkSize, toIndex - i));
for (int j = i <= toIndex - chunkSize ? i + chunkSize : toIndex; i < j; i++) {
subList.add(iter.next());
}
res.add(subList);
}
}
return res;
}
/**
*
*
* @param
* @param iter
* @param chunkSize
* @return
*/
public static ObjIterator> split(final Iterator iter, final int chunkSize) {
checkArgument(chunkSize > 0, "'chunkSize' must be greater than 0, can't be: %s", chunkSize);
if (iter == null) {
return ObjIterator.empty();
}
return new ObjIterator<>() {
private final Iterator iterator = iter;
@Override
public boolean hasNext() {
return iterator.hasNext();
}
@Override
public List next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
final List next = new ArrayList<>(chunkSize);
for (int i = 0; i < chunkSize && iterator.hasNext(); i++) {
next.add(iterator.next());
}
return next;
}
};
}
/**
* Returns consecutive substring of the specified string, each of the same length (the final list may be smaller),
* or an empty array if the specified string is {@code null} or empty.
*
* @param str
* @param chunkSize the desired size of each sub String (the last may be smaller).
* @return
*/
public static List split(final CharSequence str, final int chunkSize) {
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(str)) {
return new ArrayList<>();
}
return split(str, 0, str.length(), chunkSize);
}
/**
* Returns consecutive substring of the specified string, each of the same length (the final list may be smaller),
* or an empty array if the specified string is {@code null} or empty.
*
* @param str
* @param fromIndex
* @param toIndex
* @param chunkSize the desired size of each sub String (the last may be smaller).
* @return
*/
public static List split(final CharSequence str, final int fromIndex, final int toIndex, final int chunkSize) {
checkFromToIndex(fromIndex, toIndex, len(str));
checkArgPositive(chunkSize, "chunkSize");
if (isNullOrEmpty(str)) {
return new ArrayList<>();
}
final int len = toIndex - fromIndex;
final List res = new ArrayList<>(len % chunkSize == 0 ? len / chunkSize : (len / chunkSize) + 1);
for (int i = fromIndex; i < toIndex; i = i <= toIndex - chunkSize ? i + chunkSize : toIndex) {
res.add(str.subSequence(i, i <= toIndex - chunkSize ? i + chunkSize : toIndex).toString());
}
return res;
}
/**
*
*
* final int[] a = Array.rangeClosed(1, 7);
* splitByCount(5, 7, true, (fromIndex, toIndex) -> copyOfRange(a, fromIndex, toIndex)).forEach(Fn.println()); // [[1], [2], [3], [4, 5], [6, 7]]
* splitByCount(5, 7, false, (fromIndex, toIndex) -> copyOfRange(a, fromIndex, toIndex)).forEach(Fn.println()); // [[1, 2], [3, 4], [5], [6], [7]]
*
*
*
* @param
* @param maxCount max count of chunk want to split {@code totalSize} into.
* @param totalSize
* @param sizeSmallerFirst
* @param func
* @return the stream
*/
public static Stream splitByCount(final int maxCount, final int totalSize, final boolean sizeSmallerFirst, final IntBiFunction func) {
if (sizeSmallerFirst) {
return splitByCountSmallerFirst(maxCount, totalSize, func);
} else {
return splitByCountSmallerLast(maxCount, totalSize, func);
}
}
/**
*
*
* final int[] a = Array.rangeClosed(1, 7);
* splitByCountSmallerFirst(5, 7, (fromIndex, toIndex) -> copyOfRange(a, fromIndex, toIndex)).forEach(Fn.println()); // [[1], [2], [3], [4, 5], [6, 7]]
* splitByCountSmallerLast(5, 7, (fromIndex, toIndex) -> copyOfRange(a, fromIndex, toIndex)).forEach(Fn.println()); // [[1, 2], [3, 4], [5], [6], [7]]
*
*
*
* @param
* @param maxCount
* @param totalSize
* @param func
* @return the stream
*/
static Stream splitByCountSmallerFirst(final int maxCount, final int totalSize, final IntBiFunction func) {
checkArgPositive(maxCount, "maxCount");
checkArgNotNegative(totalSize, "totalSize");
checkArgNotNull(func, "func");
if (totalSize == 0) {
return Stream.empty();
}
final Iterator iter = new ObjIteratorEx<>() {
private final int smallerSize = Math.max(totalSize / maxCount, 1);
private final int biggerSize = totalSize % maxCount == 0 ? totalSize / maxCount : totalSize / maxCount + 1;
private int count = totalSize >= maxCount ? maxCount : totalSize;
private int biggerCount = totalSize % maxCount;
private int cursor = 0;
@Override
public boolean hasNext() {
return cursor < totalSize;
}
@Override
public T next() {
if (cursor >= totalSize) {
throw new NoSuchElementException();
}
return func.apply(cursor, cursor = (count-- > biggerCount ? cursor + smallerSize : cursor + biggerSize));
}
@Override
public void advance(long n) {
checkArgNotNegative(n, "n");
if (n > 0) {
while (n-- > 0 && cursor < totalSize) {
cursor = count-- > biggerCount ? cursor + smallerSize : cursor + biggerSize;
}
}
}
@Override
public long count() {
return count;
}
};
return Stream.of(iter);
}
/**
*
*
* final int[] a = Array.rangeClosed(1, 7);
* splitByCountSmallerFirst(5, 7, (fromIndex, toIndex) -> copyOfRange(a, fromIndex, toIndex)).forEach(Fn.println()); // [[1], [2], [3], [4, 5], [6, 7]]
* splitByCountSmallerLast(5, 7, (fromIndex, toIndex) -> copyOfRange(a, fromIndex, toIndex)).forEach(Fn.println()); // [[1, 2], [3, 4], [5], [6], [7]]
*
*
*
* @param
* @param maxCount
* @param totalSize
* @param func
* @return the stream
*/
static Stream splitByCountSmallerLast(final int maxCount, final int totalSize, final IntBiFunction func) {
checkArgPositive(maxCount, "maxCount");
checkArgNotNegative(totalSize, "totalSize");
checkArgNotNull(func, "func");
if (totalSize == 0) {
return Stream.empty();
}
final Iterator iter = new ObjIteratorEx<>() {
private final int smallerSize = Math.max(totalSize / maxCount, 1);
private final int biggerSize = totalSize % maxCount == 0 ? totalSize / maxCount : totalSize / maxCount + 1;
private int count = totalSize >= maxCount ? maxCount : totalSize;
private int smallerCount = count - totalSize % maxCount;
private int cursor = 0;
@Override
public boolean hasNext() {
return cursor < totalSize;
}
@Override
public T next() {
if (cursor >= totalSize) {
throw new NoSuchElementException();
}
return func.apply(cursor, cursor = (count-- > smallerCount ? cursor + biggerSize : cursor + smallerSize));
}
@Override
public void advance(long n) {
checkArgNotNegative(n, "n");
if (n > 0) {
while (n-- > 0 && cursor < totalSize) {
cursor = count-- > smallerCount ? cursor + biggerSize : cursor + smallerSize;
}
}
}
@Override
public long count() {
return count;
}
};
return Stream.of(iter);
}
/**
*
* @param a
* @param b
* @return
*/
public static boolean[] concat(final boolean[] a, final boolean[] b) {
if (isNullOrEmpty(a)) {
return isNullOrEmpty(b) ? EMPTY_BOOLEAN_ARRAY : b.clone();
} else if (isNullOrEmpty(b)) {
return isNullOrEmpty(a) ? EMPTY_BOOLEAN_ARRAY : a.clone();
}
final boolean[] c = new boolean[a.length + b.length];
copy(a, 0, c, 0, a.length);
copy(b, 0, c, a.length, b.length);
return c;
}
/**
*
* @param aa
* @return
*/
@SafeVarargs
public static boolean[] concat(final boolean[]... aa) {
if (isNullOrEmpty(aa)) {
return EMPTY_BOOLEAN_ARRAY;
} else if (aa.length == 1) {
return isNullOrEmpty(aa[0]) ? EMPTY_BOOLEAN_ARRAY : aa[0].clone();
}
int len = 0;
for (boolean[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
len += a.length;
}
final boolean[] c = new boolean[len];
int fromIndex = 0;
for (boolean[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
System.arraycopy(a, 0, c, fromIndex, a.length);
fromIndex += a.length;
}
return c;
}
/**
*
* @param a
* @param b
* @return
*/
public static char[] concat(final char[] a, final char[] b) {
if (isNullOrEmpty(a)) {
return isNullOrEmpty(b) ? EMPTY_CHAR_ARRAY : b.clone();
} else if (isNullOrEmpty(b)) {
return isNullOrEmpty(a) ? EMPTY_CHAR_ARRAY : a.clone();
}
final char[] c = new char[a.length + b.length];
copy(a, 0, c, 0, a.length);
copy(b, 0, c, a.length, b.length);
return c;
}
/**
*
* @param aa
* @return
*/
@SafeVarargs
public static char[] concat(final char[]... aa) {
if (isNullOrEmpty(aa)) {
return EMPTY_CHAR_ARRAY;
} else if (aa.length == 1) {
return isNullOrEmpty(aa[0]) ? EMPTY_CHAR_ARRAY : aa[0].clone();
}
int len = 0;
for (char[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
len += a.length;
}
final char[] c = new char[len];
int fromIndex = 0;
for (char[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
System.arraycopy(a, 0, c, fromIndex, a.length);
fromIndex += a.length;
}
return c;
}
/**
*
* @param a
* @param b
* @return
*/
public static byte[] concat(final byte[] a, final byte[] b) {
if (isNullOrEmpty(a)) {
return isNullOrEmpty(b) ? EMPTY_BYTE_ARRAY : b.clone();
} else if (isNullOrEmpty(b)) {
return isNullOrEmpty(a) ? EMPTY_BYTE_ARRAY : a.clone();
}
final byte[] c = new byte[a.length + b.length];
copy(a, 0, c, 0, a.length);
copy(b, 0, c, a.length, b.length);
return c;
}
/**
*
* @param aa
* @return
*/
@SafeVarargs
public static byte[] concat(final byte[]... aa) {
if (isNullOrEmpty(aa)) {
return EMPTY_BYTE_ARRAY;
} else if (aa.length == 1) {
return isNullOrEmpty(aa[0]) ? EMPTY_BYTE_ARRAY : aa[0].clone();
}
int len = 0;
for (byte[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
len += a.length;
}
final byte[] c = new byte[len];
int fromIndex = 0;
for (byte[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
System.arraycopy(a, 0, c, fromIndex, a.length);
fromIndex += a.length;
}
return c;
}
/**
*
* @param a
* @param b
* @return
*/
public static short[] concat(final short[] a, final short[] b) {
if (isNullOrEmpty(a)) {
return isNullOrEmpty(b) ? EMPTY_SHORT_ARRAY : b.clone();
} else if (isNullOrEmpty(b)) {
return isNullOrEmpty(a) ? EMPTY_SHORT_ARRAY : a.clone();
}
final short[] c = new short[a.length + b.length];
copy(a, 0, c, 0, a.length);
copy(b, 0, c, a.length, b.length);
return c;
}
/**
*
* @param aa
* @return
*/
@SafeVarargs
public static short[] concat(final short[]... aa) {
if (isNullOrEmpty(aa)) {
return EMPTY_SHORT_ARRAY;
} else if (aa.length == 1) {
return isNullOrEmpty(aa[0]) ? EMPTY_SHORT_ARRAY : aa[0].clone();
}
int len = 0;
for (short[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
len += a.length;
}
final short[] c = new short[len];
int fromIndex = 0;
for (short[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
System.arraycopy(a, 0, c, fromIndex, a.length);
fromIndex += a.length;
}
return c;
}
/**
*
* @param a
* @param b
* @return
*/
public static int[] concat(final int[] a, final int[] b) {
if (isNullOrEmpty(a)) {
return isNullOrEmpty(b) ? EMPTY_INT_ARRAY : b.clone();
} else if (isNullOrEmpty(b)) {
return isNullOrEmpty(a) ? EMPTY_INT_ARRAY : a.clone();
}
final int[] c = new int[a.length + b.length];
copy(a, 0, c, 0, a.length);
copy(b, 0, c, a.length, b.length);
return c;
}
/**
*
* @param aa
* @return
*/
@SafeVarargs
public static int[] concat(final int[]... aa) {
if (isNullOrEmpty(aa)) {
return EMPTY_INT_ARRAY;
} else if (aa.length == 1) {
return isNullOrEmpty(aa[0]) ? EMPTY_INT_ARRAY : aa[0].clone();
}
int len = 0;
for (int[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
len += a.length;
}
final int[] c = new int[len];
int fromIndex = 0;
for (int[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
System.arraycopy(a, 0, c, fromIndex, a.length);
fromIndex += a.length;
}
return c;
}
/**
*
* @param a
* @param b
* @return
*/
public static long[] concat(final long[] a, final long[] b) {
if (isNullOrEmpty(a)) {
return isNullOrEmpty(b) ? EMPTY_LONG_ARRAY : b.clone();
} else if (isNullOrEmpty(b)) {
return isNullOrEmpty(a) ? EMPTY_LONG_ARRAY : a.clone();
}
final long[] c = new long[a.length + b.length];
copy(a, 0, c, 0, a.length);
copy(b, 0, c, a.length, b.length);
return c;
}
/**
*
* @param aa
* @return
*/
@SafeVarargs
public static long[] concat(final long[]... aa) {
if (isNullOrEmpty(aa)) {
return EMPTY_LONG_ARRAY;
} else if (aa.length == 1) {
return isNullOrEmpty(aa[0]) ? EMPTY_LONG_ARRAY : aa[0].clone();
}
int len = 0;
for (long[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
len += a.length;
}
final long[] c = new long[len];
int fromIndex = 0;
for (long[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
System.arraycopy(a, 0, c, fromIndex, a.length);
fromIndex += a.length;
}
return c;
}
/**
*
* @param a
* @param b
* @return
*/
public static float[] concat(final float[] a, final float[] b) {
if (isNullOrEmpty(a)) {
return isNullOrEmpty(b) ? EMPTY_FLOAT_ARRAY : b.clone();
} else if (isNullOrEmpty(b)) {
return isNullOrEmpty(a) ? EMPTY_FLOAT_ARRAY : a.clone();
}
final float[] c = new float[a.length + b.length];
copy(a, 0, c, 0, a.length);
copy(b, 0, c, a.length, b.length);
return c;
}
/**
*
* @param aa
* @return
*/
@SafeVarargs
public static float[] concat(final float[]... aa) {
if (isNullOrEmpty(aa)) {
return EMPTY_FLOAT_ARRAY;
} else if (aa.length == 1) {
return isNullOrEmpty(aa[0]) ? EMPTY_FLOAT_ARRAY : aa[0].clone();
}
int len = 0;
for (float[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
len += a.length;
}
final float[] c = new float[len];
int fromIndex = 0;
for (float[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
System.arraycopy(a, 0, c, fromIndex, a.length);
fromIndex += a.length;
}
return c;
}
/**
*
* @param a
* @param b
* @return
*/
public static double[] concat(final double[] a, final double[] b) {
if (isNullOrEmpty(a)) {
return isNullOrEmpty(b) ? EMPTY_DOUBLE_ARRAY : b.clone();
} else if (isNullOrEmpty(b)) {
return isNullOrEmpty(a) ? EMPTY_DOUBLE_ARRAY : a.clone();
}
final double[] c = new double[a.length + b.length];
copy(a, 0, c, 0, a.length);
copy(b, 0, c, a.length, b.length);
return c;
}
/**
*
* @param aa
* @return
*/
@SafeVarargs
public static double[] concat(final double[]... aa) {
if (isNullOrEmpty(aa)) {
return EMPTY_DOUBLE_ARRAY;
} else if (aa.length == 1) {
return isNullOrEmpty(aa[0]) ? EMPTY_DOUBLE_ARRAY : aa[0].clone();
}
int len = 0;
for (double[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
len += a.length;
}
final double[] c = new double[len];
int fromIndex = 0;
for (double[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
System.arraycopy(a, 0, c, fromIndex, a.length);
fromIndex += a.length;
}
return c;
}
/**
*
* @param
* @param a
* @param b
* @return
*/
@SuppressWarnings("unchecked")
public static T[] concat(final T[] a, final T[] b) {
if (isNullOrEmpty(a)) {
return isNullOrEmpty(b) ? a : b.clone();
} else if (isNullOrEmpty(b)) {
return a.clone();
}
final T[] c = (T[]) newArray(a.getClass().getComponentType(), a.length + b.length);
copy(a, 0, c, 0, a.length);
copy(b, 0, c, a.length, b.length);
return c;
}
/**
*
* @param
* @param aa
* @return
* @throws IllegalArgumentException if the specified {@code Array} is null.
*/
@SafeVarargs
public static T[] concat(final T[]... aa) throws IllegalArgumentException {
// checkArgNotNull(aa, "aa");
if (aa == null) {
return null;
} else if (aa.length == 0) {
return newArray(aa.getClass().getComponentType().getComponentType(), 0);
} else if (aa.length == 1) {
return aa[0] == null ? newArray(aa.getClass().getComponentType().getComponentType(), 0) : aa[0].clone();
}
int len = 0;
for (T[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
len += a.length;
}
final T[] c = newArray(aa.getClass().getComponentType().getComponentType(), len);
int fromIndex = 0;
for (T[] a : aa) {
if (isNullOrEmpty(a)) {
continue;
}
System.arraycopy(a, 0, c, fromIndex, a.length);
fromIndex += a.length;
}
return c;
}
/**
*
* @param
* @param a
* @param b
* @return
*/
public static List concat(final Iterable a, final Iterable b) {
return concat(Arrays.asList(a, b));
}
/**
*
* @param
* @param a
* @return
*/
@SafeVarargs
public static List concat(final Iterable... a) {
if (isNullOrEmpty(a)) {
return new ArrayList<>();
}
return concat(Arrays.asList(a));
}
/**
*
* @param
* @param c
* @return
*/
public static List concat(final Collection> c) {
return concat(c, Factory. ofList());
}
/**
*
* @param
* @param
* @param c
* @param supplier
* @return
*/
public static > C concat(final Collection> c, final IntFunction supplier) {
if (isNullOrEmpty(c)) {
return supplier.apply(0);
}
long count = 0;
for (Iterable e : c) {
count += getSizeOrDefault(e, 0);
}
final C result = supplier.apply(Numbers.toIntExact(count));
for (Iterable e : c) {
if (e != null) {
if (e instanceof Collection) {
result.addAll((Collection) e);
} else {
for (T t : e) {
result.add(t);
}
}
}
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @return
* @see Iterators#concat(Iterator...)
*/
public static ObjIterator concat(final Iterator a, final Iterator b) {
return Iterators.concat(a, b);
}
/**
*
* @param
* @param a
* @return
* @see Iterators#concat(Iterator...)
*/
@SafeVarargs
public static ObjIterator concat(final Iterator... a) {
return Iterators.concat(a);
}
/**
*
* @param a
* @return an empty {@code boolean[]} if {@code a} is null.
*/
public static boolean[] flatten(final boolean[][] a) {
if (isNullOrEmpty(a)) {
return EMPTY_BOOLEAN_ARRAY;
}
int count = 0;
for (int i = 0, n = a.length; i < n; i++) {
count += (a[i] == null ? 0 : a[i].length);
}
final boolean[] ret = new boolean[count];
int from = 0;
for (int i = 0, n = a.length; i < n; i++) {
if (notNullOrEmpty(a[i])) {
copy(a[i], 0, ret, from, a[i].length);
from += a[i].length;
}
}
return ret;
}
/**
*
* @param a
* @return an empty {@code char[]} if {@code a} is null.
*/
public static char[] flatten(final char[][] a) {
if (isNullOrEmpty(a)) {
return EMPTY_CHAR_ARRAY;
}
int count = 0;
for (int i = 0, n = a.length; i < n; i++) {
count += (a[i] == null ? 0 : a[i].length);
}
final char[] ret = new char[count];
int from = 0;
for (int i = 0, n = a.length; i < n; i++) {
if (notNullOrEmpty(a[i])) {
copy(a[i], 0, ret, from, a[i].length);
from += a[i].length;
}
}
return ret;
}
/**
*
* @param a
* @return an empty {@code byte[]} if {@code a} is null.
*/
public static byte[] flatten(final byte[][] a) {
if (isNullOrEmpty(a)) {
return EMPTY_BYTE_ARRAY;
}
int count = 0;
for (int i = 0, n = a.length; i < n; i++) {
count += (a[i] == null ? 0 : a[i].length);
}
final byte[] ret = new byte[count];
int from = 0;
for (int i = 0, n = a.length; i < n; i++) {
if (notNullOrEmpty(a[i])) {
copy(a[i], 0, ret, from, a[i].length);
from += a[i].length;
}
}
return ret;
}
/**
*
* @param a
* @return an empty {@code short[]} if {@code a} is null.
*/
public static short[] flatten(final short[][] a) {
if (isNullOrEmpty(a)) {
return EMPTY_SHORT_ARRAY;
}
int count = 0;
for (int i = 0, n = a.length; i < n; i++) {
count += (a[i] == null ? 0 : a[i].length);
}
final short[] ret = new short[count];
int from = 0;
for (int i = 0, n = a.length; i < n; i++) {
if (notNullOrEmpty(a[i])) {
copy(a[i], 0, ret, from, a[i].length);
from += a[i].length;
}
}
return ret;
}
/**
*
* @param a
* @return an empty {@code int[]} if {@code a} is null.
*/
public static int[] flatten(final int[][] a) {
if (isNullOrEmpty(a)) {
return EMPTY_INT_ARRAY;
}
int count = 0;
for (int i = 0, n = a.length; i < n; i++) {
count += (a[i] == null ? 0 : a[i].length);
}
final int[] ret = new int[count];
int from = 0;
for (int i = 0, n = a.length; i < n; i++) {
if (notNullOrEmpty(a[i])) {
copy(a[i], 0, ret, from, a[i].length);
from += a[i].length;
}
}
return ret;
}
/**
*
* @param a
* @return an empty {@code long[]} if {@code a} is null.
*/
public static long[] flatten(final long[][] a) {
if (isNullOrEmpty(a)) {
return EMPTY_LONG_ARRAY;
}
int count = 0;
for (int i = 0, n = a.length; i < n; i++) {
count += (a[i] == null ? 0 : a[i].length);
}
final long[] ret = new long[count];
int from = 0;
for (int i = 0, n = a.length; i < n; i++) {
if (notNullOrEmpty(a[i])) {
copy(a[i], 0, ret, from, a[i].length);
from += a[i].length;
}
}
return ret;
}
/**
*
* @param a
* @return an empty {@code float[]} if {@code a} is null.
*/
public static float[] flatten(final float[][] a) {
if (isNullOrEmpty(a)) {
return EMPTY_FLOAT_ARRAY;
}
int count = 0;
for (int i = 0, n = a.length; i < n; i++) {
count += (a[i] == null ? 0 : a[i].length);
}
final float[] ret = new float[count];
int from = 0;
for (int i = 0, n = a.length; i < n; i++) {
if (notNullOrEmpty(a[i])) {
copy(a[i], 0, ret, from, a[i].length);
from += a[i].length;
}
}
return ret;
}
/**
*
* @param a
* @return an empty {@code double[]} if {@code a} is null.
*/
public static double[] flatten(final double[][] a) {
if (isNullOrEmpty(a)) {
return EMPTY_DOUBLE_ARRAY;
}
int count = 0;
for (int i = 0, n = a.length; i < n; i++) {
count += (a[i] == null ? 0 : a[i].length);
}
final double[] ret = new double[count];
int from = 0;
for (int i = 0, n = a.length; i < n; i++) {
if (notNullOrEmpty(a[i])) {
copy(a[i], 0, ret, from, a[i].length);
from += a[i].length;
}
}
return ret;
}
/**
*
* @param
* @param a
* @return {@code null} if {@code a} is null.
*/
public static T[] flatten(final T[][] a) {
if (a == null) {
return null;
}
return flatten(a, (Class) a.getClass().getComponentType().getComponentType());
}
/**
*
*
* @param
* @param a
* @param componentType
* @return an empty {@code T[]} if {@code a} is null.
*/
public static T[] flatten(final T[][] a, final Class componentType) {
if (isNullOrEmpty(a)) {
return newArray(componentType, 0);
}
int count = 0;
for (int i = 0, n = a.length; i < n; i++) {
count += (a[i] == null ? 0 : a[i].length);
}
final T[] ret = newArray(componentType, count);
int from = 0;
for (int i = 0, n = a.length; i < n; i++) {
if (notNullOrEmpty(a[i])) {
copy(a[i], 0, ret, from, a[i].length);
from += a[i].length;
}
}
return ret;
}
/**
*
* @param
* @param c
* @return
*/
public static List flatten(final Collection> c) {
return flatten(c, IntFunctions.ofList());
}
/**
*
*
* @param
* @param
* @param c
* @param supplier
* @return
*/
@SuppressWarnings("rawtypes")
public static > C flatten(final Collection> c, IntFunction supplier) {
if (isNullOrEmpty(c)) {
return supplier.apply(0);
}
int count = 0;
for (Iterable e : c) {
count += e instanceof Collection ? ((Collection) e).size() : 3; //NOSONAR
}
final C ret = supplier.apply(count);
for (Iterable e : c) {
if (e == null) {
continue; //NOSONAR
} else if (e instanceof Collection) {
ret.addAll((Collection) e);
} else {
for (T ee : e) {
ret.add(ee);
}
}
}
return ret;
}
/**
* Flatten each element if it's a {@code Iterable}, otherwise just add it to result Collection.
*
* @param iter
* @return
*/
@Beta
public static List flattenEachElement(final Iterable iter) { //NOSONAR
return flattenEachElement(iter, IntFunctions.ofList());
}
/**
* Flatten each element if it's a {@code Iterable}, otherwise just add it to result Collection.
*
*
* @param
* @param
* @param iter
* @param supplier
* @return
*/
@Beta
@SuppressWarnings("rawtypes")
public static > C flattenEachElement(final Iterable iter, final IntFunction supplier) {
if (iter == null) {
return supplier.apply(0);
}
final C result = supplier.apply(iter instanceof Collection ? ((Collection) iter).size() : 0);
flattenEachElement((Iterable