Java tutorial
/* * Copyright (C) 2001-2003 Colin Bell * colbell@users.sourceforge.net * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ import java.util.ArrayList; import java.util.List; /** * String handling utilities. * * @author <A HREF="mailto:colbell@users.sourceforge.net">Colin Bell</A> */ public class StringUtilities { /** * Return <tt>true</tt> if the passed string is <tt>null</tt> or empty. * * @param str String to be tested. * * @return <tt>true</tt> if the passed string is <tt>null</tt> or empty. */ public static boolean isEmpty(String str) { return str == null || str.length() == 0; } /** * Return whether the 2 passed strings are equal. This function * allows for <TT>null</TT> strings. If <TT>s1</TT> and <TT>s1</TT> are * both <TT>null</TT> they are considered equal. * * @param str1 First string to check. * @param str2 Second string to check. */ public static boolean areStringsEqual(String str1, String str2) { if (str1 == null && str2 == null) { return true; } if (str1 != null) { return str1.equals(str2); } return str2.equals(str1); } /** * Clean the passed string. Replace whitespace characters with a single * space. If a <TT>null</TT> string passed return an empty string. E.G. * replace * * [pre] * \t\tselect\t* from\t\ttab01 * [/pre] * * with * * [pre] * select * from tab01 * [/pre] * * @param str String to be cleaned. * * @return Cleaned string. */ public static String cleanString(String str) { final StringBuffer buf = new StringBuffer(str.length()); char prevCh = ' '; for (int i = 0, limit = str.length(); i < limit; ++i) { char ch = str.charAt(i); if (Character.isWhitespace(ch)) { if (!Character.isWhitespace(prevCh)) { buf.append(' '); } } else { buf.append(ch); } prevCh = ch; } return buf.toString(); } /** * Return the number of occurences of a character in a string. * * @param str The string to check. * @param ch The character check for. * * @return The number of times <tt>ch</tt> occurs in <tt>str</tt>. */ public static int countOccurences(String str, int ch) { if (isEmpty(str)) { return 0; } int count = 0; int idx = -1; do { idx = str.indexOf(ch, ++idx); if (idx != -1) { ++count; } } while (idx != -1); return count; } /** * Split a string based on the given delimiter, but don't remove * empty elements. * * @param str The string to be split. * @param delimiter Split string based on this delimiter. * * @return Array of split strings. Guaranteeded to be not null. */ public static String[] split(String str, char delimiter) { return split(str, delimiter, false); } /** * Split a string based on the given delimiter, optionally removing * empty elements. * * @param str The string to be split. * @param delimiter Split string based on this delimiter. * @param removeEmpty If <tt>true</tt> then remove empty elements. * * @return Array of split strings. Guaranteeded to be not null. */ public static String[] split(String str, char delimiter, boolean removeEmpty) { // Return empty list if source string is empty. final int len = (str == null) ? 0 : str.length(); if (len == 0) { return new String[0]; } final List<String> result = new ArrayList<String>(); String elem = null; int i = 0, j = 0; while (j != -1 && j < len) { j = str.indexOf(delimiter, i); elem = (j != -1) ? str.substring(i, j) : str.substring(i); i = j + 1; if (!removeEmpty || !(elem == null || elem.length() == 0)) { result.add(elem); } } return result.toArray(new String[result.size()]); } /** * Joins the specified parts separating each from one another with the * specified delimiter. If delim is null, then this merely returns the * concatenation of all the parts. * * @param parts the strings to be joined * @param delim the char(s) that should separate the parts in the result * @return a string representing the joined parts. */ public static String join(String[] parts, String delim) { StringBuilder result = new StringBuilder(); for (int i = 0; i < parts.length; i++) { String part = parts[i]; result.append(part); if (delim != null && i < parts.length - 1) { result.append(delim); } } return result.toString(); } public static String[] segment(String source, int maxSegmentSize) { ArrayList<String> tmp = new ArrayList<String>(); if (source.length() <= maxSegmentSize) { return new String[] { source }; } boolean done = false; int currBeginIdx = 0; int currEndIdx = maxSegmentSize; while (!done) { String segment = source.substring(currBeginIdx, currEndIdx); tmp.add(segment); if (currEndIdx >= source.length()) { done = true; continue; } currBeginIdx = currEndIdx; currEndIdx += maxSegmentSize; if (currEndIdx > source.length()) { currEndIdx = source.length(); } } return tmp.toArray(new String[tmp.size()]); } public static int getTokenBeginIndex(String selectSQL, String token) { String lowerSel = selectSQL.toLowerCase(); String lowerToken = token.toLowerCase().trim(); int curPos = 0; int count = 0; while (-1 != curPos) { curPos = lowerSel.indexOf(lowerToken, curPos + lowerToken.length()); if (-1 < curPos && (0 == curPos || Character.isWhitespace(lowerSel.charAt(curPos - 1))) && (lowerSel.length() == curPos + lowerToken.length() || Character.isWhitespace(lowerSel.charAt(curPos + lowerToken.length())))) { return curPos; } // If we've loop through one time for each character in the string, // then something must be wrong. Get out! if (count++ > selectSQL.length()) { break; } } return curPos; } public static Byte[] getByteArray(byte[] bytes) { if (bytes == null || bytes.length == 0) { return new Byte[0]; } Byte[] result = new Byte[bytes.length]; for (int i = 0; i < bytes.length; i++) { result[i] = Byte.valueOf(bytes[i]); } return result; } /** * Chops off the very last character of the given string. * * @param aString a string to chop * @return the specified string minus it's last character, or null for null * or empty string for a string with length == 0|1. */ public static String chop(String aString) { if (aString == null) { return null; } if (aString.length() == 0) { return ""; } if (aString.length() == 1) { return ""; } return aString.substring(0, aString.length() - 1); } /** * Returns the platform-specific line separator, or "\n" if it is not defined for some reason. * * @return the platform-specific line separator. */ public static String getEolStr() { return System.getProperty("line.separator", "\n"); } }