Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (C) 2017 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.math.RoundingMode;
import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.annotation.SuppressFBWarnings;
/**
* @implSpec classes/interfaces implemented in abacus-extra are not for daily use case. It's not going to handle {@code null} scenarios like what handled in abacus-common. It's developer's responsibility to handle {@code null} scenarios. // TODO
*
*
*/
@Beta
public sealed class Arrays permits Arrays.f {
static final char CHAR_0 = (char) 0;
static final byte BYTE_0 = (byte) 0;
static final byte BYTE_1 = (byte) 1;
static final short SHORT_0 = (short) 0;
private static final String ARRAY_PRINT_SEPARATOR = IOUtil.LINE_SEPARATOR;
private Arrays() {
// utility class.
}
/**
*
*
* @param
* @param
* @param
* @param a
* @param func
* @param targetElementType
* @return
* @throws E the e
*/
public static R[] map(final T[] a, final Throwables.Function func, final Class targetElementType)
throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final R[] c = N.newArray(targetElementType, len);
for (int i = 0; i < len; i++) {
c[i] = func.apply(a[i]);
}
return c;
}
/**
* Map to boolean.
*
* @param
* @param
* @param a
* @param func
* @return
* @throws E the e
*/
public static boolean[] mapToBoolean(final T[] a, final Throwables.ToBooleanFunction func) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final boolean[] c = new boolean[len];
for (int i = 0; i < len; i++) {
c[i] = func.applyAsBoolean(a[i]);
}
return c;
}
/**
* Map to char.
*
* @param
* @param
* @param a
* @param func
* @return
* @throws E the e
*/
public static char[] mapToChar(final T[] a, final Throwables.ToCharFunction func) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final char[] c = new char[len];
for (int i = 0; i < len; i++) {
c[i] = func.applyAsChar(a[i]);
}
return c;
}
/**
* Map to byte.
*
* @param
* @param
* @param a
* @param func
* @return
* @throws E the e
*/
public static byte[] mapToByte(final T[] a, final Throwables.ToByteFunction func) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final byte[] c = new byte[len];
for (int i = 0; i < len; i++) {
c[i] = func.applyAsByte(a[i]);
}
return c;
}
/**
* Map to short.
*
* @param
* @param
* @param a
* @param func
* @return
* @throws E the e
*/
public static short[] mapToShort(final T[] a, final Throwables.ToShortFunction func) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final short[] c = new short[len];
for (int i = 0; i < len; i++) {
c[i] = func.applyAsShort(a[i]);
}
return c;
}
/**
* Map to int.
*
* @param
* @param
* @param a
* @param func
* @return
* @throws E the e
*/
public static int[] mapToInt(final T[] a, final Throwables.ToIntFunction func) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final int[] c = new int[len];
for (int i = 0; i < len; i++) {
c[i] = func.applyAsInt(a[i]);
}
return c;
}
/**
* Map to long.
*
* @param
* @param
* @param a
* @param func
* @return
* @throws E the e
*/
public static long[] mapToLong(final T[] a, final Throwables.ToLongFunction func) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final long[] c = new long[len];
for (int i = 0; i < len; i++) {
c[i] = func.applyAsLong(a[i]);
}
return c;
}
/**
* Map to float.
*
* @param
* @param
* @param a
* @param func
* @return
* @throws E the e
*/
public static float[] mapToFloat(final T[] a, final Throwables.ToFloatFunction func) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final float[] c = new float[len];
for (int i = 0; i < len; i++) {
c[i] = func.applyAsFloat(a[i]);
}
return c;
}
/**
* Map to double.
*
* @param
* @param
* @param a
* @param func
* @return
* @throws E the e
*/
public static double[] mapToDouble(final T[] a, final Throwables.ToDoubleFunction func) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final double[] c = new double[len];
for (int i = 0; i < len; i++) {
c[i] = func.applyAsDouble(a[i]);
}
return c;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[] mapToObj(final boolean[] a, final Throwables.BooleanFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[] result = N.newArray(targetElementType, len);
for (int i = 0; i < len; i++) {
result[i] = mapper.apply(a[i]);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][] mapToObj(final boolean[][] a, final Throwables.BooleanFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][] result = N.newArray(N.newArray(targetElementType, 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][][] mapToObj(final boolean[][][] a, final Throwables.BooleanFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][][] result = N.newArray(N.newArray(N.newArray(targetElementType, 0).getClass(), 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[] mapToObj(final char[] a, final Throwables.CharFunction mapper, final Class targetElementType)
throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[] result = N.newArray(targetElementType, len);
for (int i = 0; i < len; i++) {
result[i] = mapper.apply(a[i]);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][] mapToObj(final char[][] a, final Throwables.CharFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][] result = N.newArray(N.newArray(targetElementType, 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][][] mapToObj(final char[][][] a, final Throwables.CharFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][][] result = N.newArray(N.newArray(N.newArray(targetElementType, 0).getClass(), 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[] mapToObj(final byte[] a, final Throwables.ByteFunction mapper, final Class targetElementType)
throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[] result = N.newArray(targetElementType, len);
for (int i = 0; i < len; i++) {
result[i] = mapper.apply(a[i]);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][] mapToObj(final byte[][] a, final Throwables.ByteFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][] result = N.newArray(N.newArray(targetElementType, 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][][] mapToObj(final byte[][][] a, final Throwables.ByteFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][][] result = N.newArray(N.newArray(N.newArray(targetElementType, 0).getClass(), 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[] mapToObj(final short[] a, final Throwables.ShortFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[] result = N.newArray(targetElementType, len);
for (int i = 0; i < len; i++) {
result[i] = mapper.apply(a[i]);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][] mapToObj(final short[][] a, final Throwables.ShortFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][] result = N.newArray(N.newArray(targetElementType, 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][][] mapToObj(final short[][][] a, final Throwables.ShortFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][][] result = N.newArray(N.newArray(N.newArray(targetElementType, 0).getClass(), 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[] mapToObj(final int[] a, final Throwables.IntFunction mapper, final Class targetElementType)
throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[] result = N.newArray(targetElementType, len);
for (int i = 0; i < len; i++) {
result[i] = mapper.apply(a[i]);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][] mapToObj(final int[][] a, final Throwables.IntFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][] result = N.newArray(N.newArray(targetElementType, 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][][] mapToObj(final int[][][] a, final Throwables.IntFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][][] result = N.newArray(N.newArray(N.newArray(targetElementType, 0).getClass(), 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[] mapToObj(final long[] a, final Throwables.LongFunction mapper, final Class targetElementType)
throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[] result = N.newArray(targetElementType, len);
for (int i = 0; i < len; i++) {
result[i] = mapper.apply(a[i]);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][] mapToObj(final long[][] a, final Throwables.LongFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][] result = N.newArray(N.newArray(targetElementType, 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][][] mapToObj(final long[][][] a, final Throwables.LongFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][][] result = N.newArray(N.newArray(N.newArray(targetElementType, 0).getClass(), 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[] mapToObj(final float[] a, final Throwables.FloatFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[] result = N.newArray(targetElementType, len);
for (int i = 0; i < len; i++) {
result[i] = mapper.apply(a[i]);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][] mapToObj(final float[][] a, final Throwables.FloatFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][] result = N.newArray(N.newArray(targetElementType, 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][][] mapToObj(final float[][][] a, final Throwables.FloatFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][][] result = N.newArray(N.newArray(N.newArray(targetElementType, 0).getClass(), 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[] mapToObj(final double[] a, final Throwables.DoubleFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[] result = N.newArray(targetElementType, len);
for (int i = 0; i < len; i++) {
result[i] = mapper.apply(a[i]);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][] mapToObj(final double[][] a, final Throwables.DoubleFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][] result = N.newArray(N.newArray(targetElementType, 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
* Map to obj.
*
* @param
* @param
* @param a
* @param mapper
* @param targetElementType
* @return
* @throws E the e
*/
public static T[][][] mapToObj(final double[][][] a, final Throwables.DoubleFunction mapper,
final Class targetElementType) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final T[][][] result = N.newArray(N.newArray(N.newArray(targetElementType, 0).getClass(), 0).getClass(), len);
for (int i = 0; i < len; i++) {
result[i] = mapToObj(a[i], mapper, targetElementType);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static long[] mapToLong(final int[] a, final Throwables.IntToLongFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final long[] result = new long[len];
for (int i = 0; i < len; i++) {
result[i] = mapper.applyAsLong(a[i]);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static long[][] mapToLong(final int[][] a, final Throwables.IntToLongFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final long[][] result = new long[len][];
for (int i = 0; i < len; i++) {
result[i] = mapToLong(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static long[][][] mapToLong(final int[][][] a, final Throwables.IntToLongFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final long[][][] result = new long[len][][];
for (int i = 0; i < len; i++) {
result[i] = mapToLong(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static double[] mapToDouble(final int[] a, final Throwables.IntToDoubleFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final double[] result = new double[len];
for (int i = 0; i < len; i++) {
result[i] = mapper.applyAsDouble(a[i]);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static double[][] mapToDouble(final int[][] a, final Throwables.IntToDoubleFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final double[][] result = new double[len][];
for (int i = 0; i < len; i++) {
result[i] = mapToDouble(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static double[][][] mapToDouble(final int[][][] a, final Throwables.IntToDoubleFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final double[][][] result = new double[len][][];
for (int i = 0; i < len; i++) {
result[i] = mapToDouble(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static int[] mapToInt(final long[] a, final Throwables.LongToIntFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final int[] result = new int[len];
for (int i = 0; i < len; i++) {
result[i] = mapper.applyAsInt(a[i]);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static int[][] mapToInt(final long[][] a, final Throwables.LongToIntFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final int[][] result = new int[len][];
for (int i = 0; i < len; i++) {
result[i] = mapToInt(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static int[][][] mapToInt(final long[][][] a, final Throwables.LongToIntFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final int[][][] result = new int[len][][];
for (int i = 0; i < len; i++) {
result[i] = mapToInt(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static double[] mapToDouble(final long[] a, final Throwables.LongToDoubleFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final double[] result = new double[len];
for (int i = 0; i < len; i++) {
result[i] = mapper.applyAsDouble(a[i]);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static double[][] mapToDouble(final long[][] a, final Throwables.LongToDoubleFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final double[][] result = new double[len][];
for (int i = 0; i < len; i++) {
result[i] = mapToDouble(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static double[][][] mapToDouble(final long[][][] a, final Throwables.LongToDoubleFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final double[][][] result = new double[len][][];
for (int i = 0; i < len; i++) {
result[i] = mapToDouble(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static int[] mapToInt(final double[] a, final Throwables.DoubleToIntFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final int[] result = new int[len];
for (int i = 0; i < len; i++) {
result[i] = mapper.applyAsInt(a[i]);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static int[][] mapToInt(final double[][] a, final Throwables.DoubleToIntFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final int[][] result = new int[len][];
for (int i = 0; i < len; i++) {
result[i] = mapToInt(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static int[][][] mapToInt(final double[][][] a, final Throwables.DoubleToIntFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final int[][][] result = new int[len][][];
for (int i = 0; i < len; i++) {
result[i] = mapToInt(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static long[] mapToLong(final double[] a, final Throwables.DoubleToLongFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final long[] result = new long[len];
for (int i = 0; i < len; i++) {
result[i] = mapper.applyAsLong(a[i]);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static long[][] mapToLong(final double[][] a, final Throwables.DoubleToLongFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final long[][] result = new long[len][];
for (int i = 0; i < len; i++) {
result[i] = mapToLong(a[i], mapper);
}
return result;
}
/**
*
* @param
* @param a
* @param mapper
* @return
* @throws E the e
*/
public static long[][][] mapToLong(final double[][][] a, final Throwables.DoubleToLongFunction mapper) throws E {
if (a == null) {
return null; // NOSONAR
}
final int len = N.len(a);
final long[][][] result = new long[len][][];
for (int i = 0; i < len; i++) {
result[i] = mapToLong(a[i], mapper);
}
return result;
}
/**
*
* @param a
* @return
*/
public static String println(final Object[] a) {
if (a == null) {
return N.println("null");
} else if (a.length == 0) {
return N.println("[]");
} else {
return N.println(N.toString(a));
}
}
/**
*
* @param a
* @return
*/
public static String println(final Object[][] a) {
return ff.println(a);
}
/**
*
* @param a
* @return
*/
public static String println(final Object[][][] a) {
return fff.println(a);
}
/**
*
* @param
* @param a
* @param operator
* @throws E the e
*/
public static void updateAll(final boolean[] a, final Throwables.BooleanUnaryOperator operator) throws E {
if (N.isEmpty(a)) {
return;
}
for (int i = 0, n = a.length; i < n; i++) {
a[i] = operator.applyAsBoolean(a[i]);
}
}
/**
*
* @param
* @param a
* @param operator
* @throws E the e
*/
public static void updateAll(final boolean[][] a, final Throwables.BooleanUnaryOperator operator) throws E {
if (N.isEmpty(a)) {
return;
}
for (final boolean[] element : a) {
updateAll(element, operator);
}
}
/**
*
* @param
* @param a
* @param operator
* @throws E the e
*/
public static void updateAll(final boolean[][][] a, final Throwables.BooleanUnaryOperator operator) throws E {
if (N.isEmpty(a)) {
return;
}
for (final boolean[][] element : a) {
updateAll(element, operator);
}
}
/**
*
* @param
* @param a
* @param predicate
* @param newValue
* @throws E the e
*/
public static void replaceIf(final boolean[] a, final Throwables.BooleanPredicate predicate, final boolean newValue) throws E {
if (N.isEmpty(a)) {
return;
}
for (int i = 0, n = a.length; i < n; i++) {
if (predicate.test(a[i])) {
a[i] = newValue;
}
}
}
/**
*
* @param
* @param a
* @param predicate
* @param newValue
* @throws E the e
*/
public static void replaceIf(final boolean[][] a, final Throwables.BooleanPredicate predicate, final boolean newValue) throws E {
if (N.isEmpty(a)) {
return;
}
for (final boolean[] element : a) {
replaceIf(element, predicate, newValue);
}
}
/**
*
* @param
* @param a
* @param predicate
* @param newValue
* @throws E the e
*/
public static void replaceIf(final boolean[][][] a, final Throwables.BooleanPredicate predicate, final boolean newValue) throws E {
if (N.isEmpty(a)) {
return;
}
for (final boolean[][] element : a) {
replaceIf(element, predicate, newValue);
}
}
/**
* Reshapes a one-dimensional boolean array into a two-dimensional boolean array with the specified number of columns.
*
* @param a the one-dimensional boolean array to reshape
* @param cols the number of columns for the reshaped array
* @return a two-dimensional boolean array with the specified number of columns
* @throws IllegalArgumentException if the number of columns is less than or equal to zero
*/
public static boolean[][] reshape(final boolean[] a, final int cols) throws IllegalArgumentException {
checkMForReshape(cols);
if (N.isEmpty(a)) {
return new boolean[0][0];
}
final int len = a.length;
final int n = Numbers.divide(len, cols, RoundingMode.CEILING);
final boolean[][] c = new boolean[n][];
for (int i = 0, from = 0; i < n; i++, from += cols) {
c[i] = N.copyOfRange(a, from, from + N.min(len - from, cols));
}
return c;
}
/**
* Reshapes a one-dimensional boolean array into a three-dimensional boolean array with the specified number of rows and columns.
*
* @param a the one-dimensional boolean array to reshape
* @param rows the number of rows for the reshaped sub-array
* @param cols the number of columns for the reshaped sub-array
* @return a three-dimensional boolean array with the specified number of rows and columns
* @throws IllegalArgumentException if the number of rows or columns is less than or equal to zero
*/
public static boolean[][][] reshape(final boolean[] a, final int rows, final int cols) throws IllegalArgumentException {
checkMAndLForReshape(rows, cols);
if (N.isEmpty(a)) {
return new boolean[0][0][0];
}
final int len = a.length;
final int n = Numbers.divide(len, rows * cols, RoundingMode.CEILING);
final boolean[][][] c = new boolean[n][][];
for (int i = 0, from = 0; i < n; i++) {
c[i] = new boolean[N.min(rows, Numbers.divide(len - from, cols, RoundingMode.CEILING))][];
for (int j = 0, y = c[i].length; j < y; j++, from += cols) {
c[i][j] = N.copyOfRange(a, from, from + N.min(len - from, cols));
}
}
return c;
}
/**
*
* @param a
* @return
*/
public static boolean[] flatten(final boolean[][] a) {
if (N.isEmpty(a)) {
return N.EMPTY_BOOLEAN_ARRAY;
}
final int count = Numbers.toIntExact(totalCountOfElements(a));
final boolean[] c = new boolean[count];
int from = 0;
for (final boolean[] element : a) {
if (N.isEmpty(element)) {
continue;
}
N.copy(element, 0, c, from, element.length);
from += element.length;
}
return c;
}
/**
*
* @param a
* @return
*/
public static boolean[] flatten(final boolean[][][] a) {
if (N.isEmpty(a)) {
return N.EMPTY_BOOLEAN_ARRAY;
}
final int count = Numbers.toIntExact(totalCountOfElements(a));
final boolean[] c = new boolean[count];
int from = 0;
for (final boolean[][] element : a) {
if (N.isEmpty(element)) {
continue;
}
for (final boolean[] booleans : element) {
if (N.isEmpty(booleans)) {
continue;
}
N.copy(booleans, 0, c, from, booleans.length);
from += booleans.length;
}
}
return c;
}
/**
* flatten -> execute {@code op} -> set values back.
*
*
* f.flatOp(a, t -> N.sort(t));
*
*
*
* @param
* @param a
* @param op
* @throws E the e
*/
public static void flatOp(final boolean[][] a, final Throwables.Consumer op) throws E {
if (N.isEmpty(a)) {
return;
}
final boolean[] tmp = flatten(a);
op.accept(tmp);
int idx = 0;
for (final boolean[] e : a) {
if (N.notEmpty(e)) {
N.copy(tmp, idx, e, 0, e.length);
idx += e.length;
}
}
}
/**
* flatten -> execute {@code op} -> set values back.
*
*
* f.flatOp(a, t -> N.sort(t));
*
*
*
* @param
* @param a
* @param op
* @throws E the e
*/
public static void flatOp(final boolean[][][] a, final Throwables.Consumer op) throws E {
if (N.isEmpty(a)) {
return;
}
final boolean[] tmp = flatten(a);
op.accept(tmp);
int idx = 0;
for (final boolean[][] e : a) {
if (N.notEmpty(e)) {
for (final boolean[] ee : e) {
if (N.notEmpty(ee)) {
N.copy(tmp, idx, ee, 0, ee.length);
idx += ee.length;
}
}
}
}
}
/**
*
* @param
* @param a
* @param b
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[] zip(final boolean[] a, final boolean[] b, final Throwables.BooleanBiFunction zipFunction)
throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final boolean[] result = new boolean[N.min(lenA, lenB)];
for (int i = 0, len = result.length; i < len; i++) {
result[i] = zipFunction.apply(a[i], b[i]);
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param valueForNoneA
* @param valueForNoneB
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[] zip(final boolean[] a, final boolean[] b, final boolean valueForNoneA, final boolean valueForNoneB,
final Throwables.BooleanBiFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
return zip(N.max(lenA, lenB), a, b, valueForNoneA, valueForNoneB, zipFunction);
}
/**
*
* @param
* @param len
* @param a
* @param b
* @param valueForNoneA
* @param valueForNoneB
* @param zipFunction
* @return
* @throws E the e
*/
private static boolean[] zip(final int len, final boolean[] a, final boolean[] b, final boolean valueForNoneA,
final boolean valueForNoneB, final Throwables.BooleanBiFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final boolean[] result = new boolean[len];
for (int i = 0, min = N.min(lenA, lenB, len); i < min; i++) {
result[i] = zipFunction.apply(a[i], b[i]);
}
if (lenA < lenB && lenA < len) {
for (int i = lenA, min = N.min(lenB, len); i < min; i++) {
result[i] = zipFunction.apply(valueForNoneA, b[i]);
}
} else if (lenB < lenA && lenB < len) {
for (int i = lenB, min = N.min(lenA, len); i < min; i++) {
result[i] = zipFunction.apply(a[i], valueForNoneB);
}
}
if (N.max(lenA, lenB) < len) {
for (int i = N.max(lenA, lenB); i < len; i++) {
result[i] = zipFunction.apply(valueForNoneA, valueForNoneB);
}
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param c
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[] zip(final boolean[] a, final boolean[] b, final boolean[] c,
final Throwables.BooleanTriFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final int lenC = N.len(c);
final boolean[] result = new boolean[N.min(lenA, lenB, lenC)];
for (int i = 0, len = result.length; i < len; i++) {
result[i] = zipFunction.apply(a[i], b[i], c[i]);
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param c
* @param valueForNoneA
* @param valueForNoneB
* @param valueForNoneC
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[] zip(final boolean[] a, final boolean[] b, final boolean[] c, final boolean valueForNoneA,
final boolean valueForNoneB, final boolean valueForNoneC, final Throwables.BooleanTriFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final int lenC = N.len(c);
return zip(N.max(lenA, lenB, lenC), a, b, c, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction);
}
/**
*
* @param
* @param len
* @param a
* @param b
* @param c
* @param valueForNoneA
* @param valueForNoneB
* @param valueForNoneC
* @param zipFunction
* @return
* @throws E the e
*/
private static boolean[] zip(final int len, final boolean[] a, final boolean[] b, final boolean[] c, final boolean valueForNoneA,
final boolean valueForNoneB, final boolean valueForNoneC, final Throwables.BooleanTriFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final int lenC = N.len(c);
final boolean[] result = new boolean[len];
for (int i = 0, min = N.min(lenA, lenB, lenC, len); i < min; i++) {
result[i] = zipFunction.apply(a[i], b[i], c[i]);
}
if (N.min(lenA, lenB, lenC) < len) {
for (int i = N.min(lenA, lenB, lenC); i < len; i++) {
result[i] = zipFunction.apply(i < lenA ? a[i] : valueForNoneA, i < lenB ? b[i] : valueForNoneB, i < lenC ? c[i] : valueForNoneC);
}
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[][] zip(final boolean[][] a, final boolean[][] b, final Throwables.BooleanBiFunction zipFunction)
throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final boolean[][] result = new boolean[N.min(lenA, lenB)][];
for (int i = 0, len = result.length; i < len; i++) {
result[i] = zip(a[i], b[i], zipFunction);
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param valueForNoneA
* @param valueForNoneB
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[][] zip(final boolean[][] a, final boolean[][] b, final boolean valueForNoneA, final boolean valueForNoneB,
final Throwables.BooleanBiFunction zipFunction) throws E {
return zip(N.max(N.len(a), N.len(b)), N.max(maxSubArrayLen(a), maxSubArrayLen(b)), a, b, valueForNoneA, valueForNoneB, zipFunction);
}
/**
*
* @param
* @param len
* @param rowLen
* @param a
* @param b
* @param valueForNoneA
* @param valueForNoneB
* @param zipFunction
* @return
* @throws E the e
*/
private static boolean[][] zip(final int len, final int rowLen, final boolean[][] a, final boolean[][] b, final boolean valueForNoneA,
final boolean valueForNoneB, final Throwables.BooleanBiFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final boolean[][] result = new boolean[len][];
for (int i = 0, min = N.min(lenA, lenB, len); i < min; i++) {
result[i] = zip(rowLen, a[i], b[i], valueForNoneA, valueForNoneB, zipFunction);
}
if (lenA < lenB && lenA < len) {
for (int i = lenA, min = N.min(lenB, len); i < min; i++) {
result[i] = zip(rowLen, null, b[i], valueForNoneA, valueForNoneB, zipFunction);
}
} else if (lenB < lenA && lenB < len) {
for (int i = lenB, min = N.min(lenA, len); i < min; i++) {
result[i] = zip(rowLen, a[i], null, valueForNoneA, valueForNoneB, zipFunction);
}
}
if (N.max(lenA, lenB) < len) {
for (int i = N.max(lenA, lenB); i < len; i++) {
result[i] = zip(rowLen, null, null, valueForNoneA, valueForNoneB, zipFunction);
}
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param c
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[][] zip(final boolean[][] a, final boolean[][] b, final boolean[][] c,
final Throwables.BooleanTriFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final int lenC = N.len(c);
final boolean[][] result = new boolean[N.min(lenA, lenB, lenC)][];
for (int i = 0, len = result.length; i < len; i++) {
result[i] = zip(a[i], b[i], c[i], zipFunction);
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param c
* @param valueForNoneA
* @param valueForNoneB
* @param valueForNoneC
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[][] zip(final boolean[][] a, final boolean[][] b, final boolean[][] c, final boolean valueForNoneA,
final boolean valueForNoneB, final boolean valueForNoneC, final Throwables.BooleanTriFunction zipFunction) throws E {
return zip(N.max(N.len(a), N.len(b), N.len(c)), N.max(maxSubArrayLen(a), maxSubArrayLen(b), maxSubArrayLen(c)), a, b, c, valueForNoneA, valueForNoneB,
valueForNoneC, zipFunction);
}
/**
*
* @param
* @param len
* @param rowLen
* @param a
* @param b
* @param c
* @param valueForNoneA
* @param valueForNoneB
* @param valueForNoneC
* @param zipFunction
* @return
* @throws E the e
*/
private static boolean[][] zip(final int len, final int rowLen, final boolean[][] a, final boolean[][] b, final boolean[][] c,
final boolean valueForNoneA, final boolean valueForNoneB, final boolean valueForNoneC, final Throwables.BooleanTriFunction zipFunction)
throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final int lenC = N.len(c);
final boolean[][] result = new boolean[len][];
for (int i = 0, min = N.min(lenA, lenB, lenC, len); i < min; i++) {
result[i] = zip(rowLen, a[i], b[i], c[i], valueForNoneA, valueForNoneB, valueForNoneC, zipFunction);
}
if (N.min(lenA, lenB, lenC) < len) {
for (int i = N.min(lenA, lenB, lenC); i < len; i++) {
result[i] = zip(rowLen, i < lenA ? a[i] : null, i < lenB ? b[i] : null, i < lenC ? c[i] : null, valueForNoneA, valueForNoneB, valueForNoneC,
zipFunction);
}
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[][][] zip(final boolean[][][] a, final boolean[][][] b,
final Throwables.BooleanBiFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final boolean[][][] result = new boolean[N.min(lenA, lenB)][][];
for (int i = 0, len = result.length; i < len; i++) {
result[i] = zip(a[i], b[i], zipFunction);
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param valueForNoneA
* @param valueForNoneB
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[][][] zip(final boolean[][][] a, final boolean[][][] b, final boolean valueForNoneA,
final boolean valueForNoneB, final Throwables.BooleanBiFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final boolean[][][] result = new boolean[N.max(lenA, lenB)][][];
for (int i = 0, min = N.min(lenA, lenB); i < min; i++) {
result[i] = zip(a[i], b[i], valueForNoneA, valueForNoneB, zipFunction);
}
if (lenA < lenB) {
for (int i = lenA; i < lenB; i++) {
result[i] = zip(null, b[i], valueForNoneA, valueForNoneB, zipFunction);
}
} else if (lenB < lenA) {
for (int i = lenB; i < lenA; i++) {
result[i] = zip(a[i], null, valueForNoneA, valueForNoneB, zipFunction);
}
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param c
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[][][] zip(final boolean[][][] a, final boolean[][][] b, final boolean[][][] c,
final Throwables.BooleanTriFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final int lenC = N.len(c);
final boolean[][][] result = new boolean[N.min(lenA, lenB, lenC)][][];
for (int i = 0, len = result.length; i < len; i++) {
result[i] = zip(a[i], b[i], c[i], zipFunction);
}
return result;
}
/**
*
* @param
* @param a
* @param b
* @param c
* @param valueForNoneA
* @param valueForNoneB
* @param valueForNoneC
* @param zipFunction
* @return
* @throws E the e
*/
public static boolean[][][] zip(final boolean[][][] a, final boolean[][][] b, final boolean[][][] c, final boolean valueForNoneA,
final boolean valueForNoneB, final boolean valueForNoneC, final Throwables.BooleanTriFunction zipFunction) throws E {
final int lenA = N.len(a);
final int lenB = N.len(b);
final int lenC = N.len(c);
final boolean[][][] result = new boolean[N.max(lenA, lenB, lenC)][][];
for (int i = 0, min = N.min(lenA, lenB, lenC); i < min; i++) {
result[i] = zip(a[i], b[i], c[i], valueForNoneA, valueForNoneB, valueForNoneC, zipFunction);
}
for (int i = N.min(lenA, lenB, lenC), len = result.length; i < len; i++) {
result[i] = zip(i < lenA ? a[i] : null, i < lenB ? b[i] : null, i < lenC ? c[i] : null, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction);
}
return result;
}
public static long totalCountOfElements(final boolean[][] a) {
long count = 0;
for (final boolean[] element : a) {
count += (element == null ? 0 : element.length);
}
return count;
}
public static long totalCountOfElements(final boolean[][][] a) {
long count = 0;
for (final boolean[][] element : a) {
if (N.isEmpty(element)) {
continue;
}
for (final boolean[] booleans : element) {
if (N.isEmpty(booleans)) {
continue;
}
count += booleans.length;
}
}
return count;
}
/**
* Min sub array len.
*
* @param a
* @return
*/
public static int minSubArrayLen(final boolean[][] a) {
if (N.isEmpty(a)) {
return 0;
}
int minLen = Integer.MAX_VALUE;
for (final boolean[] ae : a) {
minLen = N.min(minLen, ae == null ? 0 : ae.length);
}
return minLen;
}
/**
* Max sub array len.
*
* @param a
* @return
*/
public static int maxSubArrayLen(final boolean[][] a) {
if (N.isEmpty(a)) {
return 0;
}
int maxLen = 0;
for (final boolean[] ae : a) {
maxLen = N.max(maxLen, ae == null ? 0 : ae.length);
}
return maxLen;
}
/**
*
* @param a
* @return
*/
public static String println(final boolean[] a) {
if (a == null) {
return N.println("null");
} else if (a.length == 0) {
return N.println("[]");
} else {
return N.println(N.toString(a));
}
}
/**
*
* @param a
*/
public static String println(final boolean[][] a) {
if (a == null) {
return N.println("null");
} else if (a.length == 0) {
return N.println("[]");
} else {
final int len = a.length;
final StringBuilder sb = Objectory.createStringBuilder();
String str = null;
try {
sb.append('[');
for (int i = 0; i < len; i++) {
if (i > 0) {
sb.append(',').append(ARRAY_PRINT_SEPARATOR).append(' ');
}
if (a[i] == null) {
sb.append("null");
} else if (a[i].length == 0) {
sb.append("[]");
} else {
final boolean[] ai = a[i];
sb.append('[');
for (int j = 0, aiLen = ai.length; j < aiLen; j++) {
if (j > 0) {
sb.append(", ");
}
sb.append(ai[j]);
}
sb.append(']');
}
}
sb.append(']');
str = sb.toString();
} finally {
Objectory.recycle(sb);
}
return N.println(str);
}
}
/**
*
* @param a
* @return
*/
public static String println(final boolean[][][] a) {
if (a == null) {
return N.println("null");
} else if (a.length == 0) {
return N.println("[]");
} else {
final int len = a.length;
final StringBuilder sb = Objectory.createStringBuilder();
String str = null;
try {
sb.append('[');
for (int i = 0; i < len; i++) {
if (i > 0) {
sb.append(',').append(ARRAY_PRINT_SEPARATOR).append(' ');
}
if (a[i] == null) {
sb.append("null");
} else if (a[i].length == 0) {
sb.append("[]");
} else {
final boolean[][] ai = a[i];
sb.append('[');
for (int j = 0, aiLen = ai.length; j < aiLen; j++) {
if (j > 0) {
sb.append(',').append(IOUtil.LINE_SEPARATOR).append(" ");
}
if (ai[j] == null) {
sb.append("null");
} else if (ai[j].length == 0) {
sb.append("[]");
} else {
final boolean[] aij = ai[j];
sb.append('[');
for (int k = 0, aijLen = aij.length; k < aijLen; k++) {
if (k > 0) {
sb.append(", ");
}
sb.append(aij[k]);
}
sb.append(']');
}
}
sb.append(']');
}
}
sb.append(']');
str = sb.toString();
} finally {
Objectory.recycle(sb);
}
N.println(str);
return str;
}
}
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[], Throwables.CharUnaryOperator)
// */
// public static void plus(final char[] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (int i = 0, n = a.length; i < n; i++) {
// a[i] += param;
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[][], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[][], Throwables.CharUnaryOperator)
// */
// public static void plus(final char[][] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (final char[] element : a) {
// plus(element, param);
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[][][], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[][][], Throwables.CharUnaryOperator)
// */
// public static void plus(final char[][][] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (final char[][] element : a) {
// plus(element, param);
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[], Throwables.CharUnaryOperator)
// */
// public static void minus(final char[] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (int i = 0, n = a.length; i < n; i++) {
// a[i] -= param;
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[][], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[][], Throwables.CharUnaryOperator)
// */
// public static void minus(final char[][] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (final char[] element : a) {
// minus(element, param);
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[][][], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[][][], Throwables.CharUnaryOperator)
// */
// public static void minus(final char[][][] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (final char[][] element : a) {
// minus(element, param);
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[], Throwables.CharUnaryOperator)
// */
// public static void multipliedBy(final char[] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (int i = 0, n = a.length; i < n; i++) {
// a[i] *= param;
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[][], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[][], Throwables.CharUnaryOperator)
// */
// public static void multipliedBy(final char[][] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (final char[] element : a) {
// multipliedBy(element, param);
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[][][], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[][][], Throwables.CharUnaryOperator)
// */
// public static void multipliedBy(final char[][][] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (final char[][] element : a) {
// multipliedBy(element, param);
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[], Throwables.CharUnaryOperator)
// */
// public static void dividedBy(final char[] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (int i = 0, n = a.length; i < n; i++) {
// a[i] /= param;
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[][], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[][], Throwables.CharUnaryOperator)
// */
// public static void dividedBy(final char[][] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (final char[] element : a) {
// dividedBy(element, param);
// }
// }
//
// /**
// *
// * @param a
// * @param param
// * @deprecated replaced by {@link #replaceAll(char[][][], Throwables.CharUnaryOperator)}
// * @see #replaceAll(char[][][], Throwables.CharUnaryOperator)
// */
// public static void dividedBy(final char[][][] a, final int param) {
// if (N.isEmpty(a)) {
// return;
// }
//
// for (final char[][] element : a) {
// dividedBy(element, param);
// }
// }
/**
*
* @param
