Fatal编程技术网
  • java/
  • Java 用于PHP'；s join（）？

Java 用于PHP'；s join（）？

java arrays join

Java 用于PHP'；s join（）？,java,arrays,join,Java,Arrays,Join,我想用胶粘字符串连接字符串[]。有用于此的函数吗？从Java8开始可以使用String.join（） 生成： Hello, World, ! 否则，将有一个类，该类具有一个函数，该函数将数组连接在一起，形成一个字符串 例如： StringUtils.join(new String[] {"Hello", "World", "!"}, ", ") String joined = TextUtils.join(";", MyStringArray); 生成以下字符串： Hello, World

我想用胶粘字符串连接
字符串[]
。有用于此的函数吗？

从Java8开始可以使用
String.join（）

生成：

Hello, World, !
否则，将有一个类，该类具有一个函数，该函数将数组连接在一起，形成一个
字符串

例如：


StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")



String joined = TextUtils.join(";", MyStringArray);


生成以下
字符串
：


Hello, World, !



不在core中，不在。搜索“java数组连接字符串胶水”将为您提供一些关于如何实现这一点的代码片段

e、 g


据我所知，没有任何内在的东西


Apache有一个名为的类，其中包含许多连接函数。
您可以用大约十行代码轻松编写这样一个函数：


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();
}



字符串组合（字符串[]s，字符串粘合）
{
int k=s.长度；
如果（k==0）
{
返回null；
}
StringBuilder out=新的StringBuilder（）；
out.append（s[0]）；
对于（int x=1；x
java.util.Arrays有一个“asList”方法。与java.util.List/ArrayList API一起，这为您提供了所需的一切：


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]);
}



私有静态字符串[]连接（字符串[]数组1，字符串[]数组2）{
List List=newarraylist（Arrays.asList（array1））；
addAll（Arrays.asList（array2））；
返回list.toArray（新字符串[0]）；
}

我就是这样做的


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();
}


鉴于：

然后，作为库伯德答案的替代，胶水是“，”：

或者使用不同的字符串连接，例如“&；”


然而。。。仅当您知道数组或列表中的值不包含字符串“，”一点mod，而不是使用substring（）时，此选项才有效：


//联接（字符串数组，分隔符）
公共静态字符串联接（字符串r[]，字符串d）
{
如果（r.length==0）返回“”；
StringBuilder sb=新的StringBuilder（）；
int i；

对于（i=0；iGoogleGuava的库也有。您也可以从API中看到String[]示例

正如api中已经描述的，请注意生成器方法的不变性

它可以接受一个对象数组，因此在您的情况下它可以工作。在我以前的经验中，我尝试加入一个iterable堆栈，它工作得很好

我的样本：


Deque<String> nameStack = new ArrayDeque<>();
nameStack.push("a coder");
nameStack.push("i am");
System.out.println("|" + Joiner.on(' ').skipNulls().join(nameStack) + "|");



Deque nameStack=new ArrayDeque（）；
nameStack.push（“编码器”）；
nameStack.push（“我是”）；
System.out.println（“|”+Joiner.on（“”）.skipNulls（）.join（nameStack）+“|”）；


打印出：
|我是一名编码员
如果您正在使用，那么您就拥有了该类：


如果您在这里寻找快速的数组到字符串转换，请尝试

创建传递的
对象[]
的字符串表示形式。结果为
每个元素都被括号（
“[]”
）包围，并转换为字符串
通过
字符串.valueOf（Object）
并用
分隔，“
。如果数组是

null
，然后返回
“null”

类似的选择


/**
 * @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();
}



/**
*@param分隔符
*@param inStr
*@返回字符串
*/
公共静态字符串联接（字符串分隔符、字符串…指令）
{
StringBuilder sb=新的StringBuilder（）；
如果（仪表长度>0）
{
sb.追加（inStr[0]）；
对于（int i=1；i
如果您想在android中使用什么，它是：


String android.text.TextUtils.join(CharSequence delimiter, Object[] tokens)


例如：


StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")



String joined = TextUtils.join(";", MyStringArray);



我使用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)



公共静态字符串联接（字符串[]源，字符串分隔符）{
if（（null==源）| |（source.length<1））{
返回“”；
}
StringBuilder StringBuilder=新的StringBuilder（）；
for（字符串s：源）{
追加（s+分隔符）；
}
返回stringbuilder.toString（）；
}//连接（（字符串[]，字符串）


有一种简单的速记技巧我大部分时间都在使用

就为了“我有最短的一个”的挑战，这里有我的；）

迭代：


公共静态字符串联接（字符串s、对象…a）{
StringBuilder o=新的StringBuilder（）；
for（迭代器i=Arrays.asList（a.Iterator（）；i.hasNext（）；）
o、 append（i.next（））.append（i.hasNext（）？s:）；
返回o.toString（）；
}


递归：


公共静态字符串联接（字符串s、对象…a）{
返回a.length==0？”“：a[0]+（a.length==1？”：s+连接（s，Arrays.copyOfRange（a，1，a.length））；
}

您喜欢我的仅使用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());
}


在Java8中，您可以使用

1） 流API：


String[] a = new String[] {"a", "b", "c"};
String result = Arrays.stream(a).collect(Collectors.joining(", "));


2） 新的String.join方法：

3） java.util.StringJoiner类：
My spin


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, "");
}



公共静态字符串联接（对象[]对象，字符串分隔符）{
如果（objects.length==0）{
返回“”；
}
int capacityGuess=（objects.length*对象[0].toString（）.length（））
+（（objects.length-1）*delimiter.length（））；
StringBuilder ret=新的StringBuilder（capacityGuess）；
ret.append（对象[0]）；
for（int i=1；i
与最近的许多问题一样，Java 8起到了拯救作用：



Java 8在
Java.lang.String
中添加了一个新的静态方法，它完全满足您的需要：


public static String join(CharSequence delimeter, CharSequence... elements);


使用它：


String s = String.join(", ", new String[] {"Hello", "World", "!"});


结果：


"Hello, World, !"


要从“str1”、“str2”和“”中获取“str1，str2”：


此外，如果您正在使用Functional Java library，并且由于某些原因无法使用来自Java 8的流（在使用Android+Retrolambda插件时可能会出现这种情况），您还可以添加额外的null检查，以下是一个功能解决方案：


String joinWithSeparator(List<String> items, String separator) {
    return items
            .bind(id -> list(separator, id))
            .drop(1)
            .foldLeft(
                    (result, item) -> result + item,
                    ""
            );
}



String joinWithSeparator（列表项、字符串分隔符）{
退货项目
.bind（id->list（分隔符，id

String[] a = new String[] {"a", "b", "c"};
String result = Arrays.stream(a).collect(Collectors.joining(", "));



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, "");
}



public static String join(CharSequence delimeter, CharSequence... elements);



String s = String.join(", ", new String[] {"Hello", "World", "!"});



"Hello, World, !"



Stream.of("str1", "str2", "").filter(str -> !str.isEmpty()).collect(Collectors.joining(", ")); 



String joinWithSeparator(List<String> items, String separator) {
    return items
            .bind(id -> list(separator, id))
            .drop(1)
            .foldLeft(
                    (result, item) -> result + item,
                    ""
            );
}