Scala练习九

1. 编写一小段Scala代码，将某个文件中的行倒转顺序，将最后一行作为第一行,依此类推程序代码:import scala.io.Source
import java.io.PrintWriter
 
object ReverseLines extends App {
  val filename="File.txt"
  val RefileName="ReverseFile.txt"
 
  val source=Source.fromFile("src\\"+filename)
  lazy val ReSource=Source.fromFile("src\\"+RefileName)
  lazy val pw = new PrintWriter("src\\"+RefileName)
 
  val linesIterator=source.getLines()
  val linesRecord=linesIterator.toArray
  val reverseRecord=linesRecord.reverse
 
  reverseRecord.foreach {
    line =>pw.write(line+"\n")
  }
  pw.close()
 
  println(filename+"文件内容如下:")
  linesRecord.foreach (line=>println(line))
 
  println(RefileName+"文件内容如下:")
  ReSource.getLines().foreach(line=>println(line))
}
运行结果:File.txt文件内容如下:Inc said they plan to form a venture to manage the money market
borrowing and investment activities of both companies.
BP North America is a subsidiary of British Petroleum Co
Plc <BP>, which also owns a 55 pct interest in Standard Oil.
The venture will be called BP/Standard Financial Trading
and will be operated by Standard Oil under the oversight of a
joint management committee.
ReverseFile.txt文件内容如下:joint management committee.
and will be operated by Standard Oil under the oversight of a
The venture will be called BP/Standard Financial Trading
Plc <BP>, which also owns a 55 pct interest in Standard Oil.
BP North America is a subsidiary of British Petroleum Co
borrowing and investment activities of both companies.
Inc said they plan to form a venture to manage the money market
2. 编写Scala程序，从一个带有制表符的文件读取内容，将每个制表符替换成一组空格，使得制表符隔开的n列仍然保持纵向对齐，并将结果写入同一个文件程序代码:object TabSpace extends App{
  val FileName="TabSpace"
  val path="src\\"+FileName+".txt"
  val linesIterator=Source.fromFile(path).getLines()
  lazy val TabIterator=Source.fromFile(path).getLines()
  val linesRecord=linesIterator.toArray
  lazy val pw=new PrintWriter(path)
  println(FileName+"文件内容如下:")
  linesRecord.foreach(println)
  linesRecord.foreach {
    line =>pw.write(line.replaceAll("\t", "")+"\n")
  }
  pw.close
  println("替换后"+FileName+"文件内容如下:")
  TabIterator.foreach(println)
 
}
运行结果:TabSpace文件内容如下:Inc    said    they    plan    to    form    a    venture    to    manage    the    money    market
Inc    ssss    adfs    sdjf    sd    dskl    s    jdakwus    sd    sdskkl    sds    sdsds    djslkl
Inc    said    they    plan    to    form    a    venture    to    manage    the    money    market
Inc    ssss    adfs    sdjf    sd    dskl    s    jdakwus    sd    sdskkl    sds    sdsds    djslkl
Inc    said    they    plan    to    form    a    venture    to    manage    the    money    market        
替换后TabSpace文件内容如下:Inc said they plan to form a venture to manage the money market
Inc ssss adfs sdjf sd dskl s jdakwus sd sdskkl sds sdsds djslkl
Inc said they plan to form a venture to manage the money market
Inc ssss adfs sdjf sd dskl s jdakwus sd sdskkl sds sdsds djslkl
Inc said they plan to form a venture to manage the money market
3. 编写一小段Scala代码，从一个文件读取内容并把所有字符数大于12的单词打印到控制台。如果你能用单行代码完成会有额外奖励程序代码：object CheckString extends App{
  val FileName="CheckString"
  val path="src\\"+FileName+".txt"
  println(FileName+"文件中长度大于12的字符串为:")
  io.Source.fromFile(path).mkString.split("\\s+").foreach (str => if(str.length()>12) println(str))
}
运行结果：CheckString文件中长度大于12的字符串为:
Incsaidtheyplan
jdakwussdsdskkl
managethemoneymarket
dsklsjdakwussdsdskkl
venturetomanagethe
4. 编写Scala程序，从包含浮点数的文本文件读取内容，打印出文件中所有浮点数之和，平均值，最大值和最小值程序代码：object ReadNumber extends App{
  val pattern="(\\d+[.]\\d+)".r
  val pattern1="^\\d+(\\.\\d+)?".r
  val pattern2="[0-9]+(\\.\\d+)?".r
  val FileName="NumberFile"
  val path = "src\\"+FileName+".txt"
  val FileStr=io.Source.fromFile(path).mkString
  val StrArray=pattern2.findAllIn(FileStr).toArray
  var total=0d
  val len=StrArray.length
  StrArray.foreach (total +=_.toDouble)
  println("文本中浮点数总和: "+total)
  println("文本中浮点数平均数: "+total/len+len)
  println("文本中浮点数的最大值: "+StrArray.max)
  println("文本中浮点数的最大值: "+StrArray.min)
}
测试数据：joint    55    666.0    management    13.5    committee    12.5
joint    6.0    123.4    management    3.14    committee    170.5
joint    52    63.32    management    10.4    committee    12.5
运行结果：文本中浮点数总和: 1188.26
文本中浮点数平均数: 99.0216666666666612
文本中浮点数的最大值: 666.0
文本中浮点数的最大值: 10.4
5. 编写Scala程序，向文件中写入2的n次方及其倒数，指数n从0到20。对齐各列:1 12 0.54 0.25... ...程序代码：import java.io.PrintWriter
 
object index extends App{
  val FileName="Index"
  val path="src\\"+FileName+".txt"
  val out=new PrintWriter(path)
  for (i <- 0 to 20)
    out.println(OutIndex(i))
  out.close
  def OutIndex(n:Int)={
    val value=math.pow(2, n)
    ""*4+value.toInt+""*(11-value.toString().size)+math.pow(2, -n)
  }
}
运行结果：1 1.0
2 0.5
4 0.25
8 0.125
16 0.0625
32 0.03125
64 0.015625
128 0.0078125
256 0.00390625
512 0.001953125
1024 9.765625E-4
2048 4.8828125E-4
4096 2.44140625E-4
8192 1.220703125E-4
16384 6.103515625E-5
32768 3.0517578125E-5
65536 1.52587890625E-5
131072 7.62939453125E-6
262144 3.814697265625E-6
524288 1.9073486328125E-6
1048576 9.5367431640625E-7
6. 编写正则表达式，匹配Java或C++程序代码中类似"like this，maybe with \" or\\"这样的带引号的字符串。编写Scala程序将某个源文件中所有类似的字符串打印出来描述：没看太懂，按自己意思来的程序代码：import scala.io.Source
 
object regExp extends App{
  val FileName="Regexp"
  val path="src\\"+FileName+".txt"
  val pat1=""""like this，maybe with \\" or\\{2}"""".r
  val pat2="""like this，maybe with \\" or\\{2}""".r
  val pat3="""\w+\s+\\"""".r
  val linesIterator1=Source.fromFile(path).getLines()
  val linesIterator2=Source.fromFile(path).getLines()
  val linesIterator3=Source.fromFile(path).getLines()
  println("文本中包含:"+""""like this，maybe with \" or\\"""")
  linesIterator1.foreach(line=>pat1.findAllIn(line).foreach (println))
  println("文本中包含:"+"""like this，maybe with \" or\\""")
  linesIterator2.foreach(line=>pat2.findAllIn(line).foreach (println))
  println("文本中包含:"+"\\w+\\s+\"")
  linesIterator3.foreach(line=>pat3.findAllIn(line).foreach(println))
}
运行结果：文本中包含:"like this，maybe with \" or\\""like this，maybe with \" or\\"
文本中包含:like this，maybe with \" or\\like this，maybe with \" or\\
like this，maybe with \" or\\
like this，maybe with \" or\\
文本中包含:\w+\s+"with \"
with \"
with \"
7. 编写Scala程序，从文本文件读取内容，并打印出所有的非浮点数的词法单位。要求使用正则表达式程序代码：import io.Source
object NonFloat extends App{
  val source = Source.fromFile("src\\NumberFile.txt").mkString
  val pat1 = """[^((\d+\.){0,1}\d+)^\s+]+$""".r//去掉+试试
  val pat2 = """^((?!^[-]?\d*\.\d+$).)+$""".r
  println("模式1不包含整数:")
  for(token <- source.split("\\s+")){
    for(word <- pat1.findAllIn(token))
      if(!word.equals("")){
        println(token)
      }
  }
  println("模式2包含整数:")
  for(token <- source.split("\\s+")){
    for(word <- pat2.findAllIn(token))
      println(word)
  }
}
测试数据：joint    55    666.0    management    13.5    committee    12.5
joint    6.0    123.4    management    3.14    committee    170.5
joint    52    63.32    management    10.4    committee    12.5
0.12t    20    5.6ef    45.77ghjss    5.94    dfdxsccxz    7.9
运行结果：模式1不包含整数:joint
management
committee
joint
management
committee
joint
management
committee
0.12t
5.6ef
45.77ghjss
dfdxsccxz
模式2包含整数:joint
55
management
committee
joint
management
committee
joint
52
management
committee
0.12t
20
5.6ef
45.77ghjss
dfdxsccxz
8. 编写Scala程序打印出某个网页中所有img标签的src属性。使用正则表达式和分组程序代码：object WebSrc extends App{
  val pat = """<img.*?src=["'](.+?)["'].*?>""".r
  for (pat(src) <-pat.findAllIn(io.Source.fromURL("http://www.baidu.com").mkString)) {
    println(src)
  }
}
运行结果：//www.baidu.com/img/bd_logo1.png
//www.baidu.com/img/baidu_jgylogo3.gif
9. 编写Scala程序，盘点给定目录及其子目录中总共有多少以.class为扩展名的文件程序代码：import java.io.File
object NumDir extends App{
  val path = "."
  val dir = new File(path)
  def subdirs(dir:File):Iterator[File]={
    val children = dir.listFiles().filter(_.getName.endsWith("class"))
    children.toIterator ++ dir.listFiles().filter(_.isDirectory).toIterator.flatMap(subdirs _)
  }
  val n = subdirs(dir).length
  println(n)
}
运行结果：52
10. 扩展那个可序列化的Person类，让它能以一个集合保存某个人的朋友信息。构造出一些Person对象，让他们中的一些人成为朋友，然后将Array[Person]保存到文件。将这个数组从文件中重新读出来，校验朋友关系是否完好 注意,请在main中执行。脚本执行无法序列化。程序代码：import collection.mutable.ArrayBuffer
import java.io.{ObjectInputStream, FileOutputStream, FileInputStream, ObjectOutputStream}
 
class Person(var name:String) extends Serializable{
  val friends = new ArrayBuffer[Person]()
  def addFriend(friend : Person){
    friends += friend
  }
  override def toString() = {
    var str = "My name is " + name + " and my friends name is "
    friends.foreach(str += _.name + ",")
    str
  }
}
 
object PersonTest extends App{
  val p1 = new Person("JackChen")
  val p2 = new Person("Jhon·D")
  val p3 = new Person("Sunday")
  p1.addFriend(p2)
  p1.addFriend(p3)
  println(p1)
  val out = new ObjectOutputStream(new FileOutputStream("src\\Person.txt"))
  out.writeObject(p1)
  out.close()
  val in = new ObjectInputStream(new FileInputStream("src\\Person.txt"))
  val p = in.readObject().asInstanceOf[Person]
  println(p)
}
运行结果：My name is JackChen and my friends name is Jhon·D,Sunday
My name is JackChen and my friends name is Jhon·D,Sunday