Not logged in.  Login/Logout/Register | List snippets | | Create snippet | Upload image | Upload data


< > BotCompany Repo | #1031171 // SynchronizedList [copied from JDK]

JavaX fragment (include) [tags: use-pretranspiled]

Libraryless. Click here for Pure Java version (4775L/27K).

static persistable class SynchronizedList<E>
    extends SynchronizedCollection<E>
    implements List<E> {
    /*final*/ List<E> list;

    SynchronizedList(List<E> list) {
        this.list = list;
    SynchronizedList(List<E> list, Object mutex) {
        super(list, mutex);
        this.list = list;

    public boolean equals(Object o) {
        if (this == o)
            return true;
        synchronized (mutex) {return list.equals(o);}
    public int hashCode() {
        synchronized (mutex) {return list.hashCode();}

    public E get(int index) {
        synchronized (mutex) {return list.get(index);}
    public E set(int index, E element) {
        synchronized (mutex) {return list.set(index, element);}
    public void add(int index, E element) {
        synchronized (mutex) {list.add(index, element);}
    public E remove(int index) {
        synchronized (mutex) {return list.remove(index);}

    public int indexOf(Object o) {
        synchronized (mutex) {return list.indexOf(o);}
    public int lastIndexOf(Object o) {
        synchronized (mutex) {return list.lastIndexOf(o);}

    public boolean addAll(int index, Collection<? extends E> c) {
        synchronized (mutex) {return list.addAll(index, c);}

    public ListIterator<E> listIterator() {
        return list.listIterator(); // Must be manually synched by user

    public ListIterator<E> listIterator(int index) {
        return list.listIterator(index); // Must be manually synched by user

    public List<E> subList(int fromIndex, int toIndex) {
        synchronized (mutex) {
            return new SynchronizedList<>(list.subList(fromIndex, toIndex),

    public void replaceAll(java.util.function.UnaryOperator<E> operator) {
        synchronized (mutex) {list.replaceAll(operator);}
    public void sort(Comparator<? super E> c) {
        synchronized (mutex) {list.sort(c);}

     * SynchronizedRandomAccessList instances are serialized as
     * SynchronizedList instances to allow them to be deserialized
     * in pre-1.4 JREs (which do not have SynchronizedRandomAccessList).
     * This method inverts the transformation.  As a beneficial
     * side-effect, it also grafts the RandomAccess marker onto
     * SynchronizedList instances that were serialized in pre-1.4 JREs.
     * Note: Unfortunately, SynchronizedRandomAccessList instances
     * serialized in 1.4.1 and deserialized in 1.4 will become
     * SynchronizedList instances, as this method was missing in 1.4.
    private Object readResolve() {
        return (list instanceof RandomAccess
                ? new SynchronizedRandomAccessList<>(list)
                : this);

download  show line numbers  debug dex  old transpilations   

Travelled to 4 computer(s): bhatertpkbcr, mqqgnosmbjvj, pyentgdyhuwx, vouqrxazstgt

No comments. add comment

Snippet ID: #1031171
Snippet name: SynchronizedList [copied from JDK]
Eternal ID of this version: #1031171/3
Text MD5: 8067a7cbde7998388a2d77a7f2d44c0e
Transpilation MD5: 19a2e942523233897dca14ec53fa7f20
Author: stefan
Category: javax
Type: JavaX fragment (include)
Public (visible to everyone): Yes
Archived (hidden from active list): No
Created/modified: 2022-01-08 21:14:06
Source code size: 2982 bytes / 90 lines
Pitched / IR pitched: No / No
Views / Downloads: 89 / 244
Version history: 2 change(s)
Referenced in: [show references]