薪的刻痕

R对象结构，用.Call的调用方式更灵活地写R-package

2010-03-25T19:29:00.001-07:00

虽然R的使用资料很多也很齐备，但R的开发资料却少得可怜，写一个能管点用途的package也得大费周章。于是蜀中无大将、廖化当先锋，官方文档那区区130页不齐备而又晦涩的＜Writing R Extensions＞就成了红宝书，天天抱着啃，啃得呕心呖血再加上翻着几个现成package的源代码看，终有小小成。

R与C的调用接口有好几种，以前介绍过的.C形式是一种，此外还有.Call形式和.External形式。.Call使用最为广泛，功能也比.C形式大很多，因为使用它可以直接操作R的数据结构，可以实现在C/C++中操作R的数据及调用R的函数，然后封装为包供R使用。

R的所有数据类型（无论数据或类或函数）都是对象，都统一定义为结构SEXPREC，由指针SEXP（不要想歪，我也不明白作者为何要取这个名字）所指向。这个结构在Rinternal.h中定义为：

typedef struct SEXPREC {
SEXPREC_HEADER;
union {
struct primsxp_struct primsxp;
struct symsxp_struct symsxp;
struct listsxp_struct listsxp;
struct envsxp_struct envsxp;
struct closxp_struct closxp;
struct promsxp_struct promsxp;
} u;
} SEXPREC, *SEXP;

它包含一个HEADER及一个UNION，HEADER又是由如下宏定义：

#define SEXPREC_HEADER \
struct sxpinfo_struct sxpinfo; \
struct SEXPREC *attrib; \
struct SEXPREC *gengc_next_node, *gengc_prev_node

它包含一个32位的sxpinfo的信息头，一个指向属性的指针，两个指向前后节点的指针构成双向链表。

sxpinfo这个信息头的定义如下：

struct sxpinfo_struct {
SEXPTYPE type : 5;
unsigned int obj : 1;
unsigned int named : 2;
unsigned int gp : 16;
unsigned int mark : 1;
unsigned int debug : 1;
unsigned int trace : 1; /* functions and memory tracing */
unsigned int spare : 1; /* currently unused */
unsigned int gcgen : 1; /* old generation number */
unsigned int gccls : 3; /* node class */
}; /* Tot: 32 */

简单说几个主要字段的作用：type表示数据类型，如数字型、字符型、列表型等等；named控制引用时拷贝与否；mark为垃圾回收所用（GC）。

使用.C调用方式来做R的扩展是最简单的方式，因为不需要理会SEXP这些复杂的R结构，只需要把数据拆解为一个个向量传递给C函数即可，详情参见我以前的描述。如果.C可以实现的功能，倒不必要一定要折腾到.Call，因为后者要牵涉到很多的R API，这些API还都没有文档说明其作用及调用方式，只能根据＜Writing R Extensions＞以及参考一些包的用法来猜测着使用。不过好处是.Call的功能更丰富而且稳定，.C方式的指针纵横交错，极易使程序崩溃。

这里先用官方文档里的一个例子拿出来加以解说，阐述个大体流程，以后实践深入再结合一些经验来谈谈技巧。

在C里处理R对象，以下是一个计算外积的例子：

在C文件中的源代码为：

#include
#include // 所有R API都定义在这里，只可惜没有太多说明，需要细细看
SEXP out(SEXP x, SEXP y) // 无论参数，还是返回值，都要定义为SEXP指针类型
{
int i, j, nx, ny;
double tmp, *rx = REAL(x), *ry = REAL(y), *rans; // REAL函数取得SEXP结构中的数据指针（如果是整型，则用INTEGER），以方便对数据的操作
SEXP ans;
nx = length(x); ny = length(y);
PROTECT(ans = allocMatrix(REALSXP, nx, ny)); // 分配空间，返回一个SEXP指向的对象，REALSXP是指实数类型，这里生成一个实数矩阵。PROTECT保护该内存不被垃圾回归机制回收。
rans = REAL(ans);
for(i = 0; i < nx; i++) {
tmp = rx[i];
for(j = 0; j < ny; j++)
rans[i + nx*j] = tmp * ry[j];
}
UNPROTECT(1); // 放弃对以上PROTECT声明内存段的保护，参数1指示放弃1次，次数必须跟上面使用PROTECT次数一致。
return(ans);
}

假如文件存储为out.c，则用R CMD SHLIB out.c命令可以把源代码编译为out.so共享库。然后在R里使用如下代码即可使用：

a=1:3
b=4:6
dyn.load("out.so")
.Call("out", a, b)

把R的dataframe当成数据库来查ZZ

2010-03-25T19:27:00.000-07:00

从cos上看到一个很好玩的包：sqldf，可以把一个或多个dataframe组成数据库，然后用SQL语句来查询，这样对于一些查询计算会非常方便。其原理是先把dataframe转成SQLite的表，然后进行查询。

由于今天早上起来r-project主站无法连上，只能用镜像网站下载安装了：install.packages(“sqldf”, repos=”http://mirrors.geoexpat.com/cran/”)

使用，假设工作区里有两个dataframe：x和y，那么可以用如下方式查询

sqldf(’select * from x limit 10′)

sqldf(’select distinct id from y where status=”P” limit 10′)

sqldf(’select status, count(1) from y group by status’)

sqldf(’select y.name from x, y where x.id=1 and y.rid=x.id’)

是不是很像数据库查询，这时你的工作区就是一个数据库了。

注意：有时候表实际的列名会与dataframe的名字不一致，也即x[1:5, ]和sqldf(’select * from x limit 5′)看到的字段名是有可能会不一样的，这种情况下，以后者为准。比如我x中有一个字段user到了sqldf就变成了user__1，这时只能用user__1来作为字段名进行查询，不能再用user。最好先用sqldf(’select * from x limit 5′)确认一下具体的字段名称。

速度如何？经我的试验，10万的数据都是瞬间完成，在100万的量级都还是很快的，无论对哪个字段作为查询条件都很快，估计不是因为有索引，而是采用高效的向量化运算，并且数据都在内存里的缘故。因为即使不用sqldf，直接对data.frame作判断查询，速度也不慢，而sqldf不过作了一个漂亮的sql包装。对于更大的数据集，要考虑到内存的占用。所以如果有一个或几个可以载入到内存的数据集（又或是一些临时的结果），想做一些简单的查询计算，用sqldf就可以很快地得到结果（而且语法很简洁）。当然前提是你必须得懂简单的SQL。

不足之处在于需要依赖tcltk，这是个图形相关的包，所以在非图形界面的服务器上不会被编译安装。其实很让人费解为什么需要依赖图形包。

更新：今天收到益辉同学发来R-dev邮件组的一篇讨论帖，说sqldf并非直接依赖tcltk，而是为了加快查询而依赖gsubfn，而gsubfn依赖tcltk的缘故。我查了一下这两个包的说明，确实如此。事实上，gsubfn并非一定得依赖tcltk，后者只是起一个加速的作用，所以开发者们也在考虑是否应该把gsubfn对tcltk的depend关系改为suggest关系。我很支持，因为我在gentoo服务器上装的R是不带X进行编译的，所以不能安装tcltk。

reference：http://www.wentrue.net/blog/?p=453

R package的最简单制作ZZ

2010-03-25T19:24:00.002-07:00

R的强大之处在于它包罗万有的包，几乎任何领域都可以从CRAN里找到你所需要的实现。

如果有一些功能你希望自己来实现，又或者是用别人的包用多了，希望自己做一个，那么这是一个简单的向导。可以告诉你怎么去制作一个最简单的R包，如果你需要用到复杂的功能，可以再深入地查看资料，我以后也会根据自己的实践深入写一写。

其实最原始最详尽的R包制作指南应该是官方文档＜Writing R extensions＞，但看过的人无一不觉得这是个累赘，它面面俱到地说了所有的事情，但令初学制作者无所适从。那么，摒弃里面的大部分内容，你真正需要的东西是这样的（以下说明基于linux平台，windows用户也可参考）：

准备工作指定两个目录，一个是工作目录mydir（/home/wentrue/work），一个是包目录mylib（如/home/wentrue/Rlibs）。前者是你写R代码、运行R console的地方，后者是安装包的地方。
默认情况下在mydir是找不到mylib下的包的，因为mylib不在包的搜索路径里，解决这个问题只需要在mydir新建一个文件.Rprofile文件，里面写上：.libPaths(“/home/wentrue/Rlibs”)即可。这样在mydir运行R脚本或启动R终端，mylib就会被添加到包搜索路径中。
添加目录与文件在mydir新建一个目录，名为once，作为包名。然后生成一些目录，目录树结构见下：

$ tree once
once
|– DESCRIPTION
|– R
| |– test.R
| `– zzz.R
|– data
|– man
`– src

目录说明：必需的是DESCRIPTION文件、man目录和R目录，剩下的都是可选的。DESCRIPTION文件描述包的meta信息，后面会有一个附例；R目录下面存放R脚本文件，里面的函数可导出作为包函数库提供给外部使用；如果要在包里放一些试验数据，可以放在data目录里，常用是以csv格式存放，在R终端里data(***)可以载入，这里留空；man目录是R的帮助文档，即?xxx时显示的那些，有一定的格式要求，这里也留空；src存放c/c++/fortran源代码，必须同时放置Makefile或Makevars文件指导编译程序工作，这里留空。
作为试验，我在test.R里写了一个简单的函数，内容见下，里面的oncetest函数在once被装载时就可以被R直接调用。

oncetest <- function(x, y)
{
return(x*y)
}

zzz.R可以在载入包时做一些事情，这里留空。
一个简单的包就这样做好了，是不是很简单。如果有其它需要，只要往R目录或src目录添加文件就可以了。
安装与试验（以下步骤都在mydir目录进行）运行R CMD check once，R会检查包看是否能正确安装（并未实际安装），如果不成功会返回ERROR，并有出错信息。这个实验里会有一些warning，是因为一些目录留空的缘故，不用管它。
运行R CMD build once，会生成一个once_0.1.tar.gz安装包，其中的数字是我在DESCRIPTION里写的版本号。
运行R CMD INSTALL -l /home/wentrue/Rlibs once_0.1.tar.gz，就可以把包安装到mylib里。
运行R，进入R终端；library(once)，载入刚制作的包；search()，可以看到once已经被载入。
在R终端运行oncetest(2,3)，返回6，试验成功。
附：我的DESCRIPTION文件内容

Package: once
Version: 0.1
Date: 2009-07-31
Title: Once Test
Author: Guozhu Wen
Maintainer: Guozhu Wen
Depends: R (>= 1.9.0)
Description: A Once Test Description
License: GPL version 2 or later

参考：http://www.maths.bris.ac.uk/~maman/computerstuff/Rhelp/Rpackages.html

补充：最典型的一个应用是，你已经积累下来一批自己写的常用的R函数，但又不想每次都一个个文件source进来，那么，把它们分类做成package吧，就可以像平常用其它package一样使用这些函数了，发布给别人用也方便得多。

reference：http://www.wentrue.net/blog/?p=395

R程序调试–DEBUG R

2010-03-25T19:24:00.001-07:00

1、browser(): 在脚本文件适当的位置插入browser()，重新载入模块，运行，程序会在该行中断。命令：n: step; c: continue; where: print the call back; q: quit; enter: last command；

2、traceback(): 运行最后的出错信息；

3、定义一个全局变量捕捉中间数据信息，比如一个全局变量a，可以在函数内a<<-***来给全局变量赋值；

4、设定options(warn=1)，即时提示warning信息，不设置则警告信息会在程序执行完毕之后才会输出；

5、try() 和tryCatch()是两个很好的处理error的函数；

6、warning()输出一个警告信息，stop()函数终止程序运行并退出，geterrmessage()得到最后一次出错信息

reference: http://www.wentrue.net/blog/?cat=45

VIM编辑R脚本配置ZZ

2010-03-25T19:20:00.000-07:00

我的R脚本通常用*.R作为后缀，用VIM编辑R文件时有时会无法正确检测出文件类型来，从而无法进行正确地颜色高亮。另外，默认的配置用来编辑R脚本也不够用，翻了翻资料，作了一些简单的配置。

在我的.vimrc文件里加了如下三行配置：

imap <-
autocmd FileType r set fdm=indent
au BufNewFile,BufRead *.R set ft=r

说明：

1、第一行是在“输入模式”下作了一个映射，把ctrl+b映射为” <- “这几个字符（指代空格符），因为R里推荐的赋值操作符是”<-”，打起来很麻烦，虽然我常用的是”=”，但有时还是用得上的。

2、第二行设定当文件类型是R时，把fdm这个option设置为indent，这样可以实现代码折叠，即按z+c就可以把大括号中间的部分折叠起来，编辑多函数的文件时非常方便。用:help可以查看到autocmd这个命令的定义为：autocmd [group] {event} {pattern} [nested] {cmd}，即在{event}事件触发时，如果文件名符合{pattern}模式，则执行{cmd}的命令。具体在这里就是当FileType r这个事件被触发时，执行set fdm=indent命令。

3、第三行的au是autocmd的缩写，功能完全一样。这里的定义是指：当BufNewFile,BufRead事件被触发时，如果文件名为*.R，则set ft=r，自动设定好FileType，这就实现了根据文件名后缀自动检测文件类型。其它文件后缀与文件类型的绑定也可以通过这种方法来实现。

4、说到文件类型的检测，还得补充几句，通常你需要默认打开文件类型检测，即设定filetype plugin indent on，可以在vim里输入:filetype查看是否已经开启。除了上述提到的在.vimrc中设定之外，还有两种方法可以设定文件类型，一种是在文件的开头或结尾加上” vim: ft=c “的注释，注意两边的空格，还有不同类型的文件有不同的注释方式；另一种方法是打开文件后直接通过:set ft=r来设定。

简简单单的三行配置就使得自己的工作环境大大改善，很强大吧。

Reference: http://www.wentrue.net/blog/?p=625

zgrep/grep pipeline

2009-12-03T15:36:00.000-08:00

Table:

Roosevelt Tommy 38 54579 555-1212

Nixon Edward 19 37583 246-3457

Roosevelt Freddie 47 11745 674-6972

Lincoln Albert 26 26452 916-5763

If you wanted to find all the Roosevelts and sort them by zip code, you could do it like this:


grep Roosevelt people.txt > grep.out
sort +3 grep.out
rm grep.out

Alternately,

grep Roosevelt people.txt | sort +3 > sort-results

Common Commands (beta, Sun Grid Engine)

2009-11-25T14:11:00.000-08:00

Please see the man pages for qsub, qalter, qstat, qdel, qhost.

qsub : submit a script for execution
qlogin : request a node for interactive use: see HPC:Using qlogin
qstat -j : show the status of a job
qdel : cancel a job
qstat -f : display all of your jobs queued or running
qhost -j : display which jobs are on which host
qstat -u : display jobs queued or running for a single user
qstat -f -u '*' : to see all jobs
qacct -b 200810010000 -e 200810020000 -o username : show your usage statistics between those dates
qsub -l mem_free=4G script.sh : request that there are at least 4GB RAM free on the node where your script will run

qsub script


#$ -cwd
#$ -N yourjobname
/usr/local/bin/R CMD BATCH
/.../gwa_hmm/codes/gwa_hmm_chop_Chr.R

with -cwd option, the output will be sent to current directory;
otherwise home directory

Vector for Array

2009-11-12T09:49:00.000-08:00

One way:

           vector< vector<int> > array(3);   //R(3)
              for(int   i=0;i<3;i++)   
                  array[i].resize(3);   //C(3)
                    
              for(int   i=0;i<3;i++)   
                  for(int   j=0;j<3;j++)   
                      array[i][j]=(i*j);   
             
              for(int   i=0;i<3;i++)   
              {   
                    for(int   j=0;j<3;j++)   
                        cout<<array[i][j]<<"   ";   
                    cout<<endl;   
                }
  
            array.resize(5);   //5*3
            array[3].resize(3);   
            array[4].resize(3);

Another way:

             int m = 5, n = 2, s = 2;
              vector < vector<int> > vecInt(m, vector<int>(n)); 
vector<vector<vector<int> > > dgamma(m,vector<vector<int> >(n,vector<int>(s)));

C++ way to convert from a double to an int

2009-11-04T10:01:00.001-08:00

The C++ way to convert from a double to an int is with static_cast:


int m;
double x;

m = static_cast<int>(x);

File input and output

2009-10-30T13:26:00.000-07:00

1 output:

       
        PrintWriter out = new PrintWriter(new FileWriter(output));
  for(int i=0; i<n; i++)
  {
   for(int j=0; j<n; j++)
   {
    out.print(array[i][j] + "\t");
   }
   out.println();
  }
  out.flush();
  out.close();

2 input:


BufferedReader in = new BufferedReader(new FileReader("input-A"));
  String line;
  String s;
  s=in.readLine();
  int n= Integer.parseInt(s);
  float[][] a=new float[n][n];
  
   for(int i=0; i<n; i++)
   {
    line=in.readLine();
    if(line==null) break;
    String[] tmp=line.split(" ");
    for(int j=0; j<n; j++)
    {      
     a[i][j] = Float.parseFloat(tmp[j]);
    }
   }

Java current directory

2009-10-30T12:48:00.000-07:00


public class Main
{
  public static void main(String[] args)
  {
    System.out.println("user.dir: " + System.getProperty("user.dir"));
  }
}

Convert int to string without itoa

2009-10-24T16:59:00.000-07:00


#include <iostream>
#include <sstream>

int main() {
  string s="section"
  int number = 123;

  std::stringstream ss;
  ss << s << number;

  std::cout << ss.str() << endl;
}

Call C from R

2009-10-21T21:07:00.001-07:00

http://cos.name/bbs/read.php?tid=14434&fpage=3

http://www.math.ncu.edu.tw/~chenwc/R_note/index.php?item=loop

C++ Algorithms: next_permutation()

2009-10-17T13:27:00.000-07:00


template 
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last) {
 if (first == last) return false; //空范围
 BidirectionalIterator i = first;
 ++i;
 if (i == last) return false; //只有一个元素
 i = last; 
 --i;
 for(;;) {
  BidirectionalIterator ii = i--; //相邻元素
  if (*i <*ii) { //如果前一个小
   BidirectionalIterator j = last;
   while (!(*i <*--j)); //从末尾找,直到遇上比*i大的元素
   iter_swap(i, j); //交换
   reverse(ii, last); //重排
   return true;
  }
  if (i == first) { //进行最前面了
   reverse(first, last);
   return false;
  }
 }
}

/* Once iterators i and ii have been properly located, there are still a few more steps left. The next step is to again start searching from the end of the sequence for the first member that is greater than or equal to the member pointed to by i. Because of the previous search for i and ii, we know that at worst the search will end at ii, but it might end earlier. Once this member is located, it is pointed to by iterator j.

Once these three iterators are located, there are only two more simple steps. First, a call is made to iter_swap( i, j ). This simply swaps the members pointed to by i and j. Finally, a call is made to reverse( ii, last ). This has the effect of reversing the sequence that starts at ii and ends at the end of the sequence. */

Reference: "http://marknelson.us/2002/03/01/next-permutation"

Random numbers - API

2009-10-09T11:42:00.000-07:00

1. java.util.Random class


import java.util.Random; // Only the Random class
Random r = new Random(); // Default seed comes from system time.
int i = r.nextInt(int n); //Returns random int >= 0 and < n
int i = r.nextInt();  //Returns random int (full range)

Example: Generating a number from 1 to 6

Because nextInt(6) returns a number from 0-5, it's necessary to add 1 to scale the number into the range 1-6,


static Random randGen = new Random();
int spots = randGen.nextInt(6) + 1;

2. Math.random() method

The Math.random() method returns random double numbers in the range >=0.0 to <1.0 .
For example, if you need an int int the range 1 to 10, the following code could be used.
int n = (int)(10.0 * Math.random()) + 1;

获得路径下的所有文件名

2009-09-19T13:49:00.002-07:00

#include “sys/types.h“
#include “dirent.h“
#include “stdio.h“

int main( int argc,char *argv[] )
{
   DIR   *dp;
   struct dirent *dirp;
   if( argc != 2 )
   {
      printf("error:need argument!\n");
      return 0;
   }
   if ( ( dp = opendir(argv[1]) ) == NULL )
   {
      printf("can't open dir %s\n",argv[1] );
      return 0;
   }
   while ( (dirp = readdir (dp)) != NULL )
   {
      printf("%s\n",dirp->d_name);
   }
   closedir(dp);
   return 0;
}

ThinkVantage的恢复

2009-08-24T17:07:00.000-07:00

你在系统里面装一下IBM的rescure and recovery，再装ThinkVantage Productivity Center就好了，前者是安装恢复系统，后者是在XP下ThinkVantage键激活，主要原因是你分区后，破坏了硬盘的主引导分区MBR。原来的MBR中保留着对thinkvantage键的相应，你重新分区后就没有了。

如果你的机器的隐藏分区还在，只是你按thinkvantage进不去了，恢复方法如下：

1、复制bmgr32.exe和bootmgr.bin（在隐藏分区里搜）到C盘根目录下，然后进入CMD，在C盘根目录下运行：bmgr32 /fc:bootmgr.bin /m2 /ibm，如果没有任何信息提示即运行完毕，恭喜你，可以恢复出厂设置了。

2、重新启动，按 Access IBM 后再按tinkvange或 F11 就能进入恢复出厂设置的界面了。。。

Vista home版管理员权限

2009-08-24T14:48:00.000-07:00

开始--程序--附件-命令提示符-右键(以管理员方式运行），在命令行状态下输入：
net user Administrator /Active:Yes （启用administrator帐户）
回车会出现成功字样，然后关闭，注销。

同样，当你想要禁用Windows Vista中的Administrator账户的时候，只需像上面一样操作，只不过最后在命令行中输入的是“net user Administrator /Active:no”罢了。

JTextPane的视返回

2009-06-03T01:10:00.000-07:00

在写记事本的时候发现，textpane.setCaretPosition和textarea.setCaretPosition有偏差（每行差1），而debug时getText的换行符都是'\r\n'，毫无差别。其实问题就出在怀疑的地方，因为textPane.getText()返回的String含'\r',并紧跟着一个'\n',但是这是视返回的，不是文档返回的，而文档只包含'\n',于是把

textPane.getText();换成
textPane.getDocument().getText(0, textPane.getDocument().getLength());

这样，不管有没有'\r'也都是对的啦,而textarea.setCaretPosition并不受到换行符的影响，不晓得为什么这样。

JTextPane Java关键字变色

2009-06-02T18:43:00.000-07:00

import java.util.StringTokenizer;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.text.rtf.RTFEditorKit;

public class MyTextPane extends JTextPane {

    protected StyleContext m_context;
    protected DefaultStyledDocument m_doc;
    private   MutableAttributeSet keyAttr,normalAttr;
    private   MutableAttributeSet inputAttributes =
                new RTFEditorKit().getInputAttributes();

 private String[] keyWord={"int","float"};

    public MyTextPane() {
        super();
        m_context = new StyleContext();
        m_doc = new DefaultStyledDocument(m_context);
        this.setDocument(m_doc);

        this.addKeyListener(new KeyAdapter() {
            public void keyReleased(KeyEvent ke) {
                syntaxParse();
            }
        });

//定义关键字显示属性
        keyAttr = new SimpleAttributeSet();
        StyleConstants.setForeground(keyAttr, Color.green);

//定义一般文本显示属性
        normalAttr = new SimpleAttributeSet();
        StyleConstants.setForeground(normalAttr, Color.blue);
    }

    public void syntaxParse() {
        try {
            String s = null;
            Element root = m_doc.getDefaultRootElement();

            int cursorPos = this.getCaretPosition();    
            int line = root.getElementIndex(cursorPos); 

            Element para = root.getElement(line);
            int start = para.getStartOffset();
            int end = para.getEndOffset() - 1;
            s = m_doc.getText(start, end - start);

            int i = 0;
            int xStart = 0;

//分析关键字---
            m_doc.setCharacterAttributes(start, s.length(),normalAttr, false);
            MyStringTokenizer st = new MyStringTokenizer(s);
            while( st.hasMoreTokens()) {
                s = st.nextToken();
                if ( s == null) return;
                for (i = 0; i < keyWord.length; i++ ) {
                    if (s.equals(keyWord[i])) break;
                }
                if ( i >= keyWord.length ) continue;

                xStart = st.getCurrPosition();

                //设置关键字显示属性
                m_doc.setCharacterAttributes(start+xStart, s.length(),
                                             keyAttr, false);
            }
            inputAttributes.addAttributes(normalAttr);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("test text pane");
        frame.getContentPane().add(new MyTextPane());
        WindowListener wndCloser = new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        };
        frame.addWindowListener(wndCloser);
        final int inset = 50;
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        frame.setBounds ( inset, inset, screenSize.width - inset*2, screenSize.height - inset*2 );
        frame.show();
    }
}

/*在分析字符串的同时，记录每个token所在的位置
*
*/
class MyStringTokenizer extends StringTokenizer{
    String sval = " ";
    String oldStr,str;
    int m_currPosition = 0,m_beginPosition=0;
    MyStringTokenizer(String str) {
        super(str," ");
        this.oldStr = str;
        this.str = str;
    }

    public String nextToken() {
       try {
           String s = super.nextToken();
           int pos = -1;

           if (oldStr.equals(s)) {
               return s;
           }

           pos = str.indexOf(s + sval);
           if ( pos == -1) {
               pos = str.indexOf(sval + s);
               if ( pos == -1)
                   return null;
               else pos += 1;
           }

           int xBegin = pos + s.length();
           str = str.substring(xBegin);

           m_currPosition = m_beginPosition + pos;
           m_beginPosition = m_beginPosition + xBegin;
           return s;
       } catch (java.util.NoSuchElementException ex) {
           ex.printStackTrace();
           return null;
       }
    }

   //返回token在字符串中的位置
   public int getCurrPosition() {
       return m_currPosition;
   }
}

出处：http://blog.csdn.net/raphaelxia/archive/2006/02/12/597465.aspx

Java定时器

2009-05-31T18:53:00.000-07:00

a,编写类,实现TimeTask接口，定时执行的代码写入run()方法中

class XXXTask extends TimerTask {
  public void run() {
   do something...
  }
 }

b. Timer timer = new Timer();
timer.schedule(TimeTask子类对象, 开始执行的Date, 毫秒周期);

JTABLE如何刷新数据

2009-05-23T03:50:00.001-07:00

需要在JTable中显示内容添加到javax.swing.table.DefaultTableModel类的对象中，使用javax.swing.JTable类中的void setModel(TableModel dataModel)方法，将DefaultTableModel的对象作为参数传入到setModel方法中即可。
e.g: table.setModel(new BookTableModel(...));

java读取文本文件(txt)

2009-05-23T03:48:00.000-07:00

public void ReadData(){ 
  try { 
   FileReader read = new FileReader("D:/data.txt"); 
   BufferedReader br = new BufferedReader(read); 
   String row; 
   while((row = br.readLine())!=null){ 
    System.out.println(row); 
   } 
  } catch (FileNotFoundException e) { 
   e.printStackTrace(); 
  } catch (IOException e){ 
   e.printStackTrace(); 
  } 
}

Java中split的反斜杠（“\”）问题

2009-05-23T03:45:00.000-07:00

在Java中处理一些路径相关的问题的时候，如：上传文件路径为：C:\Documents and Settings\My Documents\ww\桌面\map4.gif，欲取出文件名：map4.gif。可以

String temp[] = name.split("\\\\");
if (temp.length > 1) {
name = temp[temp.length - 1];
}

regex为\\\\，因为在java中\\表示一个\，而regex中\\也表示\，所以当\\\\解析成regex的时候为\\。

Java中UUID的使用

2009-03-19T18:07:00.000-07:00

UUID又称为通用唯一标识符(Universally Unique Identifier)，是一个128位长的数字，一般用16进制表示，算法的核心思想是结合机器的网卡、当前时间和一个随机数来生成 UUID。UUID的应用非常广泛，比如Hibernate中ID Generator中的一种实现就是UUID。在系统中需要用到随机数的地方都可以考虑采用UUID算法。

在Java1.5中，已经包含了一个UUID的实现java.util.UUID。要随机生成一个UUID，代码为：String uuid = UUID.randomUUID().toString();

如果系统中采用了Hibernate框架，也可以用Hibernate的UUIDHexGenerator。代码为：
String uuid = (String)new UUIDHexGenerator().generate(null, null);

JDBC

2009-03-19T00:38:00.000-07:00

一. 使用JDBC的五个步骤
1.注册driver
(1). Class.forName("oracle.jdbc.driver.OracleDriver");
Connection conn=DriverManager.getConnection(url,"kettas","19851127");
(2). Driver driver=new oracle.jdbc.driver.OracleDriver();
DriverManager.registerDriver(driver);
(3). java -Djdbc.drivers=xxxxxxxxxx
2.连接db
String url=” oracle:jdbc:thin:@127.0.0.1:1525:XE”;
Connection conn=DriverManager.getConnection(url,"kettas","19851127");

3.执行sql语句
Statement stm=conn.createStatement();
stm.execute(“sql”);
4.返回结果集
ResultSet rs=stm.executeQuery("select id,sid,name from students");
while(rs.next()) {
System.out.print(rs.getInt(1)+"\t");
System.out.print(rs.getInt(2)+"\t");
System.out.println(rs.getString(3));
System.out.println("--------------------");
}
5.释放资源
xxx.close();

二.Statement对象的三个execute方法
1. execute() 返回boolean,是否有结果集
stm. getResultSet()
2. executeQuery() 返回ResultSet
3.executeUpdate() 返回 int,影响的行数

三. PreparedStatement
同构的sql语句使用,有预编译
有变量的sql语句中简化书写
sql语句在oracle的执行过程
1.语法检查 2. 权限检查 3.转化sql语句为内部指令 ----编译
4.执行
PreparedStatement pstm = conn.preparedStatement(“insert into students values(1,?,?)”);
pstm.setString(1,变量 )
pstm.setString(2, 变量)
pstm.executeUpdate();

四. Connection工厂
package com.kettas.raiha;

import java.util.*;
import java.io.*;
import java.sql.*;

public class JDBCUtil {
private static Properties env=new Properties();
static {
InputStream is=JDBCUtil.class.getResourceAsStream("connection.properties");
try {
env.load(is);
} catch (IOException e) {
System.out.println("ERROR! Can't find file : connection.properties.");
throw new ExceptionInInitializerError(e);
} finally {
if(is!=null)try { is.close();} catch (IOException e) {e.printStackTrace();}
}
}

public static Connection getConnection() throws ClassNotFoundException, SQLException{
Connection conn=null;
try{
Class.forName( env.getProperty("driver") );
} catch (ClassNotFoundException e) {
System.out.println("Mabey connection.properties file error");
throw e;
}
conn=DriverManager.getConnection(env.getProperty("url"),env.getProperty("username"), env.getProperty("password"));
return conn;
}
/*
public static void main(String[] args) {
try {
JDBCUtil.getConnection();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
*/
}

ThreadLocal
保证线程中的对象唯一的方法;
每个线程中包含一个Map,以ThreadLoacal为key,用set()存值;
get()方法获得本线程中Map的值
t1 = new ThreadLocal();
t1.set( i ) ;
t1.get();

事物
conn.setAutoCommint(false);
conn.commint();
conn,rollback();

Log4j

2009-03-19T00:25:00.000-07:00

代码中:
1.得到Logger对象
Logger logger=Logger.getRootLogger();
Logger logger=Logger.getLogger(test.class);
2.读取配置
(1)使用默认配置:
BasicConfigurator.configure();
(2)读取配置文件
PropertyConfigurator.configure("mylog4j.properties");
3.插入记录信息
Logger.debug ( Object message ) ;
Logger.info ( Object message ) ;
Logger.warn ( Object message ) ;
Logger.error ( Object message ) ;

配置文件参考:
rootLogger
#其中level就是设置需要输出信息的级别，后面是appender的输出的目的
#log4j.rootLogger=[level],appenderName, ...，
log4j.rootLogger=debug, stdout, R

LEVEL
level是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。
Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG

appender

#配置日志信息输出目的地Appender
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
#配置日志信息的格式（布局）
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
#Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n
#配置另一个Appender:R
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log
log4j.appender.R.MaxFileSize= 100KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=1
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

Log4j提供的appender
org.apache.log4j.ConsoleAppender（控制台）
org.apache.log4j.FileAppender（文件）
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生新文件）
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

Log4j提供的layout
org.apache.log4j.HTMLLayout（以HTML表格形式布局）
org.apache.log4j.PatternLayout（可以灵活地指定布局模式）
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

log4j的PatternLayout参数含义
Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下：
%m 输出代码中指定的消息
%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
%r 输出自应用启动到输出该log信息耗费的毫秒数
%c 输出所属的类目，通常就是所在类的全名
%t 输出产生该日志事件的线程名
%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：
%d{yyy MMM dd HH:mm:ss,SSS}，输出类似： 2002年10月18日 22：10：28，921
%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。

一个比较全的配置文件例子
log4j.rootLogger=DEBUG,CONSOLE,DATABASE,FILE
log4j.addivity.org.apache=true

# 应用于控制台
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Threshold=INFO
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.Encoding=GBK
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 用于数据库
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.URL=jdbc:oracle:thin:@192.168.0.103:1521:ORCL
log4j.appender.DATABASE.driver=oracle.jdbc.driver.OracleDriver
log4j.appender.DATABASE.user=Nation
log4j.appender.DATABASE.password=1
log4j.appender.CONSOLE.Threshold=WARN
log4j.appender.DATABASE.sql=INSERT INTO LOG4J(stamp,thread, infolevel,class,messages) VALUES ('%d{yyyy-MM-dd HH:mm:ss}', '%t', '%p', '%l', '%m')
# INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
# 写入数据库中的表LOG4J的Message字段中，内容％d（日期）%c: 日志信息所在地（类名）%p: 日志信息级别%m: 产生的日志具体信息 %n: 输出日志信息换行
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 每天新建日志
log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A1.File=C:/log4j/log
log4j.appender.A1.Encoding=GBK
log4j.appender.A1.Threshold=DEBUG
log4j.appender.A1.DatePattern='.'yyyy-MM-dd
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L : %m%n

#应用于文件
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=C:/log4j/file.log
log4j.appender.FILE.Append=false
log4j.appender.FILE.Encoding=GBK
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 应用于文件回滚
log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
log4j.appender.ROLLING_FILE.Threshold=ERROR
log4j.appender.ROLLING_FILE.File=rolling.log
log4j.appender.ROLLING_FILE.Append=true
log4j.appender.CONSOLE_FILE.Encoding=GBK
log4j.appender.ROLLING_FILE.MaxFileSize=10KB
log4j.appender.ROLLING_FILE.MaxBackupIndex=1
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

#自定义Appender
log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender
log4j.appender.im.host = mail.cybercorlin.net
log4j.appender.im.username = username
log4j.appender.im.password = password
log4j.appender.im.recipient = yyflyons@163.com
log4j.appender.im.layout=org.apache.log4j.PatternLayout
log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

#应用于socket
log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
log4j.appender.SOCKET.RemoteHost=localhost
log4j.appender.SOCKET.Port=5001
log4j.appender.SOCKET.LocationInfo=true
# Set up for Log Facter 5
log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n
# Log Factor 5 Appender
log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000

# 发送日志给邮件
log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.From=yyflyons@163.com
log4j.appender.MAIL.SMTPHost=www.wusetu.com
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=yyflyons@126.com
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

Tomcat配置三点

2009-03-19T00:17:00.000-07:00

1. 如何加大tomcat连接数

在tomcat配置文件server.xml中的<Connector ... />配置中，和连接数相关的参数有：
minProcessors：最小空闲连接线程数，用于提高系统处理性能，默认值为10
maxProcessors：最大连接线程数，即：并发处理的最大请求数，默认值为75
acceptCount：允许的最大连接数，应大于等于maxProcessors，默认值为100
enableLookups：是否反查域名，取值为：true或false。为了提高处理能力，应设置为false
connectionTimeout：网络连接超时，单位：毫秒。设置为0表示永不超时，这样设置有隐患的。通常可设置为30000毫秒。

其中和最大连接数相关的参数为maxProcessors和acceptCount。如果要加大并发连接数，应同时加大这两个参数。

web server允许的最大连接数还受制于操作系统的内核参数设置，通常Windows是2000个左右，Linux是1000个左右。Unix中如何设置这些参数，请参阅Unix常用监控和管理命令

tomcat4中的配置示例：
<Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080" minProcessors="10" maxProcessors="1024"
enableLookups="false" redirectPort="8443"
acceptCount="1024" debug="0" connectionTimeout="30000" />

对于其他端口的侦听配置，以此类推。

2. tomcat中如何禁止列目录下的文件
在{tomcat_home}/conf/web.xml中，把listings参数设置成false即可，如下：
<servlet>
...
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
...
</servlet>

3. 如何加大tomcat可以使用的内存

tomcat默认可以使用的内存为128MB，在较大型的应用项目中，这点内存是不够的，需要调大。

Unix下，在文件{tomcat_home}/bin/catalina.sh的前面，增加如下设置：
JAVA_OPTS='-Xms【初始化内存大小】 -Xmx【可以使用的最大内存】'
需要把这个两个参数值调大。例如：
JAVA_OPTS='-Xms256m -Xmx512m'
表示初始化内存为256MB，可以使用的最大内存为512MB

大家都知道，JAVA程序启动时都会JVM都会分配一个初始内存和最大内存给这个应用程序。这个初始内存和最大内存在一定程度都会影响程序的性能。比如说在应用程序用到最大内存的时候，JVM是要先去做垃圾回收的动作，释放被占用的一些内存。
所以想调整Tomcat的启动时初始内存和最大内存就需要向JVM声明，一般的JAVA程序在运行都可以通过中-Xms -Xmx来调整应用程序的初始内存和最大内存:
如：java -Xms64m -Xmx128m a.jar.
tomcat的启动程序是包装过的，不能直接使用java -X..... tomcat.*来改变内存的设置。在Tomcat在改变这个设置
有两种方法：
1. 就需要在环境变量中加上TOMCAT_OPTS, CATALINA_OPTS两个属性，
如 SET CATALINA_OPTS= -Xms64m -Xmx512m;
ms是最小的，mx是最大，64m, 512m分别是指内存的容量.

2. 修改Catalina.bat文件
在166行“rem Execute Java with the applicable properties ”以下每行%_EXECJAVA% %JAVA_OPTS% %CATALINA_OPTS% %DEBUG_OPTS% -Djava.endorsed.dirs="%JAVA_ENDORSED_DIRS%" -classpath "%CLASSPATH%" -Dcatalina.base="%CATALINA_BASE%" -Dcatalina.home=" CATALINA_HOME%" -Djava.io.tmpdir="%CATALINA_TMPDIR%" %MAINCLASS% %CMD_LINE_ARGS% %ACTION% 中的%CATALINA_OPTS% 替换成-Xms64m -Xmx512m

中文乱码问题

2009-03-18T20:28:00.000-07:00

JSP设置

<%@ page language="java" contentType="text/html; charset=GB2312" pageEncoding="GB2312"%>

“contentType”中的”charset=GB2312”说明http头信息指定编码为gb2312,这样浏览器就会自动选择相应的编码; pageEncoding指的是jsp文件的编码,通常不涉及乱码问题

URLEncode
在url提交中文参数的时候,会进行urlencode,例如:

<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<form action="login.jsp">
姓名:<input type="text" name="username"/>
密码:<input type="text" name="password"/>
<input type="submit"></form>
<!--此jsp页面指定浏览器使用utf-8编码,我们输入”张三”,提交,浏览器的url为-->
<!-- http://xxxx/xxxx/login.action?username=%E5%BC%A0%E4%B8%89 -->

下面我们看看使用gb2312编码的情况:

<%@ page language="java" contentType="text/html; 
charset=gb2312"pageEncoding="utf-8"%>
<!-- 只改变charset的属性,jsp文件编码依然使用utf-8 --!>
<!-- url:http://xxxx/xxxx/login.action?username=%D5%C5%C8%FD -->

URL的encode与当前浏览器的编码选择有关,因此需要指定web服务器的URIEncoding,与浏览器编码匹配

设置Tomcat的URIEncoding

<Connector connectionTimeout="20000" port="8081" 
protocol="HTTP/1.1" redirectPort="8443" URIEncoding="GB2312"/>

Action里从Request得到参数

if( name!=null ){
name = new String( name.getBytes("ISO-8859-1"),"gbk");
}

等有空学学jQuery

2009-03-18T01:53:00.000-07:00

jQuery中文入门指南：
http://www.k99k.com/jQuery_getting_started.html

官网：http://jquery.com

参考：http://api.jquery.com/
http://visualjquery.com/

另：web前端的潮流：
http://www.smashingmagazine.com/