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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
import java.util.ArrayList;
import java.util.List;
 
/**
 * 查重的总函数
 * @author admin
 *
 */
public class CongFu2 {
    /**
     * 查重
     */
    public  boolean chacong(List<String> timus,String yunsuan){
        boolean flat=false;//获取是否重复的标记
        boolean zhuzhifu=false;//在flat为true的时候,终止本次循环的标志
        for(String s:timus){
            if(!zhuzhifu){
                List<String> str1=new ArrayList<String>();//获取已经存入在list中的题目
                List<String> str2=new ArrayList<String>();//获取这次尝试的题目
                for(int i=0;i<s.length();i++){
                    str1.add(s.charAt(i)+"");
                    str2.add(yunsuan.charAt(i)+"");
                }
                flat=false;
                for(int i=0;i<str1.size();i++){
                    if(!str1.contains(str2.get(i))
                            ||!str2.contains(str1.get(i))){
                        break;
                    }else{
                        if(i==str1.size()-1){
                            flat=true;
                        }
                    }
                }
                if(flat){
                    flat=false;
                    switch (str2.get(1)) {
                    case "+":
                        flat=false;
                        switch (str2.get(3)) {
                        case "+":
                            flat=true;
                            break;
                        case "-":
                            if(str2.get(4).equals(str1.get(4))
                                    &&str2.get(3).equals(str1.get(3))
                                    ||str2.get(3).equals(str1.get(1))
                                    &&str2.get(4).equals(str1.get(2))){
                                flat=true;
                            }
                            break;
                        case "/":
                            if(str2.get(2).equals(str1.get(2))
                                    &&str2.get(3).equals(str1.get(3))
                                    &&str2.get(4).equals(str1.get(4))
                                    ||str2.get(2).equals(str1.get(0))
                                    &&str2.get(3).equals(str1.get(1))
                                    &&str2.get(4).equals(str1.get(2))){
                                flat=true;
                            }
                            break;
                        default:
                            if(str2.get(0).equals(str1.get(0))
                                    &&str2.get(1).equals(str1.get(1))
                                    ||str2.get(0).equals(str1.get(4))
                                    &&str2.get(1).equals(str1.get(3))){
                                flat=true;
                            }
                            break;
                        }
                        break;
                    case "-":
                        flat=false;
                        switch (str2.get(3)) {
                        case "+":
                            if(str2.get(2).equals(str1.get(2))
                                    &&str2.get(1).equals(str1.get(1))
                                    ||str2.get(1).equals(str1.get(3))
                                    &&str2.get(2).equals(str1.get(4))){
                                flat=true;
                            }
                            break;
                        case "-":
                            if(str2.get(0).equals(str1.get(0))){
                                flat=true;
                            }
                            break;
                        case "/":
                            if(str2.get(0).equals(str1.get(0))
                                    &&str2.get(2).equals(str1.get(2))
                                    &&str2.get(1).equals(str1.get(1))){
                                flat=true;
                            }
                            break;
                        default:
                            if(str2.get(0).equals(str1.get(0))
                                    &&str2.get(1).equals(str1.get(1))
                                    ||str2.get(0).equals(str1.get(4))
                                    &&str2.get(1).equals(str1.get(3))){
                                flat=true;
                            }
                            break;
                        }
                        break;
                    case "/":
                        flat=false;
                        switch (str2.get(3)) {
                        case "*":
                            flat=true;
                            break;
                        case "/":
                            if(str2.get(4).equals(str1.get(4))
                                    &&str2.get(3).equals(str1.get(3))
                                    ||str2.get(4).equals(str1.get(2))
                                    &&str2.get(3).equals(str1.get(1))){
                                flat=true;
                            }
                            break;
                        case "+":
                            if(str2.get(4).equals(str1.get(4))
                                    &&str2.get(3).equals(str1.get(3))
                                    ||str2.get(4).equals(str1.get(2))
                                    &&str2.get(3).equals(str1.get(1))){
                                flat=true;
                            }
                            break;
                        default:
                            if(str2.get(3).equals(str1.get(3))
                                    &&str2.get(4).equals(str1.get(4))){
                                flat=true;
                            }
                            break;
                        }
                        break;
                    default:
                        flat=false;
                        switch (str2.get(3)) {
                        case "*":
                            if(str2.get(2).equals(str1.get(2))
                                    &&str2.get(1).equals(str1.get(1))
                                    ||str2.get(2).equals(str1.get(4))
                                    &&str2.get(1).equals(str1.get(3))){
                                flat=true;
                            }
                            break;
                        case "/":
                            if(str2.get(0).equals(str1.get(0))){
                                flat=true;
                            }
                            break;
                        case "+":
                            if(str2.get(0).equals(str1.get(0))
                                    &&str2.get(1).equals(str1.get(1))
                                    &&str2.get(2).equals(str1.get(2))
                                    ||str2.get(0).equals(str1.get(2))
                                    &&str2.get(1).equals(str1.get(3))
                                    &&str2.get(2).equals(str1.get(4))){
                                flat=true;
                            }
                            break;
                        default:
                            if(str2.get(0).equals(str1.get(0))
                                    &&str2.get(1).equals(str1.get(1))
                                    &&str2.get(2).equals(str1.get(2))){
                                flat=true;
                            }
                            break;
                        }
                        break;
                    }
                    if(flat){
                        zhuzhifu=true;
                    }
                }
            }else{
                break;
            }
        }
        return flat;
    }
}

2.优化后的  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package com.jm.sizeyunsuan;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * 查重的总函数
 * @author admin
 *
 */
public class CongFu {
    /**
     * 查重
     */
    public  boolean chacong(List<String> timus,String yunsuan){
        boolean flat=false;//获取是否重复的标记
        boolean zhuzhifu=false;//在flat为true的时候,终止本次循环的标志
        for(String s:timus){
            if(!zhuzhifu){
                List<String> str=new ArrayList<String>();//获取已经存入在list中的题目
                List<String> str2=new ArrayList<String>();//获取这次尝试的题目
                for(int i=0;i<s.length();i++){
                    str.add(s.charAt(i)+"");
                    str2.add(yunsuan.charAt(i)+"");
                }
                flat= same(str, str2);//查看符号数字是不是一样
                if(flat){
                    flat=diaoYong(str,str2);//判断查重
                    if(flat){
                        zhuzhifu=true;
                    }
                }
            }else{
                break;
            }
        }
        return flat;
    }
     
    /**
     * 为了减少代码块的过多抽取调用的方法
     * @param str list中的题目
     * @param str2 现在产生的题目
     * @return
     */
    public boolean diaoYong(List<String> str,List<String> str2 ){
        CongFuAddAndJian aj=new CongFuAddAndJian();
        CongFuChengAndChu cc=new CongFuChengAndChu();
        boolean flat=false;
        switch (str2.get(1)) {
        case "+":
            flat=aj.addcopy(str,str2);
            break;
        case "-":
            flat=aj.jiancopy(str,str2);
            break;
        case "/":
            flat=cc.chucopy(str,str2);
            break;
        default:
            flat=cc.chengcopy(str,str2);
            break;
        }
        return flat;
    }
     
    /**
     * 符号数字一样
     * str1是题目
     * str2是本次产生的题目
     */
    public  boolean same(List<String> str1,List<String> str2 ){
        boolean flat=false;
        for(int i=0;i<str1.size();i++){
            if(!str1.contains(str2.get(i))
                    ||!str2.contains(str1.get(i))){
                break;
            }else{
                if(i==str1.size()-1){
                    flat=true;
                }
            }
        }
        return flat;
    }
}

  

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

  

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

  

 

posted @   尤少辉  阅读(758)  评论(13编辑  收藏  举报
努力加载评论中...
点击右上角即可分享
微信分享提示