Java在单数组布尔方法中查找唯一数

我需要问用户5个数字，只有50-100是有效的。我需要检查一下，看看这些数字是否唯一。除了独特的方法，我什么都能用。我一直在网上搜索，我尝试了很多方法让这个方法发挥作用。我的大脑不会与我合作。我添加了一个新函数

import java.util.Arrays;
import java.util.Scanner;
import java.util.Set;

public class Valid {
static Scanner input = new Scanner(System.in);
public static void main(String[] args) {

    int[] numbers;
    int uniqueCount = 0;
    int testInput;
    numbers = new int [5];
    // go up from 0 to 4 check if isValid if not take away 1 step from i.
    for (int i = 0; i < numbers.length; i++){
        System.out.print("Enter an integer (50 - 100): ");
        if (isValid(testInput = input.nextInt()) == true){
            numbers[i] = testInput;
            System.out.println(isUnique(numbers,i));
            /*if (isUnique(numbers) == true){
                uniqueCount+=1;
                System.out.println("Unique so far: " + uniqueCount);

            } else {

                System.out.println("Unique so far: ");
                System.out.print(uniqueCount);
            }*/

        }else {
            i--;
        }
    }



    }


static boolean isValid(int n){
    boolean valid = true;

 // Simple if under 50 or over 100 it is not Valid

        if (n < 50 || n > 100){
            System.out.println("Error entered non valid number must be 50-100.");
            valid = false;

        } else valid = true;

        return valid  ;
}


static boolean isUnique(int[] nArray){

    for ( int i =0; i < nArray.length - 1; i++){
        for (int  j =i + i ; j < nArray.length; j++){
            if (nArray[i] == nArray[j]){
                return false;
            }
        }
    }

return true;
}


}



static boolean isUnique(int[] nArray, int currentSizeOfArray){
    if (currentSizeOfArray == 0){
        //only number got to be unique
        return true;
    }else {
        for (int i = 0; nArray.length < currentSizeOfArray;i++){
            if (nArray[i] == nArray[0] || nArray[i] == nArray[1] || nArray[i] == nArray[2] || nArray[i] == nArray[3] || nArray[i] == nArray[4] ){
                // not unique
                return false;
            }
        }
    }




    return true;
}

导入java.util.array；
导入java.util.Scanner；
导入java.util.Set；
公共类有效{
静态扫描仪输入=新扫描仪（System.in）；
公共静态void main（字符串[]args）{
int[]数字；
int uniqueCount=0；
int测试输入；
数字=新整数[5]；
//从0上升到4，检查是否有效，如果无效，从i中删除1步。
for（int i=0；i100）{
System.out.println（“错误输入无效数字必须为50-100”）；
有效=错误；
}else valid=true；
返回有效；
}
静态布尔值是唯一的（int[]nArray）{
for（int i=0；i

将第二个循环中

j

的初始化从

j=i+i

更改为

j=i+1

；）

更新： 您在下面的回答中写道：

if (currentSizeOfArray == 0){
    //only number got to be unique
    return true;
} else if (currentSizeOfArray == 1){
    if (nArray[1] == nArray[0]){
        return false;
    }
...

你解决了这个问题。它可以用更优雅的方式书写：

static boolean isUnique(int[] nArray, int currentSizeOfArray){
    for(int i=0; i < currentSizeOfArray; i++) {
        for (int j=0; j < i; j++) {
            if (nArray[j] == nArray[i]) {
                return false;        
            }
        }        
    }
    return true; 
}  

静态布尔值是唯一的（int[]nArray，int currentSizeOfArray）{
对于（int i=0；i

将第二个循环中

j

的初始化从

j=i+i

更改为

j=i+1

；）

更新： 您在下面的回答中写道：

if (currentSizeOfArray == 0){
    //only number got to be unique
    return true;
} else if (currentSizeOfArray == 1){
    if (nArray[1] == nArray[0]){
        return false;
    }
...

你解决了这个问题。它可以用更优雅的方式书写：

static boolean isUnique(int[] nArray, int currentSizeOfArray){
    for(int i=0; i < currentSizeOfArray; i++) {
        for (int j=0; j < i; j++) {
            if (nArray[j] == nArray[i]) {
                return false;        
            }
        }        
    }
    return true; 
}  

静态布尔值是唯一的（int[]nArray，int currentSizeOfArray）{
对于（int i=0；i

这解决了它，但我一点也不喜欢它

 static boolean isUnique(int[] nArray){
    boolean unique = true;
    try{
        Set<Integer> set = new HashSet<>();

        for(int value : nArray){
            set.add(value);
        }
    }catch (IllegalArgumentException ignore){
        unique = false;
    }

    return unique;
}

这解决了它，但我一点也不喜欢它

静态布尔值是唯一的（int[]nArray）{
 static boolean isUnique(int[] nArray){
    boolean unique = true;
    try{
        Set<Integer> set = new HashSet<>();

        for(int value : nArray){
            set.add(value);
        }
    }catch (IllegalArgumentException ignore){
        unique = false;
    }

    return unique;
}

布尔唯一=真；
试一试{
Set=newhashset（）；
for（int值：nArray）{
增加（价值）；
}
}捕获（IllegalArgumentException忽略）{
唯一=错误；
}
返回唯一值；
}

静态布尔值是唯一的（int[]nArray）{
布尔唯一=真；
试一试{
Set=newhashset（）；
for（int值：nArray）{
增加（价值）；
}
}捕获（IllegalArgumentException忽略）{
唯一=错误；
}
返回唯一值；
}

最好检查当前数组中是否已存在新输入的整数。如果仍然需要方法：

static boolean isUnique(int[] array, int length, int newValue){
        for(int i=0;i< length;i++){
            if(array[i] == newValue){
                return false;
            }
        }

        return true;

    }

静态布尔值是唯一的（int[]数组，int-length，int-newValue）{
for（int i=0；i

---

检查后，您可以将

newValue

添加到数组中。

最好检查新输入的整数是否已存在于当前数组中。如果仍然需要方法：

static boolean isUnique(int[] array, int length, int newValue){
        for(int i=0;i< length;i++){
            if(array[i] == newValue){
                return false;
            }
        }

        return true;

    }

静态布尔值是唯一的（int[]数组，int-length，int-newValue）{
for（int i=0；i

---

检查后，您可以将

newValue

添加到数组中。

顺便说一句，您的示例代码完全是非面向对象的，没有支持类，不使用集合和所有静态代码。看起来更像C或基本代码，而不是Java

为了让您脱离

main

方法的静态上下文，我定义并实例化了一个

App

类。

main

方法不是面向对象的。从概念上讲，我忽略了

main

方法，因为这只是启动应用程序的解决方案

在Java集合框架（）中，a是不能包含重复元素的。是一个集合，它按排序顺序维护其元素。我使用它是为了方便查看我们的数字顺序

如果需要跟踪用户数据输入的顺序，也可以使用。它可能包含重复项。因此，仅当项目未包含在集合中时才添加项目

顺便说一下，单词“独特的”，“se”