Strings

This topic simply shows several things that can be done with strings. It is not exhaustive and focusses of things that cannot as easily be done with java strings.

Note: Because I am using Scala 2.7 we often need to use mkString to convert the processed string from a sequence of characters to a string. In scala 2.8 this is not required.

1. /*
2.    Making use of raw strings to create a multi line string
3.    I add a | at the beginning of each line so that we can line up the quote nicely 
4.    in source code then later strip it from the string using stripMargin
5. */
6. scala> val quote = """|I don-t consider myself a pessimist.                                                                                                
7.      |                |I think of a pessimist as someone who is waiting for it to rain.
8.      |                |And I feel soaked to the skin.
9.      | 
10.      |                |Leonard Cohen"""
11. quote: java.lang.String = 
12. |I don-t consider myself a pessimist. 
13.                       |I think of a pessimist as someone who is waiting for it to rain.
14.                       |And I feel soaked to the skin.
15.        
16.                       |Leonard Cohen
19. // capilize the first character of each line
20. scala> val capitalized = quote.lines.
21.      |                         map( _.trim.capitalize).mkString("\n")
22. capitalized: String = 
23. |I don-t consider myself a pessimist.
24. |I think of a pessimist as someone who is waiting for it to rain.
25. |And I feel soaked to the skin.
27. |Leonard Cohen
29. // remove the margin of each line
30. scala> quote.stripMargin        
31. res1: String = 
32. I don-t consider myself a pessimist. 
33. I think of a pessimist as someone who is waiting for it to rain.
34. And I feel soaked to the skin.
35.        
36. Leonard Cohen
38. // this is silly.  I reverse the order of each word but keep the words in order
39. scala> quote.stripMargin.         
40.      |       lines.               
41.      |       map( _.split(" ").   
42.      |              map(_.reverse).
43.      |              mkString (" ")).
44.      |      mkString("\n")
45. res16: String = 
46. I t-nod redisnoc flesym a .tsimissep
47. I kniht fo a tsimissep sa enoemos ohw si gnitiaw rof ti ot .niar
48. dnA I leef dekaos ot eht .niks
50. dranoeL nehoC
52. scala> val myPatch = "-->This is my patch<--"                
53. myPatch: java.lang.String = -->This is my patch<--
55. // I replace the characters from point 10 in the string to myPatch.length 
56. // (the full patch string)
57. scala> quote.patch(10, myPatch, myPatch.length).mkString     
58. res21: String = 
59. |I don-t c-->This is my patch<--mist.
60.                       |I think of a pessimist as someone who is waiting for it to rain.
61.                       |And I feel soaked to the skin.
62.        
63.                       |Leonard Cohen
65. // drop the first 3 lines of the string.  
66. // there is also a take method
67. scala> quote.lines.drop(3).mkString("\n").stripMargin 
68. res25: String = 
69.        
70. Leonard Cohen
72. // a bunch of examples of converting strings
73. scala> "1024".toInt
74. res26: Int = 1024
76. scala> "1024".toFloat
77. res27: Float = 1024.0
79. scala> "1024".toDouble
80. res28: Double = 1024.0
82. scala> "1024".toLong  
83. res29: Long = 1024
85. scala> "102".toByte 
86. res31: Byte = 102
88. scala> "true".toBoolean
89. res32: Boolean = true
91. // format uses the java.util.Formatter class to format a string
92. scala> "Hello %s,\nThe date is %2$tm %2$te,%2$tY".format("Jesse", new java.util.Date()) 
93. res35: String = 
94. Hello Jesse,
95. The date is 09 30,2009
97. /*
98.    More silliness
99.    I am replacing every other character with the character of the reversed string
100.   
101.    this is done by 
102.    1. convert string to a list and zip it together with its reverse
103.       We may still need to cover zipping.  It basically matches up the 
104.       corresponding elements of two lists into one list
105.       so 1,2,3 and one,two,three zipped would be (1,one),(2,two),(3,three)
106.    2. Add an index to each element in the list with zipWithIndex
107.    3. Use map to check if the element is an odd element using the index and return either the original element or the reversed element
108.   
109.    Not useful but interesting use of functional idioms
110. */
111. scala> quote.toList.                                          
112.      |       zip(quote.reverse.toList).                       
113.      |       zipWithIndex.                                    
114.      |       map {                                            
115.      |            case ((original,reversed),index) if(index % 2 == 0) => original
116.      |            case ((original,reversed),index) => reversed                   
117.      |           }.                                                              
118.      |       mkString                                                            
119. res42: String = |e oo -r noes|d r m s l     e s m s .        . i s e t o   e|a shlne  f anp|s i i t a   o e n   h  .siwrioi gifrrfig ioirwis.  h   n e o   a t i i s|pna f  enlhs a|e   o t e s i .        . s m s e     l s m r d|seon r- oo e|
121. // filter out all non-vowels
122. scala> quote.filter( "aeiou" contains _ ).mkString
123. res51: String = ooieeaeiiioaeiiaoeoeoiaiioioaieeoaeoeieoaoe