如何在Java中所属类的`List`中的`T`属性发生更改时实现并触发事件

是否有可能将下面的代码从C转换成Java Android？ 这是基于我的上一个问题

---

我刚刚将ItemPropertyChangedNotifyingList移植到ItemChangeList

在代码中，我更改了这部分

使用“ArrayList”来保存元素，而不是C中的“List” 在copyTo中，我使用了Java8流。因为您标记了“android”，所以我曾经实现了与copyTo相同的功能。 Java不支持get、set语法，我将其分为两种方法。 另一种方法是扩展ArrayList而不是_listImplementation。它可以提供更多的功能。就我个人而言，我更喜欢这种方式

编辑-1哦，我忘了在OnPropertyChangeObserver中添加参数

---

编辑-2让Kotlin对此进行优化

我不太喜欢android，但将C解决方案移植到Java/android可能不是解决您问题的最佳方案。您是否尝试使用列表？这实际上似乎是你想要的。这个问题受到元效应的影响；看见

public class ItemPropertyChangedNotifyingList<T> : IList<T>, INotifyPropertyChanged where T : INotifyPropertyChanged
    {
        private List<T> _listImplementation = new List<T>();

        public void Add(T item)
        {
            item.PropertyChanged += ItemOnPropertyChanged;
            _listImplementation.Add(item);
        }

        private void ItemOnPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            PropertyChanged?.Invoke(sender, e);
        }

        public IEnumerator<T> GetEnumerator()
        {
            return _listImplementation.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)_listImplementation).GetEnumerator();
        }

        public void Clear()
        {
            _listImplementation.ForEach(x => x.PropertyChanged -= ItemOnPropertyChanged);
            _listImplementation.Clear();
        }

        public bool Contains(T item)
        {
            return _listImplementation.Contains(item);
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            _listImplementation.CopyTo(array, arrayIndex);
        }

        public bool Remove(T item)
        {
            item.PropertyChanged -= ItemOnPropertyChanged;
            return _listImplementation.Remove(item);
        }

        public int Count => _listImplementation.Count;

        public bool IsReadOnly => false;

        public int IndexOf(T item)
        {
            return _listImplementation.IndexOf(item);
        }

        public void Insert(int index, T item)
        {
            item.PropertyChanged += ItemOnPropertyChanged;
            _listImplementation.Insert(index, item);
        }

        public void RemoveAt(int index)
        {
            _listImplementation.RemoveAt(index);
        }

        public T this[int index]
        {
            get => _listImplementation[index];
            set => _listImplementation[index] = value;
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }

public FocusManagerListener implements PropertyChangeListener {
    public void propertyChange(PropertyChangeEvent e) {
        String propertyName = e.getPropertyName();
        if ("focusOwner".equals(propertyName) {
            ...
        } else if ("focusedWindow".equals(propertyName) {
            ...
        }
    }
    ...
}

import com.annimon.stream.Stream;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ItemChangedList<T> {
    private List<T> _listImplementation = new ArrayList<>();
    private List<OnPropertyChangedObserver<T>> _changedObserverList = new ArrayList<>();

    public static final String ITEM_ADDED = "bbed36af-0b7b-4e53-abc9-02d6a14d7f34";
    public static final String ITEM_REMOVED = "7390116e-586d-4e62-9343-5b82b0a8c6c5";

    public void add(T item) {
        sendPropertyChanged(item, ITEM_ADDED);
        _listImplementation.add(item);
    }

    public Iterator<T> iterator() {
        return _listImplementation.iterator();
    }

    public void clear() {
        for (T item : _listImplementation) {
            sendPropertyChanged(item, ITEM_REMOVED);
        }
        _listImplementation.clear();
    }

    public boolean contains(T item) {
        return _listImplementation.contains(item);
    }

    public void copyTo(T[] array, int arrayIndex) {
        // Using https://github.com/aNNiMON/Lightweight-Stream-API
        _listImplementation.addAll(Stream.of(array).skip(arrayIndex).toList());

        // Traditional Java way
        // _listImplementation.addAll(Arrays.stream(array).skip(arrayIndex).collect(Collectors.toList()));
    }

    public boolean remove(T item) {
        sendPropertyChanged(item, ITEM_REMOVED);
        return _listImplementation.remove(item);
    }

    public int count() {
        return _listImplementation.size();
    }

    public boolean isReadOnly() {
        return false;
    }

    public int indexOf(T item) {
        return _listImplementation.indexOf(item);
    }

    public void insert(int index, T item) {
        sendPropertyChanged(item, ITEM_ADDED);
        _listImplementation.add(index, item);
    }

    public void removeAt(int index) {
        _listImplementation.remove(index);
    }

    public T get(int index) {
        return _listImplementation.get(index);
    }

    public void set(int index, T item) {
        _listImplementation.set(index, item);
    }

    public void addObserver(OnPropertyChangedObserver<T> observer) {
        _changedObserverList.add(observer);
    }

    public void removeObserver(OnPropertyChangedObserver<T> observer) {
        _changedObserverList.remove(observer);
    }

    public void clearObserver() {
        _changedObserverList.clear();
    }

    private void sendPropertyChanged(T item, String args) {
        for (OnPropertyChangedObserver<T> observer : _changedObserverList) {
            observer.onChanged(item, args);
        }
    }

    public interface OnPropertyChangedObserver<T> {
        void onChanged(T item, String args);
    }
}