RecyclerView.Adapterで動作するSortedList <T>とは何ですか？

Question

Android Support Library 22.1は昨日リリースされました。多くの新機能がv4サポートライブラリとv7に追加されました。その中でAndroid.support.v7.util.SortedList<T>が注目を集めています。

SortedListは新しいデータ構造であり、RecyclerView.Adapterと連動し、RecyclerViewによって提供されるアイテムの追加/削除/移動/変更アニメーションを維持すると言われています。 ListViewのList<T>のように聞こえますが、より高度で強力なようです。

それで、SortedList<T>とList<T>の違いは何ですか？どうすれば効率的に使用できますか？そうである場合、SortedList<T>をList<T>に強制することは何ですか？誰かがそれのサンプルを投稿できますか？

ヒントやコードを歓迎します。前もって感謝します。

Answer 1

SortedListは_v7 support library_にあります。

SortedList実装。アイテムを順番に保持し、リストの変更を通知して、_RecyclerView.Adapter_にバインドできるようにします。

compare(Object, Object)メソッドを使用してアイテムの順序を維持し、バイナリ検索を使用してアイテムを取得します。アイテムの並べ替え条件が変更される可能性がある場合は、編集中に適切なメソッドを呼び出して、データの不整合を回避してください。

_SortedList.Callback_パラメーターを使用して、アイテムの順序を制御し、通知を変更できます。

以下はSortedListの使用例です。あなたが望むものだと思いますので、それを見て楽しんでください！

_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;
        }
    }
}
_

Answer 2

SortedListは、Callbackを介してリサイクルアダプターへの通信を処理します。

SortedListとListの違いの1つは、以下のサンプルのaddAllヘルパーメソッドにあります。

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

1. 最後に追加されたアイテムを保持

リサイクラリストにデータが入力されたときにすぐにロードするために、10個のキャッシュされたアイテムがあるとします。同時に、同じ10個のアイテムをネットワークにクエリします。これらのアイテムは、キャッシュしてから変更された可能性があるためです。同じaddAllメソッドを呼び出すことができ、SortedListはcachedItemsを内部のfetchedItemsに置き換えます（常に最後に追加されたアイテムを保持します）。

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

通常のListでは、すべてのアイテムが重複しています（リストサイズ20）。 SortedListを使用すると、コールバックのareItemsTheSameを使用して同じアイテムが置き換えられます。

2. ビューをいつ更新するかについてスマート

FetchedItemsが追加されると、onChangeの1つ以上のタイトルが変更された場合にのみPageが呼び出されます。コールバックのSortedListでareContentsTheSameが探すものをカスタマイズできます。

3. そのパフォーマンス

複数のアイテムをSortedListに追加する場合、BatchedCallback呼び出しは、アイテムが連続したインデックスに追加されると、個々のonInserted（index、1）呼び出しを1つのonInserted（index、N）に変換します。この変更により、RecyclerViewは変更をより簡単に解決できます。

サンプル

SortedListのアダプターにゲッターを設定できますが、ヘルパーメソッドをアダプターに追加することにしました。

アダプタークラス：

  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();
    }
}

ページクラス：

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;
    }
}

ビューホルダー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>

ビューホルダークラス：

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


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

Answer 3

サポートライブラリのソースリポジトリには、RecyclerView.Adapter内でSortedListおよびSortedListAdapterCallbackを使用する方法を示すサンプルのSortedListActivityがあります。サポートライブラリがインストールされたSDKのルートから、extras/Android/support/samples/Support7Demos/src/com/example/Android/supportv7/util/SortedListActivity.Java（ github でも）。

これらの特定のサンプルの存在は、Googleのドキュメントの別のトピックを扱っているページの下部にある exactly once に言及されているので、見つけられなかったからといって非難しません。

Answer 4

SortedList実装については、_<T>_の配列によってサポートされ、デフォルトの最小容量は10アイテムです。配列がいっぱいになると、配列はsize() + 10にサイズ変更されます

ソースコードが利用可能です こちら

ドキュメント から

アイテムの順序を維持し、リストの変更を通知して、RecyclerView.Adapterにバインドできるソート済みリストの実装。

Compare（Object、Object）メソッドを使用してアイテムの順序を維持し、バイナリ検索を使用してアイテムを取得します。アイテムの並べ替え条件が変更される可能性がある場合は、編集中に適切なメソッドを呼び出して、データの不整合を回避してください。

SortedList.Callbackパラメーターを使用して、アイテムの順序を制御し、通知を変更できます。

パフォーマンスに関しては、 SortedList.BatchedCallback を追加して、一度に1つではなく複数の操作を一度に実行しました

SortedListによってディスパッチされたイベントをバッチ通知できるコールバック実装。

このクラスは、SortedListで複数の操作を行いたいが、各イベントを1つずつディスパッチしたくない場合に役立ちます。これにより、パフォーマンスの問題が発生する可能性があります。

たとえば、複数のアイテムをSortedListに追加する場合、BatchedCallback呼び出しは、アイテムが連続したインデックスに追加されると、個々のonInserted（index、1）呼び出しを1つのonInserted（index、N）に変換します。この変更により、RecyclerViewは変更をより簡単に解決できます。

SortedListの連続した変更がバッチ処理に適していない場合、BatchingCallbackはそのようなケースが検出されるとすぐにそれらをディスパッチします。 SortedListでの編集が完了したら、常にdispatchLastEvent（）を呼び出して、コールバックへのすべての変更をフラッシュする必要があります。