Returns the char arrays as an array of Strings

@param charArrays
the char array to convert
@return the char arrays as an array of Strings or null if the given char arrays is null.
326981
public static String[] charArrayToStringArray(char[][] charArrays)
	{
		if (charArrays == null)
		{
			return null;
		}
		int length = charArrays.length;
		if (length == 0)
		{
			return NO_STRINGS;
		}
		String[] strings = new String[length];
		for (int i = 0; i < length; i++)
		{
			strings[i] = new String(charArrays[i]);
		}
		return strings;
	}
393607
protected static String getArray(List<String> paths) {
        StringBuilder builder = new StringBuilder();

        for (String s : paths) {
            if (builder.length() == 0) {
                builder.append(s);
            } else {
                builder.append(",").append(s);
            }
        }

        return builder.toString();
    }
670507
public static void normalization(char[] charArray)
    {
        assert charArray != null;
        for (int i = 0; i < charArray.length; i++)
        {
            charArray[i] = CONVERT[charArray[i]];
        }
    }
145851
public String[] toStringArray() {
	String[] result;
	result = new String[size() + 2];

	result[0] = name;
	result[1] = String.valueOf(size());
	System.arraycopy(values, 0, result, 2, size());

	return result;
    }
555700
public static String[] toArrayElement(String s) {
    return (s == null || s.length() == 0) ? new String[0] : new String[]{s};
  }
408392
public static String[] toArray(Collection<String> stringCollection) {
        return JMOptional.getOptional(stringCollection).map(Collection::size)
                .map(String[]::new).map(stringCollection::toArray)
                .orElseGet(JMArrays::getEmptyStringArray);
    }
71035
@SuppressWarnings("PMD.UseVarargs")
    public static byte[] toBytes(final char[] chars) {

        // make sure we can handle null inputs
        if (chars == null) {
            return toBytes(new char[0], Charset.defaultCharset().name());
        } else {
            return toBytes(chars, Charset.defaultCharset().name());
        }
    }
1269366
public static char[] asCharacterTypeArray(List<Character> input) {
		char[] result = new char[input.size()];

		for (int i = 0; i < result.length; i++) {
			result[i] = input.get(i);
		}

		return result;
	}
1278736
public static String[] getFormats() {

        JsArrayString tempArr = nativeGetFormats();
        if ((tempArr == null) || (tempArr.length() == 0)) {
            return null;
        }
        String[] result = new String[tempArr.length()];
        for (int i = 0; i < tempArr.length(); i++) {
            result[i] = tempArr.get(i);
        }
        return result;
    }
616146
public static int[] stringToCodePoints(final String s) {
        final int m = s.codePointCount(0, s.length());
        final int[] codePoints = new int[m];
        int j = 0;
        for (int offset = 0; offset < s.length();) {
            final int codepoint = s.codePointAt(offset);
            codePoints[j++] = codepoint;
            offset += Character.charCount(codepoint);
        }
        return codePoints;
    }
1195355
private static Iterable<String> toIterable(final String[] strings) {
        if (strings == null) {
            return null;
        }

        return Arrays.asList(strings);
    }
430371
public static function charAsciiAlphaArray()
    {
        static $result = array();

        if (!$result) {
            $result = \array_merge(
                self::charAsciiAlphaLowerArray(),
                self::charAsciiAlphaUpperArray()
            );
        }

        return $result;
    }
1319130
public static Characters of(char... chars) {
        return chars.length == 0 ? Characters.NONE : new Characters(false, chars.clone());
    }
354791
public static byte[] toBytes(char[] chars) {
        final CharBuffer charBuffer = CharBuffer.wrap(chars);
        final ByteBuffer byteBuffer = Charset.forName("UTF-8").encode(charBuffer);
        final byte[] bytes = Arrays.copyOfRange(byteBuffer.array(), byteBuffer.position(), byteBuffer.limit());
        Arrays.fill(charBuffer.array(), '\u0000'); // clear sensitive data
        Arrays.fill(byteBuffer.array(), (byte) 0); // clear sensitive data
        return bytes;
    }
612783
public JSONArray toJSONArray(JSONArray names) {
		JSONArray result = new JSONArray();
		if (names == null) {
			return null;
		}
		int length = names.length();
		if (length == 0) {
			return null;
		}
		for (int i = 0; i < length; i++) {
			String name = JSON.toString(names.opt(i));
			result.put(opt(name));
		}
		return result;
	}
387107
public R toStringArray(@Nullable Iterable<String> values) {
    return handle(Value.stringArray(values));
  }
614697
public static Character[] wrap(char... values) {
		if (null == values) {
			return null;
		}
		final int length = values.length;
		if (0 == length) {
			return new Character[0];
		}

		final Character[] array = new Character[length];
		for (int i = 0; i < length; i++) {
			array[i] = Character.valueOf(values[i]);
		}
		return array;
	}