Java 在同样是递归的布尔语句中，如何写出元素是否是数组的成员？

我不知道该为if语句写什么，我正在为班级做这项工作，而且对这门语言还是非常陌生的。如果元素x是数组a[]的成员，则需要递归返回true；如果不是，则返回false

public static Boolean member (int x, int A[])
{
   if (     )//base case
       return true;
   else // general case
{

      int[] T= new int [A.length-1];
      for (int i=1; I<A.length; i++)
            T[i-1]=A[i];
      return false;
  }
}

公共静态布尔成员（int x，int A[]）
{
if（）//基本情况
返回true；
其他//一般情况
{
int[]T=新的int[A.length-1]；
对于（int i=1；i假设您有此函数/方法：
搜索（数组a、int x、int索引）


（1） 检查索引是否=a.length，如果是-返回false；

（2） 检查
x
是否等于元素
a[索引]
，如果是-返回true；

（3） 否则调用并返回
search（a，x，index+1）

这是伪代码，您只需用Java编写即可。

函数
搜索
是递归的。
创建了一个项目，它可以正常工作

package recursiveTest;

public class test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int [] test = new int[10];
        for(int i = 0; i < 10; i++){
            test[i] = i;
        }
        System.out.println(member(4, test));
    }
    public static Boolean member (int x, int A[])
    {
        Boolean res = false;
        if(A.length > 0){
            if(A[0] != x){
                int [] A_NEW = CreateANew(A);
                res = member(x, A_NEW);
            }else{
                res = true;
            }
        }
        return res;

    }
    public static int[] CreateANew(int A[]){
        int [] A_NEW = new int [A.length-1];
        for(int i = 1; i < A.length; i++){
            A_NEW[i-1] = A[i];
        }
        return A_NEW;
    }
}

包递归测试；
公开课考试{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
int[]测试=新的int[10]；
对于（int i=0；i<10；i++）{
试验[i]=i；
}
系统输出打印LN（成员（4，测试））；
}
公共静态布尔成员（int x，int A[]）
{
布尔res=false；
如果（A.长度>0）{
如果（A[0]！=x）{
int[]A_NEW=CreateANew（A）；
res=成员（x，A_新）；
}否则{
res=真；
}
}
返回res；
}
公共静态int[]重新创建（int A[]{
int[]A_NEW=newint[A.length-1]；
for（int i=1；i
还有另一种方法：我试图尊重您最初的代码流

public static Boolean member (int x, int A[])
{
   if ( x == A[0]    )//base case
       return true;
   else // general case
{

     if (A.length == 1) {
         return false;
     }
     int B[] = new int[A.length-1];
     System.arraycopy(A, 1, B, 0, B.length);
     return member(x, B);
  }
}

一个测试示例

public static void main(String[] args) {
    
    int A[] = {5,6,7,8,11,25,135,256,1875,1254};
    boolean membershipOf25 = member(25,A);
    System.out.println("Is 25 member? " + membershipOf25);
    
    boolean membershipOf256 = member(256,A);
    System.out.println("Is 256 member? " + membershipOf256);
    
    boolean membershipOf109 = member(109,A);
    System.out.println("Is 109 member? " + membershipOf109);
    
    
}

结果是：

是25人吗？是的

是256人吗？是的

109是会员吗？错

提示：递归就是从函数本身调用函数。我只是注意到我的答案看起来像@grimbode的，除了我使用的System.arraycopy