1. import java.util.Collection;
  2. import java.util.HashSet;
  3. import java.util.Set;
  4. import java.util.concurrent.atomic.AtomicReference;
  6. class CollectionObserver {
  8. // AtomicReference to hold the previous state of the collection
  9. private final AtomicReference<Collection<?>> previousCollection = new AtomicReference<>(null);
  11. // Callback interface for change notifications
  12. public interface ChangeListener {
  13. void onChange(Collection<?> collection);
  14. }
  16. // List to store listeners
  17. private final Set<ChangeListener> listeners = new HashSet<>();
  19. // Method to register a listener
  20. public void addListener(ChangeListener listener) {
  21. listeners.add(listener);
  22. }
  24. // Method to unregister a listener
  25. public void removeListener(ChangeListener listener) {
  26. listeners.remove(listener);
  27. }
  29. // Method to observe a collection
  30. public <T> void observe(Collection<T> collection) {
  31. if (previousCollection.get() == null) {
  32. // Initialize the previous state
  33. previousCollection.set(collection);
  34. notifyListeners(collection);
  35. return;
  36. }
  38. if (!collection.equals(previousCollection.get())) {
  39. // Collection has changed
  40. previousCollection.set(collection);
  41. notifyListeners(collection);
  42. }
  43. }
  45. // Method to notify listeners of a change
  46. private void notifyListeners(Collection<?> collection) {
  47. for (ChangeListener listener : listeners) {
  48. listener.onChange(collection);
  49. }
  50. }
  51. }

Add your comment