Eu quero juntar um String[]
com uma corda de cola. Existe uma função para isso?
Eu quero juntar um String[]
com uma corda de cola. Existe uma função para isso?
Respostas:
A partir do Java8 , é possível usar String.join()
.
String.join(", ", new String[]{"Hello", "World", "!"})
Gera:
Hello, World, !
Caso contrário, o Apache Commons Lang tem uma StringUtils
classe que possui uma join
função que unirá matrizes para criar a String
.
Por exemplo:
StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")
Gera o seguinte String
:
Hello, World, !
String.join()
método introduzido no Java 8. Dessa forma, o grande número de pessoas que lêem essa resposta aceita se beneficiará desse conhecimento. Atualmente, o mais votado resposta mencionar este fato é bastante perdido abaixo ...
String.join()
funcionaria apenas para List<CharSequence>
ou CharSequence[]
elementos.
Se você estava procurando o que usar no Android, é:
String android.text.TextUtils.join(CharSequence delimiter, Object[] tokens)
por exemplo:
String joined = TextUtils.join(";", MyStringArray);
No Java 8 você pode usar
1) API de fluxo:
String[] a = new String[] {"a", "b", "c"};
String result = Arrays.stream(a).collect(Collectors.joining(", "));
2) novo método String.join: https://stackoverflow.com/a/21756398/466677
3) classe java.util.StringJoiner: http://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html
Você poderia escrever facilmente essa função em cerca de dez linhas de código:
String combine(String[] s, String glue)
{
int k = s.length;
if ( k == 0 )
{
return null;
}
StringBuilder out = new StringBuilder();
out.append( s[0] );
for ( int x=1; x < k; ++x )
{
out.append(glue).append(s[x]);
}
return out.toString();
}
Um pequeno mod em vez de usar substring ():
//join(String array,delimiter)
public static String join(String r[],String d)
{
if (r.length == 0) return "";
StringBuilder sb = new StringBuilder();
int i;
for(i=0;i<r.length-1;i++){
sb.append(r[i]);
sb.append(d);
}
sb.append(r[i]);
return sb.toString();
}
.append()
duas vezes para cada um em String
vez de concatená-las e depois anexá-las ao construtor.
Como com muitas perguntas recentemente, o Java 8 para o resgate:
O Java 8 adicionou um novo método estático ao java.lang.String
qual faz exatamente o que você deseja:
public static String join(CharSequence delimeter, CharSequence... elements);
Usando isso:
String s = String.join(", ", new String[] {"Hello", "World", "!"});
Resulta em:
"Hello, World, !"
A biblioteca do Google goiaba também possui esse tipo de capacidade . Você pode ver o exemplo String [] também na API.
Como já descrito na API, tenha cuidado com a imutabilidade dos métodos do construtor.
Ele pode aceitar uma variedade de objetos para funcionar no seu caso. Na minha experiência anterior, tentei ingressar em um Stack que é iterável e funciona bem.
Amostra de mim:
Deque<String> nameStack = new ArrayDeque<>();
nameStack.push("a coder");
nameStack.push("i am");
System.out.println("|" + Joiner.on(' ').skipNulls().join(nameStack) + "|");
imprime: |i am a coder|
Dado:
String[] a = new String[] { "Hello", "World", "!" };
Então, como uma alternativa à resposta de coobird, onde a cola é ",":
Arrays.asList(a).toString().replaceAll("^\\[|\\]$", "")
Ou para concatenar com uma sequência diferente, como "& amp;".
Arrays.asList(a).toString().replaceAll(", ", " & ").replaceAll("^\\[|\\]$", "")
No entanto ... este funciona SOMENTE se você souber que os valores na matriz ou na lista NÃO contêm a cadeia de caracteres ",".
Arrays.asList(a).toString()
trabalhou para o que eu queria fazer
Se você estiver usando o Spring Framework , terá a classe StringUtils :
import static org.springframework.util.StringUtils.arrayToDelimitedString;
arrayToDelimitedString(new String[] {"A", "B", "C"}, "\n");
Não no núcleo, não. Uma pesquisa por "cola de cadeia de junção de matriz java" fornecerá alguns trechos de código sobre como conseguir isso.
por exemplo
public static String join(Collection s, String delimiter) {
StringBuffer buffer = new StringBuffer();
Iterator iter = s.iterator();
while (iter.hasNext()) {
buffer.append(iter.next());
if (iter.hasNext()) {
buffer.append(delimiter);
}
}
return buffer.toString();
}
Se você chegou aqui procurando uma conversão rápida de matriz para string, tente Arrays.toString () .
Cria uma representação String do
Object[]
passado. O resultado é cercado por colchetes ("[]"
), cada elemento é convertido em uma String por meio deString.valueOf(Object)
e separado por", "
. Se a matriz fornull
, então"null"
será retornado.
Apenas para o desafio "Eu tenho o menor" , aqui estão as minas;)
Iterativo:
public static String join(String s, Object... a) {
StringBuilder o = new StringBuilder();
for (Iterator<Object> i = Arrays.asList(a).iterator(); i.hasNext();)
o.append(i.next()).append(i.hasNext() ? s : "");
return o.toString();
}
Recursivo:
public static String join(String s, Object... a) {
return a.length == 0 ? "" : a[0] + (a.length == 1 ? "" : s + join(s, Arrays.copyOfRange(a, 1, a.length)));
}
copyOfRange()
").
Nada embutido que eu conheça.
O Apache Commons Lang tem uma classe chamada StringUtils
que contém muitas funções de junção.
É assim que eu faço.
private String join(String[] input, String delimiter)
{
StringBuilder sb = new StringBuilder();
for(String value : input)
{
sb.append(value);
sb.append(delimiter);
}
int length = sb.length();
if(length > 0)
{
// Remove the extra delimiter
sb.setLength(length - delimiter.length());
}
return sb.toString();
}
Uma alternativa semelhante
/**
* @param delimiter
* @param inStr
* @return String
*/
public static String join(String delimiter, String... inStr)
{
StringBuilder sb = new StringBuilder();
if (inStr.length > 0)
{
sb.append(inStr[0]);
for (int i = 1; i < inStr.length; i++)
{
sb.append(delimiter);
sb.append(inStr[i]);
}
}
return sb.toString();
}
Minha rotação.
public static String join(Object[] objects, String delimiter) {
if (objects.length == 0) {
return "";
}
int capacityGuess = (objects.length * objects[0].toString().length())
+ ((objects.length - 1) * delimiter.length());
StringBuilder ret = new StringBuilder(capacityGuess);
ret.append(objects[0]);
for (int i = 1; i < objects.length; i++) {
ret.append(delimiter);
ret.append(objects[i]);
}
return ret.toString();
}
public static String join(Object... objects) {
return join(objects, "");
}
Você gosta do meu caminho de 3 linhas usando apenas os métodos da classe String?
static String join(String glue, String[] array) {
String line = "";
for (String s : array) line += s + glue;
return (array.length == 0) ? line : line.substring(0, line.length() - glue.length());
}
StringBuilder
se você precisar de eficiência: P
Caso você esteja usando a biblioteca Java Funcional e, por algum motivo, não possa usar o Streams do Java 8 (que pode ser o caso ao usar o plug-in Android + Retrolambda), aqui está uma solução funcional para você:
String joinWithSeparator(List<String> items, String separator) {
return items
.bind(id -> list(separator, id))
.drop(1)
.foldLeft(
(result, item) -> result + item,
""
);
}
Observe que não é a abordagem mais eficiente, mas funciona bem para pequenas listas.
Eu faço dessa maneira usando um StringBuilder:
public static String join(String[] source, String delimiter) {
if ((null == source) || (source.length < 1)) {
return "";
}
StringBuilder stringbuilder = new StringBuilder();
for (String s : source) {
stringbuilder.append(s + delimiter);
}
return stringbuilder.toString();
} // join((String[], String)
s + delimiter
(concatenação de cadeia de caracteres com o operador mais) anula todo o objetivo de usar a StringBuilder
.
Existe uma técnica simples de taquigrafia que uso na maioria das vezes.
String op = new String;
for (int i : is)
{
op += candidatesArr[i-1]+",";
}
op = op.substring(0, op.length()-1);
java.util.Arrays possui um método 'asList'. Juntamente com a API java.util.List / ArrayList, você fornece tudo o que você precisa :;
private static String[] join(String[] array1, String[] array2) {
List<String> list = new ArrayList<String>(Arrays.asList(array1));
list.addAll(Arrays.asList(array2));
return list.toArray(new String[0]);
}