如何在java或Kotlin中拆分对象数组？

Question

我已经在这里问了一个问题，但是这个问题只回答了字符串。我不能编辑它，因为那里已经有几个答案了。

现在，我明白了如何用那篇文章中给出的空格分割它。但是，我如何用像这样的自定义类对象分割它：

public class User{
   private boolean isAdult = false;
   private int age = 0;

   @Override
   public String toString(){
      return "User : { isAdult = " + isAdult + "        age = " + age + "}"
   }

   // getters and setters
}

现在，我想在isAdult为false的地方拆分。例如，我有这个数组：

[User : { isAdult = true         age = 19}, User : { isAdult = false         age = 10}, User : { isAdult = true         age = 38}, User : { isAdult = false         age = 17}, User : { isAdult = true         age = 19}]

现在，如果将isAdult拆分为false，则如下所示：

Array1 = [User : { isAdult = true         age = 19}]
Array2 = [User : { isAdult = true         age = 38}]
Array3 = [User : { isAdult = true         age = 19}]

那么，如何在java或静态编程语言中实现这一点

Answer 1

根据tqurat的答复（Java）：

public static class User{
        boolean isFalse;
        int value;

        public User(boolean b, int v){
            this.isFalse = b;
            this.value = v;
        }

        public String toString() { return "User("+this.isFalse+", "+this.value+")"; }
}


 public static void main(String[] args) {
        User[] users = {new User(true, 5), new User(true, 1),new User(false, 7),
                new User(true, 10), new User(false, 3)};
        ArrayList<User[]> output = new ArrayList<>();

        int start = 0;
        int end = 0;
        while( end < users.length )
        {
            if( users[end].isFalse == false)
            {
                output.add( Arrays.copyOfRange( users, start, end  ));
                start = end + 1;
            }
            ++end;
        }
        if( start < end ) output.add( Arrays.copyOfRange( users, start, end ));

        for (User[] arr: output){
            System.out.println(Arrays.toString(arr));
        }

    }

给出输出：

[User(true, 5), User(true, 1)]
[User(true, 10)]

Answer 2

这是科特林的回答

我并不完全清楚，但假设您使用的是一个用户对象数组，此函数将返回一个数组，其中每个用户都是成年人：

fun convert(array : Array<User>) : Array<Array<User>> =
    array.filter { it.isAdult }.map { arrayOf(it) }.toTypedArray()

编辑：

从您希望将其分组为连续成年用户的公认答案来看，这里有一个完整的kotlin工作程序来演示它。转换没有分组，转换2具有：

data class User(var isAdult : Boolean, var age: Int) {
    override fun toString(): String {
        return "User : { isAdult = $isAdult        age = $age}"
    }
}

fun main() {
    val users = arrayOf(
        User(true, 3),
        User(true, 5),
        User(false, 6),
        User(true, 7),
        User(false, 9),
        User(true, 11)
    )

    for (array in convert(users)) {
        println(array.contentToString())
    }
    println("==============")
    for (array in convert2(users)) {
        println(array.contentToString())
    }
}

fun convert(array : Array<User>) : Array<Array<User>> =
    array.filter { it.isAdult }.map { arrayOf(it) }.toTypedArray()

fun convert2(array : Array<User>) : Array<Array<User>> =
    array.fold(arrayOf(arrayOf())) { result, user ->
        if (user.isAdult) {
            result.copyOf(result.lastIndex).filterNotNull().toTypedArray() + (result.last() + user)
        } else result + arrayOf<User>()
    }

输出：

[User : { isAdult = true        age = 3}]
[User : { isAdult = true        age = 5}]
[User : { isAdult = true        age = 7}]
[User : { isAdult = true        age = 11}]
==============
[User : { isAdult = true        age = 3}, User : { isAdult = true        age = 5}]
[User : { isAdult = true        age = 7}]
[User : { isAdult = true        age = 11}]