字符串SomeLongString = JavaAPIMethodFor（字符串[]字符串，字符串分隔符）

Question

String SomeLongString = JavaAPIMethodFor (String[] strings, String delimiter); 

或者这可能是工作，以及：

String SomeLongString = JavaAPIMethodConvertingArrayWithDelimeter (String[] strings, char delimiter) 

我想加入到字符串成一个更大的字符串，但这根本没用。我知道我可以使用Arrays.toString（Object someString）将所有数据附加到一个字符串中，然后调整字符串，删除不需要的字符。但是这不是很有效，只是为了重建它。所以通过的String []循环和各元素之间加入我的性格[S]可能是要走的路：

import static org.junit.Assert.*; 

import org.junit.Test; 

public class DelimetedString { 


    private String delimitedString(String [] test, String delimiter){ 
     StringBuilder result = new StringBuilder(); 
     int counter = 0; 
     if(test.length > counter){ 
      result.append(test[counter++]); 
      while(counter < test.length){ 
       result.append(delimiter); 
       result.append(test[counter++]); 
      } 
     } 
     return result.toString(); 
    } 

    @Test 
    public void test() { 
     String [] test = new String[] 
{"cat","dog","mice","cars","trucks","cups","I don't know", "anything!"}; 
     String delimiter = " |...| "; 
     assertEquals("DelimitedString misformed", 
     "cat |...| dog |...| mice |...| cars |...| trucks " 
      +"|...| cups |...| I don't know |...| anything!", 
     delimitedString(test, delimiter)); 
    } 

} 

我想要的是一些使用一个标记后，放在一起串什么。我放弃了这个想法，因为它可能更麻烦，所以它是值得的。我选择了从更大的字符串中处理子字符串，我在“答案”中包含了该代码。

我问的是 - java API是否具有与delimitedString函数等效的函数？几个人的回答似乎是否定的。

Answer 1

据我所知，没有内置的方法。你可以做的是采取它的子串：

String str = Arrays.toString(arrayHere); 
str = str.substring(1, str.lenght() - 1); 

Answer 2

这是一个类，我结束了扔在一起。我想将一个文本文件分解为块，然后通过使用行号的Servlet发送块以获取相关数据。这是一个在家中的服务器上运行的应用程序，它允许我在不同设备上阅读我的文本文件，并保留与文件相关的元数据。

package net.stevenpeterson.bookreaderlib; 

public class SplitStringUtility { 

private String subject; 

public SplitStringUtility(String subject) { 
    this.subject = subject; 
} 

public String getRow(int rowAddress, int charsPerRow) { 
    String result = ""; 
    if (rowAddress >= 0 && charsPerRow > 0) { 
     int startOfSubString = rowAddress * charsPerRow; 
     int endOfSubString = startOfSubString + charsPerRow; 
     result = getSubString(startOfSubString, endOfSubString); 
    } 
    return result; 
} 

private String getSubString(int startOfSubString, int endOfSubString) { 
    String result = ""; 
    if (startOfSubString <= subject.length()) { 
     if (endOfSubString <= subject.length()) { 
      result = subject.substring(startOfSubString, endOfSubString); 
     } else { 
      result = subject.substring(startOfSubString); 
     } 
    } 
    return result; 
} 

} 

我对测试：

package net.stevenpeterson.bookreaderlib; 

import static org.junit.Assert.*; 

import net.stevenpeterson.bookreaderlib.SplitStringUtility; 

import org.junit.Test; 

public class SplitStringUtilityTest { 

    public final String empty = ""; 
    public final String single ="a"; 
    public final String twoChars = "ab"; 
    public final String threeChars = "abc"; 
    public final String manyChars = "abcdefghijklmnopqrstuvwxyz"; 

    private SplitStringUtility splitter; 

    @Test 
    public void splitTestsEmpty() { 
     makeSplitter(empty); 
     assertEquals("We are trying to get a non-existant string", 
      "", 
      splitter.getRow(3,4)); 
    } 


    @Test 
    public void splitTestsNegativeRowOrColumn() { 
     makeSplitter(manyChars); 
     assertEquals("We are trying to get a non-existant string", 
      "", 
      splitter.getRow(-3,4)); 

     assertEquals("We are trying to get a non-existant string", 
      "", 
      splitter.getRow(-1,-1)); 

     assertEquals("We are trying to get a non-existant string", 
      "", 
      splitter.getRow(1,-1)); 
    } 



    @Test 
    public void splitTestsSingleCharacterStrings() { 
     makeSplitter(single); 

     assertEquals("split the string consisting of 1 character", 
      "a", 
      splitter.getRow(0,1)); 

     assertEquals("split the string consisting of 1 character, " + 
       "but ask for two characters, " + 
       "the string containing only a single char " + 
       "should be returned","a", splitter.getRow(0,2)); 

    } 

    @Test 
    public void splitTestsTwoChars() { 
     makeSplitter(twoChars); 
     assertEquals("Row #0 of the ab string in 1 column rows", 
      "a", 
      splitter.getRow(0,1)); 

     assertEquals("Row #1 of the ab string in 1 column rows", 
      "b", 
      splitter.getRow(1,1)); 

     assertEquals("Row #0 of the ab string in 2 column rows", 
      "ab", 
      splitter.getRow(0,2)); 

     assertEquals("Row #1 of the ab string in 4 column rows " 
      +"should return a blank string", 
      "", 
      splitter.getRow(1,4)); 

     assertEquals("Row #0 of the ab string in 4 column rows " 
      +"should return the ab string", 
      twoChars, 
      splitter.getRow(0,4)); 

    } 


    @Test 
    public void splitTestsManyChars() { 
     //split the alphabet into rows of 4 characters, return row 3 
     //Expect "mnop" 
     makeSplitter(manyChars); 
     assertEquals("Row #3 of the alphabet in 4 column rows", 
      "mnop", 
      splitter.getRow(3,4)); 

     assertEquals("Row #0 of the alphabet in 4 column rows", 
      "abcd", 
      splitter.getRow(0,4)); 

     assertEquals("Row #0 of the alphabet in 26 column rows", 
      manyChars, 
      splitter.getRow(0,26)); 

     assertEquals("Row #0 of the alphabet in 26 column rows", 
      "z", 
      splitter.getRow(1,25)); 

     assertEquals("Row #0 of the alphabet in 27 column rows" 
      + " since the alphabet has 26 characters " 
      + "it would be nice to get what we have", manyChars, 
      splitter.getRow(0,27)); 
    } 


    private void makeSplitter(String subject){ 
     splitter = new SplitStringUtility(subject); 
    } 


}