| /* |
| * Copyright (C) 2010 The Guava Authors |
| * |
| * 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.google.common.base; |
| |
| import static com.google.common.base.Preconditions.checkArgument; |
| import static com.google.common.base.Preconditions.checkNotNull; |
| |
| import com.google.common.annotations.GwtCompatible; |
| import com.google.common.annotations.VisibleForTesting; |
| |
| import java.util.Formatter; |
| |
| import javax.annotation.Nullable; |
| |
| /** |
| * Static utility methods pertaining to {@code String} or {@code CharSequence} |
| * instances. |
| * |
| * @author Kevin Bourrillion |
| * @since 3.0 |
| */ |
| @GwtCompatible |
| public final class Strings { |
| private Strings() {} |
| |
| /** |
| * Returns the given string if it is non-null; the empty string otherwise. |
| * |
| * @param string the string to test and possibly return |
| * @return {@code string} itself if it is non-null; {@code ""} if it is null |
| */ |
| public static String nullToEmpty(@Nullable String string) { |
| return (string == null) ? "" : string; |
| } |
| |
| /** |
| * Returns the given string if it is nonempty; {@code null} otherwise. |
| * |
| * @param string the string to test and possibly return |
| * @return {@code string} itself if it is nonempty; {@code null} if it is |
| * empty or null |
| */ |
| public static @Nullable String emptyToNull(@Nullable String string) { |
| return isNullOrEmpty(string) ? null : string; |
| } |
| |
| /** |
| * Returns {@code true} if the given string is null or is the empty string. |
| * |
| * <p>Consider normalizing your string references with {@link #nullToEmpty}. |
| * If you do, you can use {@link String#isEmpty()} instead of this |
| * method, and you won't need special null-safe forms of methods like {@link |
| * String#toUpperCase} either. Or, if you'd like to normalize "in the other |
| * direction," converting empty strings to {@code null}, you can use {@link |
| * #emptyToNull}. |
| * |
| * @param string a string reference to check |
| * @return {@code true} if the string is null or is the empty string |
| */ |
| public static boolean isNullOrEmpty(@Nullable String string) { |
| return string == null || string.length() == 0; // string.isEmpty() in Java 6 |
| } |
| |
| /** |
| * Returns a string, of length at least {@code minLength}, consisting of |
| * {@code string} prepended with as many copies of {@code padChar} as are |
| * necessary to reach that length. For example, |
| * |
| * <ul> |
| * <li>{@code padStart("7", 3, '0')} returns {@code "007"} |
| * <li>{@code padStart("2010", 3, '0')} returns {@code "2010"} |
| * </ul> |
| * |
| * <p>See {@link Formatter} for a richer set of formatting capabilities. |
| * |
| * @param string the string which should appear at the end of the result |
| * @param minLength the minimum length the resulting string must have. Can be |
| * zero or negative, in which case the input string is always returned. |
| * @param padChar the character to insert at the beginning of the result until |
| * the minimum length is reached |
| * @return the padded string |
| */ |
| public static String padStart(String string, int minLength, char padChar) { |
| checkNotNull(string); // eager for GWT. |
| if (string.length() >= minLength) { |
| return string; |
| } |
| StringBuilder sb = new StringBuilder(minLength); |
| for (int i = string.length(); i < minLength; i++) { |
| sb.append(padChar); |
| } |
| sb.append(string); |
| return sb.toString(); |
| } |
| |
| /** |
| * Returns a string, of length at least {@code minLength}, consisting of |
| * {@code string} appended with as many copies of {@code padChar} as are |
| * necessary to reach that length. For example, |
| * |
| * <ul> |
| * <li>{@code padEnd("4.", 5, '0')} returns {@code "4.000"} |
| * <li>{@code padEnd("2010", 3, '!')} returns {@code "2010"} |
| * </ul> |
| * |
| * <p>See {@link Formatter} for a richer set of formatting capabilities. |
| * |
| * @param string the string which should appear at the beginning of the result |
| * @param minLength the minimum length the resulting string must have. Can be |
| * zero or negative, in which case the input string is always returned. |
| * @param padChar the character to append to the end of the result until the |
| * minimum length is reached |
| * @return the padded string |
| */ |
| public static String padEnd(String string, int minLength, char padChar) { |
| checkNotNull(string); // eager for GWT. |
| if (string.length() >= minLength) { |
| return string; |
| } |
| StringBuilder sb = new StringBuilder(minLength); |
| sb.append(string); |
| for (int i = string.length(); i < minLength; i++) { |
| sb.append(padChar); |
| } |
| return sb.toString(); |
| } |
| |
| /** |
| * Returns a string consisting of a specific number of concatenated copies of |
| * an input string. For example, {@code repeat("hey", 3)} returns the string |
| * {@code "heyheyhey"}. |
| * |
| * @param string any non-null string |
| * @param count the number of times to repeat it; a nonnegative integer |
| * @return a string containing {@code string} repeated {@code count} times |
| * (the empty string if {@code count} is zero) |
| * @throws IllegalArgumentException if {@code count} is negative |
| */ |
| public static String repeat(String string, int count) { |
| checkNotNull(string); // eager for GWT. |
| |
| if (count <= 1) { |
| checkArgument(count >= 0, "invalid count: %s", count); |
| return (count == 0) ? "" : string; |
| } |
| |
| // IF YOU MODIFY THE CODE HERE, you must update StringsRepeatBenchmark |
| final int len = string.length(); |
| final long longSize = (long) len * (long) count; |
| final int size = (int) longSize; |
| if (size != longSize) { |
| throw new ArrayIndexOutOfBoundsException( |
| "Required array size too large: " + longSize); |
| } |
| |
| final char[] array = new char[size]; |
| string.getChars(0, len, array, 0); |
| int n; |
| for (n = len; n < size - n; n <<= 1) { |
| System.arraycopy(array, 0, array, n, n); |
| } |
| System.arraycopy(array, 0, array, n, size - n); |
| return new String(array); |
| } |
| |
| /** |
| * Returns the longest string {@code prefix} such that |
| * {@code a.toString().startsWith(prefix) && b.toString().startsWith(prefix)}, |
| * taking care not to split surrogate pairs. If {@code a} and {@code b} have |
| * no common prefix, returns the empty string. |
| * |
| * @since 11.0 |
| */ |
| public static String commonPrefix(CharSequence a, CharSequence b) { |
| checkNotNull(a); |
| checkNotNull(b); |
| |
| int maxPrefixLength = Math.min(a.length(), b.length()); |
| int p = 0; |
| while (p < maxPrefixLength && a.charAt(p) == b.charAt(p)) { |
| p++; |
| } |
| if (validSurrogatePairAt(a, p - 1) || validSurrogatePairAt(b, p - 1)) { |
| p--; |
| } |
| return a.subSequence(0, p).toString(); |
| } |
| |
| /** |
| * Returns the longest string {@code suffix} such that |
| * {@code a.toString().endsWith(suffix) && b.toString().endsWith(suffix)}, |
| * taking care not to split surrogate pairs. If {@code a} and {@code b} have |
| * no common suffix, returns the empty string. |
| * |
| * @since 11.0 |
| */ |
| public static String commonSuffix(CharSequence a, CharSequence b) { |
| checkNotNull(a); |
| checkNotNull(b); |
| |
| int maxSuffixLength = Math.min(a.length(), b.length()); |
| int s = 0; |
| while (s < maxSuffixLength |
| && a.charAt(a.length() - s - 1) == b.charAt(b.length() - s - 1)) { |
| s++; |
| } |
| if (validSurrogatePairAt(a, a.length() - s - 1) |
| || validSurrogatePairAt(b, b.length() - s - 1)) { |
| s--; |
| } |
| return a.subSequence(a.length() - s, a.length()).toString(); |
| } |
| |
| /** |
| * True when a valid surrogate pair starts at the given {@code index} in the |
| * given {@code string}. Out-of-range indexes return false. |
| */ |
| @VisibleForTesting |
| static boolean validSurrogatePairAt(CharSequence string, int index) { |
| return index >= 0 && index <= (string.length() - 2) |
| && Character.isHighSurrogate(string.charAt(index)) |
| && Character.isLowSurrogate(string.charAt(index + 1)); |
| } |
| } |