Java 有没有一种方法可以递归调用findMatch？

在这个问题中，我需要编写一个findMatch方法，该方法接收一个“流”（IFL的意思是模拟一个流），并找到流中传递谓词的第一个元素。我的尝试如下：

import java.util.function.Predicate;
import java.util.Optional;
import java.util.ArrayList;
import java.util.List;

class IFL<T> {
    Supplier<T> head;
    Supplier<IFL<T>> tail;

    IFL(Supplier<T> head, Supplier<IFL<T>> tail) {
        this.head = head;
        this.tail = tail;
    }

    static <T> IFL<T> of(List<? extends T> list) {
        return new IFL<T>(
            () -> list.get(0),
            () -> IFL.of(list.subList(1, list.size()))) {
        };
    }       

    Optional<T> findMatch(Predicate<? super T> predicate) {
        if (predicate.test(head.get())) {
            return Optional.of(this.head.get());
        } else {
            if (this.tail.get().findMatch(predicate).isPresent()) {
                return this.tail.get().findMatch(predicate);
            }
            return Optional.empty();
        }
    }
}

---

对于

列表#子列表

方法

（从索引<0 | |到索引>大小| |从索引>到索引）的非法端点索引值，会引发
索引异常

在您的
IFL#of
方法中，您需要检查给定列表的大小是否为1。如果是，请将
tail
设置为空列表

static <T> IFL<T> of(List<? extends T> list) {
 return new IFL<T>(
     () -> list.get(0),
     () -> IFL.of(list.size == 1 ? new ArrayList<T>() : list.subList(1, list.size()))) {
 };

的静态IFL（列表尝试使用以下代码

import java.util.Arrays;
import java.util.function.Predicate;
import java.util.Optional;
import java.util.List;
import java.util.function.Supplier;

class IFL<T> {
    Supplier<T> head;
    Supplier<IFL<T>> tail;
    List<? extends T> list;

    IFL(Supplier<T> head, Supplier<IFL<T>> tail, List<? extends T> list) {
        this.head = head;
        this.tail = tail;
        this.list = list;
    }

    static <T> IFL<T> of(List<? extends T> list) {
        return new IFL<T>(
                () -> list.get(0),
                () -> IFL.of(list.subList(1, list.size())), list) {
        };
    }

    Optional<T> findMatch(Predicate<? super T> predicate) {
        if (!list.isEmpty() && predicate.test(head.get())) {
            return Optional.of(this.head.get());
        } else {
            if (!list.isEmpty() && this.tail.get().findMatch(predicate).isPresent()) {
                return this.tail.get().findMatch(predicate);
            }
            return Optional.empty();
        }
    }

    public static void main(String...args) {
        IFL<String> list = IFL.of(Arrays.asList("three", "little", "pigs"));
        System.out.println(list.findMatch(str -> str.length() == 6));
        System.out.println(list.findMatch(str -> str.length() < 4));
    }
}

导入java.util.array；
导入java.util.function.Predicate；
导入java.util.Optional；
导入java.util.List；
导入java.util.function.Supplier；
IFL类{
供应商负责人；
供应商尾部；
列表您可以这样做：

通过在构造函数中检查列表大小，并在
findMatch（）
方法中检查
this.head
的空值

您不需要检查
if（this.tail.get（）.findMatch（predicate.isPresent（））
，然后再次调用
findMatch
方法

class IFL<T> {
   Supplier<T> head;
   Supplier<IFL<T>> tail;

   IFL(Supplier<T> head, Supplier<IFL<T>> tail) {
     this.head = head;
     this.tail = tail;
   }

   static <T> IFL<T> of(List<? extends T> list) {

     if (list.isEmpty())
         return new IFL<>(null, null);

     return new IFL<T>(
            () -> list.get(0),
            () -> IFL.of(list.subList(1, list.size()))) {
     };
   }

  Optional<T> findMatch(Predicate<? super T> predicate) {
     if (this.head == null)
        return Optional.empty();
     return predicate.test(head.get()) ?
         Optional.of(this.head.get()) :this.tail.get().findMatch(predicate);
  }
}   

class-IFL{
供应商负责人；
供应商尾部；
IFL（供应商负责人、供应商负责人）{
这个头=头；
this.tail=tail；
}
静态IFL（ListRecursion是自己调用方法，它不需要引用变量来调用。这里发生了一种递归，但结果没有被利用。因为它既没有分配给变量，也没有返回。你对程序的示例输入是什么？@Naman我已经将输入添加到post@sarathkumar对，我做了一些调整但是遇到了更多的问题，包括原始帖子中的更新
class IFL<T> {
   Supplier<T> head;
   Supplier<IFL<T>> tail;

   IFL(Supplier<T> head, Supplier<IFL<T>> tail) {
     this.head = head;
     this.tail = tail;
   }

   static <T> IFL<T> of(List<? extends T> list) {

     if (list.isEmpty())
         return new IFL<>(null, null);

     return new IFL<T>(
            () -> list.get(0),
            () -> IFL.of(list.subList(1, list.size()))) {
     };
   }

  Optional<T> findMatch(Predicate<? super T> predicate) {
     if (this.head == null)
        return Optional.empty();
     return predicate.test(head.get()) ?
         Optional.of(this.head.get()) :this.tail.get().findMatch(predicate);
  }
}