1.安装

版本说明:Win10+R3.2.5+JKD1.7+eclipse-jee-mars-R-win32-x86_64

install.packages("rJava")

2.R中调用Java

载入rJava包,运行library(rJava),注意:在一个会话中,包只需载入一次。如果需要,你可以自定义启动环境以自动载入会频繁使用的那些包,下面是测试程序:

> library(rJava)
> .jinit() #打开JVM
> s <- .jnew("java/lang/String","Hello World!") #新建一个字符串
> s #参看s变量
[] "Java-Object{Hello World!}"

说明:

.jinit()的作用是:初始化JVM,.jinit()在运行rJava任何方法之前必须启动。

.jnew 创建新的Java对象。

## Not run:
f <- .jnew("java/awt/Frame","Hello")
.jcall(f,,"setVisible",TRUE)

上面的程序是创建了一个Frame窗口,设置的窗口可见并且可最大化和最小化,但是不可关闭,显示如下:

.jcall calls a Java method with the supplied arguments.用来设置方法提供的参数;

.jcall("java/lang/System","S","getProperty","os.name")
if (!nzchar(Sys.getenv("NOAWT"))) {
  f <- .jnew("java/awt/Frame","Hello")
  .jcall(f,,"setVisible",TRUE)
}

3.Java中调用R

3.1设置环境变量

一定要建环境变量,不然运行eclipse时会报错,环境变量(根据自己的安装情况):

JAVA_HOME    D:\ImprtantSoft\Java\jdk1.
classpath   %JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar;%R_HOME%\library\rJava\jri
path     %R_HOME%\bin\x64;D:\ImprtantSoft\MySQL\MySQL Server 5.6\bin;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;%JAVA_HOME%\jre\bin\server
R_HOME      D:\ImprtantSoft\R\R-

l  将D:\ImprtantSoft\R\R-3.2.5\library\rJava\jri下的三个jar包(JRIEngine.jar,JRI.jar,REngine.jar)拷到D:\ImprtantSoft\Java\jdk1.7\lib目录下,即jdk目录的lib下

l  打开eclipse,创建java project。同时将上述三个包导入工程中。

l  D:\ImprtantSoft\R\R-3.2.5\library\rJava\jri\examples目录下有两个自带测试代码rtest.java和rtest2.java。

l  运行这两个代码,如果结果不报错,说明调用成功。

3.2eclipse中创建项目

rtest类:

package testR;

import java.awt.FileDialog;
import java.awt.Frame;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Enumeration;

import org.rosuda.JRI.REXP;
import org.rosuda.JRI.RList;
import org.rosuda.JRI.RMainLoopCallbacks;
import org.rosuda.JRI.RVector;
import org.rosuda.JRI.Rengine;

class TextConsole implements RMainLoopCallbacks
{
    public void rWriteConsole(Rengine re, String text, int oType) {
        System.out.print(text);
    }

    public void rBusy(Rengine re, int which) {
        System.out.println("rBusy("+which+")");
    }

    public String rReadConsole(Rengine re, String prompt, int addToHistory) {
        System.out.print(prompt);
        try {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String s=br.readLine();
            return (s==null||s.length()==0)?s:s+"\n";
        } catch (Exception e) {
            System.out.println("jriReadConsole exception: "+e.getMessage());
        }
        return null;
    }

    public void rShowMessage(Rengine re, String message) {
        System.out.println("rShowMessage \""+message+"\"");
    }

    public String rChooseFile(Rengine re, int newFile) {
    FileDialog fd = new FileDialog(new Frame(), (newFile==0)?"Select a file":"Select a new file", (newFile==0)?FileDialog.LOAD:FileDialog.SAVE);
    fd.show();
    String res=null;
    if (fd.getDirectory()!=null) res=fd.getDirectory();
    if (fd.getFile()!=null) res=(res==null)?fd.getFile():(res+fd.getFile());
    return res;
    }

    public void   rFlushConsole (Rengine re) {
    }

    public void   rLoadHistory  (Rengine re, String filename) {
    }            

    public void   rSaveHistory  (Rengine re, String filename) {
    }
}

public class rtest {
    public static void main(String[] args) {
    // just making sure we have the right version of everything
    if (!Rengine.versionCheck()) {
        System.err.println("** Version mismatch - Java files don't match library version.");
        System.exit(1);
    }
        System.out.println("Creating Rengine (with arguments)");
        // 1) we pass the arguments from the command line
        // 2) we won't use the main loop at first, we'll start it later
        //    (that's the "false" as second argument)
        // 3) the callbacks are implemented by the TextConsole class above
        Rengine re=new Rengine(args, false, new TextConsole());
        System.out.println("Rengine created, waiting for R");
        // the engine creates R is a new thread, so we should wait until it's ready
        if (!re.waitForR()) {
            System.out.println("Cannot load R");
            return;
        }

        /* High-level API - do not use RNI methods unless there is no other way
            to accomplish what you want */
        try {
            REXP x;
            re.eval("data(iris)",false);
            System.out.println(x=re.eval("iris"));
            // generic vectors are RVector to accomodate names
            RVector v = x.asVector();
            if (v.getNames()!=null) {
                System.out.println("has names:");
                for (Enumeration e = v.getNames().elements() ; e.hasMoreElements() ;) {
                    System.out.println(e.nextElement());
                }
            }
            // for compatibility with Rserve we allow casting of vectors to lists
            RList vl = x.asList();
            String[] k = vl.keys();
            if (k!=null) {
                System.out.println("and once again from the list:");
                int i=0; while (i<k.length) System.out.println(k[i++]);
            }            

            // get boolean array
            System.out.println(x=re.eval("iris[[1]]>mean(iris[[1]])"));
            // R knows about TRUE/FALSE/NA, so we cannot use boolean[] this way
            // instead, we use int[] which is more convenient (and what R uses internally anyway)
            int[] bi = x.asIntArray();
            {
                int i = 0; while (i<bi.length) { System.out.print(bi[i]==0?"F ":(bi[i]==1?"T ":"NA ")); i++; }
                System.out.println("");
            }

            // push a boolean array
            boolean by[] = { true, false, false };
            re.assign("bool", by);
            System.out.println(x=re.eval("bool"));
            // asBool returns the first element of the array as RBool
            // (mostly useful for boolean arrays of the length 1). is should return true
            System.out.println("isTRUE? "+x.asBool().isTRUE());

            // now for a real dotted-pair list:
            System.out.println(x=re.eval("pairlist(a=1,b='foo',c=1:5)"));
            RList l = x.asList();
            if (l!=null) {
                int i=0;
                String [] a = l.keys();
                System.out.println("Keys:");
                while (i<a.length) System.out.println(a[i++]);
                System.out.println("Contents:");
                i=0;
                while (i<a.length) System.out.println(l.at(i++));
            }
            System.out.println(re.eval("sqrt(36)"));
        } catch (Exception e) {
            System.out.println("EX:"+e);
            e.printStackTrace();
        }

        // Part 2 - low-level API - for illustration purposes only!
        //System.exit(0);

        // simple assignment like a<-"hello" (env=0 means use R_GlobalEnv)
        long xp1 = re.rniPutString("hello");
        re.rniAssign("a", xp1, 0);

        // Example: how to create a named list or data.frame
        double da[] = {1.2, 2.3, 4.5};
        double db[] = {1.4, 2.6, 4.2};
        long xp3 = re.rniPutDoubleArray(da);
        long xp4 = re.rniPutDoubleArray(db);

        // now build a list (generic vector is how that's called in R)
        long la[] = {xp3, xp4};
        long xp5 = re.rniPutVector(la);

        // now let's add names
        String sa[] = {"a","b"};
        long xp2 = re.rniPutStringArray(sa);
        re.rniSetAttr(xp5, "names", xp2);

        // ok, we have a proper list now
        // we could use assign and then eval "b<-data.frame(b)", but for now let's build it by hand:
        String rn[] = {"1", "2", "3"};
        long xp7 = re.rniPutStringArray(rn);
        re.rniSetAttr(xp5, "row.names", xp7);

        long xp6 = re.rniPutString("data.frame");
        re.rniSetAttr(xp5, "class", xp6);

        // assign the whole thing to the "b" variable
        re.rniAssign("b", xp5, 0);

        {
            System.out.println("Parsing");
            long e=re.rniParse("data(iris)", 1);
            System.out.println("Result = "+e+", running eval");
            long r=re.rniEval(e, 0);
            System.out.println("Result = "+r+", building REXP");
            REXP x=new REXP(re, r);
            System.out.println("REXP result = "+x);
        }
        {
            System.out.println("Parsing");
            long e=re.rniParse("iris", 1);
            System.out.println("Result = "+e+", running eval");
            long r=re.rniEval(e, 0);
            System.out.println("Result = "+r+", building REXP");
            REXP x=new REXP(re, r);
            System.out.println("REXP result = "+x);
        }
        {
            System.out.println("Parsing");
            long e=re.rniParse("names(iris)", 1);
            System.out.println("Result = "+e+", running eval");
            long r=re.rniEval(e, 0);
            System.out.println("Result = "+r+", building REXP");
            REXP x=new REXP(re, r);
            System.out.println("REXP result = "+x);
            String s[]=x.asStringArray();
            if (s!=null) {
                int i=0; while (i<s.length) { System.out.println("["+i+"] \""+s[i]+"\""); i++; }
            }
        }
        {
            System.out.println("Parsing");
            long e=re.rniParse("rnorm(10)", 1);
            System.out.println("Result = "+e+", running eval");
            long r=re.rniEval(e, 0);
            System.out.println("Result = "+r+", building REXP");
            REXP x=new REXP(re, r);
            System.out.println("REXP result = "+x);
            double d[]=x.asDoubleArray();
            if (d!=null) {
                int i=0; while (i<d.length) { System.out.print(((i==0)?"":", ")+d[i]); i++; }
                System.out.println("");
            }
            System.out.println("");
        }
        {
            REXP x=re.eval("1:10");
            System.out.println("REXP result = "+x);
            int d[]=x.asIntArray();
            if (d!=null) {
                int i=0; while (i<d.length) { System.out.print(((i==0)?"":", ")+d[i]); i++; }
                System.out.println("");
            }
        }

        re.eval("print(1:10/3)");

    if (true) {
        // so far we used R as a computational slave without REPL
        // now we start the loop, so the user can use the console
        System.out.println("Now the console is yours ... have fun");
        re.startMainLoop();
    } else {
        re.end();
        System.out.println("end");
    }
    }
}

需要修改运行参数:

在rtest类上右击→Run As→Run Configurations...

一定要在Arguments的VM arguments中添加下面的JVM参数:

-Djava.library.path="D:\ImprtantSoft\R\R-3.2.5\library\rJava\jri\x64"

输出结果:

Creating Rengine (with arguments)

R version 3.2.5 (2016-04-14) -- "Very, Very Secure Dishes"
Copyright (C) 2016 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64 (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

Rengine created, waiting for R
省略
has names:
Sepal.Length
Sepal.Width
Petal.Length
Petal.Width
Species
and once again from the list:
Sepal.Length
Sepal.Width
Petal.Length
Petal.Width
Species
[BOOLi* ]
省略
[BOOLi* ]
isTRUE? true
[LIST [REAL* (1.0)]:[SYMBOL a],([LIST [STRING "foo"]:[SYMBOL b],([LIST [INT* (1, 2, 3, 4, 5)]:[SYMBOL c],(null)])])]
Keys:
a
b
c
Contents:
[REAL* (1.0)]
[STRING "foo"]
[INT* (1, 2, 3, 4, 5)]
[REAL* (6.0)]
Parsing
Result = 237995232, running eval
Result = 237994944, building REXP
REXP result = [STRING "iris"]
Parsing
Result = 236162928, running eval
Result = 219285544, building REXP
REXP result = [省略]
Parsing
Result = 236176464, running eval
Result = 219285440, building REXP
REXP result = [STRING* ("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "Species")]
[0] "Sepal.Length"
[1] "Sepal.Width"
[2] "Petal.Length"
[3] "Petal.Width"
[4] "Species"
Parsing
Result = 236176320, running eval
Result = 219852656, building REXP
REXP result = [REAL* 省略

REXP result = [INT* (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)]
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
 [1] 0.3333333 0.6666667 1.0000000 1.3333333 1.6666667 2.0000000 2.3333333
 [8] 2.6666667 3.0000000 3.3333333
Now the console is yours ... have fun
rBusy(0)

rtest2类:

package testR;
import java.awt.Dimension;
import java.awt.FileDialog;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

import org.rosuda.JRI.RConsoleOutputStream;
import org.rosuda.JRI.RMainLoopCallbacks;
import org.rosuda.JRI.Rengine;

class TextConsole2 implements RMainLoopCallbacks
{
    JFrame f;

    public JTextArea textarea = new JTextArea();

    public TextConsole2() {
        f = new JFrame();
        f.getContentPane().add(new JScrollPane(textarea));
        f.setSize(new Dimension(800,600));
        f.show();
    }

    public void rWriteConsole(Rengine re, String text, int oType) {
        textarea.append(text);
    }

    public void rBusy(Rengine re, int which) {
        System.out.println("rBusy("+which+")");
    }

    public String rReadConsole(Rengine re, String prompt, int addToHistory) {
        System.out.print(prompt);
        try {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String s=br.readLine();
            return (s==null||s.length()==0)?s:s+"\n";
        } catch (Exception e) {
            System.out.println("jriReadConsole exception: "+e.getMessage());
        }
        return null;
    }

    public void rShowMessage(Rengine re, String message) {
        System.out.println("rShowMessage \""+message+"\"");
    }

    public String rChooseFile(Rengine re, int newFile) {
    FileDialog fd = new FileDialog(f, (newFile==0)?"Select a file":"Select a new file", (newFile==0)?FileDialog.LOAD:FileDialog.SAVE);
    fd.show();
    String res=null;
    if (fd.getDirectory()!=null) res=fd.getDirectory();
    if (fd.getFile()!=null) res=(res==null)?fd.getFile():(res+fd.getFile());
    return res;
    }

    public void   rFlushConsole (Rengine re) {
    }

    public void   rLoadHistory  (Rengine re, String filename) {
    }            

    public void   rSaveHistory  (Rengine re, String filename) {
    }
}

public class rtest2 {
    public static void main(String[] args) {
        System.out.println("Press <Enter> to continue (time to attach the debugger if necessary)");
        try { System.in.read(); } catch(Exception e) {};
        System.out.println("Creating Rengine (with arguments)");
        Rengine re=new Rengine(args, true, new TextConsole2());
        System.out.println("Rengine created, waiting for R");
        if (!re.waitForR()) {
            System.out.println("Cannot load R");
            return;
        }
        System.out.println("re-routing stdout/err into R console");
        System.setOut(new PrintStream(new RConsoleOutputStream(re, 0)));
        System.setErr(new PrintStream(new RConsoleOutputStream(re, 1)));

        System.out.println("Letting go; use main loop from now on");
    }
}

输出结果:

Press <Enter> to continue (time to attach the debugger if necessary)

Creating Rengine (with arguments)
Rengine created, waiting for R
re-routing stdout/err into R console
rBusy(0)

转载请注明链接:

http://www.cnblogs.com/homewch/p/5659756.html

rJava包---R与Java的接口的更多相关文章

  1. 解惑rJava R与Java的快速通道

    阅读导读: 1.什么是RJava? 2.怎样安装RJava? 3.怎样用RJava实现R调用Java? 1. rJava介绍 rJava是一个R语言和Java语言的通信接口.通过底层JNI实现调用,同 ...

  2. 解惑rJava R与Java的高速通道

    解惑rJava R与Java的高速通道 R的极客理想系列文章,涵盖了R的思想,使用,工具,创新等的一系列要点,以我个人的学习和体验去诠释R的强大. R语言作为统计学一门语言,一直在小众领域闪耀着光芒. ...

  3. 关于Java的接口

    其实刚开始听到接口的时候不解其意,为什么要有接口这个东西,加之老师上课我可能没仔细听(或者时间长了忘了?),这次看到了“用接口设计并实现圆,三角形,矩形的面积与周长计算”这个题目的代码,它将接口定义在 ...

  4. R语言rJava包安装载入及JAVA环境配置

    rJava 包的安装与载入 一般文本分词的教程都会贴出: install.packages("rJava") library(rJava) 来引导我们装载rJava包,运行inst ...

  5. R 安装包遇到问题(一) loadNamespace()里算'rJava'时.onLoad失败了 rJava 包的安装与载入

    > library(xlsx) Error: package or namespace load failed for ‘xlsx’: loadNamespace()里算'rJava'时.onL ...

  6. R 之 rJava 包安装错误的解决方案

    前几天在Ubuntu上安装R中的xlsx包时一直卡在了rJava包的安装上,最终各种google都没能解决问题.直到最后,我回到了安装rJava时的错误记录....我用血的教训证明,错误日志是很重要很 ...

  7. R语言:关于rJava包的安装

    R语言:关于rJava包的安装  盐池里的萝卜 2014-09-14 00:53:33 在做文本挖掘的时候,会发现分词时候rJava是必须要迈过去的坎儿,所以进行了总结: 第一步:安装rJava和jd ...

  8. R与JAVA的整合

    R是统计计算的强大工具,而JAVA是做应用系统的主流语言,两者天然具有整合的需要.关于整合,一方面,R中可以创建JAVA对象调用JAVA方法,另一方面,JAVA中可以转换R的数据类型调用R的函数,互相 ...

  9. 从jar包还原出java源码(项目文件)

    原文转载至:https://blog.csdn.net/mxmxz/article/details/73043156 上周接到个新任务,一个遗留的接口工程需要改造,然而根据前任开发留下的文档看,这个工 ...

随机推荐

  1. Python--set常用操作函数

    python提供了常用的数据结构,其中之一就是set,python中的set是不支持索引的.值不能重复.无需插入的容器. 简单记录下set常用的操作函数: 1.新建一个set: set("H ...

  2. 解的个数(codevs 1213)

    题目描述 Description 已知整数x,y满足如下面的条件: ax+by+c = 0 p<=x<=q r<=y<=s 求满足这些条件的x,y的个数. 输入描述 Input ...

  3. 【转】字符集和字符编码(Charset & Encoding)

    相信大家一定碰到过,打开某个网页,却显示一堆像乱码,如"бЇЯАзЪСЯ"."�????????"?还记得HTTP中的Accept-Charset.Accept ...

  4. c语言强制类型转换

    一.强制类型转换 printf("3/2+100.5=%f",3/2+100.5);//100.5错误表达 printf ("    (float)3/(float)2 ...

  5. NYOJ之素数求和问题

    aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAsoAAAKCCAIAAABH/2gWAAAgAElEQVR4nO3dPVLjStsG4G8T5CyEdF

  6. hdu 2057 A+B

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2057 For each test case,print the sum of A and B in h ...

  7. Xcode因为证书问题经常报的那些错

    去开始做 iOS开发的时候,因为证书问题 Xcode 经常报这样或那样的错,经过实践,现在看见 Xcode 报错已经心平气和了,经常报的错就那么多,整理一下. 1. 确认下证书是不是开发证书,如果是发 ...

  8. jquery学习笔记----元素筛选

    1.eq()  筛选指定索引号的元素2.first() 筛选出第一个匹配的元素3.last() 筛选出最后一个匹配的元素4.hasClass() 检查匹配的元素是否含有指定的类5.filter() 筛 ...

  9. Ext Js【Hello World】 ——4.1 beta 1

    准备:vs+ExtJs4.1Beta1 ExtJS 4.1  xiazai_ https://yunpan.cn/cqv6bdBwtRjAj (提取码:2733) 引用,cs文件,js主入口,zh—c ...

  10. SSAS Cube 维度成员关系Rigid 和 Flexible

    维度成员关系指示成员关系是否随时间而更改.  值为 Rigid 和 Flexible,前者表示成员之间的关系不随时间而更改,后者表示成员之间的关系随时间而更改. 默认值为 Flexible.  指定适 ...