Question

我有 n 个对象，它们具有称为状态的属性。因此，我必须检查所有对象的此属性，并为所有对象提供一个值。

让我解释一下。

status属性可以具有以下值（字符串）-“ 1”，“ 2”，“ 3”，“ 4”，“ 5”，“ 7”，“已完成”，“未完成”。 ....（1..7以外的任何字符串）

我将遍历所有对象，如果status属性的任何对象的值都为1-7，则将选择较高的值，然后将选择该值。示例

obj1.status =“ 1”，obj2.status =“ 6”。所选值=“ 6”

obj1.status =“ 4”，obj2.status =“ 2”。所选值=“ 4”

obj1.status =“ 7”，obj2.status =“ 6”。所选值=“ 7”

如果所有对象的状态属性都不为1-7，则选择的值为“ XYZ” 示例

obj1.status =“已完成”，obj2.status =“ abc”。所选值=“ XYZ”

obj1.status =“ abc”，obj2.status =“ def”。所选值=“ XYZ”

obj1.status =“ jkl”，obj2.status =“ mno”。所选值=“ XYZ”

如果至少一个对象的状态属性为1-7，其余所有对象的其他字符串都为其他字符串，则将选择数字值。

obj1.status =“ abc”，obj2.status =“ 1”。所选值=“ 1”

obj1.status =“ abc”，obj2.status =“ 5”，obj3.status =“ 4”,。值   Selected =“ 5”

Answer 1

会是这样的：

foreach (TSource source1 in source)
{
    if (predicate(source1))
        return true
}
return false;

Answer 2

也许是这样的：

Optional<YourObject> optional = test.stream().
filter(object -> (object.status.matches("[1-7]"))).sorted((o1, o2) -> Integer.valueOf(o2.status).compareTo(Integer.valueOf(o1.status))).findFirst();
String value = optional.isPresent() ? optional.get().status : "XYZ";

Answer 3

尝试一下

    String newStatus = list.stream()
            .map(Obj::getStatus)
            .map(x -> {
                try {
                    return Integer.parseInt(x);
                } catch (NumberFormatException ignore) {
                    return null;
                }
            })
            .filter(Objects::nonNull)
            .max(Comparator.naturalOrder())
            .map(x -> Integer.toString(x))
            .orElse("XYZ");

    list.forEach(x -> x.setStatus(newStatus));

Obj是您的对象的类型。

Answer 4

这是经典的reduce算法。（无需强制转换和正则表达式。）

BinaryOperator<String> reducer = (v1, v2) -> {
    if (v1.length() == 1 && v1.compareTo("1") >= 0 && v1.compareTo("7") <= 0) {
        // v1 is a number - return v2 if higher number, else v1
        return v2.length() == 1 && v2.compareTo("1") >= 0 && v2.compareTo("7") <= 0 && v1.compareTo(v2) < 0 ? v2 : v1;
    } else {
        // v1 is not a number - return v2 if number, else "XYZ" 
        return v2.length() == 1 && v2.compareTo("1") >= 0 && v2.compareTo("7") <= 0 ? v2 : "XYZ";
    }
};

测试：

Stream<String> of1 = Stream.of("3", "1", "2");
Stream<String> of2 = Stream.of("1", "incomplete", "2");
Stream<String> of3 = Stream.of("incomplete", "status");
System.out.println(of1.reduce(reducer).get()); // 3
System.out.println(of2.reduce(reducer).get()); // 2
System.out.println(of3.reduce(reducer).get()); // XYZ

Answer 5

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.regex.Pattern;

import org.junit.Assert;
import org.junit.Test;

public class LoopTest {

    private class Item {
        private String status = "";

        public Item(String status) {
            if(status != null)
                this.status = status;
        }

        public String getStatus() {
            return status;
        }       
    }

    private static final Pattern MY_REXP = Pattern.compile("[1-7]");
    private String getValue(List<Item> listValues) {
        if(listValues == null)
            return "XYZ";

        Optional<Item> opItem = listValues.stream().filter(item -> MY_REXP.matcher(item.getStatus()).matches()).max(new Comparator<Item>() {
            @Override
            public int compare(Item o1, Item o2) {
                if(o1 == null || o2 == null)
                    return -1;
                return o1.getStatus().compareTo(o2.getStatus());
            }
        });
        return opItem.isPresent() ? opItem.get().getStatus() : "XYZ";
    }

    @Test
     public void test1() {
        try {
            List<Item> listValues = Arrays.asList(new Item("1"), new Item("6"));
            String result = getValue(listValues);
            Assert.assertTrue("6".equals(result));
        } catch (Exception ex) {
            Assert.fail("Exception " + ex);
        }
    }

    @Test
     public void test2() {
        try {
            List<Item> listValues = Arrays.asList(new Item("completed"), new Item("8"));
            String result = getValue(listValues);
            Assert.assertTrue("XYZ".equals(result));
        } catch (Exception ex) {
           Assert.fail("Exception " + ex);
       }
    }

    @Test
     public void test3() {
        try {
            List<Item> listValues = Arrays.asList(new Item("abc"), new Item("5"), new Item("4"));
            String result = getValue(listValues);
            Assert.assertTrue("5".equals(result));
        } catch (Exception ex) {
           Assert.fail("Exception " + ex);
       }
    }

}

如何在Java中执行此循环

5 个答案: