001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018package org.apache.commons.codec.binary; 019 020import java.io.UnsupportedEncodingException; 021import java.nio.charset.Charset; 022 023import org.apache.commons.codec.CharEncoding; 024import org.apache.commons.codec.Charsets; 025 026/** 027 * Converts String to and from bytes using the encodings required by the Java specification. These encodings are 028 * specified in <a href="http://download.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html"> 029 * Standard charsets</a>. 030 * 031 * <p>This class is immutable and thread-safe.</p> 032 * 033 * @see CharEncoding 034 * @see <a href="http://download.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a> 035 * @version $Id: StringUtils.java 1634456 2014-10-27 05:26:56Z ggregory $ 036 * @since 1.4 037 */ 038public class StringUtils { 039 040 /** 041 * <p> 042 * Compares two CharSequences, returning <code>true</code> if they represent equal sequences of characters. 043 * </p> 044 * 045 * <p> 046 * <code>null</code>s are handled without exceptions. Two <code>null</code> references are considered to be equal. 047 * The comparison is case sensitive. 048 * </p> 049 * 050 * <pre> 051 * StringUtils.equals(null, null) = true 052 * StringUtils.equals(null, "abc") = false 053 * StringUtils.equals("abc", null) = false 054 * StringUtils.equals("abc", "abc") = true 055 * StringUtils.equals("abc", "ABC") = false 056 * </pre> 057 * 058 * <p> 059 * Copied from Apache Commons Lang r1583482 on April 10, 2014 (day of 3.3.2 release). 060 * </p> 061 * 062 * @see Object#equals(Object) 063 * @param cs1 064 * the first CharSequence, may be <code>null</code> 065 * @param cs2 066 * the second CharSequence, may be <code>null</code> 067 * @return <code>true</code> if the CharSequences are equal (case-sensitive), or both <code>null</code> 068 * @since 1.10 069 */ 070 public static boolean equals(final CharSequence cs1, final CharSequence cs2) { 071 if (cs1 == cs2) { 072 return true; 073 } 074 if (cs1 == null || cs2 == null) { 075 return false; 076 } 077 if (cs1 instanceof String && cs2 instanceof String) { 078 return cs1.equals(cs2); 079 } 080 return CharSequenceUtils.regionMatches(cs1, false, 0, cs2, 0, Math.max(cs1.length(), cs2.length())); 081 } 082 083 /** 084 * Calls {@link String#getBytes(Charset)} 085 * 086 * @param string 087 * The string to encode (if null, return null). 088 * @param charset 089 * The {@link Charset} to encode the <code>String</code> 090 * @return the encoded bytes 091 */ 092 private static byte[] getBytes(final String string, final Charset charset) { 093 if (string == null) { 094 return null; 095 } 096 return string.getBytes(charset); 097 } 098 099 /** 100 * Encodes the given string into a sequence of bytes using the ISO-8859-1 charset, storing the result into a new 101 * byte array. 102 * 103 * @param string 104 * the String to encode, may be <code>null</code> 105 * @return encoded bytes, or <code>null</code> if the input string was <code>null</code> 106 * @throws NullPointerException 107 * Thrown if {@link Charsets#ISO_8859_1} is not initialized, which should never happen since it is 108 * required by the Java platform specification. 109 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 110 * @see <a href="http://download.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a> 111 * @see #getBytesUnchecked(String, String) 112 */ 113 public static byte[] getBytesIso8859_1(final String string) { 114 return getBytes(string, Charsets.ISO_8859_1); 115 } 116 117 118 /** 119 * Encodes the given string into a sequence of bytes using the named charset, storing the result into a new byte 120 * array. 121 * <p> 122 * This method catches {@link UnsupportedEncodingException} and rethrows it as {@link IllegalStateException}, which 123 * should never happen for a required charset name. Use this method when the encoding is required to be in the JRE. 124 * </p> 125 * 126 * @param string 127 * the String to encode, may be <code>null</code> 128 * @param charsetName 129 * The name of a required {@link java.nio.charset.Charset} 130 * @return encoded bytes, or <code>null</code> if the input string was <code>null</code> 131 * @throws IllegalStateException 132 * Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen for a 133 * required charset name. 134 * @see CharEncoding 135 * @see String#getBytes(String) 136 */ 137 public static byte[] getBytesUnchecked(final String string, final String charsetName) { 138 if (string == null) { 139 return null; 140 } 141 try { 142 return string.getBytes(charsetName); 143 } catch (final UnsupportedEncodingException e) { 144 throw StringUtils.newIllegalStateException(charsetName, e); 145 } 146 } 147 148 /** 149 * Encodes the given string into a sequence of bytes using the US-ASCII charset, storing the result into a new byte 150 * array. 151 * 152 * @param string 153 * the String to encode, may be <code>null</code> 154 * @return encoded bytes, or <code>null</code> if the input string was <code>null</code> 155 * @throws NullPointerException 156 * Thrown if {@link Charsets#US_ASCII} is not initialized, which should never happen since it is 157 * required by the Java platform specification. 158 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 159 * @see <a href="http://download.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a> 160 * @see #getBytesUnchecked(String, String) 161 */ 162 public static byte[] getBytesUsAscii(final String string) { 163 return getBytes(string, Charsets.US_ASCII); 164 } 165 166 /** 167 * Encodes the given string into a sequence of bytes using the UTF-16 charset, storing the result into a new byte 168 * array. 169 * 170 * @param string 171 * the String to encode, may be <code>null</code> 172 * @return encoded bytes, or <code>null</code> if the input string was <code>null</code> 173 * @throws NullPointerException 174 * Thrown if {@link Charsets#UTF_16} is not initialized, which should never happen since it is 175 * required by the Java platform specification. 176 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 177 * @see <a href="http://download.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a> 178 * @see #getBytesUnchecked(String, String) 179 */ 180 public static byte[] getBytesUtf16(final String string) { 181 return getBytes(string, Charsets.UTF_16); 182 } 183 184 /** 185 * Encodes the given string into a sequence of bytes using the UTF-16BE charset, storing the result into a new byte 186 * array. 187 * 188 * @param string 189 * the String to encode, may be <code>null</code> 190 * @return encoded bytes, or <code>null</code> if the input string was <code>null</code> 191 * @throws NullPointerException 192 * Thrown if {@link Charsets#UTF_16BE} is not initialized, which should never happen since it is 193 * required by the Java platform specification. 194 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 195 * @see <a href="http://download.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a> 196 * @see #getBytesUnchecked(String, String) 197 */ 198 public static byte[] getBytesUtf16Be(final String string) { 199 return getBytes(string, Charsets.UTF_16BE); 200 } 201 202 /** 203 * Encodes the given string into a sequence of bytes using the UTF-16LE charset, storing the result into a new byte 204 * array. 205 * 206 * @param string 207 * the String to encode, may be <code>null</code> 208 * @return encoded bytes, or <code>null</code> if the input string was <code>null</code> 209 * @throws NullPointerException 210 * Thrown if {@link Charsets#UTF_16LE} is not initialized, which should never happen since it is 211 * required by the Java platform specification. 212 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 213 * @see <a href="http://download.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a> 214 * @see #getBytesUnchecked(String, String) 215 */ 216 public static byte[] getBytesUtf16Le(final String string) { 217 return getBytes(string, Charsets.UTF_16LE); 218 } 219 220 /** 221 * Encodes the given string into a sequence of bytes using the UTF-8 charset, storing the result into a new byte 222 * array. 223 * 224 * @param string 225 * the String to encode, may be <code>null</code> 226 * @return encoded bytes, or <code>null</code> if the input string was <code>null</code> 227 * @throws NullPointerException 228 * Thrown if {@link Charsets#UTF_8} is not initialized, which should never happen since it is 229 * required by the Java platform specification. 230 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 231 * @see <a href="http://download.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a> 232 * @see #getBytesUnchecked(String, String) 233 */ 234 public static byte[] getBytesUtf8(final String string) { 235 return getBytes(string, Charsets.UTF_8); 236 } 237 238 private static IllegalStateException newIllegalStateException(final String charsetName, 239 final UnsupportedEncodingException e) { 240 return new IllegalStateException(charsetName + ": " + e); 241 } 242 243 /** 244 * Constructs a new <code>String</code> by decoding the specified array of bytes using the given charset. 245 * 246 * @param bytes 247 * The bytes to be decoded into characters 248 * @param charset 249 * The {@link Charset} to encode the <code>String</code> 250 * @return A new <code>String</code> decoded from the specified array of bytes using the given charset, 251 * or <code>null</code> if the input byte array was <code>null</code>. 252 * @throws NullPointerException 253 * Thrown if {@link Charsets#UTF_8} is not initialized, which should never happen since it is 254 * required by the Java platform specification. 255 */ 256 private static String newString(final byte[] bytes, final Charset charset) { 257 return bytes == null ? null : new String(bytes, charset); 258 } 259 260 /** 261 * Constructs a new <code>String</code> by decoding the specified array of bytes using the given charset. 262 * <p> 263 * This method catches {@link UnsupportedEncodingException} and re-throws it as {@link IllegalStateException}, which 264 * should never happen for a required charset name. Use this method when the encoding is required to be in the JRE. 265 * </p> 266 * 267 * @param bytes 268 * The bytes to be decoded into characters, may be <code>null</code> 269 * @param charsetName 270 * The name of a required {@link java.nio.charset.Charset} 271 * @return A new <code>String</code> decoded from the specified array of bytes using the given charset, 272 * or <code>null</code> if the input byte array was <code>null</code>. 273 * @throws IllegalStateException 274 * Thrown when a {@link UnsupportedEncodingException} is caught, which should never happen for a 275 * required charset name. 276 * @see CharEncoding 277 * @see String#String(byte[], String) 278 */ 279 public static String newString(final byte[] bytes, final String charsetName) { 280 if (bytes == null) { 281 return null; 282 } 283 try { 284 return new String(bytes, charsetName); 285 } catch (final UnsupportedEncodingException e) { 286 throw StringUtils.newIllegalStateException(charsetName, e); 287 } 288 } 289 290 /** 291 * Constructs a new <code>String</code> by decoding the specified array of bytes using the ISO-8859-1 charset. 292 * 293 * @param bytes 294 * The bytes to be decoded into characters, may be <code>null</code> 295 * @return A new <code>String</code> decoded from the specified array of bytes using the ISO-8859-1 charset, or 296 * <code>null</code> if the input byte array was <code>null</code>. 297 * @throws NullPointerException 298 * Thrown if {@link Charsets#ISO_8859_1} is not initialized, which should never happen since it is 299 * required by the Java platform specification. 300 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 301 */ 302 public static String newStringIso8859_1(final byte[] bytes) { 303 return new String(bytes, Charsets.ISO_8859_1); 304 } 305 306 /** 307 * Constructs a new <code>String</code> by decoding the specified array of bytes using the US-ASCII charset. 308 * 309 * @param bytes 310 * The bytes to be decoded into characters 311 * @return A new <code>String</code> decoded from the specified array of bytes using the US-ASCII charset, 312 * or <code>null</code> if the input byte array was <code>null</code>. 313 * @throws NullPointerException 314 * Thrown if {@link Charsets#US_ASCII} is not initialized, which should never happen since it is 315 * required by the Java platform specification. 316 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 317 */ 318 public static String newStringUsAscii(final byte[] bytes) { 319 return new String(bytes, Charsets.US_ASCII); 320 } 321 322 /** 323 * Constructs a new <code>String</code> by decoding the specified array of bytes using the UTF-16 charset. 324 * 325 * @param bytes 326 * The bytes to be decoded into characters 327 * @return A new <code>String</code> decoded from the specified array of bytes using the UTF-16 charset 328 * or <code>null</code> if the input byte array was <code>null</code>. 329 * @throws NullPointerException 330 * Thrown if {@link Charsets#UTF_16} is not initialized, which should never happen since it is 331 * required by the Java platform specification. 332 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 333 */ 334 public static String newStringUtf16(final byte[] bytes) { 335 return new String(bytes, Charsets.UTF_16); 336 } 337 338 /** 339 * Constructs a new <code>String</code> by decoding the specified array of bytes using the UTF-16BE charset. 340 * 341 * @param bytes 342 * The bytes to be decoded into characters 343 * @return A new <code>String</code> decoded from the specified array of bytes using the UTF-16BE charset, 344 * or <code>null</code> if the input byte array was <code>null</code>. 345 * @throws NullPointerException 346 * Thrown if {@link Charsets#UTF_16BE} is not initialized, which should never happen since it is 347 * required by the Java platform specification. 348 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 349 */ 350 public static String newStringUtf16Be(final byte[] bytes) { 351 return new String(bytes, Charsets.UTF_16BE); 352 } 353 354 /** 355 * Constructs a new <code>String</code> by decoding the specified array of bytes using the UTF-16LE charset. 356 * 357 * @param bytes 358 * The bytes to be decoded into characters 359 * @return A new <code>String</code> decoded from the specified array of bytes using the UTF-16LE charset, 360 * or <code>null</code> if the input byte array was <code>null</code>. 361 * @throws NullPointerException 362 * Thrown if {@link Charsets#UTF_16LE} is not initialized, which should never happen since it is 363 * required by the Java platform specification. 364 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 365 */ 366 public static String newStringUtf16Le(final byte[] bytes) { 367 return new String(bytes, Charsets.UTF_16LE); 368 } 369 370 /** 371 * Constructs a new <code>String</code> by decoding the specified array of bytes using the UTF-8 charset. 372 * 373 * @param bytes 374 * The bytes to be decoded into characters 375 * @return A new <code>String</code> decoded from the specified array of bytes using the UTF-8 charset, 376 * or <code>null</code> if the input byte array was <code>null</code>. 377 * @throws NullPointerException 378 * Thrown if {@link Charsets#UTF_8} is not initialized, which should never happen since it is 379 * required by the Java platform specification. 380 * @since As of 1.7, throws {@link NullPointerException} instead of UnsupportedEncodingException 381 */ 382 public static String newStringUtf8(final byte[] bytes) { 383 return newString(bytes, Charsets.UTF_8); 384 } 385 386}