問題解答彙總

時間 2019-11-11

標籤問題解答彙總简体版

原文原文鏈接

本篇博文將介紹一些實用的、在軟工實踐過程當中可能遇到的問題及解決方法，但願能對同窗們有幫助～歡迎指正～

1、關於git代碼管理

1.安裝

在Windows上安裝Git

在Windows上使用Git，能夠從Git官網直接下載安裝程序，（網速慢的同窗請移步國內鏡像），而後按默認選項安裝便可。html

安裝完成後，在開始菜單裏找到「Git」->「Git Bash」，蹦出一個相似命令行窗口的東西，就說明Git安裝成功！java

安裝完成後，還須要最後一步設置，在命令行輸入：git

$ git config --global user.name "Your Name"
$ git config --global user.email "email@example.com"

2.建立版本庫

什麼是版本庫呢？版本庫又名倉庫，英文名repository，你能夠簡單理解成一個目錄，這個目錄裏面的全部文件均可以被Git管理起來，每一個文件的修改、刪除，Git都能跟蹤，以便任什麼時候刻均可以追蹤歷史，或者在未來某個時刻能夠「還原」。

因此，建立一個版本庫很是簡單，首先，選擇一個合適的地方，建立一個空目錄（注意：若是你使用Windows系統，爲了不遇到各類莫名其妙的問題，請確保目錄路徑中不包含中文。）github

第二步，經過git init命令把這個目錄變成Git能夠管理的倉庫ruby

$ git init

能夠發現當前目錄下多了一個.git的目錄，這個目錄是Git來跟蹤管理版本庫的，沒事千萬不要手動修改這個目錄裏面的文件，否則改亂了，就把Git倉庫給破壞了。bash

若是你沒有看到.git目錄，那是由於這個目錄默認是隱藏的，用ls -ah命令就能夠看見。app

3.添加文件到本地倉庫

第一步，使用git status命令查看修改的文件ssh
第二步，使用命令git add <file>，注意，可反覆屢次使用，添加多個文件，添加所有修改文件用 git add . (用一個實心點表示所有文件）
第三步，使用命令git commit -m 「本次提交的代碼的說明」，完成。編輯器

4.添加遠程庫

本地建立了一個Git倉庫後，在GitHub再建立一個Git倉庫，而且讓這兩個倉庫進行遠程同步函數

第一步，在GitHub上建立項目

第二步，git中生成ssh key 參考：http://www.javashuo.com/article/p-xdjfnsjx-dd.html
第三步查看ssh地址

第四步：將本地庫與遠程庫關聯

$ git remote add origin git@github.com:gongxiaoting/test.git

第五步，將本地本地庫的全部內容推送到遠程庫上

$ git push -u origin master

把本地庫的內容推送到遠程，用git push命令，其實是把當前分支master推送到遠程。

因爲遠程庫是空的，咱們第一次推送master分支時，加上了-u參數，Git不但會把本地的master分支內容推送的遠程新的master分支，還會把本地的master分支和遠程的master分支關聯起來，在之後的推送或者拉取時就能夠簡化命令。

注：團隊開發最好是一我的先上傳代碼，其餘人克隆代碼

從遠程庫克隆

$ git clone git@github.com:gongxiaoting/test.git

5.分支管理

團隊開發的時候爲了防止原有代碼被破壞，因此鼓勵同窗們都經過本身的分支上傳代碼，檢查看再merge

建立並切換到名爲dev分支

$ git checkout -b dev
Switched to a new branch 'dev'

用git branch命令查看當前分支
上傳代碼到分支

git remote add origin git@github.com:gongxiaoting/test.git

$ git push origin dev

merge分支

$ git checkout master  //切換回主分支

$ git merge dev

6.版本回退

git log查看提交歷史記錄

$ git log
commit 3628164fb26d48395383f8f31179f24e0882e1e0
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Tue Aug 20 15:11:49 2013 +0800

    append GPL                       //當前最新版本

commit ea34578d5496d7dd233c827ed32a8cd576c5ee85           //第二版本的code
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Tue Aug 20 14:53:12 2013 +0800                

    add distributed              //第二版本名

commit cb926e7ea50ad11b8f9e909c05226233bf755030      //初版本的code
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Mon Aug 19 17:51:55 2013 +0800

    wrote a readme file               //初版本名

　　如今，咱們要把當前版本「append GPL」回退到上一個版本「add distributed」，就可使用git reset命令：

$ git reset --hard HEAD^                  //返回上一版本
HEAD is now at ea34578 add distributed

　　返回上上版本 git reset --hard HEAD^^

返回上上上版本 git reset --hard HEAD^^^

返回舊版本後又後悔，能夠用 git reset --hard （版本號）回到該版本

例如git reset --hard 3628164fb回到append GPL版本（版本號只寫前幾位，系統能夠分別出便可）

參考自：https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000

2、關於效能分析

JProfiler的使用 --轉載自尤少輝助教博客

1.下載地址：http://www.ej-technologies.com/download/jprofiler/files

2.使用過程

1.點擊此圖的new Session

2.點擊左邊application settings，右邊要點擊

3.點擊的Source Path ，點擊+號的圖標，點擊add directory

4.點擊你工程的文件到bin

5.左邊是程序尚未運行的，右邊是查詢運行的

6.點擊你的項目雙擊倆下，或者點open，以後點擊OK就行了

7.點擊CPU view，點擊Call Tree，以後點擊界面的一個按鈕

8.這是一張CUP的圖，圖中顯示個個方法的使用佔的CPU

9.從中發現最大塊的函數對其進行分解優化，以及減小代碼塊的重複率。

下面舉個例子：查重模塊中調用到了diaoyong的方法，diaoyong方法調用到addcopy的方法，這樣就把200行左右的代碼分紅了7個方法，每一個方法的代碼很少於50行。

1.最大函數塊

 1 package com.jm.sizeyunsuan;
 2  
 3 import java.util.ArrayList;
 4 import java.util.List;
 5  
 6 /**
 7  * 查重的總函數
 8  * @author admin
 9  *
10  */
11 public class CongFu {
12     /**
13      * 查重
14      */
15     public  boolean chacong(List<String> timus,String yunsuan){
16         boolean flat=false;//獲取是否重複的標記
17         boolean zhuzhifu=false;//在flat爲true的時候，終止本次循環的標誌
18         for(String s:timus){
19             if(!zhuzhifu){
20                 List<String> str=new ArrayList<String>();//獲取已經存入在list中的題目
21                 List<String> str2=new ArrayList<String>();//獲取此次嘗試的題目
22                 for(int i=0;i<s.length();i++){
23                     str.add(s.charAt(i)+"");
24                     str2.add(yunsuan.charAt(i)+"");
25                 }
26                 flat= same(str, str2);//查看符號數字是否是同樣
27                 if(flat){
28                     flat=diaoYong(str,str2);//判斷查重
29                     if(flat){
30                         zhuzhifu=true;
31                     }
32                 }
33             }else{
34                 break;
35             }
36         }
37         return flat;
38     }
39      
40     /**
41      * 爲了減小代碼塊的過多抽取調用的方法
42      * @param str list中的題目
43      * @param str2 如今產生的題目
44      * @return
45      */
46     public boolean diaoYong(List<String> str,List<String> str2 ){
47         CongFuAddAndJian aj=new CongFuAddAndJian();
48         CongFuChengAndChu cc=new CongFuChengAndChu();
49         boolean flat=false;
50         switch (str2.get(1)) {
51         case "+":
52             flat=aj.addcopy(str,str2);
53             break;
54         case "-":
55             flat=aj.jiancopy(str,str2);
56             break;
57         case "/":
58             flat=cc.chucopy(str,str2);
59             break;
60         default:
61             flat=cc.chengcopy(str,str2);
62             break;
63         }
64         return flat;
65     }
66      
67     /**
68      * 符號數字同樣
69      * str1是題目
70      * str2是本次產生的題目
71      */
72     public  boolean same(List<String> str1,List<String> str2 ){
73         boolean flat=false;
74         for(int i=0;i<str1.size();i++){
75             if(!str1.contains(str2.get(i))
76                     ||!str2.contains(str1.get(i))){
77                 break;
78             }else{
79                 if(i==str1.size()-1){
80                     flat=true;
81                 }
82             }
83         }
84         return flat;
85     }
86 }

2.優化後的

  1 package com.jm.sizeyunsuan;
  2  
  3 import java.util.ArrayList;
  4 import java.util.List;
  5  
  6 /**
  7  * 查重的總函數
  8  * @author admin
  9  *
 10  */
 11 public class CongFu {
 12     /**
 13      * 查重
 14      */
 15     public  boolean chacong(List<String> timus,String yunsuan){
 16         boolean flat=false;//獲取是否重複的標記
 17         boolean zhuzhifu=false;//在flat爲true的時候，終止本次循環的標誌
 18         for(String s:timus){
 19             if(!zhuzhifu){
 20                 List<String> str=new ArrayList<String>();//獲取已經存入在list中的題目
 21                 List<String> str2=new ArrayList<String>();//獲取此次嘗試的題目
 22                 for(int i=0;i<s.length();i++){
 23                     str.add(s.charAt(i)+"");
 24                     str2.add(yunsuan.charAt(i)+"");
 25                 }
 26                 flat= same(str, str2);//查看符號數字是否是同樣
 27                 if(flat){
 28                     flat=diaoYong(str,str2);//判斷查重
 29                     if(flat){
 30                         zhuzhifu=true;
 31                     }
 32                 }
 33             }else{
 34                 break;
 35             }
 36         }
 37         return flat;
 38     }
 39      
 40     /**
 41      * 爲了減小代碼塊的過多抽取調用的方法
 42      * @param str list中的題目
 43      * @param str2 如今產生的題目
 44      * @return
 45      */
 46     public boolean diaoYong(List<String> str,List<String> str2 ){
 47         CongFuAddAndJian aj=new CongFuAddAndJian();
 48         CongFuChengAndChu cc=new CongFuChengAndChu();
 49         boolean flat=false;
 50         switch (str2.get(1)) {
 51         case "+":
 52             flat=aj.addcopy(str,str2);
 53             break;
 54         case "-":
 55             flat=aj.jiancopy(str,str2);
 56             break;
 57         case "/":
 58             flat=cc.chucopy(str,str2);
 59             break;
 60         default:
 61             flat=cc.chengcopy(str,str2);
 62             break;
 63         }
 64         return flat;
 65     }
 66      
 67     /**
 68      * 符號數字同樣
 69      * str1是題目
 70      * str2是本次產生的題目
 71      */
 72     public  boolean same(List<String> str1,List<String> str2 ){
 73         boolean flat=false;
 74         for(int i=0;i<str1.size();i++){
 75             if(!str1.contains(str2.get(i))
 76                     ||!str2.contains(str1.get(i))){
 77                 break;
 78             }else{
 79                 if(i==str1.size()-1){
 80                     flat=true;
 81                 }
 82             }
 83         }
 84         return flat;
 85     }
 86 }
 87

 1 package com.jm.sizeyunsuan;
 2  
 3 import java.util.List;
 4  
 5 /**
 6  * 判斷重複的第一個符號爲加減的
 7  * @author
 8  *
 9  */
10 public class CongFuAddAndJian {
11      
12     /**
13      * 第一個爲加號判斷重複
14      * ||以前爲符號位置的一致，||以後的爲符號位置不一樣
15      */
16     public  boolean addcopy(List<String> str1,List<String> str2){
17         boolean flat=false;
18         switch (str2.get(3)) {
19         case "+":
20             flat=true;
21             break;
22         case "-":
23             if(str2.get(4).equals(str1.get(4))
24                     &&str2.get(3).equals(str1.get(3))
25                     ||str2.get(3).equals(str1.get(1))
26                     &&str2.get(4).equals(str1.get(2))){
27                 flat=true;
28             }
29             break;
30         case "/":
31             if(str2.get(2).equals(str1.get(2))
32                     &&str2.get(3).equals(str1.get(3))
33                     &&str2.get(4).equals(str1.get(4))
34                     ||str2.get(2).equals(str1.get(0))
35                     &&str2.get(3).equals(str1.get(1))
36                     &&str2.get(4).equals(str1.get(2))){
37                 flat=true;
38             }
39             break;
40         default:
41             if(str2.get(0).equals(str1.get(0))
42                     &&str2.get(1).equals(str1.get(1))
43                     ||str2.get(0).equals(str1.get(4))
44                     &&str2.get(1).equals(str1.get(3))){
45                 flat=true;
46             }
47             break;
48         }
49         return flat;
50     }
51      
52  
53     /**
54      * 第一個爲減號判斷重複
55      * ||以前爲符號位置的一致，||以後的爲符號位置不一樣
56      */
57     public  boolean jiancopy(List<String> str1,List<String> str2){
58         boolean flat=false;
59         switch (str2.get(3)) {
60         case "+":
61             if(str2.get(2).equals(str1.get(2))
62                     &&str2.get(1).equals(str1.get(1))
63                     ||str2.get(1).equals(str1.get(3))
64                     &&str2.get(2).equals(str1.get(4))){
65                 flat=true;
66             }
67             break;
68         case "-":
69             if(str2.get(0).equals(str1.get(0))){
70                 flat=true;
71             }
72             break;
73         case "/":
74             if(str2.get(0).equals(str1.get(0))
75                     &&str2.get(2).equals(str1.get(2))
76                     &&str2.get(1).equals(str1.get(1))){
77                 flat=true;
78             }
79             break;
80         default:
81             if(str2.get(0).equals(str1.get(0))
82                     &&str2.get(1).equals(str1.get(1))
83                     ||str2.get(0).equals(str1.get(4))
84                     &&str2.get(1).equals(str1.get(3))){
85                 flat=true;
86             }
87             break;
88         }
89         return flat;
90     }
91  
92      
93 }

 1 package com.jm.sizeyunsuan;
 2  
 3 import java.util.List;
 4  
 5 /**
 6  * 判斷重複的第一個符號爲乘除的
 7  * @author
 8  *
 9  */
10 public class CongFuChengAndChu {
11     /**
12      * 第一個爲乘法判斷重複
13      * ||以前爲符號位置的一致，||以後的爲符號位置不一樣
14      */
15     public  boolean chengcopy(List<String> str1,List<String> str2){
16         boolean flat=false;
17         switch (str2.get(3)) {
18         case "*":
19             flat=true;
20             break;
21         case "/":
22             if(str2.get(4).equals(str1.get(4))
23                     &&str2.get(3).equals(str1.get(3))
24                     ||str2.get(4).equals(str1.get(2))
25                     &&str2.get(3).equals(str1.get(1))){
26                 flat=true;
27             }
28             break;
29         case "+":
30             if(str2.get(4).equals(str1.get(4))
31                     &&str2.get(3).equals(str1.get(3))
32                     ||str2.get(4).equals(str1.get(2))
33                     &&str2.get(3).equals(str1.get(1))){
34                 flat=true;
35             }
36             break;
37         default:
38             if(str2.get(3).equals(str1.get(3))
39                     &&str2.get(4).equals(str1.get(4))){
40                 flat=true;
41             }
42             break;
43         }
44         return flat;
45     }
46  
47     /**
48      * 第一個爲除法判斷重複
49      * ||以前爲符號位置的一致，||以後的爲符號位置不一樣
50      */
51     public  boolean chucopy(List<String> str1,List<String> str2){
52         boolean flat=false;
53         switch (str2.get(3)) {
54         case "*":
55             if(str2.get(2).equals(str1.get(2))
56                     &&str2.get(1).equals(str1.get(1))
57                     ||str2.get(2).equals(str1.get(4))
58                     &&str2.get(1).equals(str1.get(3))){
59                 flat=true;
60             }
61             break;
62         case "/":
63             if(str2.get(0).equals(str1.get(0))){
64                 flat=true;
65             }
66             break;
67         case "+":
68             if(str2.get(0).equals(str1.get(0))
69                     &&str2.get(1).equals(str1.get(1))
70                     &&str2.get(2).equals(str1.get(2))
71                     ||str2.get(0).equals(str1.get(2))
72                     &&str2.get(1).equals(str1.get(3))
73                     &&str2.get(2).equals(str1.get(4))){
74                 flat=true;
75             }
76             break;
77         default:
78             if(str2.get(0).equals(str1.get(0))
79                     &&str2.get(1).equals(str1.get(1))
80                     &&str2.get(2).equals(str1.get(2))){
81                 flat=true;
82             }
83             break;
84         }
85         return flat;
86     }
87  
88 }