其实所谓Linux命令很难的说法，根源还是所学知识没有投产，你如果仅仅是玩玩linux命令，那么几个月后，你肯定会忘记一大半，你要思考那些牛人为什么开发这个工具，这肯定是有需求的，我觉得普通开发人员（像我这样的人）使用Linux就是因为在现实生活中会用到很多Linux的小工具，比如Linux下面的文本处理 awk，sed，等等，假设有一个需求：为一个文本日志文件加上行号（假设你是java程序员），你是不是打开eclipse（或许你是editplus）开始coding，no，其实你只需要awk完成这个任务，所谓牛人就是能熟练地运用所学知识，而不仅仅是一味的学习。

总之你不要惧怕，当然也千万不要认为会使用100多个Linux命令就能行走江湖了，你应该好高鹜远，看看 http://www.commandlinefu.com/commands/browse ，这样的网站。

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

这道题有一个陷阱,上面这个解法显然不是高效的，我从编程之美中学到一个思路，
就是通过比较字符串对应的ASCII码的和，来判断

public class CompareString{
    public static void main(String args[]){
       System.out.println(compare(args[0],args[1]));
    }
    public static boolean compare(String str1,String str2){
        char [] char1 = str1.toCharArray();
        char [] char2 = str2.toCharArray();
        if(char1.length != char2.length ){
            return false;
        }
        int sum1=0,sum2=0;
        for(char c:char1){
            sum1 = sum1+(int)c;
        }
        for(char c:char2){
            sum2 = sum2+(int)c;
        }
        if(sum1 == sum2){
            return true;
        }
        return false;
    }
}

</pre>

import java.io.*;
import java.util.*;
import java.lang.*;
/**
*   统计某一目录下每个文件中出现的字母个数、数字个数、空格个数及行数
*/
public class TextStatisticsMain{
    public static void main(String args[]){
        TextStatisticsMain tm = new TextStatisticsMain(args[0]);
        tm.print();
    }
    private List textStatistics = new ArrayList();
    private String rootPath;
    public TextStatisticsMain(String file){
        this.rootPath = file;
    }

    public void print(){
         statistics(new File(this.rootPath));
          System.out.println("==== Statistics ====");
          System.out.println("                     ");
        for(TextStatistics t:textStatistics){
            System.out.println("File: "+t.getFileName());
            System.out.println("letCount: "+ t.getLetCount());
            System.out.println("numCount: "+ t.getNumCount());
            System.out.println("spaceCount: "+t.getSpaceCount());
            System.out.println("lines: "+t.getLines() );
            System.out.println("----------------------------");
        }
    }
    private  void statistics(File file){
        if(file.isDirectory()){
        //是目录
            for(File f:file.listFiles()){
                statistics(f);
            }
        }else{
        //是文件
          try{
            FileReader fread = new FileReader(file);
            BufferedReader lnf = new BufferedReader(fread);
            String b;
            String fileName = file.getPath();
            int letCount=0, numCount=0,spaceCount=0, lines=0;
            while ((b = lnf.readLine()) != null) {
                lines++;
                for(char c:b.toCharArray()){
                  //对比ASCII码
                  if((int)c>=48 && (int)c<=57){
                  //是数字
                   numCount++;
                  }else if((int)c==32){
                  //空格
                    spaceCount++;
                  }else if((int)c>=65 && (int)c<=90){
                  //大写字母
                    letCount++;
                  }else if((int)c>=97 && (int)c<=122){
                  //小写字母
                    letCount++;
                  }
                }
            }
                textStatistics.add(new TextStatistics(fileName,letCount,numCount,spaceCount,lines));
            }catch(Exception e){
                System.out.println(e);
            }

        }
    }
}

public class TextStatistics{
    private String fileName;
    private int letCount;
    private int numCount;
    private int spaceCount;
    private int lines;
    public TextStatistics(String fileName,int letCount,int numCount,int spaceCount,int lines ){
        this.fileName=fileName;
        this.letCount=letCount;
        this.numCount=numCount;
        this.spaceCount=spaceCount;
        this.lines=lines;
    }
    public String getFileName(){
        return this.fileName;
    }
    public int getLetCount(){
        return this.letCount;
    }
    public int getNumCount(){
        return this.numCount;
    }
    public int getSpaceCount(){
        return this.spaceCount;
    }
    public int getLines(){
        return this.lines;
    }

}

2.现在一个表，有姓名、性别、年龄，字段分别为varchar(20),varchar(20),int，
现有表中已经有上百万条记录了，在姓名上建索引，现在有一个文本文件，已经格式化为姓名、性别、年龄，写一个函数，
怎么样一次性的将该文件中的数据以最快的速度导入到数据库中。
如有函数，实现该函数：
save(Connection c,File f)
{
//直接导入文件就行了,大概思路就是这样
Statement s = c.createStatement();
s.execute("LOAD DATA INFILE '"+f.getPath()+"' INTO TABLE tablename fields terminated by ',' lines terminated by '\n'");
}

man awk

详细看完这个简单的教程。
简单的说，awk是一个简单的动态解释性脚本语言，数值比较，控制流，循环，数组，这些语法基本上和C语言一样，所以我只需要了解awk独特的地方就行了。
awk是按行和列来处理输入，简单地说awk是按照table的样式处理数据，就像我们excel数据一样。
有如下的测试数据：

It hurts to love someone and not
But what is more painful is to love someone
and never find the courage to let that

awk解析数据为表格格式：

|It  |hurts |to   |love |someone |and |not
|But |what  |is   |more |painful |is  |to  |love |someone
|and |never |find |the  |courage |to  |let |that

同时保存测试数据为 test.txt
我们来点实例：
假如只输出第二列数据，可以在控制台中：

cat test.txt|awk '{print $1}'

或者

awk '{print $1}' < test.txt

输出:

hurts
what
never

这里只是展示了awk在命令行下的运用，在命令行下
执行 awk 'expression' ,其中 expression 就是awk的语句，上面的例子只是简单的输出，awk还可以在开始读入数据的前后，做一些处理，例如：

cat test.txt|awk 'BEGIN {print "--START--"} {print $0} END { print "--END--"}'

输出：

--START--
It hurts to love someone and not
But what is more painful is to love someone
and never find the courage to let that
--END--

这里的 BEGIN 和 END 是awk的特殊语法
大家看到这里可能就应该知道awk脚本几个特殊的地方，比如上文种出现的 $0 ,$2,还有print，这些代表什么含义，上文我们说了awk的按行和列处理数据的，所以这里的 $ 是变量前缀，$0 代表整行，$1,代表第一个字段，也就是按照分割符的第一列数据，$2,$3...类推，这些都是awk内嵌变量。

find . -name test.log

该命令是用于查找当前目录下名字为test.log的文件，当然你可以用正则来查找一类文件，

find . -name test＊.log

查找当前目录下名字为test开头，.log结尾的文件，比如test0.log,test1.log …
find还有很多有用的参数可选
当你找到一个文本文件后，你当然想看一下它了，如果文件不是很大，不到1M，你可以直接vi打开（vi的使用网上有很多的教程了），
但是如果文件太大，而且你也不想看文件的全部内容，那确实太多了，这时候你就需要用到head命令了

head -n 5 test.log

只看test.log文件的前5行
当然了Linux是一门艺术，如果你想看文件名以test开头的所有文件的第一行，可以这样：

head -1 test*

好吧，其实我很少用head这个命令，因为日志文件的写入都是在文件的最后，所以我更想看文件的最后几行

tail -n 1 test*

tail命令还有一个重要的功能，比如你想实时观察web服务器的访问日志，那么

tail -f -n 10 test.log

该命令会动态返回文件最后10行的变化.
我比较奇怪，我就是喜欢看浏览你们所有的东西，那么

cat test.log

cat命令是将文件的内容全部输出到标准输出上的（zcat 命令可以查看压缩包里面的所有文本文件），如果文件很多超过你的显示器，其实你只能看到一屏的显示，这时候，就得使用组合命令了，
很多时候，你其实在看日志文件的时候，往往会过滤掉无用的信息的（日志文件不是武侠小说），所以你会借助 grep这个命令来看你想看的内容，

cat test.log | grep "test"

该命令过过滤出文件中所有含有test的行，其中” | ” 是linux下的强大的管道命令，也是很有想象力的命令，借助它你可以写出外星人都无法理解却又神奇的命令组合。
我无聊，我就是喜欢拿日志文件当小说看，

cat test.log | more

more这个命令用于分页查看文件，可以单独使用，

 more test.log

如果每页只显示文件的一行，可以这样

 more -1 test.log

more也可以一次打开多个文件，当然个人觉得没什么用处，
与more相对的就是less命令，less是从文件的最后分页的。

上面总结的这几个简单的命令很多linuxer都应该很熟悉，这些命令主要还是用于肉眼查看分析。

/+ org.restlet.* （restlet API）
+ org.restlet.engine.* (restlet的一个默认实现)
+ org.restlet.example.*
+ org.restlet.ext.*
+ org.restlet.test.*

restlet源码中主要包括三个部分，核心API，引擎，和扩展。
2）核心API
restlet是构建http协议之上的，按照http://roy.gbiv.com/pubs/dissertation/rest_arch_style.htm实现,所以在restlet的API中很多类名都是完全按照论文所提到的概念来设计。
核心API主要分为以下一个包：

• Base package
• Data package（针对数据的抽象）
• Representation package（表示层的抽象）
• Resource package（资源的抽象）
• Routing package（请求路由）
• Security package（安全）
• Service package（服务）
• Util package

详细的API说明可以查看http://wiki.restlet.org/docs_2.0/13-restlet/27-restlet.html
目前对restlet框架的代码结构有了一个简单的认识后，我们来看看restlet到底做了哪些工作。
restlet就是实现了HTTP协议下对一个URL资源的访问，所以restlet必然要实现HTTP协议，然后将请求路由到指定的处理类上，过程就这么简单，现在我们就来看看核心API，这里需要引入大师的文字：

Uniform REST interface. “The central feature that distinguishes the REST
* architectural style from other network-based styles is its emphasis on a
* uniform interface between components. By applying the software engineering
* principle of generality to the component interface, the overall system
* architecture is simplified and the visibility of interactions is improved.
* Implementations are decoupled from the services they provide, which
* encourages independent evolvability.” Roy T. Fielding

大概意思就是说明：REST架构区别与其他基于网络的软件架构最重要的特点就是REST强调组件之间接口统一。
所以在restlet核心API中所有的类都继承org.restlet.Uniform这个接口。

Uniform接口中只有一个handle方法，注意到Restlet这个类是一个抽象类，在restlet的wiki中说到，Restlet设计成抽象类完全是为了API设计，因为大家都知道，如果想更改一个接口，那么对他的实现影响会很大，如果有什么新特性需要添加，可以在这个抽象类中进行，这样不会直接影响到实现类,所以Restlet仅仅是一个抽象类，而没有提供抽象方法，这也是设计中的一个很好实践。

简介： 具象状态传输（Representational state transfer，REST）是设计基于命名资源而非消息的松耦合应用程序的一种风格。构建 RESTful 应用程序的最困难的部分在于确定要公开哪些资源。解决了这个问题之后，再使用开源 Restlet 框架构建 RESTful Web 服务就是小菜一碟了。本教程从 REST 的基本概念开始，逐步指导您使用 Restlet 框架构建应用程序。

IBM上有针对REST规范的详细描述，本文只针对Restlet框架的解读。
在REST实现框架中，restlet算是比较老牌，目前支持REST规范的框架有：
restlet: http://www.restlet.org/
cetia4：http://www.acsinet-solutions.com/en/cetia4/
axis2：http://axis.apache.org/axis2/java/core/（更多的还是面向SOAP / WSDL ）
sqlrest：http://sqlrest.sourceforge.net/
rest-art：http://rest-art.sourceforge.net/（貌似已经没有更新了）
serfj：http://serfj.sourceforge.net/
resteasy：http://www.jboss.org/resteasy/
这里只是简单罗列了一些，如果想了解更多，可以到http://www.oschina.net/上找找。
上面罗列的这些框架，目前有强大团队支持的就restlet和resteasy，定期发布版本，有比较完善的wiki。
个人只对restlet有过深入使用，其他框架只有肤浅的认识，不过在后续的解读中，尽量将restlet与另外一款流行的REST框架对比。
解读Restlet之前，先下载Restlet源码:

svn co http://restlet.tigris.org/svn/restlet restlet

[2011-01-27 18:24:35] 415615 [resin-tcp-connection-*:10002-8] INFO impl.AbstractController  - Controller has been stopped.
[2011-01-27 18:24:35] java.io.IOException: Too many open files
[2011-01-27 18:24:35] 	at sun.nio.ch.EPollArrayWrapper.epollCreate(Native Method)
[2011-01-27 18:24:35] 	at sun.nio.ch.EPollArrayWrapper.(EPollArrayWrapper.java:68)
[2011-01-27 18:24:35] 	at sun.nio.ch.EPollSelectorImpl.(EPollSelectorImpl.java:52)
[2011-01-27 18:24:35] 	at sun.nio.ch.EPollSelectorProvider.openSelector(EPollSelectorProvider.java:18)
[2011-01-27 18:24:35] 	at java.nio.channels.Selector.open(Selector.java:209)
... ...

问题显然是处在epoll上，最后修改了一下系统参数：
echo “1024″ > /proc/sys/fs/epoll/max_user_instances
echo “1306071″ > /proc/sys/fs/epoll/max_user_max_user_watches