改造上一节 ROM【1】，

1.利用 LiveData<List<Word>> 与 observe 中的 onChanged 配合，删除掉之前的textView更新函数（updateTextView）

引入 LiveData 与 observe ，只要数据发生改变，就会自动更新内容。

Database 单例模式，因为Database实例化，会消耗大量资源，所以整个过程只实例化一个对象

  1. package com.example.roombasic;
  2.  
  3. import android.content.Context;
  4.  
  5. import androidx.room.Database;
  6. import androidx.room.Room;
  7. import androidx.room.RoomDatabase;
  8.  
  9. //抽象类
  10.  
  11. //singleton //单例模式，只允许实例化一个对象， Database 实例化很耗资源
  12. @Database(entities = {Word.class},version = 1,exportSchema = false)  //如果有多个实体，再加上逗号后加实体.Class,这里版本比较重要，每次更新都要改变
  13. public abstract class WordDatabase extends RoomDatabase {
  14.  
  15.     private static WordDatabase INSTANCE;
  16.     static WordDatabase getDatabase(Context context){
  17.         if(INSTANCE == null) {
  18.             //context.getApplicationContext()  获取当前Activity 的唯一的 Context
  19.             INSTANCE = Room.databaseBuilder(context.getApplicationContext(), WordDatabase.class, "word_database")
  20.                     //.allowMainThreadQueries() 强制允许主线程操作
  21.                     .build();
  22.         }
  23.         return INSTANCE;
  24.     }
  25.  
  26.     public abstract WordDao getWordDao();
  27. }

　　

MainActity类中的代码：

  1. LiveData<List<Word>>    allWordsLive;
  2.  
  3. allWordsLive = wordDao.getAllWordLive();
  4.  
  5. //利用 LiveData<> 与 observe的onChanged配合，数据自动刷新
  6. allWordsLive.observe(this, new Observer<List<Word>>() {
  7.     @Override
  8.     public void onChanged(List<Word> words) {
  9.         //当数据改变时会自动呼叫这个函数
  10.         //String text="";
  11.         StringBuilder text = new StringBuilder();
  12.         textView.setText(text); //先将 textView 清空
  13.         for(int i=0;i<words.size();i++){
  14.             Word word = words.get(i);
  15.             text.append(word.getId() + ":" + word.getWord() + "=" + word.getChineseMeaning() + "\n");
  16.  
  17.             textView.setText(text);
  18.         }
  19.     }
  20. });

　　

WordDao类 中将数据返回类型改成 LiveData<List<Word>> 类型

  1. @Query("SELECT * FROM WORD ORDER BY ID DESC")
  2.     LiveData<List<Word>> getAllWordLive();

　　

2.引入 AsyncTask，用子线程更新数据

  1. wordDatabase = Room.databaseBuilder(this,WordDatabase.class,"word_database")
  2.                 //.allowMainThreadQueries() //allowMainThreadQueries() 强制允许在主线程运行
  3.                 .build();

注释掉 allowMainThreadQueries()

在 MainActivity 中 添加内部类

  1. //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  2.     static class InsertAsyncTask extends AsyncTask<Word,Void,Void>{
  3.         private WordDao wordDao;
  4.  
  5.         public InsertAsyncTask(WordDao wordDao) {
  6.             this.wordDao = wordDao;
  7.         }
  8.  
  9.         @Override
  10.         protected Void doInBackground(Word... words) {
  11.             //在工作线程在后台做什么操作
  12.             wordDao.insertWords(words);
  13.             return null;
  14.         }
  15.  
  16.         /*@Override
  17.         protected void onPostExecute(Void aVoid) {
  18.             //任务完成时会呼叫，将结果带回给主线程
  19.             super.onPostExecute(aVoid);
  20.         }
  21.  
  22.         @Override
  23.         protected void onProgressUpdate(Void... values) {
  24.             //当进度发生更新时，会呼叫
  25.             super.onProgressUpdate(values);
  26.         }
  27.  
  28.         @Override
  29.         protected void onPreExecute() {
  30.             //在后台任务执行之前会呼叫
  31.             super.onPreExecute();
  32.         }*/
  33.     }
  34.  
  35.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  36.     static class UpdateAsyncTask extends AsyncTask<Word,Void,Void>{
  37.         private WordDao wordDao;
  38.  
  39.         public UpdateAsyncTask(WordDao wordDao) {
  40.             this.wordDao = wordDao;
  41.         }
  42.  
  43.         @Override
  44.         protected Void doInBackground(Word... words) {
  45.             //在工作线程在后台做什么操作
  46.             wordDao.updateWords(words);
  47.             return null;
  48.         }
  49.     }
  50.  
  51.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  52.     static class DeleteAsyncTask extends AsyncTask<Word,Void,Void>{
  53.         private WordDao wordDao;
  54.  
  55.         public DeleteAsyncTask(WordDao wordDao) {
  56.             this.wordDao = wordDao;
  57.         }
  58.  
  59.         @Override
  60.         protected Void doInBackground(Word... words) {
  61.             //在工作线程在后台做什么操作
  62.             wordDao.deleteWords(words);
  63.             return null;
  64.         }
  65.     }
  66.  
  67.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  68.     static class DeleteAllAsyncTask extends AsyncTask<Void,Void,Void>{
  69.         private WordDao wordDao;
  70.  
  71.         public DeleteAllAsyncTask(WordDao wordDao) {
  72.             this.wordDao = wordDao;
  73.         }
  74.  
  75.         @Override
  76.         protected Void doInBackground(Void... Voids) {
  77.             //在工作线程在后台做什么操作
  78.             wordDao.deleteAllWords();
  79.             return null;
  80.         }
  81.     }

　　

原来的4个操作方法中，注释掉主线程操作，改成由子线程操作数据

  1. buttonInsert.setOnClickListener(new View.OnClickListener() {
  2.             @Override
  3.             public void onClick(View v) {
  4.                 Word word1 = new Word("Hello","你好");
  5.                 Word word2 = new Word("World","世界");
  6.  
  7.                 //wordDao.insertWords(word1,word2); //这里是主线程直接插入数据
  8.  
  9.                 new InsertAsyncTask(wordDao).execute(word1,word2); //改成子线程对父线程插入数据
  10.                 //updateView();
  11.             }
  12.         });
  13.  
  14.         buttonUpdate.setOnClickListener(new View.OnClickListener() {
  15.             @Override
  16.             public void onClick(View v) {
  17.                 Word word = new Word("English","英语");
  18.                 word.setId(46); //更新是用主键来更新的
  19.                 //wordDao.updateWords(word);    //主线程操作
  20.                 new UpdateAsyncTask(wordDao).execute(word); //子线程操作
  21.  
  22.                 //updateView();
  23.             }
  24.         });
  25.  
  26.         //删除所有的记录
  27.         buttonClear.setOnClickListener(new View.OnClickListener() {
  28.             @Override
  29.             public void onClick(View v) {
  30.                 //wordDao.deleteAllWords(); //主线程操作
  31.                 new DeleteAllAsyncTask(wordDao).execute();//由子线程来操作
  32.                 //updateView();
  33.             }
  34.         });
  35.  
  36.         buttonDelete.setOnClickListener(new View.OnClickListener() {
  37.             @Override
  38.             public void onClick(View v) {
  39.                 Word word = new Word("English","英语");
  40.                 word.setId(46); //删除也是用主键来更新的
  41.                 //wordDao.deleteWords(word);   主线程操作
  42.                 new DeleteAsyncTask(wordDao).execute(word); //子线程操作
  43.                 //updateView();
  44.             }
  45.         });

　　

 3. 引入 AndroidViewModel ，简化 MainActivity 

  1. package com.example.roombasic;
  2.  
  3. import android.app.Application;
  4. import android.os.AsyncTask;
  5.  
  6. import androidx.annotation.NonNull;
  7. import androidx.lifecycle.AndroidViewModel;
  8. import androidx.lifecycle.LiveData;
  9.  
  10. import java.util.List;
  11.  
  12. public class WordViewModel extends AndroidViewModel {
  13.  
  14.     private WordDao wordDao;
  15.     private LiveData<List<Word>>    allWordsLive;
  16.  
  17.     public WordViewModel(@NonNull Application application) {
  18.         super(application);
  19.  
  20.         WordDatabase wordDatabase = WordDatabase.getDatabase(application);
  21.         wordDao = wordDatabase.getWordDao();
  22.         allWordsLive = wordDao.getAllWordLive();
  23.     }
  24.  
  25.     public LiveData<List<Word>> getAllWordsLive() {
  26.         return allWordsLive;
  27.     }
  28.  
  29.     public void insertWords(Word ... words){
  30.         new InsertAsyncTask(wordDao).execute(words);
  31.     }
  32.  
  33.     public void updateWords(Word ... words){
  34.         new UpdateAsyncTask(wordDao).execute(words);
  35.     }
  36.  
  37.     public void deleteWords(Word ... words){
  38.         new DeleteAsyncTask(wordDao).execute(words);
  39.     }
  40.  
  41.     public void deleteAllWords(Word ... words){
  42.         new DeleteAllAsyncTask(wordDao).execute();
  43.     }
  44.  
  45.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  46.     static class InsertAsyncTask extends AsyncTask<Word,Void,Void> {
  47.         private WordDao wordDao;
  48.  
  49.         public InsertAsyncTask(WordDao wordDao) {
  50.             this.wordDao = wordDao;
  51.         }
  52.  
  53.         @Override
  54.         protected Void doInBackground(Word... words) {
  55.             //在工作线程在后台做什么操作
  56.             wordDao.insertWords(words);
  57.             return null;
  58.         }
  59.  
  60.         /*@Override
  61.         protected void onPostExecute(Void aVoid) {
  62.             //任务完成时会呼叫，将结果带回给主线程
  63.             super.onPostExecute(aVoid);
  64.         }
  65.  
  66.         @Override
  67.         protected void onProgressUpdate(Void... values) {
  68.             //当进度发生更新时，会呼叫
  69.             super.onProgressUpdate(values);
  70.         }
  71.  
  72.         @Override
  73.         protected void onPreExecute() {
  74.             //在后台任务执行之前会呼叫
  75.             super.onPreExecute();
  76.         }*/
  77.     }
  78.  
  79.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  80.     static class UpdateAsyncTask extends AsyncTask<Word,Void,Void>{
  81.         private WordDao wordDao;
  82.  
  83.         public UpdateAsyncTask(WordDao wordDao) {
  84.             this.wordDao = wordDao;
  85.         }
  86.  
  87.         @Override
  88.         protected Void doInBackground(Word... words) {
  89.             //在工作线程在后台做什么操作
  90.             wordDao.updateWords(words);
  91.             return null;
  92.         }
  93.     }
  94.  
  95.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  96.     static class DeleteAsyncTask extends AsyncTask<Word,Void,Void> {
  97.         private WordDao wordDao;
  98.  
  99.         public DeleteAsyncTask(WordDao wordDao) {
  100.             this.wordDao = wordDao;
  101.         }
  102.  
  103.         @Override
  104.         protected Void doInBackground(Word... words) {
  105.             //在工作线程在后台做什么操作
  106.             wordDao.deleteWords(words);
  107.             return null;
  108.         }
  109.     }
  110.  
  111.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  112.     static class DeleteAllAsyncTask extends AsyncTask<Void,Void,Void>{
  113.         private WordDao wordDao;
  114.  
  115.         public DeleteAllAsyncTask(WordDao wordDao) {
  116.             this.wordDao = wordDao;
  117.         }
  118.  
  119.         @Override
  120.         protected Void doInBackground(Void... Voids) {
  121.             //在工作线程在后台做什么操作
  122.             wordDao.deleteAllWords();
  123.             return null;
  124.         }
  125.     }
  126. }

　　

MainActivity.java

  1. package com.example.roombasic;
  2.  
  3. import android.os.Bundle;
  4. import android.view.View;
  5. import android.widget.Button;
  6. import android.widget.TextView;
  7.  
  8. import androidx.appcompat.app.AppCompatActivity;
  9. import androidx.lifecycle.LiveData;
  10. import androidx.lifecycle.Observer;
  11. import androidx.lifecycle.SavedStateViewModelFactory;
  12. import androidx.lifecycle.ViewModelProvider;
  13.  
  14. import java.util.List;
  15.  
  16. public class MainActivity extends AppCompatActivity {
  17.  
  18.     //WordDatabase wordDatabase;
  19.     //WordDao wordDao;
  20.     Button buttonInsert,buttonUpdate,buttonClear,buttonDelete;
  21.     TextView textView;
  22.     LiveData<List<Word>> allWordsLive;
  23.  
  24.     WordViewModel wordViewModel;
  25.  
  26.     @Override
  27.     protected void onCreate(Bundle savedInstanceState) {
  28.         super.onCreate(savedInstanceState);
  29.         setContentView(R.layout.activity_main);
  30.         //wordDatabase = Room.databaseBuilder(this,WordDatabase.class,"word_database")
  31.                 //.allowMainThreadQueries() //allowMainThreadQueries() 强制允许在主线程运行
  32.         //        .build();
  33.  
  34.         //wordDao = wordDatabase.getWordDao();
  35.  
  36.         //wordViewModel = ViewModelProviders
  37.         wordViewModel = new ViewModelProvider(this,new SavedStateViewModelFactory(getApplication(),this)).get(WordViewModel.class);
  38.  
  39.         //allWordsLive = wordDao.getAllWordLive();
  40.  
  41.         textView = findViewById(R.id.textView);
  42.         buttonInsert = findViewById(R.id.buttonInsert);
  43.         buttonUpdate = findViewById(R.id.buttonUpdate);
  44.         buttonClear = findViewById(R.id.buttonClear);
  45.         buttonDelete = findViewById(R.id.buttonDelete);
  46.  
  47.         //利用 LiveData<> 与 observe的onChanged配合，数据自动刷新
  48.         //allWordsLive.observe(this, new Observer<List<Word>>() {
  49.         wordViewModel.getAllWordsLive().observe(this, new Observer<List<Word>>() {
  50.             @Override
  51.             public void onChanged(List<Word> words) {
  52.                 //当数据改变时会自动呼叫这个函数
  53.                 //String text="";
  54.                 StringBuilder text = new StringBuilder();
  55.                 textView.setText(text); //先将 textView 清空
  56.                 for(int i=0;i<words.size();i++){
  57.                     Word word = words.get(i);
  58.                     text.append(word.getId() + ":" + word.getWord() + "=" + word.getChineseMeaning() + "\n");
  59.  
  60.                     textView.setText(text);
  61.                 }
  62.             }
  63.         });
  64.  
  65.         buttonInsert.setOnClickListener(new View.OnClickListener() {
  66.             @Override
  67.             public void onClick(View v) {
  68.                 Word word1 = new Word("Hello","你好");
  69.                 Word word2 = new Word("World","世界");
  70.                 wordViewModel.insertWords(word1,word2);
  71.                 //wordDao.insertWords(word1,word2);  主线程操作
  72.                 //new InsertAsyncTask(wordDao).execute(word1,word2); //改成子线程对父线程插入数据
  73.                 //updateView();
  74.             }
  75.         });
  76.  
  77.         buttonUpdate.setOnClickListener(new View.OnClickListener() {
  78.             @Override
  79.             public void onClick(View v) {
  80.                 Word word = new Word("English","英语");
  81.                 word.setId(68); //更新是用主键来更新的
  82.                 wordViewModel.updateWords(word);
  83.                 //wordDao.updateWords(word);
  84.                 //new UpdateAsyncTask(wordDao).execute(word);
  85.                 //updateView();
  86.             }
  87.         });
  88.  
  89.         //删除所有的记录
  90.         buttonClear.setOnClickListener(new View.OnClickListener() {
  91.             @Override
  92.             public void onClick(View v) {
  93.                 //wordDao.deleteAllWords();
  94.                 //new DeleteAllAsyncTask(wordDao).execute();
  95.                 //updateView();
  96.                 wordViewModel.deleteAllWords();
  97.             }
  98.         });
  99.  
  100.         buttonDelete.setOnClickListener(new View.OnClickListener() {
  101.             @Override
  102.             public void onClick(View v) {
  103.                 Word word = new Word("English","英语");
  104.                 word.setId(68); //删除也是用主键来更新的
  105.                 wordViewModel.deleteWords(word);
  106.                 //wordDao.deleteWords(word);
  107.                 //new DeleteAsyncTask(wordDao).execute(word);
  108.                 //updateView();
  109.             }
  110.         });
  111.  
  112.     }
  113.  
  114.     /*void updateView(){
  115.         List<Word> list = wordDao.getAllWords();
  116.         String text="";
  117.         textView.setText(text); //先将 textView 清空
  118.         for(int i=0;i<list.size();i++){
  119.             Word word = list.get(i);
  120.             text += word.getId() + ":" + word.getWord() + "=" + word.getChineseMeaning() + "\n";
  121.  
  122.             textView.setText(text);
  123.         }
  124.     }*/
  125.  
  126. }

　　

 4. 创建 仓库类，简化 ViewModel

  1. package com.example.roombasic;
  2.  
  3. import android.content.Context;
  4. import android.os.AsyncTask;
  5.  
  6. import androidx.lifecycle.LiveData;
  7.  
  8. import java.util.List;
  9.  
  10. public class WordRepository {
  11.     //数据仓库
  12.  
  13.     private WordDao wordDao;
  14.  
  15.     private LiveData<List<Word>>    allWordsListLive;
  16.  
  17.     public WordRepository(Context context) {
  18.         WordDatabase wordDatabase = WordDatabase.getDatabase(context.getApplicationContext());
  19.         wordDao = wordDatabase.getWordDao();
  20.         allWordsListLive = wordDao.getAllWordLive();
  21.     }
  22.  
  23.     public LiveData<List<Word>> getAllWordsListLive() {
  24.         return allWordsListLive;
  25.     }
  26.  
  27.     public void insertWords(Word ... words){
  28.         new InsertAsyncTask(wordDao).execute(words);
  29.     }
  30.  
  31.     public void updateWords(Word ... words){
  32.         new UpdateAsyncTask(wordDao).execute(words);
  33.     }
  34.  
  35.     public void deleteWords(Word ... words){
  36.         new DeleteAsyncTask(wordDao).execute(words);
  37.     }
  38.  
  39.     public void deleteAllWords(Word ... words){
  40.         new DeleteAllAsyncTask(wordDao).execute();
  41.     }
  42.  
  43.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  44.     static class InsertAsyncTask extends AsyncTask<Word,Void,Void> {
  45.         private WordDao wordDao;
  46.  
  47.         public InsertAsyncTask(WordDao wordDao) {
  48.             this.wordDao = wordDao;
  49.         }
  50.  
  51.         @Override
  52.         protected Void doInBackground(Word... words) {
  53.             //在工作线程在后台做什么操作
  54.             wordDao.insertWords(words);
  55.             return null;
  56.         }
  57.  
  58.         /*@Override
  59.         protected void onPostExecute(Void aVoid) {
  60.             //任务完成时会呼叫，将结果带回给主线程
  61.             super.onPostExecute(aVoid);
  62.         }
  63.  
  64.         @Override
  65.         protected void onProgressUpdate(Void... values) {
  66.             //当进度发生更新时，会呼叫
  67.             super.onProgressUpdate(values);
  68.         }
  69.  
  70.         @Override
  71.         protected void onPreExecute() {
  72.             //在后台任务执行之前会呼叫
  73.             super.onPreExecute();
  74.         }*/
  75.     }
  76.  
  77.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  78.     static class UpdateAsyncTask extends AsyncTask<Word,Void,Void>{
  79.         private WordDao wordDao;
  80.  
  81.         public UpdateAsyncTask(WordDao wordDao) {
  82.             this.wordDao = wordDao;
  83.         }
  84.  
  85.         @Override
  86.         protected Void doInBackground(Word... words) {
  87.             //在工作线程在后台做什么操作
  88.             wordDao.updateWords(words);
  89.             return null;
  90.         }
  91.     }
  92.  
  93.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  94.     static class DeleteAsyncTask extends AsyncTask<Word,Void,Void> {
  95.         private WordDao wordDao;
  96.  
  97.         public DeleteAsyncTask(WordDao wordDao) {
  98.             this.wordDao = wordDao;
  99.         }
  100.  
  101.         @Override
  102.         protected Void doInBackground(Word... words) {
  103.             //在工作线程在后台做什么操作
  104.             wordDao.deleteWords(words);
  105.             return null;
  106.         }
  107.     }
  108.  
  109.     //内部类，AsyncTask 类型的类 如果以内部类形式出现，必须用 static，否则告警，说内存泄漏
  110.     static class DeleteAllAsyncTask extends AsyncTask<Void,Void,Void>{
  111.         private WordDao wordDao;
  112.  
  113.         public DeleteAllAsyncTask(WordDao wordDao) {
  114.             this.wordDao = wordDao;
  115.         }
  116.  
  117.         @Override
  118.         protected Void doInBackground(Void... Voids) {
  119.             //在工作线程在后台做什么操作
  120.             wordDao.deleteAllWords();
  121.             return null;
  122.         }
  123.     }
  124. }

　　

Android Studio 之 ROM【2】， LiveData+ViewModel+AsyncTask+Repository的更多相关文章

  1. Android Studio 之 ROM【3】，LiveData+ViewModel+AsyncTask+Repository+RecyclerView

    教程地址:https://www.bilibili.com/video/av65180549 源码地址:https://github.com/longway777/Android-2019-Tutor ...

  2. Android Studio 之 ROM【1】， Entity,Dao,Database

    Android Studio 之 ROM, Entity,DAO,DataBase 1.Entity 实体类 package com.example.roombasic; import android ...

  3. How to distribute your own Android library through jCenter and Maven Central from Android Studio

    In Android Studio, if you wish to include any library to your application. You could just simply add ...

  4. Android Studio 之 LiveData 的配合使用，底层数据变化，自动通知界面

    Android Studio 之 LiveData 的配合使用,底层数据变化,自动通知界面 viewModelWithLikeData.getLikeNumber().observe(this, ne ...

  5. Android studio 分析内存泄漏

    以前用eclipse的时候,我们采用的是DDMS和MAT,不仅使用步骤复杂繁琐,而且要手动排查内存泄漏的位置,操作起来比较麻烦.后来随着Android studio的潮流,我也抛弃了eclipse加入 ...

  6. Android 适配多种ROM的快捷方式

    快捷方式 应该来说 很多人都做过,我们就来看一下基本的快捷方式 是怎么实现的,会有什么问题? 首先 肯定要获取权限: <!-- 添加快捷方式 --> <uses-permission ...

  7. [App]Android Studio First App

    准备着看Android Studio的体验如何. 通过Android Studio构建一个默认的项目,添加一些元素 <RelativeLayout xmlns:android="htt ...

  8. Ubuntu 14.04 64位安装Android Studio 和 genymotion （下）

    接上一篇,上回书说到,我们可以进android studio的编辑器了.感觉不错.挺好的,先不说genymotion,先看看你的android项目有没有r文件,项目有没有错误? 如果没有问题的话,下面 ...

  9. linux安装安卓开发工具android studio

    http://www.android-studio.org/ http://android-studio.org/index.php/docs/guide 最近要接触android编程,本来想装ecl ...

随机推荐

  1. MediaWiki上传文件大小设置

    一.概述 MediaWiki默认最大上传文件大小为2M,碰到文件较大需要修改这个限制,需要改为8M. 二.修改php.ini 使用docker运行的MediaWiki,默认是没有php.ini这个文件 ...

  2. JavaIO学习：序列化流

    对象流 1.涉及到的类 ObjectInputStream 和 ObjectOutputStream 用于存储和读取基本数据类型数据或对象的处理流. 2.作用 ObjectOutputStream:内 ...

  3. windows下生成ssl

    1.安装git window 需要安装 git 按部就班即可 https://git-scm.com/ 2.安装完之后,打开 Git Bash 输入以下命令并执行,然后一路按“回车”即可,效果见图: ...

  4. Java Automic包下的AtomicInteger

    感谢这两位博主的文章,文章源于: https://www.cnblogs.com/chenpi/p/5375805.html https://blog.csdn.net/fanrenxiang/art ...

  5. Golang fmt Printf 格式化参数手册/详解/说明

    fmt 包实现了格式化I/O函数,类似于C的 printf 和 scanf. 格式“占位符”衍生自C,但比C更简单. fmt 包的官方文档对Printing和Scanning有很详细的说明.这里就直接 ...

  6. Form之action提交不刷新不跳转

    <div class="file-box"> <form action="/File/fileUpLoad" id="form1&q ...

  7. python课程单元三编程题讲解(上)

    目录 1.快乐的数字 2.凯撒密码I 3.凯撒密码II 4.括号配对检测 A @     下面向大家介绍一下我在学习python课程的一些题目的解法,如果大家有什么更好的解法请私信我.这里只显示题目与 ...

  8. java内存溢出实战

    通过设置-XX:+HeapDumpOnOutOfMemoryError 自动生成dump文件,进行分析内存溢出原因 1.堆溢出堆溢出原因莫过于对象太多导致. 错误:java.lang.OutOfMem ...

  9. codeforces #577(Div.2)

    codeforces #577(Div.2) A  Important Exam A class of students wrote a multiple-choice test. There are ...

  10. C#实现outlook自动签名

    Outlook下实现自动签名的方式   网上找到一篇资料是在outlook里用vba实现的,但是这样实现的方式由于数字认证的问题不便于部署 在此介绍一种C#下实现的方式,目前确定的outlook版本为 ...