2006年6月7日

1.集合中元素个数,10M
2.根据上限和下限从一个Set中过滤出满足要求的元素集合.

测试效果:集合大小100K, 运算时间 3000ms+

1     void filerSet(Set<BigDecimal> targetSet, String lower, String higher) {
2         BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
3         BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
4
5         Set<BigDecimal> returnSet = new HashSet<BigDecimal>();
6         for (BigDecimal object : targetSet) {
7             if (isInRange(object, bdLower, bdHigher)) {
9             }
10         }
11     }
12
13     private boolean isInRange(BigDecimal object, BigDecimal bdLower,
14             BigDecimal bdHigher) {
15         return object.compareTo(bdLower) >= 0
16                 && object.compareTo(bdHigher) <= 0;
17     }

测试效果: 集合大小10M, 运算时间: 12000ms+(获得TreeSet) , 200ms(获得结果)

1     Set<BigDecimal> getSubSet(TreeSet<BigDecimal> targetSet, String lower,
2             String higher) {
3
4         BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
5         BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
6
7         if ((bdHigher.compareTo(targetSet.first()) == -1)
8                 || (bdLower.compareTo(targetSet.last()) == 1)) {
9             return null;
10         }
11
12         boolean hasLower = targetSet.contains(bdLower);
13         boolean hasHigher = targetSet.contains(bdHigher);
14         if (hasLower) {
15             if (hasHigher) {
16                 System.out.println("get start:" + bdLower);
17                 System.out.println("get end:" + bdHigher);
18                 return targetSet.subSet(bdLower, true, bdHigher, true);
19             } else {
20                 BigDecimal newEnd = null;
21                 System.out.println("get start:" + bdLower);
22                 SortedSet<BigDecimal> returnSet = null;
23                 if (bdHigher.compareTo(targetSet.last()) != -1) {
24                     newEnd = targetSet.last();
25                 } else {
26                     SortedSet<BigDecimal> newTargetSet = targetSet
27                             .tailSet(bdLower);
28                     for (BigDecimal object : newTargetSet) {
29                         if (object.compareTo(bdHigher) == 1) {
30                             newEnd = object;
31                             break;
32                         } else if (object.compareTo(bdHigher) == 0) {
33                             newEnd = object;
34                             break;
35                         }
36                     }
37                 }
38                 returnSet = targetSet.subSet(bdLower, true, newEnd, true);
39                 if (newEnd.compareTo(bdHigher) == 1) {
40                     returnSet.remove(newEnd);
41                 }
42                 return returnSet;
43             }
44
45         } else {
46             if (hasHigher) {
47                 System.out.println("get end:" + bdHigher);
48                 TreeSet<BigDecimal> newTargetSet = (TreeSet<BigDecimal>) targetSet
50                 BigDecimal newStart = null;
51                 SortedSet<BigDecimal> returnSet = null;
52
53                 if (bdLower.compareTo(targetSet.first()) == -1) {
54                     newStart = targetSet.first();
55                 } else {
56                     for (BigDecimal object : newTargetSet) {
57                         if (object.compareTo(bdLower) != -1) {
58                             newStart = object;
59                             break;
60                         }
61                     }
62                 }
63                 returnSet = targetSet.subSet(newStart, true, bdHigher, true);
64
65                 return returnSet;
66             } else {
67                 System.out.println("Not get start:" + bdLower);
68                 System.out.println("Not get end:" + bdHigher);
69                 BigDecimal newStart = null;
70                 BigDecimal newEnd = null;
71                 if (bdHigher.compareTo(targetSet.last()) != -1) {
72                     newEnd = targetSet.last();
73                 }
74                 if (bdLower.compareTo(targetSet.first()) == -1) {
75                     newStart = targetSet.first();
76                 }
77                 for (BigDecimal object : targetSet) {
78                     if (newStart == null) {
79                         if (object.compareTo(bdLower) != -1) {
80                             newStart = object;
81                             if (newEnd != null) {
82                                 break;
83                             }
84                         }
85                     }
86
87                     if (newEnd == null) {
88                         if (object.compareTo(bdHigher) != -1) {
89                             newEnd = object;
90                             if (newStart != null) {
91                                 break;
92                             }
93                         }
94                     }
95                 }
96
97                 if (newStart == null) {
98                     if (newEnd == null) {
99                         if ((bdHigher.compareTo(targetSet.first()) == -1)
100                                 || (bdLower.compareTo(targetSet.last()) == 1)) {
101                             return null;
102                         }
103                         return targetSet;
104                     } else {
106                                 newEnd, true);
107                         if (newEnd.compareTo(bdHigher) == 1) {
108                             newTargetSet.remove(newEnd);
109                         }
110                         return newTargetSet;
111                     }
112                 } else {
113                     if (newEnd == null) {
114                         SortedSet<BigDecimal> newTargetSet = targetSet.tailSet(
115                                 newStart, true);
116                         return newTargetSet;
117                     } else {
118                         SortedSet<BigDecimal> newTargetSet = targetSet.subSet(
119                                 newStart, true, newEnd, true);
120                         if (newEnd.compareTo(bdHigher) == 1) {
121                             newTargetSet.remove(newEnd);
122                         }
123                         return newTargetSet;
124                     }
125                 }
126             }
127         }
128     }

测试效果:集合大小10M,过滤结果1M, 运算时间: 1000ms+

1 //过滤的主体逻辑
2     void filterSet(Set<BigDecimal> targetSet, String lower, String higher) {
3         final BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
4         final BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
5
6         Predicate predicate = new Predicate() {
7             public boolean evaluate(Object object) {
8                 BigDecimal bDObject = (BigDecimal) object;
9                 return bDObject.compareTo(bdLower) >= 0
10                         && bDObject.compareTo(bdHigher) <= 0;
11             }
12         };
13
14         CollectionUtils.filter(targetSet, predicate);
15     }

测试效果:集合大小10M,过滤结果1M, 运算时间: 100ms-

1 //guava filter
2
3     Set<BigDecimal> filterSet(Set<BigDecimal> targetSet, String lower,
4             String higher) {
5         final BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
6         final BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
7
8         Set<BigDecimal> filterCollection = Sets.filter(targetSet,
9                 new Predicate<BigDecimal>() {
10                     @Override
11                     public boolean apply(BigDecimal input) {
12                         BigDecimal bDObject = (BigDecimal) input;
13                         return bDObject.compareTo(bdLower) >= 0
14                                 && bDObject.compareTo(bdHigher) <= 0;
15                     }
16                 });
17
18         return filterCollection;
19     }

posted @ 2014-06-21 23:33 混沌中立 阅读(7223) | 评论 (10)编辑 收藏

posted @ 2009-09-02 10:53 混沌中立 阅读(209) | 评论 (0)编辑 收藏

posted @ 2009-08-20 13:43 混沌中立 阅读(1305) | 评论 (1)编辑 收藏

1.Cell:表示一个Cell，是一个游戏中的一个单元格。
Cell主要由3个部分组成，Point,Value,Status.
2.Point:表示一个坐标，主要格式为:(2,3).
！！！注意：由于个人比较懒,所以开始的错误被贯彻了下来。
这个错误就是（2，3）表示的是由最左上的位置为坐标原点，第二行和第三列所确定的那个单元格。也就是纵坐标在前，横坐标在后了。
3.Value:表示一个值
4.Status:表示Cell的状态，只有两个状态，一个是NotSure,另一个是Sure.

5.AbstractCells：表示一些cell的集合，主要有三个子类
BlockCells：表示一个由多个Cell组成的块，例如一个2*2由4个Cell组成的块，或者一个2*3由6个Cell组成的块
HorizonCells:表示一个横行，即：从（0，0）到(0,n)坐标确定的所有Cell的集合。
VerticalCells:表示一个纵行，即：从（0，0）到(n,0)坐标确定的所有Cell的集合。
6.AbstractPolicy:就是游戏的策略。
这个主要表示的是：4*4的游戏，还是9*9的游戏。
可以在以后对此类进行继承和扩展，例如16*16的游戏我就没有实现。
主要扩展3个方法：
1）getValueRange，返回当前policy的value的个数。4*4的游戏的getValueRange返回的就应该是4。
2）getStep：表示当前policy中相邻的两个BlockCells的坐标差。
3）getIncrease：说不明白了：）（只可意会不可言传。）
7.Game：进行Policy的场所（我一直想抛弃这个类）
8.TestGame:游戏运行的地方，包括从PolicyFactory取得指定的Policy,设置输入输出文件的路径。
9.PolicyFactory：取得Policy的工厂。
getPolicy(int x) :这个方法获得的是正方形的sudoku的策略。例如:4*4的，9*9,16*16。
getPolicy(int x, int y)：这个方法获得的是长方形的Sudoku的策略。例如：9*12的。

1.在一个Cell中出现的Value,不会在和这个Cell处在同一个AbstractCells中的所有Cell中出现；
2.如果一个Cell中，所有可能出现的Value的个数为1，那么Cell的Value必然是这个最后的Value；
2.如果一个Value,如果在当前AbstractCells的所有其他的Cell中都不可能出现，那么它必然是最后一个Cell的Value。

http://www.blogjava.net/Files/GandofYan/sudoku.rar

http://www.blogjava.net/Files/GandofYan/temp.rar

posted @ 2006-07-13 16:19 混沌中立 阅读(2096) | 评论 (4)编辑 收藏

``软件的度量对于设计者和开发者非常重要，之前只是对这些有一个简单的了解。今天看来，了解的还远远不够。``
• Cyclomatic Complexity （圈复杂性）
• Response for Class （类的响应）
• Weighted methods per class （每个类重量方法）
`一个系统中的所有类的这三个度量能够说明这个系统的设计上的一些问题（不是全部），这三个度量越大越不好。如果一个类这三个度量很高，证明了这个类需要重构了。以第一个度量来说，有下面的一个表格：`
 CC Value Risk 1-10 Low risk program 11-20 Moderate risk 21-50 High risk >50 Most complex and highly unstable method

`CC数值高，可以通过减少if else（switch case也算）判断来达到目的；可以通过减少类与其他类的调用来减少RFC；通过分割大方法和大类来达到减少WMPC.`
`而Uncle Bob和Jdepend的度量标准应该算是另一个度量系统。`
• 关系内聚性（H）

H=(R+1)/N
R:包内类的关系数目（与包外部的类没有关系）
N:包内类的数量

• Number of Classes (Cc)

• Afferent Couplings (Ca)

• Efferent Couplings (Ce)

• Abstractness (A)

A=Cc/N
• Instability (I)

I＝Ce/（Ce＋Ca）
• Distance (D)
被分析package和理想曲线A＋I＝1的垂直距离，用于衡量package在稳定性和抽象性之间的平衡。理想          的package要么完全是抽象类和稳定（x＝0，y＝1），要么完全是具体类和不稳定（x＝1，y＝0）。
取值范围为0－1，D＝0表示完全符合理想标准，D＝1表示package最大程度地偏离了理想标准。
D = |A+I-1|/0.70710678
注：0.70710678*0.70710678 =2，既为“根号2“

public void findApplications(String id, String name){
``     if(id!=null && name!=null) {        //do something     }else{        //do something     }}``

``Cyclomatic Complexity` （`CC） = no of decision points + no of logical operations +1        （1）``Cyclomatic Complexity (CC) = number of decision points +1                                （2）参考了JDepend的参数和Uncle Bob的《`Agile Software Development: Principles, Patterns, and Practices`》 `（敏捷软件开发：原则、模式与实践）`
posted @ 2006-06-07 10:52 混沌中立 阅读(1426) | 评论 (3)编辑 收藏