Java Code Examples for org.apache.commons.collections4.CollectionUtils#find()

public void addRow(final Village pVillage, boolean pFake, int pAmount) {
    Object result = CollectionUtils.find(elements, new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((TAPAttackTargetElement) o).getVillage().equals(pVillage);
        }
    });

    if (result == null) {
        elements.add(new TAPAttackTargetElement(pVillage, pFake, pAmount));
    } else {
        TAPAttackTargetElement resultElem = (TAPAttackTargetElement) result;
        resultElem.setAttacks(pAmount);
        resultElem.setFake(pFake);
    }
    fireTableDataChanged();
}
 

public boolean removeRow(final Village pVillage, boolean pNotify) {

        REFSourceElement elem = (REFSourceElement) CollectionUtils.find(elements, new Predicate() {

            @Override
            public boolean evaluate(Object o) {
                return ((REFSourceElement) o).getVillage().equals(pVillage);
            }
        });

        if (elem != null) {
            elements.remove(elem);
        }

        if (pNotify) {
            fireTableDataChanged();
        }
        return elem != null;
    }
 

public void addRow(final SupportSourceElement pElement, boolean pCheck) {

        Object result = CollectionUtils.find(elements, new Predicate() {

            @Override
            public boolean evaluate(Object o) {
                return ((SupportSourceElement) o).getVillage().equals(pElement.getVillage());
            }
        });

        if (result == null) {
            elements.add(pElement);
        }
        if (pCheck) {
            fireTableDataChanged();
        }
    }
 

public DefenseInformation findElement(final Village pTarget) {
    return (DefenseInformation) CollectionUtils.find(entries, new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((DefenseInformation) o).getTarget().equals(pTarget);
        }
    });
}
 

private static void testSearch() {
    Collection<String> collection = Lists.newArrayList("2", "14", "3", "13", "43");
    MutableList<String> mutableList = FastList.newListWith("2", "14", "3", "13", "43");
    Iterable<String> iterable = collection;

    // найти элемент в неотсортированной коллекции
    String jdk = collection.stream().filter("13"::equals).findFirst().get();
    String guava = Iterables.find(iterable, "13"::equals);
    String apache = CollectionUtils.find(iterable, "13"::equals);
    String gs = mutableList.select("13"::equals).get(0);

    System.out.println("find = " + jdk + ":" + guava + ":" + apache + ":" + gs); // напечатает find = 13:13:13:13
}
 

public static void assertContainsPlot(final int x, final int y, final Elements color, List<Plot> plots) {
    Object foundPlot = CollectionUtils.find(plots, (Predicate) object -> {
        Plot plot = (Plot) object;
        return plot.getColor() == color && plot.getX() == x && plot.getY() == y;
    });
    assertNotNull("Plot with coordinates (" + x + "," + y + ") color: " + color + " not found", foundPlot);
}
 

public SOSRequest getRequest(final Tribe pTribe) {
  if (pTribe == null) {
    return null;
  }

  Object result = CollectionUtils.find(getAllElements(), new Predicate() {

    @Override
    public boolean evaluate(Object o) {
      return ((SOSRequest) o).getDefender().equals(pTribe);
    }
  });

  return (SOSRequest) result;
}
 

public boolean containsElementByIcon(final int pIcon) {
    Object result = CollectionUtils.find(getAllElements(), new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((StandardAttack) o).getIcon() == pIcon;
        }
    });

    return result != null;
}
 

public boolean containsElementByName(final String pName) {
    Object result = CollectionUtils.find(getAllElements(), new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((StandardAttack) o).getName().equals(pName);
        }
    });

    return result != null;
}
 

public StandardAttack getElementByIcon(final int pIcon) {
    Object result = CollectionUtils.find(getAllElements(), new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((StandardAttack) o).getIcon() == pIcon;
        }
    });

    return (StandardAttack) result;
}
 

public StandardAttack getElementByName(final String pName) {
    Object result = CollectionUtils.find(getAllElements(), new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((StandardAttack) o).getName().equals(pName);
        }
    });

    return (StandardAttack) result;
}
 

public void addRow(final Village pVillage, int pStash, int pWood, int pClay, int pIron, int pAvailableMerchants, int pMerchants, int pAvailableFarm, int pOverallFarm, VillageMerchantInfo.Direction pDirection) {
    Object result = CollectionUtils.find(elements, new Predicate() {
        
        @Override
        public boolean evaluate(Object o) {
            return ((VillageMerchantInfo) o).getVillage().equals(pVillage);
        }
    });
    
    if (result == null) {
        VillageMerchantInfo vmi = new VillageMerchantInfo(pVillage, pStash, pWood, pClay, pIron, pAvailableMerchants, pMerchants, pAvailableFarm, pOverallFarm);
        vmi.setDirection(pDirection);
        elements.add(vmi);
    } else {
        VillageMerchantInfo resultElem = (VillageMerchantInfo) result;
        resultElem.setWoodStock(pWood);
        resultElem.setClayStock(pClay);
        resultElem.setIronStock(pIron);
        resultElem.setStashCapacity(pStash);
        resultElem.setAvailableMerchants(pAvailableMerchants);
        resultElem.setOverallMerchants(pMerchants);
        resultElem.setAvailableFarm(pAvailableFarm);
        resultElem.setOverallFarm(pOverallFarm);
        resultElem.setDirection(pDirection);
    }
    fireTableDataChanged();
}
 

public void addRow(final Village pVillage, int pStash, int pWood, int pClay, int pIron, int pAvailableMerchants, int pMerchants, int pAvailableFarm, int pOverallFarm, VillageMerchantInfo.Direction pDirection, boolean pCheck) {
    Object result = CollectionUtils.find(elements, new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((VillageMerchantInfo) o).getVillage().equals(pVillage);
        }
    });

    if (result == null) {
        VillageMerchantInfo vmi = new VillageMerchantInfo(pVillage, pStash, pWood, pClay, pIron, pAvailableMerchants, pMerchants, pAvailableFarm, pOverallFarm);
        vmi.setDirection(pDirection);
        elements.add(vmi);
    } else {
        VillageMerchantInfo resultElem = (VillageMerchantInfo) result;
        resultElem.setWoodStock(pWood);
        resultElem.setClayStock(pClay);
        resultElem.setIronStock(pIron);
        resultElem.setStashCapacity(pStash);
        resultElem.setAvailableMerchants(pAvailableMerchants);
        resultElem.setOverallMerchants(pMerchants);
        resultElem.setAvailableFarm(pAvailableFarm);
        resultElem.setOverallFarm(pOverallFarm);
        resultElem.setDirection(pDirection);
    }
    if (pCheck) {
        fireTableDataChanged();
    }
}
 

public void addRow(final Village pVillage, int pSupports) {
    Object existing = CollectionUtils.find(elements, new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((SupportSourceElement) o).getVillage().equals(pVillage);
        }
    });
    if (existing == null) {
        elements.add(new SupportSourceElement(pVillage, pSupports));
    }
}
 

public void decreaseRowCount(final Village pVillage) {
    Object result = CollectionUtils.find(elements, new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((TAPAttackTargetElement) o).getVillage().equals(pVillage);
        }
    });

    if (result != null) {
        TAPAttackTargetElement resultElem = (TAPAttackTargetElement) result;
        resultElem.removeAttack();
        fireTableDataChanged();
    }
}
 

public void increaseRowCount(final Village pVillage) {
    Object result = CollectionUtils.find(elements, new Predicate() {

        @Override
        public boolean evaluate(Object o) {
            return ((TAPAttackTargetElement) o).getVillage().equals(pVillage);
        }
    });

    if (result != null) {
        TAPAttackTargetElement resultElem = (TAPAttackTargetElement) result;
        resultElem.addAttack();
        fireTableDataChanged();
    }
}
 

public static void assertContainsPlot(final int x, final int y,  List<Plot> plots) {
    Object foundPlot = CollectionUtils.find(plots, (Predicate) object -> {
        Plot plot = (Plot) object;
        return plot.getX() == x && plot.getY() == y;
    });
    assertNotNull("Plot with coordinates (" + x + "," + y + ") not found", foundPlot);
}
 

public boolean addSupport(final Village pSource, UnitHolder pUnit, boolean pPrimary, boolean pMultiUse) {
    long runtime = DSCalculator.calculateMoveTimeInMillis(pSource, target, pUnit.getSpeed());
    boolean allowed = false;
    if (getFirstAttack().getTime() - runtime > System.currentTimeMillis() + DateUtils.MILLIS_PER_MINUTE) {
        //high priority
        allowed = true;
    } else if (getLastAttack().getTime() - runtime > System.currentTimeMillis() + DateUtils.MILLIS_PER_MINUTE) {
        //low priority
        allowed = !pPrimary;
    } else {// if (getLastAttack().getTime() - runtime < System.currentTimeMillis() - DateUtils.MILLIS_PER_MINUTE) {
        //impossible
    }
    if (allowed) {
        Object result = CollectionUtils.find(defenses, new Predicate() {

            @Override
            public boolean evaluate(Object o) {
                return ((Defense) o).getSupporter().equals(pSource);
            }
        });
        if (result == null || pMultiUse) {
            defenses.add(new Defense(this, pSource, pUnit));
            return true;
        }
    }
    return false;
}
 

public boolean addAttack(final Village pSource, final Date pArrive, UnitHolder pUnit, boolean fake, boolean snob) {
    List<TimedAttack> attacksFromSource = timedAttacks.get(pSource);
    if (attacksFromSource == null) {
        attacksFromSource = new LinkedList<>();
        timedAttacks.put(pSource, attacksFromSource);
    }
    
    Object result = CollectionUtils.find(attacksFromSource, new Predicate() {
        
        @Override
        public boolean evaluate(Object o) {
            TimedAttack t = (TimedAttack) o;
            return t.getSource().equals(pSource) && t.getlArriveTime().equals(pArrive.getTime());
        }
    });
    
    if (result == null) {
        TimedAttack a = new TimedAttack(pSource, pArrive);
        a.setPossibleFake(fake);
        a.setPossibleSnob(snob);
        a.setUnit(pUnit);
        attacksFromSource.add(a);
        Collections.sort(attacksFromSource, SOSRequest.ARRIVE_TIME_COMPARATOR);
        updateAttackInfo();
        return true;
    }
    return false;
}
 

private <T extends Entry> T find(
        Class<T> resultClass, final Entry.Type type, final Predicate<T> searchPredicate) {
    return (T)
            CollectionUtils.find(
                    this, entry -> entry.type == type && searchPredicate.evaluate((T) entry));
}