构造字符串字面量

方法一：
最简单的使用单引号或者双引号括起来的字符串，比如"hello"。

方法二：
使用%q配合分界符，%q代表单引号
str=%q!he/lo!

方法三：
使用%Q配合分界符，%Q代表双引号
str=%Q{he/lo}

方法四：
here document构建字符串，该方法比较适合用于多行字符串的创建。由<<和边界字符串作为开头，由边界字符串作为结尾，比如下列代码：
str = <<END_OF_STRING1
  We are here now,
  where are you?
END_OF_STRING1
puts str
输出结果为：
  We are here now,
  where are you?

较为复杂的是允许多个边界字符串对出现。
str = <<END_OF_STRING1,<<END_OF_STRING2
  We are here now,
  where are you?
END_OF_STRING1
  I will leave now,
  would you like to go with me?
END_OF_STRING2

puts str
输出结果为：
  We are here now,
  where are you?
  I will leave now,
  would you like to go with me?

连接字符串

    + 连接。ruby的+操作符不会将其右侧操作数自动转为字符串，你必须亲自动手:

planet_number=5
"hello planet #" + planet_number.to_s # to_s converts to str

在ruby中，采用字符串内插通常要比采用+操作符连接简单一些。在字符串内插时，对to_s的调用是自动进行的:
"hello planet ##{planet_number}"

字面量与copy-on-write技术

在Java中，如果两个String对象a和b的值都是"abcdef",如下：
String a="abcdef";
String b="abcdef";
那 么，JVM只会创建一个常量对象"abcdef",让a和b都指向它。但是在ruby中，采用了智能指针（熟悉c++的朋友清楚）的一个高级技术 copy-on-write，一开始也是共享同一个字符常量，但是一旦之后某个对象（比如b对象)进行了修改操作，则"abcdef"将产生一个副本，b 的修改操作在这个副本上进行。
更详细的讨论请参考http://developer.51cto.com/art/200811/98630.htm。

和Java的一些其他区别
Java的String每次执行修改操作，都不会改变自身，而是创建一个新的String对象，而Ruby每次的修改操作都会修改自身。

计算长度

           puts "hello".length

访问字符和子字符串访问某个元素时返回的有由单个字符组成的字符串。
s="hello"
s[0] # "h"
s[s.length-1]
重点：
如果你试图访问一个超出了字符串末尾的字符，ruby不会抛出异常，只是简单的返回nil。

赋值:
赋值右侧可以是任意一个字符串，既可以包含多字符，也可以是空字符。
irb(main):067:0> s="hello"
=> "hello"
irb(main):068:0> s[-1]="abc"
=> "abc"
irb(main):069:0> s
=> "hellabc"
irb(main):070:0>

s[-s.length]等于s[1]

s[s.length]等于nil

获取子串：
方括号中使用有两个都好分割的操作数，第一个指定index（可以为负的），第二个指定长度值（必须非负）。

s = "hello"
s[0,2] # "he"
s[-1,1] # "o": returns a string, not the character code ?o
s[0,0] # "": a zero-length substring is always empty
s[0,10] # "hello": returns all the characters that are available
s[s.length,1] # "": there is an empty string immediately beyond the end
s[s.length+1,1] # nil: it is an error to read past that
s[0,-1] # nil: negative lengths don‘t make any sense

删除：
赋值非空字符串相当于删除。相应第，如果左侧的长度值为0，那么相当于插入：

s = "hello"
s[0,1] = "H" # Replace first letter with a capital letter
s[s.length,0] = " world" # Append by assigning beyond the end of the string 增加
s[5,0] = "," # Insert a comma, without deleting anything
s[5,6] = "" # Delete with no insertion; s == "Hellod"

Another way to extract, insert, delete, or replace a substring is by indexing a string
with a Range object. We’ll explain ranges in detail in §3.5 later. For our purposes here,
a Range is two integers separated by dots. When a Range is used to index a string, the
return value is the substring whose characters fall within the Range:

s = "hello"
s[2..3] # "ll": characters 2 and 3
s[-3..-1] # "llo": negative indexes work, too
s[0..0] # "h": this Range includes one character index

s[0...0] # "": this Range is empty
s[2..1] # "": this Range is also empty
s[7..10] # nil: this Range is outside the string bounds
s[-2..-1] = "p!" # Replacement: s becomes "help!"
s[0...0] = "Please " # Insertion: s becomes "Please help!"
s[6..10] = "" # Deletion: s becomes "Please!"

Don’t confuse string indexing with two comma-separated integers with this form that
uses a single Range object. Although both involve two integers, there is an important
difference: the form with the comma specifies an index and a length; the form that uses
a Range object specifies two indexes.

还可以用一个字符串来索引另一个字符串。

It is also possible to index a string with a string. When you do this, the return value is
the first substring of the target string that matches the index string, or nil, if no match
is found. This form of string indexing is really only useful on the lefthand side of an
assignment statement when you want to replace the matched string with some other
string:
s = "hello" # Start with the word "hello"
while(s["l"]) # While the string contains the substring "l"
 s["l"] = "L"; # Replace first occurrence of "l" with "L"
end # Now we have "heLLo"
Finally, you can index a string using a regular expression. (Regular expression objects
are covered in §9.2.) The result is the first substring of the string that matches the
pattern, and again, this form of string indexing is most useful when used on the
lefthand side of an assignment:
s[/[aeiou]/] = ‘*‘ # Replace first vowel with an asterisk

对字符串进行迭代

更多：

http://blog.csdn.net/csfreebird/article/details/4646140