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}