Was ist die SortedList & lt; T & gt; Arbeiten mit RecyclerView.Adapter?

Android-Support-Bibliothek 22.1 wurde gestern veröffentlicht. Viele neue Funktionen wurden Hinzugefügt, in die v4 support library und v7, unter denen android.support.v7.util.SortedList<T> zieht meine Aufmerksamkeit auf sich.

Es wird erzählt, dass SortedList ist eine neue Datenstruktur, arbeitet mit RecyclerView.Adapter ist, hat das Element Hinzugefügt/gelöscht/verschoben/geändert Animationen zur Verfügung gestellt von RecyclerView. Es klingt wie ein List<T> im ListView aber scheint weiter Fortgeschritten und mächtig.

Also, was ist der Unterschied zwischen SortedList<T> und List<T>? Wie kann ich es effizient? Was die Durchsetzung der SortedList<T> über List<T> wenn es so ist? Kann jemand post einige Proben davon?

Irgendwelche Tipps oder codes, werden geschätzt. Vielen Dank im Voraus.

InformationsquelleAutor der Frage SilentKnight | 2015-04-22

SortedList übernimmt die Kommunikation zu den Recycler-adapter über Callback.

Einen Unterschied zwischen SortedList und List ist zu sehen in der addAll Helfer-Methode im Beispiel unten.

public void addAll(List<Page> items) {
        mPages.beginBatchedUpdates();
        for (Page item : items) {
            mPages.add(item);
        }
        mPages.endBatchedUpdates();
    }

Hält den zuletzt hinzugefügten Element

Sagen, ich habe 10 zwischengespeicherten Elemente zu laden, sofort, wenn meine recycler Liste wird gefüllt. Zur gleichen Zeit, ich meine Abfrage Netzwerk für die 10 gleichen Elementen, weil Sie sich geändert haben, seit ich zwischengespeichert. Ich kann rufen Sie die gleiche addAll Methode und SortedList ersetzen die cachedItems mit fetchedItems unter der Haube (immer das zuletzt hinzugefügte Element).

//After creating adapter
myAdapter.addAll(cachedItems)
//Network callback
myAdapter.addAll(fetchedItems)

In regelmäßigen List hätte ich die Duplikate alle meine items (Liste Größe von 20). Mit SortedList seine ersetzt die Elemente, die identisch sind mit dem Rückruf ist areItemsTheSame.

Seine smart-etwa beim aktualisieren der Ansichten

Wenn die fetchedItems Hinzugefügt werden, onChange wird nur aufgerufen werden, wenn eine oder mehrere der Page's Titel geändert. Sie können anpassen, was SortedList sucht in der Callback -areContentsTheSame.

Seine performant

Wenn Sie zum hinzufügen mehrerer Elemente zu einer SortedList, BatchedCallback rufen Sie konvertieren einzelne onInserted(index, 1) - Aufrufe in eine onInserted(index, N), wenn Elemente Hinzugefügt werden, die in aufeinander folgende Indizes. Diese änderung kann helfen, RecyclerView beheben änderungen viel leichter.

Probe

Können Sie eine get auf Ihrem adapter für Ihr SortedListaber ich habe einfach entschieden, um Hilfsmethoden, um meinen adapter.

Adapter-Klasse:

  public class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
    private SortedList<Page> mPages;

    public MyAdapter() {
        mPages = new SortedList<Page>(Page.class, new SortedList.Callback<Page>() {
            @Override
            public int compare(Page o1, Page o2) {
                return o1.getTitle().compareTo(o2.getTitle());
            }

            @Override
            public void onInserted(int position, int count) {
                notifyItemRangeInserted(position, count);
            }

            @Override
            public void onRemoved(int position, int count) {
                notifyItemRangeRemoved(position, count);
            }

            @Override
            public void onMoved(int fromPosition, int toPosition) {
                notifyItemMoved(fromPosition, toPosition);
            }

            @Override
            public void onChanged(int position, int count) {
                notifyItemRangeChanged(position, count);
            }

            @Override
            public boolean areContentsTheSame(Page oldItem, Page newItem) {
                //return whether the items' visual representations are the same or not.
                return oldItem.getTitle().equals(newItem.getTitle());
            }

            @Override
            public boolean areItemsTheSame(Page item1, Page item2) {
                return item1.getId() == item2.getId();
            }
        });

    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext())
                .inflate(R.layout.viewholder_page, parent, false);
        return new PageViewHolder(view);
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        PageViewHolder pageViewHolder = (PageViewHolder) holder;
        Page page = mPages.get(position);
        pageViewHolder.textView.setText(page.getTitle());
    }

    @Override
    public int getItemCount() {
        return mPages.size();
    }

    //region PageList Helpers
    public Page get(int position) {
        return mPages.get(position);
    }

    public int add(Page item) {
        return mPages.add(item);
    }

    public int indexOf(Page item) {
        return mPages.indexOf(item);
    }

    public void updateItemAt(int index, Page item) {
        mPages.updateItemAt(index, item);
    }

    public void addAll(List<Page> items) {
        mPages.beginBatchedUpdates();
        for (Page item : items) {
            mPages.add(item);
        }
        mPages.endBatchedUpdates();
    }

    public void addAll(Page[] items) {
        addAll(Arrays.asList(items));
    }

    public boolean remove(Page item) {
        return mPages.remove(item);
    }

    public Page removeItemAt(int index) {
        return mPages.removeItemAt(index);
    }

    public void clear() {
       mPages.beginBatchedUpdates();
       //remove items at end, to avoid unnecessary array shifting
       while (mPages.size() > 0) {
          mPages.removeItemAt(mPages.size() - 1);
       }
       mPages.endBatchedUpdates();
    }
}

Seite Klasse:

public class Page {
    private String title;
    private long id;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }
}

Viewholder xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <TextView
        android:id="@+id/text_view"
        style="@style/TextStyle.Primary.SingleLine"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</LinearLayout>

Viewholder Klasse:

public class PageViewHolder extends RecyclerView.ViewHolder {
    public TextView textView;


    public PageViewHolder(View itemView) {
        super(itemView);
        textView = (TextView)item.findViewById(R.id.text_view);
    }
}

InformationsquelleAutor der Antwort Amozoss

SortedList ist in v7 support library.

Einen SortedList Umsetzung, halten Sie Gegenstände in Ordnung und auch
Benachrichtigung bei änderungen in der Liste solche, die es gebunden werden können, um eine
RecyclerView.Adapter.

Hält bestellten Artikel mithilfe des compare(Object, Object) Methode und
benutzt binäre Suche, um Elemente abzurufen. Wenn die Sortier-Kriterien von Ihre
Elemente die sich ändern können, stellen Sie sicher, Sie rufen entsprechende Methoden während der Bearbeitung
Sie zu vermeiden, Daten-Inkonsistenzen.

Können Sie die Reihenfolge der Elemente, und ändern Sie die Meldungen über die
SortedList.Callback parameter.

Hier unten ist ein Beispiel der Verwendung von SortedList ich denke, es ist, was Sie wollen, werfen Sie einen Blick auf Sie es und genießen Sie!

public class SortedListActivity extends ActionBarActivity {
    private RecyclerView mRecyclerView;
    private LinearLayoutManager mLinearLayoutManager;
    private SortedListAdapter mAdapter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.sorted_list_activity);
        mRecyclerView = (RecyclerView) findViewById(R.id.recycler_view);
        mRecyclerView.setHasFixedSize(true);
        mLinearLayoutManager = new LinearLayoutManager(this);
        mRecyclerView.setLayoutManager(mLinearLayoutManager);
        mAdapter = new SortedListAdapter(getLayoutInflater(),
                new Item("buy milk"), new Item("wash the car"),
                new Item("wash the dishes"));
        mRecyclerView.setAdapter(mAdapter);
        mRecyclerView.setHasFixedSize(true);
        final EditText newItemTextView = (EditText) findViewById(R.id.new_item_text_view);
        newItemTextView.setOnEditorActionListener(new TextView.OnEditorActionListener() {
            @Override
            public boolean onEditorAction(TextView textView, int id, KeyEvent keyEvent) {
                if (id == EditorInfo.IME_ACTION_DONE &&
                        (keyEvent == null || keyEvent.getAction() == KeyEvent.ACTION_DOWN)) {
                    final String text = textView.getText().toString().trim();
                    if (text.length() > 0) {
                        mAdapter.addItem(new Item(text));
                    }
                    textView.setText("");
                    return true;
                }
                return false;
            }
        });
    }

    private static class SortedListAdapter extends RecyclerView.Adapter<TodoViewHolder> {
        SortedList<Item> mData;
        final LayoutInflater mLayoutInflater;
        public SortedListAdapter(LayoutInflater layoutInflater, Item... items) {
            mLayoutInflater = layoutInflater;
            mData = new SortedList<Item>(Item.class, new SortedListAdapterCallback<Item>(this) {
                @Override
                public int compare(Item t0, Item t1) {
                    if (t0.mIsDone != t1.mIsDone) {
                        return t0.mIsDone ? 1 : -1;
                    }
                    int txtComp = t0.mText.compareTo(t1.mText);
                    if (txtComp != 0) {
                        return txtComp;
                    }
                    if (t0.id < t1.id) {
                        return -1;
                    } else if (t0.id > t1.id) {
                        return 1;
                    }
                    return 0;
                }

                @Override
                public boolean areContentsTheSame(Item oldItem,
                        Item newItem) {
                    return oldItem.mText.equals(newItem.mText);
                }

                @Override
                public boolean areItemsTheSame(Item item1, Item item2) {
                    return item1.id == item2.id;
                }
            });
            for (Item item : items) {
                mData.add(item);
            }
        }

        public void addItem(Item item) {
            mData.add(item);
        }

        @Override
        public TodoViewHolder onCreateViewHolder(final ViewGroup parent, int viewType) {
            return new TodoViewHolder (
                    mLayoutInflater.inflate(R.layout.sorted_list_item_view, parent, false)) {
                @Override
                void onDoneChanged(boolean isDone) {
                    int adapterPosition = getAdapterPosition();
                    if (adapterPosition == RecyclerView.NO_POSITION) {
                        return;
                    }
                    mBoundItem.mIsDone = isDone;
                    mData.recalculatePositionOfItemAt(adapterPosition);
                }
            };
        }

        @Override
        public void onBindViewHolder(TodoViewHolder holder, int position) {
            holder.bindTo(mData.get(position));
        }

        @Override
        public int getItemCount() {
            return mData.size();
        }
    }

    abstract private static class TodoViewHolder extends RecyclerView.ViewHolder {
        final CheckBox mCheckBox;
        Item mBoundItem;
        public TodoViewHolder(View itemView) {
            super(itemView);
            mCheckBox = (CheckBox) itemView;
            mCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
                @Override
                public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                    if (mBoundItem != null && isChecked != mBoundItem.mIsDone) {
                        onDoneChanged(isChecked);
                    }
                }
            });
        }

        public void bindTo(Item item) {
            mBoundItem = item;
            mCheckBox.setText(item.mText);
            mCheckBox.setChecked(item.mIsDone);
        }

        abstract void onDoneChanged(boolean isChecked);
    }

    private static class Item {
        String mText;
        boolean mIsDone = false;
        final public int id;
        private static int idCounter = 0;

        public Item(String text) {
            id = idCounter ++;
            this.mText = text;
        }
    }
}

InformationsquelleAutor der Antwort SilentKnight

5

Es ist ein Beispiel SortedListActivity in der support-library-source-repository, welches veranschaulicht, wie SortedList und SortedListAdapterCallback innerhalb einer RecyclerView.- Adapter. Aus der Wurzel des SDK, mit der support-library installiert, es sollte auf extras/android/support/samples/Support7Demos/src/com/example/android/supportv7/util/SortedListActivity.java (auch auf github).

Die Existenz dieser bestimmten Muster ist erwähnt genau einmal in der Google-Dokumentation, an der Unterseite der einen Seite der Umgang mit einem anderen Thema, so dass ich nicht die Schuld Sie für es nicht zu finden.

InformationsquelleAutor der Antwort moskvax
2

Über SortedList Umsetzung, es wird unterstützt durch ein array von <T> mit einem Standard-min-Kapazität von 10 Elementen. Sobald das array voll ist, wird das array verkleinert, um size() + 10

Den source-code verfügbar ist, hier

Vom Dokumentation

Einer Sortierten Liste-Implementierung, können Elemente in Ordnung und auch
Benachrichtigung bei änderungen in der Liste solche, die es gebunden werden können, um eine
RecyclerView.Adapter.

Es hält Gegenstände bestellt mit dem compare(Object, Object) - Methode und
benutzt binäre Suche, um Elemente abzurufen. Wenn die Sortier-Kriterien von Ihre
Elemente die sich ändern können, stellen Sie sicher, Sie rufen entsprechende Methoden während der Bearbeitung
Sie zu vermeiden, Daten-Inkonsistenzen.

Können Sie die Reihenfolge der Elemente, und ändern Sie die Meldungen über die
Der SortedList.Parameter Callback.

Bezug zu der Leistung, die Sie auch Hinzugefügt Der SortedList.BatchedCallback zur Durchführung mehrere operation auf einmal und nicht ein zu der Zeit

Einer callback-Implementierung, können batch-Benachrichtigen Ereignisse, die ausgelöst werden,
die SortedList.

Dieser Klasse kann nützlich sein, wenn Sie wollen, um mehrere Vorgänge auf einem
SortedList wollen aber nicht Versand jedes Ereignis einzeln, die kann
Ergebnis in ein performance-Problem.

Zum Beispiel, wenn Sie gehen, um mehrere Elemente hinzuzufügen, um eine SortedList,
BatchedCallback rufen Sie konvertieren einzelne onInserted(index, 1) ruft
in einer onInserted(index, N), wenn Elemente Hinzugefügt werden, die in aufeinander folgenden
die Indizes. Diese änderung kann helfen, RecyclerView beheben verpasst vieles mehr
leicht.

Wenn aufeinanderfolgende änderungen in der SortedList sind nicht geeignet für
Batchverarbeitung, BatchingCallback setzt Sie, sobald ein solcher Fall ist
erkannt. Nachdem Sie Ihre Bearbeitungen in der SortedList abgeschlossen ist, müssen Sie
rufen Sie immer dispatchLastEvent() Spülen, um alle änderungen, die an den Callback.

InformationsquelleAutor der Antwort Axxiss

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.