1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.List;
  5. class CollectionConstraintChecker {
  7. /**
  8. * Checks if a collection satisfies specified constraints.
  9. *
  10. * @param collection The collection to check.
  11. * @param constraintFunction A function that takes a Collection and returns true if it satisfies the constraint, false otherwise.
  12. * @param errorMessage The message to display if the constraint is not met.
  13. * @param <T> The type of elements in the collection.
  14. * @throws IllegalArgumentException if the collection is null or the constraint function is null.
  15. */
  16. public static <T> void checkCollectionConstraint(Collection<T> collection,
  17. ConstraintFunction<T> constraintFunction,
  18. String errorMessage) {
  19. if (collection == null) {
  20. throw new IllegalArgumentException("Collection cannot be null.");
  21. }
  22. if (constraintFunction == null) {
  23. throw new IllegalArgumentException("Constraint function cannot be null.");
  24. }
  26. if (!constraintFunction.isValid(collection)) {
  27. System.err.println("Collection constraint failed: " + errorMessage);
  28. throw new IllegalArgumentException(errorMessage); // Or handle the failure appropriately
  29. }
  30. }
  33. /**
  34. * Functional interface representing a constraint function for collections.
  35. * @param <T> The type of elements in the collection.
  36. */
  37. public interface ConstraintFunction<T> {
  38. boolean isValid(Collection<T> collection);
  39. }
  42. public static void main(String[] args) {
  43. // Example usage: Check if a list contains only positive numbers.
  44. ConstraintFunction<Integer> positiveNumbersOnly = collection -> {
  45. for (Integer num : collection) {
  46. if (num <= 0) {
  47. return false;
  48. }
  49. }
  50. return true;
  51. };
  53. List<Integer> numbers1 = new ArrayList<>();
  54. numbers1.add(1);
  55. numbers1.add(2);
  56. numbers1.add(3);
  58. List<Integer> numbers2 = new ArrayList<>();
  59. numbers2.add(1);
  60. numbers2.add(-2);
  61. numbers2.add(3);
  63. try {
  64. checkCollectionConstraint(numbers1, positiveNumbersOnly, "List must contain only positive numbers.");
  65. System.out.println("numbers1 passed constraint.");
  66. } catch (IllegalArgumentException e) {
  67. System.err.println("numbers1 failed constraint: " + e.getMessage());
  68. }
  71. try {
  72. checkCollectionConstraint(numbers2, positiveNumbersOnly, "List must contain only positive numbers.");
  73. System.out.println("numbers2 passed constraint.");
  74. } catch (IllegalArgumentException e) {
  75. System.err.println("numbers2 failed constraint: " + e.getMessage());
  76. }
  79. //Example with string collection
  80. ConstraintFunction<String> nonBlankStrings = collection -> {
  81. for(String str : collection){
  82. if(str == null || str.trim().isEmpty()){
  83. return false;
  84. }
  85. }
  86. return true;
  87. };
  89. List<String> strings1 = new ArrayList<>();
  90. strings1.add("hello");
  91. strings1.add("world");
  93. List<String> strings2 = new ArrayList<>();
  94. strings2.add("hello");
  95. strings2.add("");
  98. try {
  99. checkCollectionConstraint(strings1, nonBlankStrings, "List must contain non-blank strings");
  100. System.out.println("strings1 passed constraint");
  101. } catch (IllegalArgumentException e) {
  102. System.err.println("strings1 failed constraint: " + e.getMessage());
  103. }
  105. try {
  106. checkCollectionConstraint(strings2, nonBlankStrings, "List must contain non-blank strings");
  107. System.out.println("strings2 passed constraint");
  108. } catch (IllegalArgumentException e) {
  109. System.err.println("strings2 failed constraint: " + e.getMessage());
  110. }
  111. }
  112. }

Add your comment