241 lines
8.0 KiB
Java
241 lines
8.0 KiB
Java
|
/*
|
||
|
|
* 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 java.util.Formatter;
|
||
|
|
|
||
|
|
import javax.annotation.Nullable;
|
||
|
|
|
||
|
|
import com.google.common.annotations.GwtCompatible;
|
||
|
|
import com.google.common.annotations.VisibleForTesting;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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));
|
||
|
|
}
|
||
|
|
}
|