使用 Java 流转换特定于过滤器的逻辑

Question

I am trying to convert the working code to java streams but not able to do so.

I have written a code where it filters Address id, name , Code, and indicator

The logic which i wrote is as follows

address details list image

from the image

There are two rows with same address id .

I have priority that to filter unique address id based on condition.

1. The condition is to check if address id and names of the rows are same.
2. After the above condition is met then high priority is given when code field is A and indicator is Y.
3. The least priority is to check atleast the Code field is A.

A Map is created where address id as the key and checking if code field is A while iterating that address id is added that to map.

later checking if that address id exists in the map . If so then compare it with current and previous element in the address table which is a list and checking if current has Code of A and indicator as Y then add it to the map .

Please find the code

class Address {

    private final String id;
    private final String name;
    private final String code;
    private final String indicator;
    
}

public class Test {

    public static void main(String[] args) {
        Address address0 = new Address("1", "name1", "N", "Y");
        Address address1 = new Address("1", "name1", "A", "N");
        Address address2 = new Address("2", "name1", "A", "N");
        Address address3 = new Address("2", "name1", "A", "Y");
        Address address4 = new Address("3", "name1", "C", "M");
        Address address5 = new Address("3", "name1", "A", "Y");
        List<Address> addrList = Arrays.asList(address0, address1, address2, address3, address4, address5);

        Map<String, Address> map = new HashMap<>();

        for (Address currentAddressElement : addrList) {
            String currentId = currentAddressElement.getId();
            String currentName = currentAddressElement.getName();
            String currentCode = currentAddressElement.getCode();
            String currentInd = currentAddressElement.getIndicator();
            Address previousAddressElement = map.get(currentAddressElement.getId());

            // Adding in the map if the code is A
            if (!map.containsKey(currentAddressElement.getId()) && "A".equals(currentCode))
                map.put(currentAddressElement.getId(), currentAddressElement);
            else if (previousAddressElement != null) {
                String prevId = previousAddressElement.getId();
                String prevName = previousAddressElement.getName();
                String prevCode = previousAddressElement.getCode();
                String prevInd = previousAddressElement.getIndicator();

                // adding to map if current code is A and current indicator Y  and previousCode is A and previous indicator is not Y
                if (prevId.equals(currentId)
                        && prevName.equals(currentName)
                        && "A".equals(prevCode)
                        && !"Y".equals(prevInd)
                        && "A".equals(currentCode)
                        && "Y".equals(currentInd))
                    map.put(currentId, currentAddressElement);
            }
        }

        System.out.println(new ArrayList<>(map.values()));
    }

}

Answer 1

public static void main(String[] args) {
    final BinaryOperator<Address> MERGE_BY_PRIORITY_RULE = (existed, replacement) -> {
        boolean existedHasCodeA = "A".equalsIgnoreCase(existed.getCode());
        boolean existedHasIndicatorY = "Y".equalsIgnoreCase(existed.getIndicator());
        boolean replacementHasCodeA = "A".equalsIgnoreCase(replacement.getCode());
        boolean replacementHasIndicatorY = "Y".equalsIgnoreCase(replacement.getIndicator());

        if (existedHasCodeA && existedHasIndicatorY)
            return existed;
        if (replacementHasCodeA && replacementHasIndicatorY)
            return replacement;
        if (existedHasCodeA)
            return existed;
        if (replacementHasCodeA)
            return replacement;

        return existed;
    };

    List<Address> addresses = Arrays.asList(
            new Address("1", "name1", "N", "Y"),
            new Address("1", "name1", "A", "N"),
            new Address("2", "name2", "A", "N"),
            new Address("2", "name2", "A", "Y"),
            new Address("3", "name3", "C", "M"),
            new Address("3", "name3", "A", "Y"));

    System.out.println(addresses.stream()
                                .collect(Collectors.toMap(Address::getId, Function.identity(), MERGE_BY_PRIORITY_RULE))
                                .values());
}