为何Retrofit外部打印ArrayList为空？已声明全局变量仍无效

Hey there! The issue you're facing boils down to asynchronous execution—let me break it down clearly and show you how to fix it.

What's Happening? #

Retrofit's enqueue() method runs your network request in the background (off the main thread). When you call enqueue(), your code doesn't pause to wait for the request to finish—it immediately jumps to the for loop outside to print profileList. At that point, the network request hasn't completed yet, so profileList is still empty.

The onResponse() callback, however, only runs after the network request succeeds and the data is fully fetched. That's why your print statement inside onResponse() works perfectly—by then, profileList has been filled with the data you need.

Solutions to Access the Data Outside onResponse #

1. Process Data Directly Inside onResponse (Simplest Approach) #

Wrap your print logic (or any other data processing) in a separate method, then call that method from onResponse once the data is ready:

// Define a method to handle your profile list
private void handleProfileList(List<Profile> profileList) {
    for (Profile p : profileList){
        Log.i("info", p.getUserid() + '\n' + p.getNickname());
    }
    // You can also update your UI here if needed
}

// In your Retrofit call:
apiService.getGetlistuser("getlistuser").enqueue(new Callback<ResponseDaftar>() {
    @Override
    public void onResponse(Call<ResponseDaftar> call, Response<ResponseDaftar> response) {
        if (response.isSuccessful()) {
            List<GetlistuserItem> getlistuserItemList = response.body().getGetlistuser();
            for (int i = 0; i < getlistuserItemList.size(); i++) {
                profileList.add(new Profile(
                    getlistuserItemList.get(i).getUserID(),
                    getlistuserItemList.get(i).getNickname()
                ));
            }
            // Call the method to process the data
            handleProfileList(profileList);
        }
    }

    @Override
    public void onFailure(Call<ResponseDaftar> call, Throwable t) {
        Log.e("error", "Failed to fetch data: " + t.getMessage());
    }
});

2. Use a Custom Callback Interface (Better Separation of Concerns) #

If you want to decouple data fetching from processing, create a callback interface to notify when the data is ready:

// Define the callback interface
public interface ProfileListListener {
    void onProfileListLoaded(List<Profile> profileList);
    void onError(String errorMessage);
}

// Create a method to fetch data with the callback
public void fetchProfiles(ProfileListListener listener) {
    apiService.getGetlistuser("getlistuser").enqueue(new Callback<ResponseDaftar>() {
        @Override
        public void onResponse(Call<ResponseDaftar> call, Response<ResponseDaftar> response) {
            if (response.isSuccessful()) {
                List<GetlistuserItem> getlistuserItemList = response.body().getGetlistuser();
                List<Profile> profileList = new ArrayList<>();
                for (int i = 0; i < getlistuserItemList.size(); i++) {
                    profileList.add(new Profile(
                        getlistuserItemList.get(i).getUserID(),
                        getlistuserItemList.get(i).getNickname()
                    ));
                }
                // Notify the listener that data is ready
                listener.onProfileListLoaded(profileList);
            } else {
                listener.onError("Request failed: " + response.code());
            }
        }

        @Override
        public void onFailure(Call<ResponseDaftar> call, Throwable t) {
            listener.onError("Network error: " + t.getMessage());
        }
    });
}

// Usage:
fetchProfiles(new ProfileListListener() {
    @Override
    public void onProfileListLoaded(List<Profile> profileList) {
        // Process the data here
        for (Profile p : profileList){
            Log.i("info", p.getUserid() + '\n' + p.getNickname());
        }
    }

    @Override
    public void onError(String errorMessage) {
        Log.e("error", errorMessage);
    }
});

3. Use LiveData (Android Jetpack, Recommended for UI Updates) #

If you're building an Android app with Jetpack, LiveData is a robust way to observe data changes:

// In your ViewModel or repository
private MutableLiveData<List<Profile>> profileLiveData = new MutableLiveData<>();

public LiveData<List<Profile>> getProfileLiveData() {
    return profileLiveData;
}

public void fetchProfiles() {
    apiService.getGetlistuser("getlistuser").enqueue(new Callback<ResponseDaftar>() {
        @Override
        public void onResponse(Call<ResponseDaftar> call, Response<ResponseDaftar> response) {
            if (response.isSuccessful()) {
                List<GetlistuserItem> getlistuserItemList = response.body().getGetlistuser();
                List<Profile> profileList = new ArrayList<>();
                for (int i = 0; i < getlistuserItemList.size(); i++) {
                    profileList.add(new Profile(
                        getlistuserItemList.get(i).getUserID(),
                        getlistuserItemList.get(i).getNickname()
                    ));
                }
                // Update LiveData with the new data
                profileLiveData.setValue(profileList);
            }
        }

        @Override
        public void onFailure(Call<ResponseDaftar> call, Throwable t) {
            // Handle error (e.g., post an error message to LiveData)
        }
    });
}

// In your Activity/Fragment:
viewModel.getProfileLiveData().observe(this, profileList -> {
    // This runs every time the data is updated
    for (Profile p : profileList){
        Log.i("info", p.getUserid() + '\n' + p.getNickname());
    }
});

4. Use Kotlin Coroutines (If You're Using Kotlin) #

For Kotlin projects, coroutines make async code look and behave like synchronous code:

// In a coroutine scope (e.g., viewModelScope in ViewModel)
viewModelScope.launch {
    try {
        val response = apiService.getGetlistuser("getlistuser")
        if (response.isSuccessful) {
            val profileList = response.body()?.getGetlistuser()?.map {
                Profile(it.userID, it.nickname)
            } ?: emptyList()
            // Process the list here
            for (p in profileList) {
                Log.i("info", "${p.userid}\n${p.nickname}")
            }
        }
    } catch (e: Exception) {
        Log.e("error", e.message.toString())
    }
}

// Update your Retrofit interface to use suspend functions:
@POST("GetListNews.php")
@FormUrlEncoded
suspend fun getGetlistuser(@Field("TableName") paramTable: String): Response<ResponseDaftar>

Key Takeaway #

You can't access the fetched data immediately after calling enqueue()—you have to wait for the asynchronous operation to complete. All the solutions above ensure you only process the data after it's been successfully fetched.

内容的提问来源于stack exchange，提问作者senaa