Question

我需要能够编写自己的分割字符串方法，以便像

那样输入

String[] test1 = mySplit("ab#cd#efg#", "#");
System.out.println(Arrays.toString(test1));

将[ab, #, cd, #, efg, #]打印到控制台。到目前为止，我已经将它分开了，但是我的方式留下了尴尬的空间，其中2个分隔符连续，或者分隔符位于输入的开头。

public static String[] mySplit(String str, String regex)
{
    String[] storeSplit = new String[str.length()];
    char compare1, compare2;
    int counter = 0;

    //Initializes all the string[] values to "" so when the string
    //and char concatonates, 'null' doesn't appear.
    for(int i=0; i<str.length(); i++) {
        storeSplit[i] = "";
    }

    //Puts the str values into the split array and concatonates until
    //a delimiter is found, then it moves to the next array index.
    for(int i=0; i<str.length(); i++) {
        compare1 = str.charAt(i);
        compare2 = regex.charAt(0);

            if(!(compare1 == compare2)) {
                storeSplit[counter] += ""+str.charAt(i);
            } else {
                counter++;
                storeSplit[counter] = ""+str.charAt(i);
                counter++;
            }
    }
    return storeSplit;
}

当我在Test main中使用该方法时，我得到输出[ab，＃，cd，＃，efg，＃,,,,]。所以我迷失了如何修复它的间距，我还需要能够允许我的代码当前无法处理的多个分隔符。

此外，我知道此代码实际上很草率，只是在优化之前尝试放下概念。

Answer 1

问题很简单，你有一个偏移通过寻找新的匹配（pos），另一个显示你找到匹配（开始）的最后一个地方的结束。

public static String[] mySplit(String str, String regex)
{
    Vector<String> result = new Vector<String>;
    int start = 0;
    int pos = str.indexOf(regex);
    while (pos>=start) {
        if (pos>start) {
            result.add(str.substring(start,pos));
        }
        start = pos + regex.length();
        result.add(regex);
        pos = str.indexOf(regex,start); 
    }
    if (start<str.length()) {
        result.add(str.substring(start));
    }
    String[] array = result.toArray(new String[0]);
    return array;
}

这样可以避免额外循环并仅复制每个字符一次。实际上，由于子字符串的工作方式，不会复制任何字符，只会创建指向原始字符缓冲区的小字符串对象。根本没有完成字符串的连接，这是一个重要的考虑因素。

Answer 2

我认为你的问题是你分配的storeSplit []的长度比你需要的长。如果允许使用ArrayList，则使用它来累积结果（并使用ArrayList.toArray（）方法获取函数的最终返回值。）

如果你不能使用ArrayList，那么你需要在返回之前截断你的数组（你的计数器变量将用于确定正确的长度）。为此，您需要分配一个正确长度的数组，然后使用System.arraycopy来填充它。更简单的使用ArrayList，但我不知道你的任务的确切要求。

Answer 3

正如评论中指出的那样，问题在于您将数组大小设置为String的长度。相反，您希望将其设置为两倍于分隔符的数量。然后，相应地调整：

如果第一个字符是分隔符，则减去一个
如果最后一个字符不是分隔符，请添加一个。

// Calculate number of delimiters in str
int delimiters = str.length() - str.replaceAll(regex, "").length();
// Calculate array size
int arraySize = (delimiters * 2) + (str.startsWith(regex) ? -1 : 0);
arraySize = str.endsWith(regex) ? arraySize : arraySize + 1;
String[] storeSplit = new String[arraySize];

Answer 4

看起来你遇到的间距问题是因为你的storeSplit数组是一个固定的长度。

假设您的输入字符串长度为5个字符;你的storeSplit数组将有5个'空格'。该输入字符串可能只包含一个分隔符; “ab＃ef”例如，创建3个子字符串 - “ab”，“＃”和“ef”。

要避免这种情况，请改为创建一个List：

List<String> storeSplit = new ArrayList<String>();

然后，不是递增计数器并删除文本，而是添加到列表中：

storeSplit.add(""+str.charAt(i));

而不是

storeSplit[counter] = ""+str.charAt(i);

Answer 5

以下是我要做的事情：

String[] test1 = "ab#cd#efg#".split("#");//splits the string on '#'
String result="";
for(String test:test1)//loops through the array
    result+="#"+test;//adds each member to the array putting the '#' in front of each one
System.out.println(result.substring(1));//prints out the string minus the first char, which is a '#'

我希望这会有所帮助。

Answer 6

here is the output of my code simply click on it软件包演示;

public class demo8 {

static int count = 0;
static int first = 0;
static int j = 0;

public static void main(String[] args) {

    String s = "ABHINANDAN TEJKUMAR CHOUGULE";
    int size = 0;

    for (int k = 0; k < s.length(); k++) {
        if (s.charAt(k) == ' ') {
            size++;
        }

    }

    String[] last = new String[size + 1];

    for (int i = 0; i < s.length(); i++) {
        int temp = s.length();

        if (i == s.length() - 1) {
            last[j] = s.substring(first, i + 1);
        }

        if (s.charAt(i) == ' ') {
            last[j] = s.substring(first, i);
            j++;
            first = i + 1;

        }

    }
    for (String s1 : last) {
        System.out.println(s1);
    }
[I tested my code and output is also attached with it ...!][1]}}

Answer 7

我已经使用递归来解决它。

static void splitMethod(String str, char splitChar, ArrayList<String> list) {
        String restOfTheStr = null;
        StringBuffer strBufWord = new StringBuffer();
        int pos = str.indexOf(splitChar);
        if(pos>=0) {
            for(int i = 0; i<pos; i++) {
                strBufWord.append(str.charAt(i));
            }
            String word = strBufWord.toString();
            list.add(word);
            restOfTheStr = str.substring(pos+1);//As substring includes the 
            //splitChar, we need to do pos + 1
            splitMethod(restOfTheStr, splitChar, list);
        }
        if(pos == -1) {
            list.add(str);
            return;
        }

    }

使用：

ArrayList<String> list= new ArrayList<String>();//in this list
    //the words will be stored
    String str = "My name is Somenath";
    splitMethod(str,' ', list );

Answer 8

下面是方法

UPDATE A A
SET
    A.COL_A_B = (
        SELECT
            COL_B
        FROM
            (
                SELECT
                    COL_B,
                    TRUNC(DBMS_RANDOM.VALUE(1, COUNT(1) OVER())) RANDOM_NUMBER  --GENERATES RANDOM NUMBER
                FROM
                    (
                        SELECT DISTINCT
                            B.COL_B -- FETCHING DISTINCT RESULT
                        FROM
                            B B
                            -- EXISTS IS CONVERTED INTO JOIN
                            JOIN C C ON ( B.ID = C.COL_B_ID 
                                          AND C.COL_C = 'c1' )
                    )
                ORDER BY
                    RANDOM_NUMBER -- ORDERING IS DONE BY RANDOM NUMBER
                FETCH FIRST ROWS ONLY -- FETCHING ONLY FIRST ROW FROM ORDERED RECORDS
            )
    )

Answer 9

    public List<String> split(String str , String regex) {
    char c ;
    int count=0;
    int len = regex.length();
    String temp;
    List<String> result = new ArrayList<>();
    for(int i=0;i<str.length();i++) {
        //System.out.println(str.substring(i, i+len-1));
        temp = str.substring(i, i+len>str.length()?str.length():i+len);
        if(temp.compareTo(regex) == 0) {
            result.add(str.substring(count , i));
            count = i+len;
        }
    }
    result.add(str.substring(count, str.length()));
    return result;
}

Java，编写自己的split string方法

9 个答案: