Java 在这种情况下，如何创建子列表。。。？

假设我有这样一个列表：

[a, b, c, d, e, f, PASS, g, h]

但我希望无论何时出现单词

“PASS”

，都用剩余的数据制作另一个列表

像这样：

[[a, b, c, d, e, f], [g, h]]

---

下面是一个使用循环“拆分”分隔符上的

可比较的

列表的方法：

private static <T extends Comparable<T>> List<List<T>> split(
       List<T> original, T delimiter) {

    List<List<T>> res = new ArrayList<>();

    List<T> current = new ArrayList<>();
    for (T f : original) {
        if (f.compareTo(delimiter) == 0) {
            res.add(current);
            current = new ArrayList<>();
            continue;
        }

        current.add(f);
    }

    if (!current.isEmpty()) {
        res.add(current);
    }

    return res;
}

---

你的案子的另一个解决方案

public static void main(String[] args) {

    String[] ar = { "a", "b", "c", "d", "e", "f", "PASS", "g", "h" };

    ArrayList<String> al = new ArrayList<String>(Arrays.asList(ar));

    ArrayList<String> al1 = new ArrayList<String>(al.subList(0, al.indexOf("PASS")));

    ArrayList<String> al2 = new ArrayList<String>(al.subList(al.indexOf("PASS") + 1, al.size()));

    ArrayList<ArrayList<String>> listOLists = new ArrayList<ArrayList<String>>();
    listOLists.add(al1);
    listOLists.add(al2);

}

publicstaticvoidmain（字符串[]args）{
字符串[]ar={“a”、“b”、“c”、“d”、“e”、“f”、“PASS”、“g”、“h”}；
ArrayList al=新的ArrayList（Arrays.asList（ar））；
ArrayList al1=新的ArrayList（al.subList（0，al.indexOf（“PASS”））；
ArrayList al2=新的ArrayList（al.subList（al.indexOf（“PASS”）+1，al.size（））；
ArrayList listOLists=新的ArrayList（）；
添加（al1）；
添加（al2）；
}

您可以从创建startIndex和endIndex开始。跟踪每个索引，当您看到“PASS”时，只需将列表从startIndex到endIndex制作一个子列表。然后，相应地更新索引

public static List<List<String>> getSplittedList (List<String> li)
   {
    List<List<String>> lists = new ArrayList<>();
    int startIndex = 0;
    int endIndex = 0;
    for(int i = 0; i < li.size(); i++)
    {
        if(li.get(i).equals("PASS"))
        {
            if(startIndex < endIndex)
                lists.add(li.subList(startIndex, endIndex));
            startIndex = i+1;
            endIndex = i+1;
        }
        else
            endIndex++;
    }
    if(startIndex < li.size())
        lists.add(li.subList(startIndex, li.size()));
    return lists;
}

公共静态列表getSplittedList（列表li）
{
List lists=新建ArrayList（）；
int startIndex=0；
int-endIndex=0；
对于（int i=0；i

这可以作为一种通用方法编写（我的stackoverflow答案中已经有了这个方法，所以我想我以前在某个地方读过这方面的内容……我会尝试找到具体的位置）：

私有静态列表拆分依据（列表列表，T分隔符）{
int[]index=IntStream.rangeClosed（-1，list.size（））
.filter（i->i==-1
||i==list.size（）
||delimiter.equals（list.get（i））.toArray（）；
返回IntStream.range（0，index.length-1）
.mapToObj（x->list.subList（索引[x]+1，索引[x+1]））
//或者从java-11开始，更好一点：
//.filter（谓词.not（列表：：isEmpty））
.filter（l->！l.isEmpty（））
.collect（Collectors.toList（））；
}

我安排了简单的解决方案，请检查此方案是否适合您。多谢各位

/**
 * @author Duminda Hettiarachchi
*/


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StringSubList {

ArrayList<String> subList;

public StringSubList() {
    subList = new ArrayList<String>();
}

public void subList(List<String> list) {

    int passIndex = list.indexOf("PASS");

    List<String> list1 = (List<String>) list.subList(0, passIndex);
    List<String> list2 = (List<String>) list.subList(passIndex+1, list.size());

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

    subLists.add(list1);
    subLists.add(list2);

    System.out.println("List 1 :" + subLists.get(0));
    System.out.println("List 2 : " + subLists.get(1));
}

public static void main(String[] args) {

    String mainArr[] = {"a", "b", "c", "d", "e", "f", "PASS", "g", "h"};

    List<String> myList = Arrays.asList("a", "b", "c", "d", "e", "f", "PASS", "g", "h");

    new StringSubList().subList(myList);       `enter code here`

    }
}

/**
*@作者杜明达·赫蒂亚拉奇
*/
导入java.util.ArrayList；
导入java.util.array；
导入java.util.List；
公共类子列表{
ArrayList子列表；
公共子列表（）{
subList=新的ArrayList（）；
}
公共无效子列表（列表）{
int passIndex=list.indexOf（“PASS”）；
List list1=（List）List.subList（0，passIndex）；
list2=（List）List.subList（passIndex+1，List.size（））；
列表子列表=新建ArrayList（）；
子列表。添加（列表1）；
子列表。添加（列表2）；
System.out.println（“列表1:+子列表.get（0））；
System.out.println（“列表2:+子列表.get（1））；
}
公共静态void main（字符串[]args）{
字符串mainArr[]={“a”、“b”、“c”、“d”、“e”、“f”、“PASS”、“g”、“h”}；
List myList=array.asList（“a”、“b”、“c”、“d”、“e”、“f”、“PASS”、“g”、“h”）；
new StringSubList（）.subList（myList）；`在此处输入代码`
}
}

输出：

清单1:[a、b、c、d、e、f]

---

清单2:[g，h]

非常有趣的方法。您可能只需要记下一个事实，即您希望

T

有一个正确重写的

对象。equals

@ernest\k这不是我的方法，我理解并记住这一点，但最初不是我的想法。。。

private static <T> List<List<T>> splitBy(List<T> list, T delimiter) {

    int[] indexes = IntStream.rangeClosed(-1, list.size())
            .filter(i -> i == -1 
                    || i == list.size()
                    || delimiter.equals(list.get(i))).toArray();

    return IntStream.range(0, indexes.length - 1)
            .mapToObj(x -> list.subList(indexes[x] + 1, indexes[x + 1]))
            // or since java-11, a bit nicer:
            // .filter(Predicate.not(List::isEmpty))
            .filter(l -> !l.isEmpty())
            .collect(Collectors.toList());
}

/**
 * @author Duminda Hettiarachchi
*/


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StringSubList {

ArrayList<String> subList;

public StringSubList() {
    subList = new ArrayList<String>();
}

public void subList(List<String> list) {

    int passIndex = list.indexOf("PASS");

    List<String> list1 = (List<String>) list.subList(0, passIndex);
    List<String> list2 = (List<String>) list.subList(passIndex+1, list.size());

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

    subLists.add(list1);
    subLists.add(list2);

    System.out.println("List 1 :" + subLists.get(0));
    System.out.println("List 2 : " + subLists.get(1));
}

public static void main(String[] args) {

    String mainArr[] = {"a", "b", "c", "d", "e", "f", "PASS", "g", "h"};

    List<String> myList = Arrays.asList("a", "b", "c", "d", "e", "f", "PASS", "g", "h");

    new StringSubList().subList(myList);       `enter code here`

    }
}