Java 判断 三个字符串其中一个不为空 并返回不为空的字符串，和名称

可以使用以下代码实现：

public String checkNotEmpty(String str1, String str2, String str3) {
    if(str1 != null && !str1.isEmpty()) {
        return "str1: " + str1;
    }
    if(str2 != null && !str2.isEmpty()) {
        return "str2: " + str2;
    }
    if(str3 != null && !str3.isEmpty()) {
        return "str3: " + str3;
    }
    return null;
}

这个方法接收三个字符串参数，依次判断是否为空，如果不为空则返回该字符串以及名称，如果三个字符串都为空，则返回 null。

相关问题

java检测某字符串是否被包含在枚举类内

可以使用Java中的Enum类的values()方法获取所有枚举值，然后遍历枚举值，判断目标字符串是否与枚举值相等或包含在枚举值中。

例如，假设有一个枚举类Color，包含了红、绿、蓝三种颜色：

public enum Color {
    RED, GREEN, BLUE;
}

现在要检测字符串"RED"是否被包含在Color枚举类内，可以按照以下方式实现：

String target = "RED";
boolean isContained = false;

for (Color color : Color.values()) {
    if (color.name().equals(target)) {
        isContained = true;
        break;
    }
}

if (isContained) {
    System.out.println(target + " is contained in Color enum.");
} else {
    System.out.println(target + " is not contained in Color enum.");
}

其中，Color.values()方法返回一个Color枚举类的数组，遍历该数组，使用name()方法获取枚举值的名称，与目标字符串进行比较即可。如果匹配成功，则将isContained标记为true并退出循环。最后根据isContained的值输出结果。

Java中不固定参数名和参数类型如何接受及解析

### 回答1：
在 Java 中，可以使用可变参数列表实现不固定参数名和参数类型的接受和解析。

可变参数列表是指方法参数的数量是可变的，方法定义中使用“...”表示，例如：

public void printValues(String... values) {
    for (String value : values) {
        System.out.println(value);
    }
}

在上面的例子中，printValues() 方法接受一个或多个字符串作为参数，并遍历打印每个字符串。

调用可变参数列表方法时，可以传递任意数量的参数，例如：

printValues("Hello", "World"); // 输出 Hello World
printValues("Java", "is", "cool"); // 输出 Java is cool

在方法体内，可变参数列表被视为一个数组，因此可以使用数组的方式来处理参数。例如，可以使用 length 属性获取参数的数量：

public void printValues(String... values) {
    System.out.println("Number of values: " + values.length);
    for (String value : values) {
        System.out.println(value);
    }
}

在调用上面的方法时，输出结果为：

Number of values: 2
Hello
World

需要注意的是，可变参数列表必须是方法参数列表的最后一个参数。如果存在多个参数，可变参数列表之前的参数必须显式指定参数名称。例如：

public void printValues(int count, String... values) {
    System.out.println("Number of values: " + count);
    for (String value : values) {
        System.out.println(value);
    }
}

在调用上面的方法时，需要显式指定参数名称：

printValues(2, "Hello", "World"); // 输出 Number of values: 2\nHello\nWorld

### 回答2：
在Java中，可以使用不固定参数名和参数类型的方式来接受和解析参数。

对于不固定的参数名，可以使用数组或列表来接受多个参数。例如，可以使用以下方法签名来接受不固定参数名的整数类型参数：

public void processIntegers(int... numbers) {
    for (int num : numbers) {
        // 对参数进行相应的处理操作
    }
}

在调用该方法时，可以传入任意数量的整数参数：

int[] arr1 = {1, 2, 3};
processIntegers(arr1);

processIntegers(4, 5, 6);

对于不固定的参数类型，可以使用泛型来接受不同类型的参数。例如，可以使用以下方法签名来接受不同类型的参数：

public <T> void processObjects(T... objects) {
    for (T obj : objects) {
        // 对参数进行相应的处理操作
    }
}

在调用该方法时，可以传入任意类型的参数：

processObjects(1, "hello", true);

在方法内部，可以根据参数的不同类型来进行适当的处理。例如，可以使用 instanceof 运算符来判断参数的类型，并根据类型执行相应的操作：

public <T> void processObjects(T... objects) {
    for (T obj : objects) {
        if (obj instanceof Integer) {
            // 对整数类型参数进行处理
        } else if (obj instanceof String) {
            // 对字符串类型参数进行处理
        } else {
            // 对其他类型参数进行处理
        }
    }
}

通过以上方式，可以灵活地接受和解析不固定参数名和参数类型，从而提高程序的灵活性和扩展性。

### 回答3：
在Java中，没有固定参数名和参数类型的情况下，我们可以使用不定参数来接受和解析。

Java中的不定参数是通过在方法声明中使用"..."（三个连续的句点）来表示的。该参数可以接受任意数量的参数，即使在方法调用时没有显式地传递参数也是可以的。

不定参数在方法内部被当作数组来处理。这意味着我们可以像操作数组一样来使用这些参数，如访问数组的长度、遍历参数等。

我们可以使用一个示例来说明如何使用不定参数。假设我们有一个方法，需要接受任意数量的整数，并计算它们的和。代码如下所示：

public static int calculateSum(int... numbers) {
int sum = 0;
for (int number : numbers) {
sum += number;
}
return sum;
}

在上述代码中，calculateSum方法接受一个不定参数numbers，它可以接受任意数量的整数。通过使用foreach循环遍历numbers数组，我们可以将每个整数加到sum变量上，最后返回计算得到的总和。

使用不定参数的方法调用示例如下：

int sum1 = calculateSum(1, 2, 3); // 6
int sum2 = calculateSum(4, 5, 6, 7); // 22
int sum3 = calculateSum(); // 0

上述代码中，我们通过传递不同数量的整数来调用calculateSum方法，可以看到它们都能够正确地计算出对应的和。

总而言之，在Java中，我们可以使用不定参数来接受和解析不固定参数名和参数类型的情况。这为我们提供了更灵活的方法设计和调用方式。