public String getRandomAlphabetic(int count) {
            count = count <= 0 ? 5 : count; //默认为5
            //构建一个包含所有英文字母的字符串
            String alphabet="abcdefghijklmnopqistuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
            StringBuffer sb = new StringBuffer(count);
            for (int i = 0; i < count; i++) {
                int character=(int)(Math.random()*26);
                sb.append(alphabet.substring(character, character+1));
            }
            return sb.toString();
    }

    def random_alphabetic(size=5)
            chars = ('a'..'z').to_a + ('A'..'Z').to_a # 构建一个从a到Z的一个字母表数组
           (0...size).collect { chars[rand(chars.length)] }.join # 从chars数组中返回指定长度的随机字符数组（默认5个），调用join方法，将这个数组中的所有元素连接成一个字符串
    end

    data =<<-EOF
    {
    "order_id": "xxx-xxxxx-xxx",
    "books": [
        {"ISBN": "2323-2323", "number": 2, "price": 20.00},
        {"ISBN": "2323-2324", "number": 3, "price": 30.00},
        {"ISBN": "2323-2325", "number": 2, "price": 20.00},
        {"ISBN": "2323-2326", "number": 3, "price": 30.00},
        {"ISBN": "2323-2327", "number": 2, "price": 20.00}
      ]
    }
    EOF         # 该数据为json格式的一段字符串

    order = JSON.parse(data)
    p order['books'][0]['ISBN'] #=> 2323-2323 

   # 这是一段注释
    puts 'Hello, World !' #打印Hello, World!这个字符串，相当于Java中的System.out.println
    ('a'..'z')  #声明一个a到z的range类型的数据，range表示一个连续的范围，当然也可以是一段连续的数字
    ('a'..'z').to_a #简单调用方法to_a将一个range类型的数据转换成一个数组

    <<-EOF
    ...
    EOF  # Ruby通过配对EOF的方式声明一个多行的字符串

    [1,2,3,4,5] #声明一个数组
    [..].each {|it| puts it } #通过each方法遍历每个元素，其中{...}表示一个代码块，在这里的语义是在遍历每个元素时打印这个元素，其中it是隐式声明的参数，表示当前被遍历到的元素
    对于数组可以用select, find, collect等方法遍历，用<<, push, pop, delete等方法改变数组里的元素

    h = {'id'=>'1', 'name'=>'foo', 'age'=>24} #简单声明一个Hash
    h['name'] = 'bar' #对key为name的条目赋值
    h['age'] #24

    class Foo < Base #通过class关键字声明一个类，‘< Base’表示从基类Base继承
        @name     #声明一个实例变量
        @@count  #声明一个类变量，相当于Java中static关键字修饰的变量
    end

    require 'java'                    #引入对Java的支持
    import 'java.util.ArrayList'   #导入需要的某个包

    list = ArrayList.new           #创建一个ArrayList
    [1,2,3,4,5].to_java           #将Ruby类型转成对应的Java类型

<plugins>

        ...

        <plugin>

            <groupId>org.jtestr</groupId>

            <artifactId>jtestr</artifactId>

            <version>0.3.1</version>

            <configuration>

                <!-- Ruby测试文件所在目录 -->

                <tests>src/test/ruby</tests>

            </configuration>

            <executions>

                <execution>

                    <goals>

                        <goal>test</goal>

                    </goals>

                </execution>

            </executions>

        </plugin>

        ...

    </plugins>

    class MyFirstJRubyTests < Test::Unit::TestCase
        def test_true
            assert true
        end
    end

    [INFO] [jtestr:test {execution: default}]

    Other TestUnit: 1 tests, 0 failures, 0 errors

    public interface KeywordFilterService {
        //过滤访客评论字符串数组，返回一个新的不包含敏感关键字的结果
        String[] filter(String[] comments);
        //获取被过滤的访客评论
        String[] getFiltedComments();
    }

    require 'test/unit'

    class KeywordFilterServiceTest < Test::Unit::TestCase
        def setup
            @keywords = %w{X XX XXX XXXX XXXXX XXXXXX XXXXXXX} #不用加引号，更方便
        end
        def test_filter
            
        end
    end

        def random_alphabetic(size=5)
            chars = ('a'..'z').to_a + ('A'..'Z').to_a
            (0...size).collect { chars[rand(chars.length)] }.join
        end
       
        def random_comments
            comments ||= []
            10.times do
                keyword = rand(10) % 3 == 0 ? ' ' : @keywords[rand(@keywords.length)] #随机决定是否包含关键字
                comment = random_alphabetic + keyword + random_alphabetic
                comments << comment
            end
            return comments
        end

    import 'com.alisoft.research.JRuby.service.KeywordFilterServiceImpl'

        def test_filter
            comments = random_comments
            service = KeywordFilterServiceImpl.new(@keywords.to_java :String)
            filted = service.filter(comments.to_java :String)

            forbiddens = service.getFiltedComments
           
            assert forbiddens.length == comments.length - filted.length
            assert_equal forbiddens.sort, (comments - filted).sort
        end

    [INFO] [jtestr:test {execution: default}]

    Other TestUnit: 2 tests, 0 failures, 0 errors

    Ruby:
    require 'test/unit'

    import 'com.alisoft.research.JRuby.service.KeywordFilterServiceImpl'

    class KeywordFilterServiceTest < Test::Unit::TestCase
        def setup
            @keywords = %w{X XX XXX XXXX XXXXX XXXXXX XXXXXXX}
        end
       
        def test_filter
            comments = random_comments
            service = KeywordFilterServiceImpl.new(@keywords.to_java :String)
            filted = service.filter(comments.to_java :String)

            forbiddens = service.getFiltedComments
           
            assert forbiddens.length == comments.length - filted.length
            assert_equal forbiddens.sort, (comments - filted).sort
        end
       
        def random_alphabetic(size=5)
            chars = ('a'..'z').to_a + ('A'..'Z').to_a
            (0...size).collect { chars[rand(chars.length)] }.join
        end
       
        def random_comments
            comments ||= []
            10.times do
                keyword = rand(10) % 3 == 0 ? ' ' : @keywords[rand(@keywords.length)]
                comment = random_alphabetic + keyword + random_alphabetic
                comments << comment
            end
            return comments
        end
    end

    Java:
    package com.alisoft.research.JRuby.test;

    import static org.junit.Assert.assertArrayEquals;
    import static org.junit.Assert.assertEquals;

    import Java.util.ArrayList;
    import Java.util.Arrays;
    import Java.util.List;

    import org.apache.commons.lang.RandomStringUtils;
    import org.apache.commons.lang.math.RandomUtils;
    import org.junit.Test;

    import com.alisoft.research.JRuby.service.KeywordFilterServiceImpl;

    public class KeywordFilterServiceTest {

        @Test
        public void testFilteredResults() {
            String[] comments = getRandomComments();

            KeywordFilterServiceImpl service = new KeywordFilterServiceImpl(
                    getKeywords());

            String[] filted = service.filter(comments);
            String[] forbiddens = service.getFiltedComments();

            assertEquals(filted.length + forbiddens.length, comments.length);

            assertArrayEquals(forbiddens, sub(comments, filted));
        }
        //实现减法操作
        private String[] sub(String[] all, String[] part) {
            List allList = new ArrayList(Arrays.asList(all));
            allList.removeAll(Arrays.asList(part));
            return allList.toArray(new String[allList.size()]);
        }

        private String[] getRandomComments() {
            String[] comments = new String[RandomUtils.nextInt(10)];
            for (int i = 0; i < comments.length; i++) {
                String comment = RandomStringUtils.randomAlphabetic(5);
                String keyword = RandomUtils.nextBoolean() ? getKeywords()[RandomUtils
                        .nextInt(getKeywords().length)]
                        : "";
                comment += keyword + RandomStringUtils.randomAlphabetic(5);
                comments[i] = comment;
            }
            return comments;
        }

        private String[] getKeywords() {
            String[] keywords = new String[] { "X", "XX", "XXX", "XXXX",
                    "XXXXX", "XXXXXX", "XXXXXXX" };
            return keywords;
        }

    }