Java 提交更改时，域始终自动对我的列表排序

为了好玩，我制作了一个示例领域应用程序。领域版本：0.88.2

我遇到的问题是，每次尝试修改元素时，排序设置都会自动消失

我的步骤如下： 我有一个歌曲列表

我按id ASC对歌曲进行排序

我单击一个项目，然后该元素的int计数器（不是id）将递增。我提交交易

一切都很好

我按id对歌曲进行排序

我单击一个项目，然后该元素的int计数器（不是id）将递增。我提交交易

整个列表将按id ASC再次排序，这是不需要的。我调试了我写的所有东西，没有执行任何排序

代码如下：

主要活动：

public class MainActivity extends AppCompatActivity implements OnClickInterface {
    @Bind(R.id.tool_bar)
    Toolbar toolBar;
    @Bind(R.id.list)
    ListView list;
    private Realm realm;
    boolean isChecked = false;
    RealmListviewAdapter adapter;
    boolean sort = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
        setSupportActionBar(toolBar);
        realm = Realm.getDefaultInstance();
        adapter = new RealmListviewAdapter(this, null, true);
        adapter.setListener(this);
        list.setAdapter(adapter);
        if (isChecked) {
            updateAllSongs();
        } else {
            realm.where(Song.class).findFirstAsync().asObservable()
                    .filter(new Func1<RealmObject, Boolean>() {
                        @Override
                        public Boolean call(RealmObject realmObject) {
                            return realmObject.isLoaded();
                        }
                    })
                    .first()
                    .subscribeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Action1<RealmObject>() {
                        @Override
                        public void call(RealmObject realmObject) {
                            if (!realmObject.isValid()) {
                                addUsers();
                            } else {
                                updateAllSongs();
                            }
                        }
                    });
            isChecked = true;
        }
    }

    @OnClick(R.id.tool_bar)
    public void onClickToolbar() {
        if (sort) {
            adapter.getRealmResults().sort("_id");
        } else {
            adapter.getRealmResults().sort("_id", Sort.DESCENDING);
        }
        sort = !sort;
        adapter.notifyDataSetChanged();
    }

    private void addUsers() {
        realm.executeTransactionAsync(new Realm.Transaction() {
            @Override
            public void execute(Realm realm) {
                String[] titles = getResources().getStringArray(R.array.song_titles);
                for (int i = 0; i < titles.length; i++) {
                    Song song = new Song();
                    song.set_id(i);
                    song.set_trackNumber(i + 1);
                    song.set_title(titles[i]);
                    song.set_favorite(false);
                    song.set_frequency(0);
                    song.set_lyrics("");
                    song.set_downloaded(false);
                    realm.copyToRealm(song);
                }
            }
        }, new Realm.Transaction.OnSuccess() {
            @Override
            public void onSuccess() {
                updateAllSongs();
            }
        });
    }

    private void updateAllSongs() {
        realm.where(Song.class).findAllSortedAsync("_id").asObservable()
                .filter(new Func1<RealmResults<Song>, Boolean>() {
                    @Override
                    public Boolean call(RealmResults<Song> songs) {
                        return songs.isLoaded();
                    }
                })
                .first()
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<RealmResults<Song>>() {
                    @Override
                    public void call(RealmResults<Song> songs) {
                        adapter.updateRealmResults(songs);
                    }
                });
    }

    @Override
    public void onClickedItem(int position) {
        System.out.println("Pressed position " + position);
        Song song = adapter.getRealmResults().get(position);
        realm.beginTransaction();
        Log.d("frequency", String.valueOf(song.get_frequency()));
        song.set_frequency(song.get_frequency() + 1);
        realm.commitTransaction();
        Log.d("frequency", String.valueOf(song.get_frequency()));
        //Log.d("frequency", String.valueOf(_data.get(position).get_frequency()));
    }
}

public类MainActivity扩展了AppCompatActivity实现了OnClick接口{
@绑定（R.id.工具条）
工具栏；
@绑定（R.id.list）
列表视图列表；
私人领域；
布尔值isChecked=false；
RealmListviewAdapter；
布尔排序=假；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
把（这个）绑起来；
设置支持操作栏（工具栏）；
realm=realm.getDefaultInstance（）；
adapter=新的RealmListviewAdapter（this，null，true）；
setListener（this）；
list.setAdapter（适配器）；
如果（已检查）{
更新歌曲（）；
}否则{
realm.where（Song.class）.findFirstAsync（）.asObservable（）
.filter（新函数1（）{
@凌驾
公共布尔调用（RealmObject RealmObject）{
返回realmObject.isLoaded（）；
}
})
.first（）
.subscribeOn（AndroidSchedulers.mainThread（））
.订阅（新操作1（）{
@凌驾
公共void调用（RealmObject RealmObject）{
如果（！realmObject.isValid（））{
addUsers（）；
}否则{
更新歌曲（）；
}
}
});
isChecked=true；
}
}
@OnClick（R.id.工具条）
public void onClickToolbar（）{
如果（排序）{
adapter.getRealmResults（）.sort（“_id”）；
}否则{
adapter.getRealmResults（）.sort（“\u id”，sort.DESCENDING）；
}
排序=！排序；
adapter.notifyDataSetChanged（）；
}
私有void addUsers（）{
realm.executeTransactionAsync（新realm.Transaction（）{
@凌驾
公共void执行（领域）{
String[]titles=getResources（）.getStringArray（R.array.song_titles）；
对于（int i=0；i

我的适配器：

public class RealmListviewAdapter extends RealmBaseAdapter<Song> implements ListAdapter{
    private OnClickInterface _listener;

    public RealmListviewAdapter(Context context, RealmResults<Song> realmResults, boolean automaticUpdate) {
        super(context, realmResults, automaticUpdate);
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        SongViewHolder viewHolder;
        if (convertView == null) {
            convertView = inflater.inflate(R.layout.eachsong, parent, false);
            viewHolder = new SongViewHolder(convertView);
            convertView.setTag(viewHolder);
        } else {
            viewHolder = (SongViewHolder) convertView.getTag();
        }
        Song song = realmResults.get(position);
        viewHolder.track.setText(String.valueOf(song.get_trackNumber()));
        viewHolder.title.setText(song.get_title());
        viewHolder.position = position;
        return convertView;
    }

    public void updateRealmResults(RealmResults<Song> queryResults) {
        super.updateRealmResults(queryResults);
        Log.d("Adapter", "UpdateRealmResults is called");
    }

    public RealmResults<Song> getRealmResults() {
        return realmResults;
    }

    public void setListener(OnClickInterface listener) {
        _listener = listener;
    }

    class SongViewHolder{
        @Bind(R.id.tracknumber)
        TextView track;
        @Bind(R.id.title)
        TextView title;
        @Bind(R.id.freq)
        TextView freq;
        @Bind(R.id.fav_star)
        ImageView fav;
        int position;

        public SongViewHolder(View itemView) {
            ButterKnife.bind(this, itemView);
        }

        @OnClick(R.id.item_row)
        public void onClickItem() {
            _listener.onClickedItem(position);
        }
    }
}

公共类RealmListviewAdapter扩展RealmBaseAdapter实现ListAdapter{
私有onclick接口_侦听器；
公共RealmListviewAdapter（上下文上下文、RealmResults RealmResults、布尔自动日期）{
super（上下文、realmResults、automaticUpdate）；
}
@凌驾
公共视图getView（int位置、视图转换视图、视图组父视图）{
歌曲视盘视盘；
if（convertView==null）{
convertView=充气机。充气（R.layout.eachsong，父项，false）；
viewHolder=新歌曲viewHolder（convertView）；
convertView.setTag（viewHolder）；
}否则{
viewHolder=（SongViewHolder）convertView.getTag（）；
}
宋宋=realmResults.get（位置）；
viewHolder.track.setText（String.valueOf（song.get_trackNumber（））；
viewHolder.title.setText（song.get_title（））；
viewHolder.position=位置；
返回视图；
}
public void updateralmResults（RealmResults queryResults）{
super.updateralmResults（queryResults）；
Log.d（“适配器”、“更新”