Java方法不适用于参数错误

我正在编写一个程序，并出现以下类型的错误：

类型中的方法orElse（整数）可能不适用于参数（字符串）

我得到的另一个错误是：无法在中从对象转换为字符串

   msg = Maybe.of(txt)
               .filter(t -> t.length() > 0)
               .orElse("Txt is null or empty"); 

此外，我不完全确定orElse（）和filter（）方法是否正常工作，但出现此错误后，我无法继续前进。提前谢谢你的帮助

这是我的主要观点：

package Maybe;


public class Main {

  public static void test() {

    Integer num = null;

    // orElse() METHOD
    // INSTEAD OF
    String snum = null;
    if (num != null) snum = "Value is: " + num;
    if (snum != null) System.out.println(snum);
    else System.out.println("Value unavailable");

//    //ONE CAN WRITE
//    String res = Maybe.of(num).map(n -> "Value is: "+n)
//                      .orElse("Value unavailable");
//    System.out.println(res);

    //filter(...) METHOD

    String txt = "Dog";
    String msg = "";
    //INSTEAD OF
    if (txt != null && txt.length() > 0) {
      msg = txt;
    } else {
      msg = "Txt is null or empty";
    }

    //ONE CAN WRITE
//    msg = Maybe.of(txt)
//               .filter(t -> t.length() > 0)
//               .orElse("Txt is null or empty"); 
//    System.out.println(msg);


  }

  public static void main(String[] args) {
    test();
  }
}

还有我的班级：

package Maybe;

import java.util.NoSuchElementException;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class Maybe<T> {

    T cont;

    public Maybe(T val) {
        this.cont = val;
    }

    public Maybe() {
    }

    public static <T> Maybe <T> of(T val) {
        Maybe <T> m = new Maybe<T>(val);        
        return m;
    }

    public void ifPresent(Consumer<T> cons) {
        if(isPresent()) {
            cons.accept(get());
        }
    }

    public <R> Maybe <T> map(Function<T, R> func) {
        Maybe<T> mb = new Maybe();
        if(isPresent()) {
            mb = new Maybe(func.apply(get()));
        }
        return mb;
    }

    public T get(){     
        if(isPresent()) {
            return this.cont;
        } else {
            NoSuchElementException exc = new NoSuchElementException("maybe is empty");
            throw exc;
        }
    }

    public boolean isPresent() {
        if(this.cont != null) {
            return true;
        } else {
            return false;
        }
    }

    public T orElse(T defVal) {
        if(isPresent()) {
            return get();
        }
        return defVal;
    }

    public Maybe filter(Predicate pred) {
        if(pred.test(pred) || !isPresent()) {
            return this;
        } else {
            Maybe mb = new Maybe();
            return mb;
        }
    }



    public String toString() {
        if(isPresent()) {
            return "Maybe has value " + cont;
        }else {
            return "Maybe is empty";
        }

    }

}

包可能；
导入java.util.NoSuchElementException；
导入java.util.function.Consumer；
导入java.util.function.function；
导入java.util.function.Predicate；
也许是公共课{
T续；
公共可能（T val）{
this.cont=val；
}
公众可能{
}
公共静态值（T val）{
Maybe m=新Maybe（val）；
返回m；
}
公共场所（消费者反对）{
if（isPresent（））{
cons.accept（get（））；
}
}
公共地图（功能func）{
Maybe mb=新Maybe（）；
if（isPresent（））{
mb=newmaybe（func.apply（get（））；
}
返回mb；
}
公共不获取（）{
if（isPresent（））{
返回此.cont；
}否则{
NoSuchElementException exc=新的NoSuchElementException（“可能是空的”）；
抛出exc；
}
}
公共布尔值isPresent（）{
如果（this.cont！=null）{
返回true；
}否则{
返回false；
}
}
公共交通工具（交通工具）{
if（isPresent（））{
返回get（）；
}
返回定义；
}
公共过滤器（谓词pred）{
if（pred.test（pred）| |！isPresent（））{
归还这个；
}否则{
Maybe mb=新Maybe（）；
返回mb；
}
}
公共字符串toString（）{
if（isPresent（））{
返回“可能有价值”+续；
}否则{
返回“可能是空的”；
}
}
}

您的

filter

方法接受一个谓词并返回一个原始

可能

这意味着它需要一个对任何对象都有效的谓词，并且它给出了一个可能包含任何类型对象的
Maybe

应该是这样的

public Maybe<T> filter(Predicate<? super T> pred) {
    if (isPresent() && !pred.test(cont)) {
        return new Maybe<T>();
    }
    return this;
}

这假设在
T
应用了
func
之后，您将有一个
可能
。但实际上你可能会有一个
函数，因为
R
是
func
函数产生的

这将更有意义：

public <R> Maybe<R> map(Function<T, R> func) {
    if (isPresent()) {
        return new Maybe<R>(func.apply(cont));
    }
    return new Maybe<R>();
}

错误是正确的，因为
orElse
返回类型是
T
类型，在您的情况下是
Integer
。（Integer num）如果您打开所有编译器警告并注意它们，您可以在将来避免这种情况。这很有帮助，但我仍然得到一个ClassCastException错误。也许您希望在问题中添加异常的堆栈跟踪，以及导致异常的代码段。堆栈跟踪：线程“main”中的异常java.lang.ClassCastException:Maybe.Main$$Lambda$5/1149319664无法转换为java.lang.String，这会导致错误：msg=Maybe.of（txt）。过滤器（t->t.length（）>0）.orElse（“Txt为null或空”）；System.out.println（msg）；非常感谢，函数和谓词仍然让我困惑，但是你的解释帮助很大！谢谢
public <R> Maybe <T> map(Function<T, R> func)

public <R> Maybe<R> map(Function<T, R> func) {
    if (isPresent()) {
        return new Maybe<R>(func.apply(cont));
    }
    return new Maybe<R>();
}

jshell> String txt = "Hi";
txt ==> "Hi"

jshell> String msg = Maybe.of(txt).filter(t -> t.length() > 0).orElse("Empty");
msg ==> "Hi"

jshell> txt = "";
txt ==> ""

jshell> msg = Maybe.of(txt).filter(t -> t.length() > 0).orElse("Empty");
msg ==> "Empty"