站内搜索: 请输入搜索关键词

当前页面: 开发资料首页 → J2SE 专题 → J2SE 5.0 Generic应用

J2SE 5.0 Generic应用

摘要: J2SE 5.0 Generic应用

<table class="MsoNormalTable" id="table1" style="BORDER-RIGHT: medium none; BORDER-TOP: medium none; BACKGROUND: #e6e6e6; MARGIN-LEFT: 46pt; BORDER-LEFT: medium none; BORDER-BOTTOM: medium none; BORDER-COLLAPSE: collapse" cellspacing="0" cellpadding="0" width="953" border="1"><tr style="HEIGHT: 23.25pt"><td style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1pt solid; WIDTH: 937px; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; HEIGHT: 23.25pt" valign="top">J2SE 5.0 Generic应用一：类型安全的functor

一、简介

函数式编程是非常常用和非常重要的一种编程范式，有的语言直接提供支持，C++则通过()运算符重载和模板提供了还算灵活的支持，而Java中的函数式编程则由于语言本身的局限没有得到广泛应用，Apache Commons Functor 项目是一个正在开发中的函数式编程库，但目前看来并不是类型安全的；J2SE 5.0提供了有限的generic能力，除了用于Collection之外，类型安全的functor也是其用武之地，已有一个开源项目Generic Algorithms for Java开始了这方面的工作

二、示例

public interface UnaryFunction {
R evaluate(P obj);
}

public interface UnaryPredicate {
boolean test(T obj);
}

public interface UnaryProcedure {
void run(T obj);
}

public interface BinaryFunction {
R evaluate(T left, S right);
}

public interface BinaryPredicate {
boolean test(T left, S right);
}

public interface BinaryProcedure {
void run(T left, S right);
}

public interface Filter extends UnaryFunction{
}

public static List transform(Collection source, UnaryFunction transformer){
List result = new ArrayList();
for(Source item : source){
result.add(transformer.evaluate(item));
}
return result;
}

public static List select(Collection source, UnaryPredicate selector){
List result = new ArrayList();
for(T item : source){
if(selector.test(item)){
result.add(item);
}
}
return result;
}

public static void foreach(Collection source, UnaryProcedure procedure){
for(T item : source){
procedure.run(item);
}
}

public class And implements UnaryPredicate, Serializable{
private UnaryPredicate[] predicates;
public And(UnaryPredicate... predicates){
this.predicates = predicates;
}
public boolean test(T obj) {
for(UnaryPredicate predicate : predicates){
if( !predicate.test(obj) ){
return false;
}
}
return true;
}
public static And and(UnaryPredicate... predicates){
return new And(predicates);
}
}

public class Or implements UnaryPredicate, Serializable{
private UnaryPredicate[] predicates;
public Or(UnaryPredicate... predicates){
this.predicates = predicates;
}
public boolean test(T obj) {
for(UnaryPredicate predicate : predicates){
if( predicate.test(obj) ){
return true;
}
}
return false;
}
public static Or or(UnaryPredicate... predicates){
return new Or(predicates);
}
}

public class Not implements UnaryPredicate, Serializable{
private UnaryPredicate predicate;
public Not(UnaryPredicate predicate){
this.predicate = predicate;
}
public boolean test(T obj) {
return !predicate.test(obj);
}
public static Not not(UnaryPredicate predicate){
return new Not(predicate);
}
}

三、问题

1，interface vs. functor

functor在Java里就是一个“只包含一个method的接口”，在使用接口的大部分地方都可以使用functor，优点是低侵入性（不需要实现接口），缺点是无法访问类的私有信息；鉴于目前Generic的实现，涉及到Java动态特性（序列化/反序列化，反射等）的模块，优先使用interface，其它场合可酌情使用泛化的functor

2，function vs. functor

只在内部使用的，做成function，在多处使用的，做成functor

3，classic vs. modern

传统分支控制语句if，else，switch在面向对象的程序中，可使用“子类化”大面积的消除

传统循环控制语句for，do while也该使用“algorithm + functor”大面积消除了

</td></tr></table>

<table class="MsoNormalTable" id="table2" style="BORDER-RIGHT: medium none; BORDER-TOP: medium none; BACKGROUND: #e6e6e6; MARGIN-LEFT: 46pt; BORDER-LEFT: medium none; BORDER-BOTTOM: medium none; BORDER-COLLAPSE: collapse" cellspacing="0" cellpadding="0" width="952" border="1"><tr style="HEIGHT: 23.25pt"><td style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 1pt solid; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1pt solid; WIDTH: 936px; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; HEIGHT: 23.25pt" valign="top">J2SE 5.0 Generic应用二：类型安全的多返回值

一、简介

out参数和ref参数提供了同一个函数返回多个值的途径，C++和C#分别用引用和out、ref关键字支持，Java中一般用数组或集合解决这个问题；Generic提供了另外一种途径，但并不比数组来得方便实用，所以这里仅仅是为了泛型而泛型，没有实际价值；另外pair等技术也常被使用，其实就是map.entry

二、示例

public class Out {
private T obj = null;
public T get() {
return obj;
}
public void set(T obj) {
this.obj = obj;
}
}

public class Ref {
private T obj = null;
public RefHolder(T obj){
this.obj = obj;
}
public T get() {
return obj;
}
public void set(T obj) {
this.obj = obj;
}
}

public class Pair {

private First first;
private Second second;

public Pair(First first, Second second) {
this.first = first;
this.second = second;
}

public First getFirst() {
return this.first;
}
public void setFirst(First first) {
this.first = first;
}

public Second getSecond() {
return this.second;
}
public void setSecond(Second second) {
this.second = second;
}

public boolean equals(Object obj) {
Pair pair = Pair.class.cast(obj);
return pair == null ? false : pair.first.equals(first) && pair.second.equals(second);
}

public int hashCode() {
return first.hashCode() * 7 + second.hashCode();
}
}

</td></tr></table>




↑返回目录
前一篇: 关于J2SE5.0的泛型
后一篇: [ZT]使用J2SE API读取Properties文件的六种方法