Java/Data Type/String Join
Содержание
- 1 Concatenates two arrays of strings
- 2 Join an array of strings into one delimited string
- 3 Joins array elements into a single String: specify the start index and end index.
- 4 Joins array elements into a single String without specifying the start index and end index.
- 5 Joins array elements: Null objects or empty strings within the array are represented by empty strings.
- 6 Joins the elements of Collection into a single String with string separator.
- 7 Joins the elements of Iterator into a single with char value as separator.
- 8 Joins the elements of the provided array into a single String containing the provided list of elements.
- 9 Joins the elements of the provided Collection into a single String containing the provided elements.
- 10 Joins the elements of the provided Iterator into a single String containing the provided elements.
- 11 Join String
- 12 Remove/collapse multiple spaces.
- 13 Reverse the split operation.
- 14 Split and join strings
- 15 Split and join strings 2
Concatenates two arrays of strings
<source lang="java">
/*
* Copyright 2000,2005 wingS development team. * * This file is part of wingS (http://wingsframework.org). * * wingS is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2.1 * of the License, or (at your option) any later version. * * Please see COPYING for the complete licence. */
import java.util.StringTokenizer; /**
* Some string manipulation utilities. * * @author */
public class StringUtil {
/** * concatenates two arrays of strings. * * @param s1 the first array of strings. * @param s2 the second array of strings. * @return the resulting array with all strings in s1 and s2 */ public static final String[] concat(String[] s1, String[] s2) { String[] erg = new String[s1.length + s2.length]; System.arraycopy(s1, 0, erg, 0, s1.length); System.arraycopy(s2, 0, erg, s1.length, s2.length); return erg; }
}
</source>
Join an array of strings into one delimited string
<source lang="java">
/*
* JBoss, Home of Professional Open Source * Copyright 2005, JBoss Inc., and individual contributors as indicated * by the @authors tag. See the copyright.txt in the distribution for a * full listing of individual contributors. * * This is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this software; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA, or see the FSF site: http://www.fsf.org. */
public class Main{
///////////////////////////////////////////////////////////////////////// // Joining/Concatenation Methods // ///////////////////////////////////////////////////////////////////////// /** * Join an array of strings into one delimited string. * * @param buff String buffered used for join (buffer is not reset). * @param array Array of objects to join as strings. * @param delim Delimiter to join strings with or null. * @return Joined string. */ public static String join(final StringBuffer buff, final Object array[], final String delim) { boolean haveDelim = (delim != null); for (int i = 0; i < array.length; i++) { buff.append(array[i]); // if this is the last element then don"t append delim if (haveDelim && (i + 1) < array.length) { buff.append(delim); } } return buff.toString(); } /** * Join an array of strings into one delimited string. * * @param array Array of objects to join as strings. * @param delim Delimiter to join strings with or null. * @return Joined string. */ public static String join(final Object array[], final String delim) { return join(new StringBuffer(), array, delim); } /** * Convert and join an array of objects into one string. * * @param array Array of objects to join as strings. * @return Converted and joined objects. */ public static String join(final Object array[]) { return join(array, null); } /** * Convert and join an array of bytes into one string. * * @param array Array of objects to join as strings. * @return Converted and joined objects. */ public static String join(final byte array[]) { Byte bytes[] = new Byte[array.length]; for (int i = 0; i < bytes.length; i++) { bytes[i] = new Byte(array[i]); } return join(bytes, null); } /** * Return a string composed of the given array. * * @param buff Buffer used to construct string value (not reset). * @param array Array of objects. * @param prefix String prefix. * @param separator Element sepearator. * @param suffix String suffix. * @return String in the format of: * prefix + n ( + separator + n+i)* + suffix. */ public static String join(final StringBuffer buff, final Object[] array, final String prefix, final String separator, final String suffix) { buff.append(prefix); join(buff, array, separator); buff.append(suffix); return buff.toString(); } /** * Return a string composed of the given array. * * @param array Array of objects. * @param prefix String prefix. * @param separator Element sepearator. * @param suffix String suffix. * @return String in the format of: * prefix + n ( + separator + n+i)* + suffix. */ public static String join(final Object[] array, final String prefix, final String separator, final String suffix) { return join(new StringBuffer(), array, prefix, separator, suffix); }
}
</source>
Joins array elements into a single String: specify the start index and end index.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */
import java.util.ArrayList; import java.util.List; public class Main {
/***
Joins the elements of the provided array into a single String * containing the provided list of elements.
**
No delimiter is added before or after the list.
* A null
separator is the same as an empty String ("").
* Null objects or empty strings within the array are represented by
* empty strings.
**
* StringUtils.join(null, *) = null * StringUtils.join([], *) = "" * StringUtils.join([null], *) = "" * StringUtils.join(["a", "b", "c"], "--") = "a--b--c" * StringUtils.join(["a", "b", "c"], null) = "abc" * StringUtils.join(["a", "b", "c"], "") = "abc" * StringUtils.join([null, "", "a"], ",") = ",,a" *
*
* @param array the array of values to join together, may be null
* @param separator the separator character to use, null treated as ""
* @param startIndex the first index to start joining from. It is
* an error to pass in an end index past the end of the array
* @param endIndex the index to stop joining from (exclusive). It is
* an error to pass in an end index past the end of the array
* @return the joined String, null
if null array input
*/
public static String join(Object[] array, String separator, int startIndex, int endIndex) {
if (array == null) {
return null;
}
if (separator == null) {
separator = "";
}
// endIndex - startIndex > 0: Len = NofStrings *(len(firstString) + len(separator))
// (Assuming that all Strings are roughly equally long)
int bufSize = (endIndex - startIndex);
if (bufSize <= 0) {
return "";
}
bufSize *= ((array[startIndex] == null ? 16 : array[startIndex].toString().length())
+ separator.length());
StringBuffer buf = new StringBuffer(bufSize);
for (int i = startIndex; i < endIndex; i++) {
if (i > startIndex) {
buf.append(separator);
}
if (array[i] != null) {
buf.append(array[i]);
}
}
return buf.toString();
}
}
</source>
Joins array elements into a single String without specifying the start index and end index.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */
import java.util.ArrayList; import java.util.List; public class Main {
/***
Joins the elements of the provided array into a single String * containing the provided list of elements.
**
No delimiter is added before or after the list.
* A null
separator is the same as an empty String ("").
* Null objects or empty strings within the array are represented by
* empty strings.
**
* StringUtils.join(null, *) = null * StringUtils.join([], *) = "" * StringUtils.join([null], *) = "" * StringUtils.join(["a", "b", "c"], "--") = "a--b--c" * StringUtils.join(["a", "b", "c"], null) = "abc" * StringUtils.join(["a", "b", "c"], "") = "abc" * StringUtils.join([null, "", "a"], ",") = ",,a" *
*
* @param array the array of values to join together, may be null
* @param separator the separator character to use, null treated as ""
* @return the joined String, null
if null array input
*/
public static String join(Object[] array, String separator) {
if (array == null) {
return null;
}
return join(array, separator, 0, array.length);
}
/**
* Joins the elements of the provided array into a single String * containing the provided list of elements.
**
No delimiter is added before or after the list.
* A null
separator is the same as an empty String ("").
* Null objects or empty strings within the array are represented by
* empty strings.
**
* StringUtils.join(null, *) = null * StringUtils.join([], *) = "" * StringUtils.join([null], *) = "" * StringUtils.join(["a", "b", "c"], "--") = "a--b--c" * StringUtils.join(["a", "b", "c"], null) = "abc" * StringUtils.join(["a", "b", "c"], "") = "abc" * StringUtils.join([null, "", "a"], ",") = ",,a" *
*
* @param array the array of values to join together, may be null
* @param separator the separator character to use, null treated as ""
* @param startIndex the first index to start joining from. It is
* an error to pass in an end index past the end of the array
* @param endIndex the index to stop joining from (exclusive). It is
* an error to pass in an end index past the end of the array
* @return the joined String, null
if null array input
*/
public static String join(Object[] array, String separator, int startIndex, int endIndex) {
if (array == null) {
return null;
}
if (separator == null) {
separator = "";
}
// endIndex - startIndex > 0: Len = NofStrings *(len(firstString) + len(separator))
// (Assuming that all Strings are roughly equally long)
int bufSize = (endIndex - startIndex);
if (bufSize <= 0) {
return "";
}
bufSize *= ((array[startIndex] == null ? 16 : array[startIndex].toString().length())
+ separator.length());
StringBuffer buf = new StringBuffer(bufSize);
for (int i = startIndex; i < endIndex; i++) {
if (i > startIndex) {
buf.append(separator);
}
if (array[i] != null) {
buf.append(array[i]);
}
}
return buf.toString();
}
}
</source>
Joins array elements: Null objects or empty strings within the array are represented by empty strings.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */
import java.util.ArrayList; import java.util.List; public class Main {
/***
Joins the elements of the provided array into a single String * containing the provided list of elements.
**
No separator is added to the joined String. * Null objects or empty strings within the array are represented by * empty strings.
**
* StringUtils.join(null) = null * StringUtils.join([]) = "" * StringUtils.join([null]) = "" * StringUtils.join(["a", "b", "c"]) = "abc" * StringUtils.join([null, "", "a"]) = "a" *
*
* @param array the array of values to join together, may be null
* @return the joined String, null
if null array input
* @since 2.0
*/
public static String join(Object[] array) {
return join(array, null);
}
/**
* Joins the elements of the provided array into a single String * containing the provided list of elements.
**
No delimiter is added before or after the list.
* A null
separator is the same as an empty String ("").
* Null objects or empty strings within the array are represented by
* empty strings.
**
* StringUtils.join(null, *) = null * StringUtils.join([], *) = "" * StringUtils.join([null], *) = "" * StringUtils.join(["a", "b", "c"], "--") = "a--b--c" * StringUtils.join(["a", "b", "c"], null) = "abc" * StringUtils.join(["a", "b", "c"], "") = "abc" * StringUtils.join([null, "", "a"], ",") = ",,a" *
*
* @param array the array of values to join together, may be null
* @param separator the separator character to use, null treated as ""
* @return the joined String, null
if null array input
*/
public static String join(Object[] array, String separator) {
if (array == null) {
return null;
}
return join(array, separator, 0, array.length);
}
/**
* Joins the elements of the provided array into a single String * containing the provided list of elements.
**
No delimiter is added before or after the list.
* A null
separator is the same as an empty String ("").
* Null objects or empty strings within the array are represented by
* empty strings.
**
* StringUtils.join(null, *) = null * StringUtils.join([], *) = "" * StringUtils.join([null], *) = "" * StringUtils.join(["a", "b", "c"], "--") = "a--b--c" * StringUtils.join(["a", "b", "c"], null) = "abc" * StringUtils.join(["a", "b", "c"], "") = "abc" * StringUtils.join([null, "", "a"], ",") = ",,a" *
*
* @param array the array of values to join together, may be null
* @param separator the separator character to use, null treated as ""
* @param startIndex the first index to start joining from. It is
* an error to pass in an end index past the end of the array
* @param endIndex the index to stop joining from (exclusive). It is
* an error to pass in an end index past the end of the array
* @return the joined String, null
if null array input
*/
public static String join(Object[] array, String separator, int startIndex, int endIndex) {
if (array == null) {
return null;
}
if (separator == null) {
separator = "";
}
// endIndex - startIndex > 0: Len = NofStrings *(len(firstString) + len(separator))
// (Assuming that all Strings are roughly equally long)
int bufSize = (endIndex - startIndex);
if (bufSize <= 0) {
return "";
}
bufSize *= ((array[startIndex] == null ? 16 : array[startIndex].toString().length())
+ separator.length());
StringBuffer buf = new StringBuffer(bufSize);
for (int i = startIndex; i < endIndex; i++) {
if (i > startIndex) {
buf.append(separator);
}
if (array[i] != null) {
buf.append(array[i]);
}
}
return buf.toString();
}
}
</source>
Joins the elements of Collection into a single String with string separator.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */
import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; public class Main {
/***
Joins the elements of the provided Collection
into
* a single String containing the provided elements.
**
No delimiter is added before or after the list.
* A null
separator is the same as an empty String ("").
**
See the examples here: {@link #join(Object[],String)}.
* * @param collection the*Collection
of values to join together, may be null * @param separator the separator character to use, null treated as "" * @return the joined String,null
if null iterator input * @since 2.3 */ public static String join(Collection collection, String separator) { if (collection == null) { return null; } return join(collection.iterator(), separator); } /**
Joins the elements of the provided Iterator
into
* a single String containing the provided elements.
**
No delimiter is added before or after the list.
* A null
separator is the same as an empty String ("").
**
See the examples here: {@link #join(Object[],String)}.
* * @param iterator the*Iterator
of values to join together, may be null * @param separator the separator character to use, null treated as "" * @return the joined String,null
if null iterator input */ public static String join(Iterator iterator, String separator) { // handle null, zero and one elements before building a buffer if (iterator == null) { return null; } if (!iterator.hasNext()) { return ""; } Object first = iterator.next(); if (!iterator.hasNext()) { return toString(first); } // two or more elements StringBuffer buf = new StringBuffer(256); // Java default is 16, probably too small if (first != null) { buf.append(first); } while (iterator.hasNext()) { if (separator != null) { buf.append(separator); } Object obj = iterator.next(); if (obj != null) { buf.append(obj); } } return buf.toString(); } // ToString //----------------------------------------------------------------------- /**
Gets the toString
of an Object
returning
* an empty string ("") if null
input.
**
* ObjectUtils.toString(null) = "" * ObjectUtils.toString("") = "" * ObjectUtils.toString("bat") = "bat" * ObjectUtils.toString(Boolean.TRUE) = "true" *
* * @see StringUtils#defaultString(String) * @see String#valueOf(Object) * @param obj the Object totoString
, may be null * @return the passed in Object"s toString, or nullStr ifnull
input * @since 2.0 */ public static String toString(Object obj) { return obj == null ? "" : obj.toString(); }
}
</source>
Joins the elements of Iterator into a single with char value as separator.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Main {
/***
Joins the elements of the provided Iterator
into
* a single String containing the provided elements.
**
No delimiter is added before or after the list. Null objects or empty * strings within the iteration are represented by empty strings.
**
See the examples here: {@link #join(Object[],char)}.
* * @param iterator the*Iterator
of values to join together, may be null * @param separator the separator character to use * @return the joined String,null
if null iterator input * @since 2.0 */ public static String join(Iterator iterator, char separator) { // handle null, zero and one elements before building a buffer if (iterator == null) { return null; } if (!iterator.hasNext()) { return ""; } Object first = iterator.next(); if (!iterator.hasNext()) { return toString(first); } // two or more elements StringBuffer buf = new StringBuffer(256); // Java default is 16, probably too small if (first != null) { buf.append(first); } while (iterator.hasNext()) { buf.append(separator); Object obj = iterator.next(); if (obj != null) { buf.append(obj); } } return buf.toString(); } // ToString //----------------------------------------------------------------------- /**
Gets the toString
of an Object
returning
* an empty string ("") if null
input.
**
* ObjectUtils.toString(null) = "" * ObjectUtils.toString("") = "" * ObjectUtils.toString("bat") = "bat" * ObjectUtils.toString(Boolean.TRUE) = "true" *
* * @see StringUtils#defaultString(String) * @see String#valueOf(Object) * @param obj the Object totoString
, may be null * @return the passed in Object"s toString, or nullStr ifnull
input * @since 2.0 */ public static String toString(Object obj) { return obj == null ? "" : obj.toString(); }
}
</source>
Joins the elements of the provided array into a single String containing the provided list of elements.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */
import java.util.ArrayList; import java.util.List; public class Main {
/***
Joins the elements of the provided array into a single String * containing the provided list of elements.
**
No delimiter is added before or after the list. * Null objects or empty strings within the array are represented by * empty strings.
**
* StringUtils.join(null, *) = null * StringUtils.join([], *) = "" * StringUtils.join([null], *) = "" * StringUtils.join(["a", "b", "c"], ";") = "a;b;c" * StringUtils.join(["a", "b", "c"], null) = "abc" * StringUtils.join([null, "", "a"], ";") = ";;a" *
*
* @param array the array of values to join together, may be null
* @param separator the separator character to use
* @return the joined String, null
if null array input
* @since 2.0
*/
public static String join(Object[] array, char separator) {
if (array == null) {
return null;
}
return join(array, separator, 0, array.length);
}
/**
* Joins the elements of the provided array into a single String * containing the provided list of elements.
**
No delimiter is added before or after the list. * Null objects or empty strings within the array are represented by * empty strings.
**
* StringUtils.join(null, *) = null * StringUtils.join([], *) = "" * StringUtils.join([null], *) = "" * StringUtils.join(["a", "b", "c"], ";") = "a;b;c" * StringUtils.join(["a", "b", "c"], null) = "abc" * StringUtils.join([null, "", "a"], ";") = ";;a" *
*
* @param array the array of values to join together, may be null
* @param separator the separator character to use
* @param startIndex the first index to start joining from. It is
* an error to pass in an end index past the end of the array
* @param endIndex the index to stop joining from (exclusive). It is
* an error to pass in an end index past the end of the array
* @return the joined String, null
if null array input
* @since 2.0
*/
public static String join(Object[] array, char separator, int startIndex, int endIndex) {
if (array == null) {
return null;
}
int bufSize = (endIndex - startIndex);
if (bufSize <= 0) {
return "";
}
bufSize *= ((array[startIndex] == null ? 16 : array[startIndex].toString().length()) + 1);
StringBuffer buf = new StringBuffer(bufSize);
for (int i = startIndex; i < endIndex; i++) {
if (i > startIndex) {
buf.append(separator);
}
if (array[i] != null) {
buf.append(array[i]);
}
}
return buf.toString();
}
}
</source>
Joins the elements of the provided Collection into a single String containing the provided elements.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */
import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; public class Main {
/***
Joins the elements of the provided Collection
into
* a single String containing the provided elements.
**
No delimiter is added before or after the list. Null objects or empty * strings within the iteration are represented by empty strings.
**
See the examples here: {@link #join(Object[],char)}.
* * @param collection the*Collection
of values to join together, may be null * @param separator the separator character to use * @return the joined String,null
if null iterator input * @since 2.3 */ public static String join(Collection collection, char separator) { if (collection == null) { return null; } return join(collection.iterator(), separator); } /**
Joins the elements of the provided Iterator
into
* a single String containing the provided elements.
**
No delimiter is added before or after the list. Null objects or empty * strings within the iteration are represented by empty strings.
**
See the examples here: {@link #join(Object[],char)}.
* * @param iterator the*Iterator
of values to join together, may be null * @param separator the separator character to use * @return the joined String,null
if null iterator input * @since 2.0 */ public static String join(Iterator iterator, char separator) { // handle null, zero and one elements before building a buffer if (iterator == null) { return null; } if (!iterator.hasNext()) { return ""; } Object first = iterator.next(); if (!iterator.hasNext()) { return toString(first); } // two or more elements StringBuffer buf = new StringBuffer(256); // Java default is 16, probably too small if (first != null) { buf.append(first); } while (iterator.hasNext()) { buf.append(separator); Object obj = iterator.next(); if (obj != null) { buf.append(obj); } } return buf.toString(); } // ToString //----------------------------------------------------------------------- /**
Gets the toString
of an Object
returning
* an empty string ("") if null
input.
**
* ObjectUtils.toString(null) = "" * ObjectUtils.toString("") = "" * ObjectUtils.toString("bat") = "bat" * ObjectUtils.toString(Boolean.TRUE) = "true" *
* * @see StringUtils#defaultString(String) * @see String#valueOf(Object) * @param obj the Object totoString
, may be null * @return the passed in Object"s toString, or nullStr ifnull
input * @since 2.0 */ public static String toString(Object obj) { return obj == null ? "" : obj.toString(); }
}
</source>
Joins the elements of the provided Iterator into a single String containing the provided elements.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Main {
/***
Joins the elements of the provided Iterator
into
* a single String containing the provided elements.
**
No delimiter is added before or after the list.
* A null
separator is the same as an empty String ("").
**
See the examples here: {@link #join(Object[],String)}.
* * @param iterator the*Iterator
of values to join together, may be null * @param separator the separator character to use, null treated as "" * @return the joined String,null
if null iterator input */ public static String join(Iterator iterator, String separator) { // handle null, zero and one elements before building a buffer if (iterator == null) { return null; } if (!iterator.hasNext()) { return ""; } Object first = iterator.next(); if (!iterator.hasNext()) { return toString(first); } // two or more elements StringBuffer buf = new StringBuffer(256); // Java default is 16, probably too small if (first != null) { buf.append(first); } while (iterator.hasNext()) { if (separator != null) { buf.append(separator); } Object obj = iterator.next(); if (obj != null) { buf.append(obj); } } return buf.toString(); } // ToString //----------------------------------------------------------------------- /**
Gets the toString
of an Object
returning
* an empty string ("") if null
input.
**
* ObjectUtils.toString(null) = "" * ObjectUtils.toString("") = "" * ObjectUtils.toString("bat") = "bat" * ObjectUtils.toString(Boolean.TRUE) = "true" *
* * @see StringUtils#defaultString(String) * @see String#valueOf(Object) * @param obj the Object totoString
, may be null * @return the passed in Object"s toString, or nullStr ifnull
input * @since 2.0 */ public static String toString(Object obj) { return obj == null ? "" : obj.toString(); }
}
</source>
Join String
<source lang="java">
/*
* Static String formatting and query routines. * Copyright (C) 2001-2005 Stephen Ostermiller * http://ostermiller.org/contact.pl?regarding=Java+Utilities * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * See COPYING.TXT for details. */
import java.util.HashMap; import java.util.regex.Pattern; /**
* Utilities for String formatting, manipulation, and queries. * More information about this class is available from . * * @author Stephen Ostermiller http://ostermiller.org/contact.pl?regarding=Java+Utilities * @since ostermillerutils 1.00.00 */
public class StringHelper {
/** * Join all the elements of a string array into a single * String.*
* If the given array empty an empty string * will be returned. Null elements of the array are allowed * and will be treated like empty Strings. * * @param array Array to be joined into a string. * @return Concatenation of all the elements of the given array. * @throws NullPointerException if array is null. * * @since ostermillerutils 1.05.00 */ public static String join(String[] array){ return join(array, ""); } /** * Join all the elements of a string array into a single * String. * <p> * If the given array empty an empty string * will be returned. Null elements of the array are allowed * and will be treated like empty Strings. * * @param array Array to be joined into a string. * @param delimiter String to place between array elements. * @return Concatenation of all the elements of the given array with the the delimiter in between. * @throws NullPointerException if array or delimiter is null. * * @since ostermillerutils 1.05.00 */ public static String join(String[] array, String delimiter){ // Cache the length of the delimiter // has the side effect of throwing a NullPointerException if // the delimiter is null. int delimiterLength = delimiter.length(); // Nothing in the array return empty string // has the side effect of throwing a NullPointerException if // the array is null. if (array.length == 0) return ""; // Only one thing in the array, return it. if (array.length == 1){ if (array[0] == null) return ""; return array[0]; } // Make a pass through and determine the size // of the resulting string. int length = 0; for (int i=0; i<array.length; i++){ if (array[i] != null) length+=array[i].length(); if (i<array.length-1) length+=delimiterLength; } // Make a second pass through and concatenate everything // into a string buffer. StringBuffer result = new StringBuffer(length); for (int i=0; i<array.length; i++){ if (array[i] != null) result.append(array[i]); if (i<array.length-1) result.append(delimiter); } return result.toString(); } } </source>
Remove/collapse multiple spaces.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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. */
/**
* * @author * @version $Id: StringUtils.java 685685 2008-08-13 21:43:27Z nbubna $ */
public class Main {
/** * Remove/collapse multiple spaces. * * @param argStr string to remove multiple spaces from. * @return String */ public static String collapseSpaces(String argStr) { char last = argStr.charAt(0); StringBuffer argBuf = new StringBuffer(); for (int cIdx = 0 ; cIdx < argStr.length(); cIdx++) { char ch = argStr.charAt(cIdx); if (ch != " " || last != " ") { argBuf.append(ch); last = ch; } } return argBuf.toString(); }
}
</source>
Reverse the split operation.
<source lang="java">
import java.util.Collection; import java.util.Iterator; /**********************************************************************************
* $URL: https://source.sakaiproject.org/svn/util/branches/sakai_2-5-4/util-util/util/src/java/org/sakaiproject/util/StringUtil.java $ * $Id: StringUtil.java 34934 2007-09-10 22:52:23Z lance@indiana.edu $ *********************************************************************************** * * Copyright (c) 2003, 2004, 2005, 2006 The Sakai Foundation. * * Licensed under the Educational Community License, Version 1.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.opensource.org/licenses/ecl1.php * * 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. * **********************************************************************************/
/**
* <p> * StringUtil collects together some string utility classes.*
*/
public class StringUtil {
/** * Reverse the split operation. * * @param parts * The parts to combine * @param index * the index to the fist part to use * @param length * the number of parts to use * @param splitter * The between-parts text */ public static String unsplit(String[] parts, int index, int length, String splitter) { if (parts == null) return null; if ((index < 0) || (index >= parts.length)) return null; if (index+length > parts.length) return null; StringBuilder buf = new StringBuilder(); for (int i = index; i < index+length; i++) { if (parts[i] != null) buf.append(parts[i]); buf.append(splitter); } // remove the trailing splitter buf.setLength(buf.length()-splitter.length()); return buf.toString(); }
}
</source>
Split and join strings
<source lang="java">
/*
* Copyright (C) 2001-2003 Colin Bell * colbell@users.sourceforge.net * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
import java.util.ArrayList; import java.util.List; /**
* String handling utilities. * * @author */
public class StringUtilities {
/** * Return true if the passed string is null or empty. * * @param str String to be tested. * * @return true if the passed string is null or empty. */ public static boolean isEmpty(String str) { return str == null || str.length() == 0; } /** * Return whether the 2 passed strings are equal. This function * allows for null strings. If s1 and s1 are * both null they are considered equal. * * @param str1 First string to check. * @param str2 Second string to check. */ public static boolean areStringsEqual(String str1, String str2) { if (str1 == null && str2 == null) { return true; } if (str1 != null) { return str1.equals(str2); } return str2.equals(str1); } /** * Clean the passed string. Replace whitespace characters with a single * space. If a null string passed return an empty string. E.G. * replace * * [pre] * \t\tselect\t* from\t\ttab01 * [/pre] * * with * * [pre] * select * from tab01 * [/pre] * * @param str String to be cleaned. * * @return Cleaned string. */ public static String cleanString(String str) { final StringBuffer buf = new StringBuffer(str.length()); char prevCh = " "; for (int i = 0, limit = str.length(); i < limit; ++i) { char ch = str.charAt(i); if (Character.isWhitespace(ch)) { if (!Character.isWhitespace(prevCh)) { buf.append(" "); } } else { buf.append(ch); } prevCh = ch; } return buf.toString(); } /** * Return the number of occurences of a character in a string. * * @param str The string to check. * @param ch The character check for. * * @return The number of times ch occurs in str. */ public static int countOccurences(String str, int ch) { if (isEmpty(str)) { return 0; } int count = 0; int idx = -1; do { idx = str.indexOf(ch, ++idx); if (idx != -1) { ++count; } } while (idx != -1); return count; } /** * Split a string based on the given delimiter, but don"t remove * empty elements. * * @param str The string to be split. * @param delimiter Split string based on this delimiter. * * @return Array of split strings. Guaranteeded to be not null. */ public static String[] split(String str, char delimiter) { return split(str, delimiter, false); } /** * Split a string based on the given delimiter, optionally removing * empty elements. * * @param str The string to be split. * @param delimiter Split string based on this delimiter. * @param removeEmpty If true then remove empty elements. * * @return Array of split strings. Guaranteeded to be not null. */ public static String[] split(String str, char delimiter, boolean removeEmpty) { // Return empty list if source string is empty. final int len = (str == null) ? 0 : str.length(); if (len == 0) { return new String[0]; } final List<String> result = new ArrayList<String>(); String elem = null; int i = 0, j = 0; while (j != -1 && j < len) { j = str.indexOf(delimiter,i); elem = (j != -1) ? str.substring(i, j) : str.substring(i); i = j + 1; if (!removeEmpty || !(elem == null || elem.length() == 0)) { result.add(elem); } } return result.toArray(new String[result.size()]); } /** * Joins the specified parts separating each from one another with the * specified delimiter. If delim is null, then this merely returns the * concatenation of all the parts. * * @param parts the strings to be joined * @param delim the char(s) that should separate the parts in the result * @return a string representing the joined parts. */ public static String join(String[] parts, String delim) { StringBuilder result = new StringBuilder(); for (int i = 0; i < parts.length; i++) { String part = parts[i]; result.append(part); if (delim != null && i < parts.length-1) { result.append(delim); } } return result.toString(); } public static String[] segment(String source, int maxSegmentSize) { ArrayList<String> tmp = new ArrayList<String>(); if (source.length() <= maxSegmentSize) { return new String[] { source }; } boolean done = false; int currBeginIdx = 0; int currEndIdx = maxSegmentSize; while (!done) { String segment = source.substring(currBeginIdx, currEndIdx); tmp.add(segment); if (currEndIdx >= source.length()) { done = true; continue; } currBeginIdx = currEndIdx; currEndIdx += maxSegmentSize; if (currEndIdx > source.length()) { currEndIdx = source.length(); } } return tmp.toArray(new String[tmp.size()]); } public static int getTokenBeginIndex(String selectSQL, String token) { String lowerSel = selectSQL.toLowerCase(); String lowerToken = token.toLowerCase().trim(); int curPos = 0; int count = 0; while(-1 != curPos) { curPos = lowerSel.indexOf(lowerToken, curPos + lowerToken.length()); if(-1 < curPos && (0 == curPos || Character.isWhitespace(lowerSel.charAt(curPos-1))) && (lowerSel.length() == curPos + lowerToken.length() || Character.isWhitespace(lowerSel.charAt(curPos + lowerToken.length()))) ) { return curPos; } // If we"ve loop through one time for each character in the string, // then something must be wrong. Get out! if (count++ > selectSQL.length()) { break; } } return curPos; } public static Byte[] getByteArray(byte[] bytes) { if (bytes == null || bytes.length == 0 ) { return new Byte[0]; } Byte[] result = new Byte[bytes.length]; for (int i = 0; i < bytes.length; i++) { result[i] = Byte.valueOf(bytes[i]); } return result; } /** * Chops off the very last character of the given string. * * @param aString a string to chop * @return the specified string minus it"s last character, or null for null * or empty string for a string with length == 0|1. */ public static String chop(String aString) { if (aString == null) { return null; } if (aString.length() == 0) { return ""; } if (aString.length() == 1) { return ""; } return aString.substring(0, aString.length()-1); } /** * Returns the platform-specific line separator, or "\n" if it is not defined for some reason. * * @return the platform-specific line separator. */ public static String getEolStr() { return System.getProperty("line.separator", "\n"); }
}
</source>
Split and join strings 2
<source lang="java">
import java.awt.FontMetrics; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; /**
* Globally available utility classes, mostly for string manipulation. * * @author Jim Menard, */
public class StringUtils {
protected static final int DEFAULT_MAX_MESSAGE_WIDTH = 78; /** * Returns a list of substrings created by splitting the given string at the * given delimiter. The return value will be*null
if the string * isnull
, else it will be a non-empty list of strings. If * delim isnull
or is not found in the string, the * list will contain one element: the original string.
* This isn"t the same thing as using a tokenizer. delim is a
* literal string, not a set of characters any of which may be a delimiter.
*
* @param str
* the string we"re splitting
* @param delim
* the delimter string
*/
public static List split(String str, String delim) {
if (str == null)
return null;
ArrayList list = new ArrayList();
if (delim == null) {
list.add(str);
return list;
}
int subStart, afterDelim = 0;
int delimLength = delim.length();
while ((subStart = str.indexOf(delim, afterDelim)) != -1) {
list.add(str.substring(afterDelim, subStart));
afterDelim = subStart + delimLength;
}
if (afterDelim <= str.length())
list.add(str.substring(afterDelim));
return list;
}
/**
* Returns a string consisting of all members of a collection separated by the
* specified string. The toString
method of each collection
* member is called to convert it to a string.
*
* @param c
* a collection of objects
* @param joinWith
* the string that will separate each member of the collection
*/
public static String join(Collection c, String joinWith) {
if (c == null)
return "";
StringBuffer buf = new StringBuffer();
boolean first = true;
for (Iterator iter = c.iterator(); iter.hasNext();) {
if (first)
first = false;
else if (joinWith != null)
buf.append(joinWith);
buf.append(iter.next().toString());
}
return buf.toString();
}
/**
* Returns an array of strings, one for each line in the string. Lines end
* with any of cr, lf, or cr lf. A line ending at the end of the string will
* not output a further, empty string.
* <p>
* This code assumes str is not null
.
*
* @param str
* the string to split
* @return a non-empty list of strings
*/
public static List splitIntoLines(String str) {
ArrayList strings = new ArrayList();
int len = str.length();
if (len == 0) {
strings.add("");
return strings;
}
int lineStart = 0;
for (int i = 0; i < len; ++i) {
char c = str.charAt(i);
if (c == "\r") {
int newlineLength = 1;
if ((i + 1) < len && str.charAt(i + 1) == "\n")
newlineLength = 2;
strings.add(str.substring(lineStart, i));
lineStart = i + newlineLength;
if (newlineLength == 2) // skip \n next time through loop
++i;
} else if (c == "\n") {
strings.add(str.substring(lineStart, i));
lineStart = i + 1;
}
}
if (lineStart < len)
strings.add(str.substring(lineStart));
return strings;
}
/**
* Appends a string to a string buffer, adding extra newlines so the message
* is not too wide. Max width is not guaranteed; if there is no space in a
* line before DEFAULT_MAX_MESSAGE_WIDTH
then the next one
* after it will be used insetead. Each line will be trimmed before and after
* it"s added, so some whitespace may be goofed up. This is used for error
* message wrapping, so it"s not critical that whitespace be preserved.
* <p>
* TODO Looks for space, not all whitespace. This should probably change.
*
* @param buf
* the string buffer
* @param str
* the string
*/
public static void splitUp(StringBuffer buf, String str) {
splitUp(buf, str, DEFAULT_MAX_MESSAGE_WIDTH);
}
/**
* Appends a string to a string buffer, adding extra newlines so the message
* is not too wide. Max width is not guaranteed; if there is no space in a
* line before maxWidth then the next one after it will be used
* instead. Each line will be trimmed before and after it"s added, so some
* whitespace may be goofed up. This is used for error message wrapping, so
* it"s not critical that whitespace be preserved.
* <p>
* TODO Looks for space, not all whitespace. This should probably change.
*
* @param buf
* the string buffer
* @param str
* the string
* @param maxWidth
* maximum number of chars in each line
*/
public static void splitUp(StringBuffer buf, String str, int maxWidth) {
if (str == null)
return;
str = str.trim();
while (str.length() >= maxWidth) {
int pos = str.lastIndexOf(" ", maxWidth);
if (pos == -1) { // No spaces before; look for first one after
pos = str.indexOf(" ", maxWidth);
if (pos == -1)
break;
}
buf.append(str.substring(0, pos).trim());
buf.append("\n");
str = str.substring(pos + 1).trim();
}
buf.append(str);
}
}
</source>