Java8中的拆分和循环

我想用java 8解决这个问题

我有一个由

A.B.C.D

字符串中的字符数可能会有所不同

我有一个方法，它把字符串作为输入，它的深度是多少， 我必须循环使用“.”对字符串进行拆分后得到的数字，然后进入给定的深度

private String getResponse (String str, int level) {
// for now, simply print the entire string first and then start removing last alphabet of it one by one till the value of level
// ex : str = A.B.C.D
// System.out.println("Doing a call with key as = " + str); => should give me A.B.C.D
// Apply logic of split 
// System.out.println("Doing a call with key as = " + str); => should give me A.B.C
// Split again
// System.out.println("Doing a call with key as = " + str); => should give me A.B
// this should go in loop till we reach the level
}

---

这可以在java 8中完成吗？

注意：不使用java 8解决问题

public class StringLoop {

    public static void main(String[] args) {

        getResponse("A.B.C.D", 2);

        System.out.println();
        getResponse("A.B.C.D", 3);

    }

    // Recursive function
    private static void getResponse (String str, int level) {

        if(level < 0 || str.equals(""))
            return;

        // Prints out the current string
        System.out.println(str);

        int lastIndex = str.lastIndexOf(".");
        if(lastIndex == - 1)
            lastIndex = 0;

        // Remove content after last connector
        // Decrement level
        getResponse(str.substring(0, lastIndex), level - 1);
    }
}

---

以下是Java-8解决方案：

static void getResponse(String input, int level) {
    Stream.iterate(input, str -> {
        int pos = str.lastIndexOf('.');
        return pos == -1 ? "" : str.substring(0, pos);
    }).limit(level+1).forEach(System.out::println);
}

如果您确定该级别不超过点数，则可以省略检查：

static void getResponseUnsafe(String input, int level) {
    Stream.iterate(input, str -> str.substring(0, str.lastIndexOf('.')))
            .limit(level + 1).forEach(System.out::println);
}

---

您的注释提到使用

split（）

，因此下面是一个使用

split（）

、

Arrays.copyOfRange（）

（删除最后一个字母）和

String.Join（）

将

Arrays.copyOfRange（）

的结果放回一起进行下一次递归调用的示例

public static void main(String[] args) {
    String string = "A.B.C.D";
    getResponse(string, 3);
    System.out.println();

    getResponse(string, 2);
    System.out.println();

    getResponse(string, 1);
    System.out.println();
}

private static void getResponse(String str, int level) {
    if (level < 0 || str.isEmpty())
        return;

    System.out.println(str);

    String[] strPieces = str.split("\\.");
    if (strPieces.length > level) {
        getResponse(String.join(".", Arrays.copyOfRange(strPieces, 0, strPieces.length - 1)), level - 1);
    }
}

---

不需要循环，因为字符串可以在单个

string.split调用中拆分为一个数组。（注意
String.split
需要一个正则表达式。）要处理“level”，只需从split数组的长度中减去它。不要复制数组子范围，而是将其转换为列表并使用subList（）：

请注意，这确实需要Java8，因为它需要
String.join（）
。（但它不需要流，甚至不需要lambda！）
如果您只对结果
String
感兴趣，则无需创建中间
String
s，也无需拆分为多个部分，然后将它们粘在一起。只需迭代
字符串中的匹配索引
，并创建一个结果
字符串
：

static String getResponse(String str, int level) {
    for(int index=str.length(); index>0; index=str.lastIndexOf('.', index-1))
        if(level-- == 0) return str.substring(0, index);
    if(level==0) return "";
    throw new IllegalArgumentException(str+" has not enough dots");
}

这没有使用任何Java 8功能，但也很难想象Java 8功能会如何改进这个简单的操作…
那么您的问题是什么？您是否试图打印出
A.B.C.D
，然后是
A.B.C
，依此类推，最后一个是
A
？你说的“给定深度”是什么意思？最后一个可能不是A，我应该停下来，直到我达到深度的值。如果级别的值为2，我应该在A.BIf停止。如果级别为3，
A.B.C
？因此，它就像连接器的最终数量，即在这种情况下，
，应该等于
级别-1
？如果级别为3，则只需
A
。我必须从最后一个开始，向第一个移动。你可以通过一次拆分得到一个字符串数组。那有什么问题？
A.B.C.D
A.B.C
A.B
A

A.B.C.D
A.B.C
A.B

A.B.C.D
A.B.C

String getResponse(String str, int level) {
    String[] splits = str.split("\\.");
    if (level < 0 || level > splits.length) {
        throw new IllegalArgumentException();
    }
    return String.join(".", Arrays.asList(splits).subList(0, splits.length - level));
}

    for (int level = 0; level < 5; level++) {
        System.out.printf("level %d: %s%n", level, getResponse("A.B.C.D", level));
    }

level 0: A.B.C.D
level 1: A.B.C
level 2: A.B
level 3: A
level 4: 

static String getResponse(String str, int level) {
    for(int index=str.length(); index>0; index=str.lastIndexOf('.', index-1))
        if(level-- == 0) return str.substring(0, index);
    if(level==0) return "";
    throw new IllegalArgumentException(str+" has not enough dots");
}