Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.tajo.util; import com.google.common.base.Function; import com.google.common.collect.Iterables; import io.netty.util.CharsetUtil; import org.apache.commons.lang.CharUtils; import org.apache.commons.lang.StringEscapeUtils; import org.apache.commons.lang.SystemUtils; import org.apache.hadoop.util.Shell; import org.apache.hadoop.util.ShutdownHookManager; import org.apache.hadoop.util.SignalLogger; import org.apache.tajo.storage.StorageConstants; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.charset.Charset; import java.nio.charset.CharsetDecoder; import java.nio.charset.CharsetEncoder; import java.nio.charset.CoderResult; import java.nio.charset.CodingErrorAction; import java.util.Arrays; import java.util.BitSet; import java.util.Iterator; public class StringUtils { /** * Priority of the StringUtils shutdown hook. */ public static final int SHUTDOWN_HOOK_PRIORITY = 0; /** * * Given the time in long milliseconds, returns a * String in the format X hrs, Y mins, S sec, M msecs * * @param timeDiff The time difference to format */ public static String formatTime(long timeDiff) { StringBuilder buf = new StringBuilder(); long hours = timeDiff / (60 * 60 * 1000); long rem = (timeDiff % (60 * 60 * 1000)); long minutes = rem / (60 * 1000); rem = rem % (60 * 1000); long seconds = rem / 1000; if (hours != 0) { buf.append(hours); buf.append(" hrs, "); } if (minutes != 0) { buf.append(minutes); buf.append(" mins, "); } if (seconds != 0) { buf.append(seconds); buf.append(" sec"); } if (timeDiff < 1000) { buf.append(timeDiff); buf.append(" msec"); } return buf.toString(); } /** * Check Seven-bit ASCII */ public static boolean isPureAscii(String v) { // get thread-safe encoder CharsetEncoder asciiEncoder = CharsetUtil.getEncoder(CharsetUtil.US_ASCII); return asciiEncoder.canEncode(v); } public static String quote(String str) { return "'" + str + "'"; } public static String doubleQuote(String str) { return "\"" + str + "\""; } public static boolean isPartOfAnsiSQLIdentifier(char character) { return isLowerCaseAlphabet(character) || isUpperCaseAlphabet(character) || isDigit(character) || isUndersscore(character); } public static boolean isUndersscore(char character) { return character == '_'; } public static boolean isLowerCaseAlphabet(char character) { return 'a' <= character && character <= 'z'; } public static boolean isUpperCaseAlphabet(char character) { return 'A' <= character && character <= 'Z'; } public static boolean isDigit(char character) { return '0' <= character && character <= '9'; } private static final String REGEX_SPECIAL_CHARACTERS = "([.*${}?|\\^\\-\\[\\]])"; public static String escapeRegexp(String literal) { return literal.replaceAll(REGEX_SPECIAL_CHARACTERS, "\\\\$1"); } private static final String LIKE_SPECIAL_CHARACTERS = "([_%])"; public static String escapeLike(String literal) { return literal.replaceAll(LIKE_SPECIAL_CHARACTERS, "\\\\$1"); } /** * Return a message for logging. * @param prefix prefix keyword for the message * @param msg content of the message * @return a message for logging */ private static String toStartupShutdownString(String prefix, String[] msg) { StringBuilder b = new StringBuilder(prefix); b.append("\n/************************************************************"); for (String s : msg) b.append("\n" + prefix + s); b.append("\n************************************************************/"); return b.toString(); } /** * Print a log message for starting up and shutting down * @param clazz the class of the server * @param args arguments * @param LOG the target log object */ public static void startupShutdownMessage(Class<?> clazz, String[] args, final org.apache.commons.logging.Log LOG) { final String hostname = org.apache.hadoop.net.NetUtils.getHostname(); final String classname = clazz.getSimpleName(); LOG.info(toStartupShutdownString("STARTUP_MSG: ", new String[] { "Starting " + classname, " host = " + hostname, " args = " + Arrays.asList(args), " version = " + org.apache.tajo.util.VersionInfo.getVersion(), " classpath = " + System.getProperty("java.class.path"), " build = " + org.apache.tajo.util.VersionInfo.getUrl() + " -r " + org.apache.tajo.util.VersionInfo.getRevision() + "; compiled by '" + org.apache.tajo.util.VersionInfo.getUser() + "' on " + org.apache.tajo.util.VersionInfo.getDate(), " java = " + System.getProperty("java.version") })); if (SystemUtils.IS_OS_UNIX) { try { SignalLogger.INSTANCE.register(LOG); } catch (Throwable t) { LOG.warn("failed to register any UNIX signal loggers: ", t); } } ShutdownHookManager.get().addShutdownHook(new Runnable() { @Override public void run() { LOG.info(toStartupShutdownString("SHUTDOWN_MSG: ", new String[] { "Shutting down " + classname + " at " + hostname })); } }, SHUTDOWN_HOOK_PRIORITY); } public static String unicodeEscapedDelimiter(String value) { try { String delimiter = StringEscapeUtils.unescapeJava(value); StringBuilder builder = new StringBuilder(); for (char achar : delimiter.toCharArray()) { builder.append(unicodeEscapedDelimiter(achar)); } return builder.toString(); } catch (Throwable e) { } return value; } public static String unicodeEscapedDelimiter(char c) { return CharUtils.unicodeEscaped(c); } /** * The following lines of code that deals with escape characters is mostly copied from HIVE's FileUtils.java */ static BitSet charToEscape = new BitSet(128); static { for (char c = 0; c < ' '; c++) { charToEscape.set(c); } /** * ASCII 01-1F are HTTP control characters that need to be escaped. * \u000A and \u000D are \n and \r, respectively. */ char[] clist = new char[] { '\u0001', '\u0002', '\u0003', '\u0004', '\u0005', '\u0006', '\u0007', '\u0008', '\u0009', '\n', '\u000B', '\u000C', '\r', '\u000E', '\u000F', '\u0010', '\u0011', '\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017', '\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D', '\u001E', '\u001F', '"', '#', '%', '\'', '*', '/', ':', '=', '?', '\\', '\u007F', '{', '[', ']', '^' }; for (char c : clist) { charToEscape.set(c); } if (Shell.WINDOWS) { // On windows, following chars need to be escaped as well char[] winClist = { ' ', '<', '>', '|' }; for (char c : winClist) { charToEscape.set(c); } } } static boolean needsEscaping(char c) { return c >= 0 && c < charToEscape.size() && charToEscape.get(c); } public static String escapePathName(String path) { return escapePathName(path, null); } /** * Escapes a path name. * @param path The path to escape. * @param defaultPath * The default name for the path, if the given path is empty or null. * @return An escaped path name. */ public static String escapePathName(String path, String defaultPath) { if (path == null || path.length() == 0) { if (defaultPath == null) { return StorageConstants.DEFAULT_PARTITION_NAME; } else { return defaultPath; } } StringBuilder sb = new StringBuilder(); for (int i = 0; i < path.length(); i++) { char c = path.charAt(i); if (needsEscaping(c)) { sb.append('%'); sb.append(String.format("%1$02X", (int) c)); } else { sb.append(c); } } return sb.toString(); } public static String unescapePathName(String path) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < path.length(); i++) { char c = path.charAt(i); if (c == '%' && i + 2 < path.length()) { int code = -1; try { code = Integer.valueOf(path.substring(i + 1, i + 3), 16); } catch (Exception e) { code = -1; } if (code >= 0) { sb.append((char) code); i += 2; continue; } } sb.append(c); } return sb.toString(); } public static char[][] padChars(char[]... bytes) { char[] startChars = bytes[0]; char[] endChars = bytes[1]; char[][] padded = new char[2][]; int max = Math.max(startChars.length, endChars.length); padded[0] = new char[max]; padded[1] = new char[max]; System.arraycopy(startChars, 0, padded[0], 0, startChars.length); for (int i = startChars.length; i < max; i++) { padded[0][i] = 0; } System.arraycopy(endChars, 0, padded[1], 0, endChars.length); for (int i = endChars.length; i < max; i++) { padded[1][i] = 0; } return padded; } public static char[] convertBytesToChars(byte[] src, Charset charset) { CharsetDecoder decoder = charset.newDecoder(); char[] resultArray = new char[(int) (src.length * decoder.maxCharsPerByte())]; if (src.length != 0) { ByteBuffer byteBuffer = ByteBuffer.wrap(src); CharBuffer charBuffer = CharBuffer.wrap(resultArray); decoder.onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE); decoder.reset(); CoderResult coderResult = decoder.decode(byteBuffer, charBuffer, true); if (coderResult.isUnderflow()) { coderResult = decoder.flush(charBuffer); if (coderResult.isUnderflow()) { if (resultArray.length != charBuffer.position()) { resultArray = Arrays.copyOf(resultArray, charBuffer.position()); } } } } return resultArray; } public static byte[] convertCharsToBytes(char[] src, Charset charset) { CharsetEncoder encoder = charset.newEncoder(); byte[] resultArray = new byte[(int) (src.length * encoder.maxBytesPerChar())]; if (src.length != 0) { CharBuffer charBuffer = CharBuffer.wrap(src); ByteBuffer byteBuffer = ByteBuffer.wrap(resultArray); encoder.onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE); encoder.reset(); CoderResult coderResult = encoder.encode(charBuffer, byteBuffer, true); if (coderResult.isUnderflow()) { coderResult = encoder.flush(byteBuffer); if (coderResult.isUnderflow()) { if (resultArray.length != byteBuffer.position()) { resultArray = Arrays.copyOf(resultArray, byteBuffer.position()); } } } } return resultArray; } /** * Concatenate all objects' string with the delimiter ", " * * @param objects Iterable objects * @return A joined string */ public static String join(Iterable objects) { return join(objects, ", "); } /** * Concatenate all objects' string with a delimiter string * * @param objects Iterable objects * @param delimiter Delimiter string * @return A joined string */ public static String join(Iterable objects, String delimiter) { return join(objects, delimiter, 0, Iterables.size(objects)); } /** * Concatenate all objects' string with a delimiter string * * @param objects object Iterable * @param delimiter Delimiter string * @param startIndex the begin index to join * @return A joined string */ public static String join(Iterable objects, String delimiter, int startIndex) { return join(objects, delimiter, startIndex, Iterables.size(objects)); } /** * Concatenate all objects' string with a delimiter string * * @param objects object Iterable * @param delimiter Delimiter string * @param startIndex the begin index to join * @param length the number of columns to be joined * @return A joined string */ public static String join(Iterable objects, String delimiter, int startIndex, int length) { return join(objects, delimiter, startIndex, length, new Function<Object, String>() { @Override public String apply(Object input) { return input.toString(); } }); } /** * Concatenate all objects' string with a delimiter string * * @param objects object Iterable * @param delimiter Delimiter string * @param f convert from a type to string * @return A joined string */ public static <T> String join(Iterable<T> objects, String delimiter, Function<T, String> f) { return join(objects, delimiter, 0, Iterables.size(objects), f); } public static <T> String join(Iterable<T> objects, String delimiter, int startIndex, int length, Function<T, String> f) { boolean first = true; StringBuilder sb = new StringBuilder(); int endIndex = startIndex + length; Iterator itr = objects.iterator(); for (int i = 0; i < endIndex; i++) { if (i < startIndex) { itr.next(); } else { if (first) { first = false; } else { sb.append(delimiter); } sb.append(f.apply((T) itr.next())); } } return sb.toString(); } /** * Concatenate all objects' string with the delimiter ", " * * @param objects Iterable objects * @return A joined string */ public static String join(Object[] objects) { return join(objects, ", "); } /** * Concatenate all objects' string with the delimiter ", " * * @param objects Iterable objects * @return A joined string */ public static String join(Object[] objects, String delimiter) { return join(objects, delimiter, 0, objects.length); } /** * Concatenate all objects' string with a delimiter string * * @param objects object array * @param delimiter Delimiter string * @param startIndex the begin index to join * @return A joined string */ public static String join(Object[] objects, String delimiter, int startIndex) { return join(objects, delimiter, startIndex, objects.length); } /** * Concatenate all objects' string with a delimiter string * * @param objects object array * @param delimiter Delimiter string * @param startIndex the begin index to join * @param length the number of columns to be joined * @return A joined string */ public static String join(Object[] objects, String delimiter, int startIndex, int length) { return join(objects, delimiter, startIndex, length, new Function<Object, String>() { @Override public String apply(Object input) { return input.toString(); } }); } /** * Concatenate all objects' string with a delimiter string * * @param objects object array * @param delimiter Delimiter string * @param f convert from a type to string * @return A joined string */ public static <T> String join(T[] objects, String delimiter, Function<T, String> f) { return join(objects, delimiter, 0, objects.length, f); } public static <T> String join(T[] objects, String delimiter, int startIndex, int length, Function<T, String> f) { boolean first = true; StringBuilder sb = new StringBuilder(); int endIndex = startIndex + length; for (int i = startIndex; i + startIndex < endIndex; i++) { if (first) { first = false; } else { sb.append(delimiter); } sb.append(f.apply(objects[i])); } return sb.toString(); } /** * <p>Checks if a String is empty ("") or null.</p> * * <pre> * StringUtils.isEmpty(null) = true * StringUtils.isEmpty("") = true * StringUtils.isEmpty(" ") = false * StringUtils.isEmpty("bob") = false * StringUtils.isEmpty(" bob ") = false * </pre> * * <p>NOTE: This method changed in Lang version 2.0. * It no longer trims the String. * That functionality is available in isBlank().</p> * * @param str the String to check, may be null * @return <code>true</code> if the String is empty or null */ public static boolean isEmpty(String str) { return str == null || str.length() == 0; } }