001 /*
002 * Copyright (C) 2010 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package com.google.common.base;
018
019 import static com.google.common.base.Preconditions.checkArgument;
020 import static com.google.common.base.Preconditions.checkNotNull;
021
022 import com.google.common.annotations.GwtCompatible;
023
024 import java.util.Formatter;
025
026 import javax.annotation.Nullable;
027
028 /**
029 * Static utility methods pertaining to {@code String} or {@code CharSequence}
030 * instances.
031 *
032 * @author Kevin Bourrillion
033 * @since 3
034 */
035 @GwtCompatible
036 public final class Strings {
037 private Strings() {}
038
039 /**
040 * Returns the given string if it is non-null; the empty string otherwise.
041 *
042 * @param string the string to test and possibly return
043 * @return {@code string} itself if it is non-null; {@code ""} if it is null
044 */
045 public static String nullToEmpty(@Nullable String string) {
046 return (string == null) ? "" : string;
047 }
048
049 /**
050 * Returns the given string if it is nonempty; {@code null} otherwise.
051 *
052 * @param string the string to test and possibly return
053 * @return {@code string} itself if it is nonempty; {@code null} if it is
054 * empty or null
055 */
056 public static @Nullable String emptyToNull(@Nullable String string) {
057 return isNullOrEmpty(string) ? null : string;
058 }
059
060 /**
061 * Returns {@code true} if the given string is null or is the empty string.
062 *
063 * <p>Consider normalizing your string references with {@link #nullToEmpty}.
064 * If you do, you can use {@link String#isEmpty()} instead of this
065 * method, and you won't need special null-safe forms of methods like {@link
066 * String#toUpperCase} either. Or, if you'd like to normalize "in the other
067 * direction," converting empty strings to {@code null}, you can use {@link
068 * #emptyToNull}.
069 *
070 * @param string a string reference to check
071 * @return {@code true} if the string is null or is the empty string
072 */
073 public static boolean isNullOrEmpty(@Nullable String string) {
074 return string == null || string.length() == 0; // string.isEmpty() in Java 6
075 }
076
077 /**
078 * Returns a string, of length at least {@code minLength}, consisting of
079 * {@code string} prepended with as many copies of {@code padChar} as are
080 * necessary to reach that length. For example,
081 *
082 * <ul>
083 * <li>{@code padStart("7", 3, '0')} returns {@code "007"}
084 * <li>{@code padStart("2010", 3, '0')} returns {@code "2010"}
085 * </ul>
086 *
087 * <p>See {@link Formatter} for a richer set of formatting capabilities.
088 *
089 * @param string the string which should appear at the end of the result
090 * @param minLength the minimum length the resulting string must have. Can be
091 * zero or negative, in which case the input string is always returned.
092 * @param padChar the character to insert at the beginning of the result until
093 * the minimum length is reached
094 * @return the padded string
095 */
096 public static String padStart(String string, int minLength, char padChar) {
097 checkNotNull(string); // eager for GWT.
098 if (string.length() >= minLength) {
099 return string;
100 }
101 StringBuilder sb = new StringBuilder(minLength);
102 for (int i = string.length(); i < minLength; i++) {
103 sb.append(padChar);
104 }
105 sb.append(string);
106 return sb.toString();
107 }
108
109 /**
110 * Returns a string, of length at least {@code minLength}, consisting of
111 * {@code string} appended with as many copies of {@code padChar} as are
112 * necessary to reach that length. For example,
113 *
114 * <ul>
115 * <li>{@code padEnd("4.", 5, '0')} returns {@code "4.000"}
116 * <li>{@code padEnd("2010", 3, '!')} returns {@code "2010"}
117 * </ul>
118 *
119 * <p>See {@link Formatter} for a richer set of formatting capabilities.
120 *
121 * @param string the string which should appear at the beginning of the result
122 * @param minLength the minimum length the resulting string must have. Can be
123 * zero or negative, in which case the input string is always returned.
124 * @param padChar the character to append to the end of the result until the
125 * minimum length is reached
126 * @return the padded string
127 */
128 public static String padEnd(String string, int minLength, char padChar) {
129 checkNotNull(string); // eager for GWT.
130 if (string.length() >= minLength) {
131 return string;
132 }
133 StringBuilder sb = new StringBuilder(minLength);
134 sb.append(string);
135 for (int i = string.length(); i < minLength; i++) {
136 sb.append(padChar);
137 }
138 return sb.toString();
139 }
140
141 /**
142 * Returns a string consisting of a specific number of concatenated copies of
143 * an input string. For example, {@code repeat("hey", 3)} returns the string
144 * {@code "heyheyhey"}.
145 *
146 * @param string any non-null string
147 * @param count the number of times to repeat it; a nonnegative integer
148 * @return a string containing {@code string} repeated {@code count} times
149 * (the empty string if {@code count} is zero)
150 * @throws IllegalArgumentException if {@code count} is negative
151 */
152 public static String repeat(String string, int count) {
153 checkNotNull(string); // eager for GWT.
154 checkArgument(count >= 0, "invalid count: %s", count);
155
156 // If this multiplication overflows, a NegativeArraySizeException or
157 // OutOfMemoryError is not far behind
158 StringBuilder builder = new StringBuilder(string.length() * count);
159 for (int i = 0; i < count; i++) {
160 builder.append(string);
161 }
162 return builder.toString();
163 }
164 }
165