Java onCreate、onResume&；onPause保存回收器查看旋转位置？

无论我选择遵循stackoverflow中的哪个示例，我都没有得到期望的结果

我想在旋转时保存recyclerView滚动位置，但选择的保存状态

（最受欢迎的电影、最喜爱的电影和流行电影）

似乎会覆盖该状态，以便从屏幕顶部重新加载所需的选择

例如，在底部的一半或全部，然后旋转它保存选择类型（例如，旋转前显示的内容），但从开始重新加载（顶部（不需要，我需要保持在同一位置））

我的代码：

主要活动

public class MainActivity extends AppCompatActivity {


    public static final String TAG = MainActivity.class.getSimpleName();
    public static final int POP = 1;
    public static final int TOP = 2;
    public static final int FAV = 3;
    int selection = -1;
    private RecyclerView rv;
    private MovieAdapter adapter;
    private MovieDbHelper dbHelper;
    private FrameLayout frame;
    private AppCompatActivity activity = MainActivity.this;
    private static final String BUNDLE_RECYCLER_LAYOUT = "classname.recycler.layout";
    public static int index = -1;
    public static int top = -1;
    int currentVisiblePosition;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        if (!isOnline()) {
            Toast.makeText(activity, "No Connection", Toast.LENGTH_SHORT).show();
        } else {

            initControls();
            dbHelper = new MovieDbHelper(activity);
            if (savedInstanceState != null) {
                selection = savedInstanceState.getInt("selection");
                //Now just load the list
                switch (selection) {
                    case POP:
                        loadJSON(POP);
                        break;
                    case TOP:
                        loadJSON(TOP);
                        break;
                    case FAV:
                        initializeFavorites();
                        break;
                    case -1:
                        initializeViews();
                        break;
                }
            } else {
                initializeViews();
            }
        }

    }




    private void initControls() {
        rv = findViewById(R.id.rv_main);
        adapter = new MovieAdapter(this, new ArrayList<Movie>());

        rv.setLayoutManager(new GridLayoutManager(this, ScreenSizeUtil.calculateNoOfColumns(this)));


        rv.setItemAnimator(new DefaultItemAnimator());
        rv.setAdapter(adapter);



        dbHelper = new MovieDbHelper(activity);

        frame = findViewById(R.id.frame);

        checkSortOrder();
    }

    private void initializeViews() {

        Toast.makeText(this, "Change sort order via the Settings Menu....", Toast.LENGTH_SHORT).show();
    }

    private void initializeFavorites() {


        getAllFavorites();

    }
    private boolean isOnline() {
        ConnectivityManager cm =
                (ConnectivityManager) getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo netInfo = cm.getActiveNetworkInfo();
        return netInfo != null && netInfo.isConnectedOrConnecting();
    }




    private void loadJSON(int listType) {

        try {
            if (BuildConfig.THE_MOVIE_DB_API_TOKEN.isEmpty()) {
                Toast.makeText(this, "Error with Api Key....", Toast.LENGTH_SHORT).show();

                return;
            }
            Client Client = new Client();
            Service apiService =
                    Client.getClient().create(Service.class);

            Call<MovieResponse> call = listType==TOP? apiService
                    .getMovies("top_rated",BuildConfig.THE_MOVIE_DB_API_TOKEN): apiService.getMovies("popular",BuildConfig.THE_MOVIE_DB_API_TOKEN) ;
            call.enqueue(new Callback<MovieResponse>() {
                @Override
                public void onResponse(Call<MovieResponse> call, final Response<MovieResponse> response) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            List<Movie> movies = response.body().getResults();
                            adapter.setMovieList(movies);
                            rv.scrollToPosition(0);


                        }
                    });


                }

                @Override
                public void onFailure(Call<MovieResponse> call, Throwable t) {

                    Log.d("Error", t.getMessage());
                    Toast.makeText(MainActivity.this, "Error with Data!", Toast.LENGTH_SHORT).show();
                }
            });
        } catch (Exception e) {
            Log.d("Error", e.getMessage());
            Toast.makeText(this, e.toString(), Toast.LENGTH_SHORT).show();
        }


    }



    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putParcelable(BUNDLE_RECYCLER_LAYOUT, rv.getLayoutManager().onSaveInstanceState());
    }

    private void checkSortOrder(){
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
        String sortOrder = preferences.getString(
                this.getString(R.string.pref_sort_order_key),
                this.getString(R.string.pref_most_popular)
        );
        if (sortOrder.equals(this.getString(R.string.pref_most_popular))) {
            Log.d(TAG, "Sorting by most popular");
            loadJSON(POP);
        } else if (sortOrder.equals(this.getString(R.string.pref_highest_rated))){
            Log.d(TAG, "Sorting by Top rated");
            loadJSON(TOP);
        } else{
            Log.d(TAG, "Sorting by Favorites");
            initializeFavorites();
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu, menu);

        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {

        int id = item.getItemId();


        if (id == R.id.action_settings) {
            Intent intent = new Intent(this, SettingsActivity.class);
            startActivity(intent);
            return true;
        }
        return super.onOptionsItemSelected(item);

    }

    @Override
    protected void onResume() {
        super.onResume();
        (rv.getLayoutManager()).scrollToPosition(currentVisiblePosition);
        currentVisiblePosition = 0;
    }

    @Override
    public void onPause() {
        super.onPause();
        currentVisiblePosition = 0;
        currentVisiblePosition = ((LinearLayoutManager)rv.getLayoutManager()).findFirstCompletelyVisibleItemPosition();}

    private void getAllFavorites() {
        new AsyncTask<Void, Void, ArrayList<Movie>>() {
            @Override
            protected ArrayList<Movie> doInBackground(Void... voids) {
                return new ArrayList<>(dbHelper.getAllFavorites());
            }

            @Override
            protected void onPostExecute(ArrayList<Movie> aVoid) {
                super.onPostExecute(aVoid);
                adapter.setMovieList(aVoid);
            }
        }.execute();
    }



}

public类MainActivity扩展了AppCompatActivity{
公共静态最终字符串标记=MainActivity.class.getSimpleName（）；
公共静态最终int POP=1；
公共静态最终int TOP=2；
公共静态最终整数FAV=3；
整数选择=-1；
私人回收车；
私人电影适配器；
私人电影助手；
专用框架布局框架；
私有AppCompativeActivity=MainActivity.this；
私有静态最终字符串包\u RECYCLER\u LAYOUT=“classname.RECYCLER.LAYOUT”；
公共静态整数指数=-1；
公共静态int top=-1；
int-currentVisiblePosition；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
如果（！isOnline（））{
Toast.makeText（活动“无连接”，Toast.LENGTH_SHORT）.show（）；
}否则{
initControls（）；
dbHelper=新的MovieDbHelper（活动）；
如果（savedInstanceState！=null）{
selection=savedInstanceState.getInt（“selection”）；
//现在只需加载列表
开关（选择）{
个案流行：
loadJSON（POP）；
打破
案例顶部：
loadJSON（顶部）；
打破
案例FAV：
初始化为vorites（）；
打破
案例1：
初始化视图（）；
打破
}
}否则{
初始化视图（）；
}
}
}
私有控件（）{
rv=findViewById（R.id.rv_main）；
adapter=new MovieAdapter（这个，new ArrayList（））；
rv.setLayoutManager（新的GridLayoutManager（此，ScreenSizeUtil.CalculateNofColumns（此））；
rv.setItemAnimator（新的DefaultItemAnimator（））；
rv.设置适配器（适配器）；
dbHelper=新的MovieDbHelper（活动）；
frame=findviewbyd（R.id.frame）；
checkSortOrder（）；
}
private void initializeViews（）{
Toast.makeText（这是“通过设置菜单更改排序顺序…”），Toast.LENGTH_SHORT.show（）；
}
私有void initializeFavorites（）{
getAllFavorites（）；
}
私有布尔isOnline（）{
连接管理器cm=
（ConnectionManager）getApplicationContext（）.getSystemService（Context.CONNECTIVITY_服务）；
NetworkInfo netInfo=cm.getActiveNetworkInfo（）；
返回netInfo！=null&&netInfo.isConnectedOrConnecting（）；
}
私有void loadJSON（int-listType）{
试一试{
if（BuildConfig.THE\u MOVIE\u DB\u API\u TOKEN.isEmpty（））{
Toast.makeText（这是“Api键出错…”，Toast.LENGTH_SHORT.show（）；
返回；
}
客户端=新客户端（）；
服务业=
Client.getClient（）.create（Service.class）；
Call Call=listType==TOP？apiService
.getMovies（“最高评级”，BuildConfig.THE_MOVIE\u DB\u API\u令牌）：apiService.getMovies（“流行”，BuildConfig.THE_MOVIE\u DB\u API\u令牌）；
call.enqueue（新回调（）{
@凌驾
公共void onResponse（呼叫、最终响应）{
runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
List movies=response.body（）.getResults（）；
adapter.setMovieList（电影）；
右心室位置（0）；
}
});
}
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
Log.d（“Error”，t.getMessage（））；
Toast.makeText（MainActivity.this，“数据错误！”，Toast.LENGTH_SHORT.show（）；
}
});
}捕获（例外e）{
Log.d（“错误”，例如getMessage（））；
Toast.makeText（例如toString（），Toast.LENGTH_SHORT）.show（）；
}
}
@凌驾
SaveInstanceState上的公共无效（束超出状态）{
super.onSaveInstanceState（超出状态）；
outState.putParcelable（BUNDLE\u RECYCLER\u布局，rv.getLayoutManager（）.onSaveInstanceState（））；
}
私有无效检查排序器（）{
SharedReferences preferences=PreferenceManager.GetDefaultSharedReferences（此）；
String sortOrder=preferences.getString(
这个.getString（R.string.pref\u sort\u order\u键），
this.getString（R.string.pref\u最流行）
);
if（sortOrder.equals（this.getString（R.string.pref_most_popular）））{
Log.d（标签，“按最流行的排序”）；
loadJSON（POP）；
}else if（sortOrder.equals（this.getString（R.string.pref\u highest\u rated）））{
Log.d（标签“按最高评级排序”）；
loadJSON（顶部）；
}否则{
Log.d（标记“按收藏夹排序”）；
初始化为vorites（）；
}
}
@凌驾
公共布尔onCreateOptions菜单（菜单）