Greetings,

I find the following utility macros helpful when wanting to access Java from Lisp.  I will give some examples after the actual code.

(defmacro defun-class-method (lfun cls-name meth-name &rest arg-types)
  (let ((arglist (mapcar (lambda (x) (gensym)) arg-types))
(method (gensym))
(cls (gensym)))
    `(let ((,method (jmethod ,cls-name ,meth-name ,@arg-types))
   (,cls (jclass ,cls-name)))
       (defun ,lfun ,arglist
 (jcall ,method ,cls ,@arglist)))))

(defmacro defun-instance-method (lfun cls-name meth-name &rest arg-types)
  (let ((arglist (mapcar (lambda (x) (gensym)) (cons nil arg-types)))
(method (gensym)))
    `(let ((,method (jmethod ,cls-name ,meth-name ,@arg-types)))
       (defun ,lfun ,arglist
 (jcall ,method ,@arglist)))))

(defmacro defun-constructor (lfun cls-name &rest arg-types)
  (let ((arglist (mapcar (lambda (x) (gensym)) arg-types))
(method (gensym)))
    `(let ((,method (jconstructor ,cls-name ,@arg-types)))
       (defun ,lfun ,arglist
 (jnew ,method ,@arglist)))))

Examples:

The following line defines a lisp function named "java-abs".  java-abs is a proxy for the java version.  It takes the same arguments.  

(defun-class-method java-abs "java.lang.Math" "abs" "int")

After the above is called, you may call the Java method from lisp as follows:

(java-abs -44)

The lisp functions created by these utilities are fast because they are closures.  The class and method lookups are only done once.

Other examples:

(defun-constructor newInteger "java.lang.Integer" "int")
(defun-instance-method hashCode "java.lang.Integer" "hashCode")

I am in the process of doing the same thing for Java.  Stay tuned.

Blake McBride