public class Weather {

    private String key;
    private String value;

    public Weather(String key, String value){
        this.key = key;
        this.value = value;
    }

    public String getKey(){
        return key;
    }

    public String getValue(){
        return value;
    }

}

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;

import app.cap.ajm.Model.Weather;

public class WeatherDBhelper {
    public static final String KEY_ROWID = "_id";
    public static final String KEY_FOR_VALUE = "key"; // key
    public static final String KEY_CONTENT_NAME = "value";  //value

    private static final String TAG = WeatherDBhelper.class.getSimpleName();

    private DatabaseHelper mDbHelper;
    private SQLiteDatabase mDb;

    private static final String DATABASE_NAME = "weathers" ;//weather DB
    private static final String DATABASE_TABLE = "weatherTable";
    private static final int DATABASE_VERSION = 1;
    private static final String DATABASE_CREATE =
            "CREATE TABLE "+ DATABASE_TABLE +" ("
                    +KEY_ROWID+" INTEGER PRIMARY KEY AUTOINCREMENT, "
                    +KEY_FOR_VALUE+" TEXT,"
                    +KEY_CONTENT_NAME+" TEXT"+");";

    private final Context ctx;
    private List<Weather> weathers;
    private static class DatabaseHelper extends SQLiteOpenHelper {

        DatabaseHelper(Context context) {
            super(context, DATABASE_NAME, null, DATABASE_VERSION);
        }

        //버전이 업데이트 되었을 경우 DB를 다시 만들어 준다.
        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            Log.w(TAG, "Upgrading database from version " + oldVersion + " to " + newVersion
                    + ", which will destroy all old data");

            db.execSQL("DROP TABLE IF EXISTS lists");
            onCreate(db);
        }

        //최초 DB를 만들때 한번만 호출된다.
        @Override
        public void onCreate(SQLiteDatabase db) {
            Log.w(TAG, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~onCreate~~~~~~~~~~~~~~~~~~~~~~~~~");
            db.execSQL(DATABASE_CREATE);
        }
    }

    public WeatherDBhelper(Context ctx){
        this.ctx = ctx;
    }

    public WeatherDBhelper open() throws SQLException{
        mDbHelper = new DatabaseHelper(ctx);
        mDb = mDbHelper.getWritableDatabase();
        return this;
    }

    public void close(){
        mDbHelper.close();
    }

    public long createList(String key, String value) {
        ContentValues initialValues = new ContentValues();
        initialValues.put(KEY_FOR_VALUE, key);
        initialValues.put(KEY_CONTENT_NAME, value);
        return mDb.insert(DATABASE_TABLE, null, initialValues);
    }
    // 날씨 정보 반환
    public List<Weather> fetchForList(){
        weathers = new ArrayList<>();
        mDbHelper = new WeatherDBhelper.DatabaseHelper(ctx);
        mDb =  mDbHelper.getReadableDatabase();
        Cursor res = mDb.query(DATABASE_TABLE, new String[]{KEY_ROWID, KEY_FOR_VALUE, KEY_CONTENT_NAME}, null, null, null, null, null);
        res.moveToFirst();
        while (!res.isAfterLast()) {
            String key = res.getString(res.getColumnIndex(KEY_FOR_VALUE));
            String value = res.getString(res.getColumnIndex(KEY_CONTENT_NAME));
            weathers.add(new Weather(key, value));
            res.moveToNext();
        }
        if (res.getCount()==0){
            return null;
        }
        res.close();
        return weathers;
    }

    //모든 레코드 반환
    public Cursor fetchAllList() {
        return mDb.query(DATABASE_TABLE, new String[]{KEY_ROWID, KEY_FOR_VALUE, KEY_CONTENT_NAME}, null, null, null, null,null);
    }
}

//...중략
import app.cap.ajm.Helper.WeatherDBhelper;
import jxl.Sheet;
import jxl.Workbook;

public class SplashActivity extends AppCompatActivity {
private WeatherDBhelper weatherDBhelper;
//... 중략
protected void onCreate(Bundle savedInstanceState) {
        //... 중략
        this.weatherDBhelper = new WeatherDBhelper(this);
        weatherDBhelper.open();
        Cursor cursor = weatherDBhelper.fetchAllList();
        Log.w("How many Value?:", String.valueOf(cursor.getCount()));
        if (cursor.getCount() == 0)
            excelToWeather();
        weatherDBhelper.close();
        cursor.close();
    }
    //... 중략
    // 날씨 정보를 DB에 저장한다.
    private void excelToWeather(){
        Workbook workbook = null;
        try{
            InputStream is = getBaseContext().getResources().getAssets().open("weathers.xls");
            workbook = Workbook.getWorkbook(is);
            if (workbook != null) {
                Sheet sheet = workbook.getSheet(0);
                if (sheet != null) {
                    int nMaxColumn = sheet.getColumns();
                    int nRowStartIndex = 0;
                    int nRowEndIndex = sheet.getColumn(nMaxColumn - 1).length - 1;
                    int nColumnStartIndex = 0;
                    weatherDBhelper.open();
                    for (int nRow = nRowStartIndex + 1; nRow <= nRowEndIndex; nRow++) {
                        String key = sheet.getCell(nColumnStartIndex, nRow).getContents();
                        String value = sheet.getCell(nColumnStartIndex + 1, nRow).getContents();
                        weatherDBhelper.createList(key, value);
                    }
                    weatherDBhelper.close();
                } else {
                    Log.i(TAG, "Sheet is null!!");
                }
            }else{
                    Log.i(TAG, "Woorkbook is null!!!");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (workbook != null) {
                workbook.close();
            }
        }
    }
//...중략    
}

import butterknife.BindView;
import github.vatsal.easyweather.Helper.ForecastCallback;
import github.vatsal.easyweather.Helper.TempUnitConverter;
import github.vatsal.easyweather.Helper.WeatherCallback;
import github.vatsal.easyweather.WeatherMap;
import github.vatsal.easyweather.retrofit.models.ForecastResponseModel;
import github.vatsal.easyweather.retrofit.models.WeatherResponseModel;
import butterknife.ButterKnife;
import android.widget.TextView;
import static app.cap.ajm.BuildConfig.OWM_API_KEY; // API 키 사용을 위해 import

//...중략
public class MainActivity extends AppCompatActivity {

    public final String weather_id = BuildConfig.OWM_API_KEY; //API 키
    @BindView(R.id.weather2) TextView weather2; //습도 정보를 표시할 TextView
    @BindView(R.id.weather5) TextView weather5; //온도 정보를 표시팔 TextView
    //...중략
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
        //...중략
    }
    @Override
    protected void onResume() {
        loadWeather("seoul");
    }
    //...중략
    private void loadWeather(String city) {
        WeatherMap weatherMap = new WeatherMap(this, weather_id);
        weatherMap.getCityWeather(city, new WeatherCallback() {
            @Override
            public void success(WeatherResponseModel response) {
                populateWeather(response);
            }

            @Override
            public void failure(String message) {
            }
        });
        weatherMap.getCityForecast(city, new ForecastCallback() {
            @Override
            public void success(ForecastResponseModel response) {
            }

            @Override
            public void failure(String message) {
            }
        });
    }

    private void populateWeather(WeatherResponseModel response) {
        weather2.setText(response.getMain().getHumidity()+ "%");
        weather5.setText(TempUnitConverter.convertToCelsius(response.getMain().getTemp()).intValue() + "°C");
    }
    //...중략
}

//...중략
import app.cap.ajm.Helper.WeatherDBhelper;
import static app.cap.ajm.BuildConfig.OWM_API_KEY;

public class WeatherActivity extends AppCompatActivity {
    private final String APP_ID = OWM_API_KEY;
    private final String city = "Seoul";
    @BindView(R.id.weather_title) TextView weatherTitle; // 한글로 표시하길 원하는 데이터
    //...중략
    private WeatherDBhelper weatherDBhelper;
    private List<app.cap.ajm.Model.Weather>weathers;
    //...중략
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_weather);
        ButterKnife.bind(this);
        loadWeather(city);
        weatherDBhelper = new WeatherDBhelper(this); //DBhelper 객체 생성
        weathers = new ArrayList<app.cap.ajm.Model.Weather>(); //한글로 날씨를 표시하기 위한 임시 List 컬렉션 객체 생성 (import한 패키지와 이름 충돌이 발생하므로 패키지명을 모두 작성한다.)
    }

    private void loadWeather(final String city) {
        WeatherMap weatherMap = new WeatherMap(this, APP_ID);
        weatherMap.getCityWeather(city, new WeatherCallback() {
            @Override
            public void success(WeatherResponseModel response) {
                populateWeather(response);
            }
            @Override
            public void failure(String message) {}
        });

        weatherMap.getCityForecast(city, new ForecastCallback() {
            @Override
            public void success(ForecastResponseModel response) {}
            @Override
            public void failure(String message) {
                Toast.makeText(getApplicationContext(), message, Toast.LENGTH_SHORT).show();
            }
        });
    }
    private void populateWeather(WeatherResponseModel response) {
        Weather weather[] = response.getWeather();
        condition.setText(weather[0].getMain());
       
        if(response.getName().equals("Seoul")&& Locale.getDefault().getLanguage().equals("ko")){
           location.setText("서울");
        }else{
            location.setText(response.getName());
        }
        String key = weather[0].getMain();
        // 언어 설정이 한글일 경우에 한해서 실행한다. (안전모는 다국어 지원을 위한 언어 설정이 따로 들어가있다.)
        if (Locale.getDefault().getLanguage().equals("ko")) {
            String value = getWeatherValue(key);
            //null 값 처리
            if(value !=null){
                condition.setText(value);
            }else{
                condition.setText(key);
            }
        }else {
            condition.setText(key);
        }
        String link = weather[0].getIconLink();
        Picasso.with(this).load(link).into(weatherIcon);
    }

    public String getWeatherValue(String key){
        String value = null;
        weatherDBhelper.open();
        // DB에서 모든 key를 받아온다.
        weathers = weatherDBhelper.fetchForList();
        for(app.cap.ajm.Model.Weather w : weathers){
            // 키(영어 날씨)에 해당하는 값을 할당한다.
            if(w.getKey().equals(key))
                value = w.getValue();
        }
        // 한글로 작성된 날씨 반환.
        return value;
    }

    //...중략
}