Hi Eric,

I am just learning Java and am trying to write a method that does

something like

//=============== =============== =============

public Static List find(double[] array,double val,String relationalOp)

It's a good example method. Unfortunately, Java is not very good at

handling such cases, because it does not treat methods (or operations)

as normal values. You cannot directly pass a method as an argument to

another method.

The closest you could get would be to use anonymous classes as a

substitute, as in the following (beware, very verbose)!

import java.util.*;

public class Main {

abstract static class DoubleOp

{

abstract boolean test(double x, double y);

}

public static List find(double[] array,double val, DoubleOp op){

List list = new ArrayList();

for (int m = 0;m < array.length;m+ +) {

// The following line is the problem

if (op.test(array[m], val)) {

list.add(new Double(array[m]));

}

}

return list;

}

public static void main(String[] args) {

double[] numbers = new double[]{ -10, -1, 0, 2, 5, 11 };

DoubleOp leq = new DoubleOp() {

boolean test(double x, double y) {

return x < y;

}

};

List negative = find(numbers, 0, leq);

System.out.prin tln("Negative numbers: " + negative);

DoubleOp neq = new DoubleOp() {

boolean test(double x, double y) {

return x != y;

}

};

List nonZero = find(numbers, 0, neq);

System.out.prin tln("Non-zero numbers: " + nonZero);

}

}

It is much easier if you can use a language that support methods as

values. For instance, here is the same code in the Nice language, which

is an extension of Java with many features, including method values (I

am one of the developers of Nice. You can find more about it at

http://nice.sf.net)

List<double> find(double[] array,double val,(double,dou ble)->boolean op)

{

List<double> list = new ArrayList();

for (int m = 0;m < array.length;m+ +) {

// The following line was the problem

if (op(array[m], val)) {

list.add(array[m]);

}

}

return list;

}

void main(String[] args)

{

double[] numbers = [ -10, -1, 0, 2, 5, 11 ];

let negative = find(numbers, 0, (double x,double y)=> x < y);

System.out.prin tln("Negative numbers: " negative);

let nonZero = find(numbers, 0, (double x,double y)=> x != y);

System.out.prin tln("Non-zero numbers: " nonZero);

}

Some comments:

(double,double)->boolean

This is the type of a method, which has two arguments of type

double, and returns a boolean.

let negative =

This is a way to declare a local variable, letting the compiler

find what is its type.

(double x,double y)=> x < y

This is an expression that represents the '<' comparison on doubles.

One way to generalize your method find is to give it only two arguments:

the array of number, and a method with _one_ argument of type double,

returning a boolean to say if that number should be included in the

results. This generalization is what we call 'filter'. So this code

could be simply rewritten as:

void main(String[] args)

{

double[] numbers = [ -10, -1, 0, 2, 5, 11 ];

let negative = filter(numbers, (double x)=> x < 0);

System.out.prin tln("Negative numbers: " negative);

let nonZero = filter(numbers, (double x)=> x != 0);

System.out.prin tln("Non-zero numbers: " nonZero);

}

Enjoy!

Daniel

The Nice programming language:

http://nice.sf.net