package cn.itcast.scala
object ScalaTest {
val myFunc =(x:Int)=>{
x*x}
def main(args: Array[String]): Unit ={
//方法就是函数，函数就是对象
def myMethod(x:Int): Int ={
x*x}
val myArray0 =Array(1,3,5,7,9).map(x => x*x)//匿名函数优先使用
val myArray1 =Array(1,3,5,7,9).map(myFunc)//函数就是对象
val myArray2 =Array(1,3,5,7,9).map(myMethod)//方法就是函数
val myArray3 =Array(1,3,5,7,9).map(_*2)//实现不了x*x功能 因为x出现了两次，不能使用_println(myArray0.mkString(","))println(myArray1.mkString(","))println(myArray2.mkString(","))println(myArray3.mkString(","))}}
1.2 匿名函数
package cn.itcast.scala
object ScalaTest {
def main(args: Array[String]): Unit ={
println((x:Int,y:Int)=>{
x * y})// }}
1.3 高阶函数
package cn.itcast.scala
object ScalaTest {
def main(args: Array[String]): Unit ={
val func3:(String, Int)=>(Int, String)={
(x, y)=>(y +2, x +"hello")}//函数匿名函数定义第二种方式
def myMethod3(hello:(String, Int)=>(Int, String)): Int ={
val result:(Int, String)=hello("zhangsan",60)
result._1
}
val result: Int =myMethod3(func3)println(result)//62}}
1.4 高阶函数作为方法的返回类型
package cn.itcast.scala
object ScalaTest {
def main(args: Array[String]): Unit ={
def myFunc4(x:Int)={
//方法的最后返回值，是一个匿名函数(y:String)=>y + x
}println(myFunc4(50))//}}
1.5 参数类型推断
package cn.itcast.scala
object ScalaTest {
def main(args: Array[String]): Unit ={
val myArray =Array(1,3,5,7,9)//map当中需要传入一个函数，我们可以直接定义一个函数println(myArray.map((x: Int)=> x *2).mkString("==="))//进一步化简 参数推断省去类型信息println(myArray.map((x)=> x *2).mkString("==="))//进一步化简 单个参数可以省去括号println(myArray.map(x => x *2).mkString("==="))///进一步化简 如果变量只在=>右边只出现一次，可以用_来代替println(myArray.map(_ *2).mkString("==="))/*
2===6===10===14===18
2===6===10===14===18
2===6===10===14===18
2===6===10===14===18
*\
}
}
1.6 闭包与柯里化
package cn.itcast.scala
object ScalaTest {
def main(args: Array[String]): Unit ={
//柯里化 柯里化定义形式
def kery(x:Int)(y:Int)={
x+y
}
val kery1: Int =kery(30)(20)println(kery1)
val keryResult =(x:Int)=>{
(y:Int)=>{
x + y}}// 函数的返回值也是函数，为function1，切内部是匿名函数无法赋值println(keryResult(10))//keryResult(20) => 匿名函数 y:Int => 20+y <=1,3,5,7,9
val myArray =Array(1,3,5,7,9).map(keryResult(20))println(myArray.toBuffer)//ArrayBuffer(21, 23, 25, 27, 29)//柯里化推导过程//柯里化守门Scala面向函数式编程，必然导致的一种结果
def keryMethod(x:Int)={
//里面的函数，将外面的参数包起来了，叫做闭包
y:Int =>{
y + x}}keryMethod(30)}}
package cn.itcast.scala
classPerson{
//定义一个属性，叫做name的，使用val不可变量来进行修饰// 用val修饰的变量是可读属性，有getter但没有setter（相当与Java中用final修饰的变量）自动生成该方法
val name:String ="zhangsan"//定义一个属性，叫做age的，使用var可变量来进行修饰//用var修饰的变量都既有getter，又有setter 自动生成该方法
var age:Int =28//类私有字段，只能在类的内部使用或者伴生对象中访问private val address:String ="地球上"//类私有字段，访问权限更加严格的，该字段在当前类中被访问//在伴生对象里面也不可以访问private[this] var pet ="小强"//在类当中定义了一个方法，
def hello(first:Int,second:String):Int ={
println(first+"\t"+second)250}/**
* 定义了一个函数
*/
val func1 =(x:Int,y:Int)=>{
x+y
}}
2.2 类的实例化以及使用
package cn.itcast.scala
object ScalaClass {
def main(args: Array[String]): Unit ={
val person =newPerson
val name: String = person.name
val age: Int = person.age
println(name)println(age)
person.age =(30)// 这个是赋值操作
person.age=(30)// age= 这个是set方法，.age=连起来写
person.age_=(80)// age_= 这个是set方法println(person.age)//这个是get方法//调用函数或者方法
val hello: Int = person.hello(120,"zhangsan")println(hello)//250}}
package cn.itcast.scala
/**
* 顶一个class类，主构造器带有两个参数，name与age
*
* @param name
* @param age
* scala的执行代码，可以直接将代码写在class当中，而在java当中不能
* 在Scala编译之后成为.class文件
* 将我们所有class类的代码都进入到了主构造器方法当中去了
* class Dog{
* public Dog(String name,int age){
* println(name)
* println(age)
* }
* }
*/classDog(name: String, age: Int){
println(name)println(age)
var gender: String ="";//使用this关键字来定义我们的构造器
def this(name: String, age: Int, gender: String){
//每个辅助构造器，都必须以其他辅助构造器，或者主构造器的调用作为第一句this(name: String, age: Int)this.gender = gender
}
var color ="";/**
* 我们也可以通过private来进行修饰我们的构造器，
*
* @param name
* @param age
* @param color
* @param gender
*/private def this(name: String, age: Int, color: String, gender: String){
this(name: String, age: Int)this.color = color
}}
两个构造器之间不能相互调用 Object通过构造器生成对象
package cn.itcast.scala
object ScalaClass {
def main(args: Array[String]): Unit ={
val xiaoheigou: Dog =newDog("xiaoheigou",3)
val xiaobaigou: Dog =newDog("xiaobaigou",2,"cixing")}}
3.scala当中的对象
Java中
public class MyClass{
public static String name="xxx"
public String age = "xxx"
public static String getMyAge(){
return "xxx"
}
public int getMyRealAge(){
return 1;
}
}
package cn.itcast.scala
classClassObject{
val id =1private var name ="itcast"
def printName(): Unit ={
//在Dog类中可以访问伴生对象Dog的私有属性println(ClassObject.CONSTANT + name )}}
object ClassObject{
//伴生对象中的私有属性private val CONSTANT ="汪汪汪 : "
def main(args: Array[String]){
val p =newClassObject//访问私有的字段name
p.name ="123"
p.printName()}}
3.3 scala当中的apply方法
通过apply方法来创建我们的伴生类，可以通过伴生对象来创建我们的伴生类，更加简洁和方便
package cn.itcast.scala
//定义一个class类，主构造器传入一个参数classApplyClassObject(name:String){
println(name)}
object ApplyClassObject{
def apply(name: String): ApplyClassObject =newApplyClassObject(name)
def main(args: Array[String]): Unit ={
val applyClassObject1 =newApplyClassObject("张三")//通过伴生对象，直接调用调用apply方法，来获取我们的一个伴生类
val applyClassObject2 =ApplyClassObject("lisi")//底层还是调用了apply方法，apply还是new Array[Int](5)
val myArray =Array(1,2,3,4,5)
val myArray2 =newArray[Int](10)myArray2(0)=1myArray2(1)=2}}
ackage cn.itcast.extends_demo
classPerson{
val name="super"
def getName=this.name
}classStudentextendsPerson{
//继承加上关键字
override
val name="sub"//重写方法
override def getName ="xxx"//子类可以定义自己的field和method
val score="A"
def getScore=this.score
}
4.2 Scala中override 和 super 关键字
classPerson1{
private val name ="leo"
val age=50
def getName =this.name
}classStudent1extendsPerson1{
private val score ="A"//子类可以覆盖父类的 val field,使用override关键字
override
val age=30
def getScore =this.score
//覆盖父类非抽象方法，必须要使用 override 关键字//同时调用父类的方法，使用super关键字
override def getName ="your name is "+super.getName
}
4.3 Scala中isInstanceOf 和 asInstanceOf
Class B extends Class A
Class C
B instanceOf A => 如果判断 B是A的子类 (A)B
C instanceOf A ==> 如果判断 C不是A的子类 不能强转
java当中只提供了子类判断是否属于父类形 instanceOf，没有提供判断一个类是否是另外一个类的父类的方法
isInstanceOf 和 asInstanceOf
isInstanceOf ==> 类似于java当中的instanceOf 做类型判断的
如果 判断 A isInstanceOf B 为true
可以调用 A asInstanceOf B 做类型转换
asInstanceOf ==> 做类型转换的
package cn.itcast.extends_demo
classPerson3{
}classStudent3extendsPerson3
object Student3{
def main (args: Array[String]){
val p: Person3 =newStudent3
var s: Student3 = null
//如果对象是 null，则 isInstanceOf 一定返回 false
println (s.isInstanceOf[Student3])// 判断 p 是否为 Student3 对象的实例if(p.isInstanceOf[Student3]){
//把 p 转换成 Student3 对象的实例
s = p.asInstanceOf[Student3]}
println (s.isInstanceOf[Student3])}}
package cn.itcast.extends_demo
classPerson5{
}classStudent5extendsPerson5
object Student5{
def main(args: Array[String]){
val p:Person5=newStudent5
p match {
// 匹配是否为Person类或其子类对象case per:Person5 =>println("This is a Person5's Object!")// 匹配所有剩余情况case _ =>println("Unknown type!")}}}
4.6 Scala中protected （了解）
package cn.itcast.extends_demo
classPerson6{
protected var name:String="tom"protected[this] var hobby:String ="game"protected def sayBye=println("再见...")}classStudent6extendsPerson6{
//父类使用protected 关键字来修饰 field可以直接访问
def sayHello =println("Hello "+name)//父类使用protected 关键字来修饰method可以直接访问
def sayByeBye=sayBye
def makeFriends(s:Student6)={
println("My hobby is "+hobby+", your hobby is UnKnown")}}
object Student6{
def main(args: Array[String]){
val s:Student6=newStudent6
s.sayHello
s.makeFriends(s)
s.sayByeBye
}}
4.7 Scala中调用父类的constructor
package cn.itcast.extends_demo
classPerson7(val name:String,val age:Int){
var score :Double=0.0
var address:String="beijing"
def this(name:String,score:Double)={
//每个辅助constructor的第一行都必须调用其他辅助constructor或者主constructor代码//主constructor代码this(name,30)this.score=score
}//其他辅助constructor
def this(name:String,address:String)={
this(name,100.0)this.address=address
}}classStudent7(name:String,score:Double)extendsPerson7("abc",23){
var myaddress ="上海"//注意:子类的辅助构造器，只能够调用子类的主构造器，或者子类的辅助构造器//不能够调用父类的辅助构造器或者，或者父类的主构造器
def this(name:String,myaddress:String){
//this(name,"tianjin")this(name,23.0)}}
object Student7{
def main(args: Array[String]): Unit ={
val zhangsan =newStudent7("zhangsan","lisi")println(zhangsan)}}
4.8 Scala中抽象类
package cn.itcast.extends_demo
abstractclassPerson9(val name:String){
//必须指出返回类型，不然默认返回为Unit
def sayHello:String
def sayBye:String
val age:Int //变量的初始化}classStudent9(name:String)extendsPerson9(name){
//随便传一个与构造器类型一直的//必须指出返回类型，不然默认
def sayHello: String ="Hello,"+name
def sayBye: String ="Bye,"+name
val age: Int =50//变量集成后赋值}
object Student9{
def main(args: Array[String]){
val s =newStudent9("tom")println(s.sayHello)println(s.sayBye)}}
5.scala当中的特质trait
5.1 将trait作为接口使用
1.将特质当作接口使用
package cn.itcast.triat
trait HelloTrait{
def sayHello(): Unit
}
trait MakeFriendsTrait{
def makeFriends(c: Children): Unit
}//多重继承 traitclassChildren(val name: String)extendsHelloTrait with MakeFriendsTrait with Cloneable with Serializable{
def sayHello()=println("Hello, "+this.name)
def makeFriends(c: Children)=println("Hello, my name is "+this.name +", your name is "+ c.name)}
object Children{
def main(args: Array[String]){
val c1=newChildren("tom")
val c2=newChildren("jim")
c1.sayHello()//Hello, tom
c1.makeFriends(c2)//Hello, my name is tom, your name is jim}}
5.2 在trait中定义具体的方法
2.特质当中的方法如果实现了方法体，在子类当中就不用覆写了，直接可以拿过来调用
package cn.itcast.triat
/**
* 比如 trait 中可以包含很多子类都通用的方法，例如打印日志或其他工具方法等等。
* spark就使用trait定义了通用的日志打印方法；
*/
trait Logger{
def log(message: String): Unit =println(message)}classPersonForLog(val name: String)extendsLogger{
def makeFriends(other: PersonForLog)={
println("Hello, "+ other.name +"! My name is "+this.name +", I miss you!!")this.log("makeFriends method is invoked with parameter PersonForLog[name = "+ other.name +"]")}}
object PersonForLog{
def main(args: Array[String]){
val p1=newPersonForLog("jack")
val p2=newPersonForLog("rose")
p1.makeFriends(p2)//Hello, rose! My name is jack, I miss you!!//makeFriens method is invoked with parameter PersonForLog[name = rose]}}
5.3 在trait中定义具体field
如果trait当中已经定义好了一个字段，且字段赋值了，在子类当中可以直接使用
package cn.itcast.triat
trait PersonForField{
val age:Int=50}//继承 trait 获取的field直接被添加到子类中classStudentForField(val name: String)extendsPersonForField{
def sayHello =println("Hi, I'm "+this.name +", my age is "+ age)}
object StudentForField{
def main(args: Array[String]){
val s=newStudentForField("tom")
s.sayHello
}}
5.4 在trait中定义抽象field
如果特制当中的字段没有实现，那么我们必须在子类当中给实现了
trait SayHelloTrait{
//注意，这个字段，没有实现
val msg:String
def sayHello(name: String)=println(msg +", "+ name)}classPersonForAbstractField(val name: String)extendsSayHelloTrait{
//必须覆盖抽象 field
val msg ="Hello"
def makeFriends(other: PersonForAbstractField)={
this.sayHello(other.name)println("I'm "+this.name +", I want to make friends with you!!")}}
object PersonForAbstractField{
def main(args: Array[String]){
val p1=newPersonForAbstractField("Tom")
val p2=newPersonForAbstractField("Rose")
p1.makeFriends(p2)}}
5.5 在实例对象指定混入某个trait
在对象当中混入某个特质—>利于在不改变代码的情况下进行功能扩展
trait LoggedTrait{
// 该方法为实现的具体方法
def log(msg: String)={
}}
trait MyLoggerextendsLoggedTrait{
// 覆盖 log() 方法
override def log(msg: String)=println("log: "+ msg)}
trait MyLogger2{
def MyNewMethod(name:String)={
println("hahhaha")}}classPersonForMixTraitMethod(val name: String)extendsLoggedTrait{
def sayHello ={
println("Hi, I'm "+this.name)log("sayHello method is invoked!")}}/*class PersonForMixTraitMethod(val name: String) extends MyLogger {
def sayHello = {
println("Hi, I'm " + this.name)
log("sayHello method is invoked!")
}
}*/
object PersonForMixTraitMethod{
def main(args: Array[String]){
val tom=newPersonForMixTraitMethod("Tom").sayHello //结果为：Hi, I'm Tom// 使用 with 关键字，指定混入MyLogger trait
val rose =newPersonForMixTraitMethod("Rose") with MyLogger
rose.sayHello
val rose2 =newPersonForMixTraitMethod("Rose") with MyLogger2
// 结果为： Hi, I'm Rose// 结果为： log: sayHello method is invoked!}}
def main(args: Array[String]): Unit ={
val charStr ='6'
charStr match {
case'+'=>println("匹配上了加号")case'-'=>println("匹配上了减号")case'*'=>println("匹配上了乘号")case'/'=>println("匹配上了除号")//注意。所有的模式匹配都必须最终匹配上一个值，如果没有匹配上任何值，就会报错case _ =>println("都没有匹配上，我是默认值")}}
6.2 匹配字符串
def main(args: Array[String]): Unit ={
val arr =Array("hadoop","zookeeper","spark")
val name =arr(Random.nextInt(arr.length))
name match {
case"hadoop"=>println("大数据分布式存储和计算框架...")case"zookeeper"=>println("大数据分布式协调服务框架...")case"spark"=>println("大数据分布式内存计算框架...")case _ =>println("我不认识你...")}}
6.3 守卫
模式匹配当中，我们也可以通过条件进行判断
def main(args: Array[String]): Unit ={
var ch ="500"
var sign =0
ch match {
case"+"=> sign =1case"-"=> sign =2case _ if ch.equals("500")=> sign =3case _ => sign =4}println(ch +" "+ sign)}
6.4 匹配类型
注意在map当中会存在泛型擦除的情况。注意在进行非数组的类型匹配的时候，类型都会进行擦除
def main(args: Array[String]): Unit ={
//注意泛型擦除，在模式匹配当中的类型匹配中，除了Array类型以外，所有的其他的数据类型都会被擦除掉
val a =3
val obj =if(a ==1)1elseif(a ==2)"2"elseif(a ==3)BigInt(3)elseif(a ==4)Map("aa"->1)elseif(a ==5)Map(1->"aa")elseif(a ==6)Array(1,2,3)elseif(a ==7)Array("aa",1)elseif(a ==8)Array("aa")
val r1 = obj match {
case x: Int => x
case s: String => s.toInt
case BigInt =>-1//不能这么匹配case _: BigInt => Int.MaxValue
case m: Map[String, Int]=>"Map[String, Int]类型的Map集合"case m: Map[_, _]=>"Map集合"case a: Array[Int]=>"It's an Array[Int]"case a: Array[String]=>"It's an Array[String]"case a: Array[_]=>"It's an array of something other than Int"case _ =>0}println(r1 +", "+ r1.getClass.getName)}
6.5 匹配数组、元组、集合
def main(args: Array[String]): Unit ={
val arr =Array(0,3,5)
arr match {
caseArray(0, x, y)=>println(x +" "+ y)caseArray(0)=>println("only 0")//匹配数组以1 开始作为第一个元素caseArray(1, _*)=>println("0 ...")case _ =>println("something else")}
val lst =List(3,-1)
lst match {
case0:: Nil =>println("only 0")case x :: y :: Nil =>println(s"x: $x y: $y")case0:: tail =>println("0 ...")case _ =>println("something else")}
val tup =(1,3,7)
tup match {
case(1, x, y)=>println(s"1, $x , $y")case(_, z,5)=>println(z)case _ =>println("else")}}
6.6 样例类
caseclassSubmitTask(id:String,name:String)caseclassHeartBeat(time:Long)case object CheckTimeOutTask
object CaseDemo04 {
def main(args: Array[String]): Unit ={
val arr =Array(CheckTimeOutTask,HeartBeat(12333),SubmitTask("0001","task-0001"))
val myInt: Int = Random.nextInt(arr.length)println(myInt)
val arrayResult =arr(1)
arrayResult match {
case CheckTimeOutTask =>println("匹配上了CheckTimeOut")caseSubmitTask(x,y)=>println(s"$x....$y")caseHeartBeat(x)=>println("心跳时间为 "+ x)}}}
6.7 偏函数
val func1: PartialFunction[String, Int]={
case"one"=>1case"two"=>2// case _ => -1}
def func2(num: String): Int = num match {
case"one"=>1case"two"=>2case _ =>-1}
def main(args: Array[String]){
println(func1("one"))println(func2("one"))//如果偏函数当中没有匹配上，那么就会报错，我们可以通过isDefinedAt来进行判断// println(func1("three"))println(func1.isDefinedAt("three"))if(func1.isDefinedAt("three")){
println("hello world")}else{
println("world hello")}}
7.scala当中的类型参数（了解）
7.1 scala当中的类的泛型
object Demo8 {
def main(args: Array[String]): Unit ={
val result1 =newMyClass("hello",50)
val result2 =newMyClass[Any,Any]("zhangsan","Lisi");}}/**
* 定义一个class类，接收两个参数，但是两个参数都是泛型，泛型的类型，会根据我们
* 创建类的实例化对象的时候，动态的传递进行动态的推断
* @param first
* @param second
* @tparam T
* @tparam B
*/classMyClass[T,B](first:T,second:B){
println(first+","+second)}
7.2 函数的泛型
object methodType{
def getMiddle[T](canshu:T)={
canshu
}
def main(args: Array[String]): Unit ={
// 从参数类型来推断类型println(getMiddle(Array("Bob","had","a","little","brother")).getClass.getTypeName)//指定类型，并保存为具体的函数。
val f = getMiddle[String] _
println(f("Bob"))}}
7.3 scala当中的上下界之泛型类型的限定
泛型的上界限定（必须是该类的子类）
classPair1[T <: Comparable[T]](val first: T, val second: T){
def smaller =if(first.compareTo(second)<0) first else second
}
object Main1 extendsApp{
override def main(args: Array[String]): Unit ={
val p =newPair1("hello","Brooks")println(p.smaller)}}
泛型的下界限定（必须是该类的父类）
classPair2[T](val first: T, val second: T){
def replaceFirst[R >: T](newFirst: R)=newPair2[R](newFirst, second)
override def toString ="("+ first +","+ second +")"}
object Main2 extendsApp{
override def main(args: Array[String]): Unit ={
val p =newPair2("Nick","Alice")println(p)println(p.replaceFirst("Joke"))println(p)}}
7.4 scala当中的视图界定
/**
* 使用 <% 来实现我们类型的隐式转换
* @param first
* @param second
* @tparam T
*/classPair3[T <% Comparable[T]](val first: T, val second: T){
def smaller =if(first.compareTo(second)<0) first else second
override def toString ="("+ first +","+ second +")"}
object Main3 extendsApp{
val p =newPair3(4,2)//RichInt有CompareTo方法println(p.smaller)}
7.5 scala当中的协变，逆变和非变
Java当中，这两个玩意儿没有关系
class Anmial {}
class Cat extends Anmial{}
List[Cat] List[Anmial]
package cn.itcast.scala_actor
import scala.actors.Actor
classActor1extendsActor{
override def act(): Unit ={
for(x <-1 to 10){
println(x)}}}
object Actor2 extendsActor{
override def act(): Unit ={
for(j <-1 to 10){
println("j"+j)}}}
object Actor1{
def main(args: Array[String]): Unit ={
val actor: Actor1 =newActor1
actor.act()
Actor2.act()}}
第二个例子 实现发送，接收消息
package cn.itcast.scala_actor
import scala.actors.Actor
classMyActor2extendsActor{
//通过act方法当中，使用receive来进行消息接收
override def act(): Unit ={
receive{
case"start"=>println("start.....")}}}
object MyActor2{
def main(args: Array[String]): Unit ={
val actor =newMyActor2//启动我们的actor，类似我们启动线程
actor.start()//发送一个异步没有返回值的消息
actor !"xxx"
actor !"start"}}
classMyActor3extendsActor{
override def act(): Unit ={
while(true){
receive{
//每次来一条消息都会启动一个线程去执行，线程开销太大case"start"=>println("starting")case"stop"=>println("stopping")}}}}
object MyActor3{
def main(args: Array[String]): Unit ={
val actor =newMyActor3
actor.start()
actor !"start"
actor !"stop"}}
classMyActor4extendsActor{
override def act(): Unit ={
loop{
react{
case"start"=>println("starting")case"stop"=>println("stopping")}}}}
object MyActor4{
def main(args: Array[String]): Unit ={
val actor =newMyActor4
actor.start()
actor !"start"
actor !"stop"}}
//异步消息caseclassAsyncMessage(id:Int,message:String)//同步消息caseclassSyncMessage(id:Int,message:String)//返回消息caseclassReplyMessage(id:Int,message:String)classMyActor5extendsActor{
override def act(): Unit ={
loop{
react{
caseAsyncMessage(id,message)=>{
println(s"$id,$message")
sender !ReplyMessage(2,"异步有返回值的消息处理成功")}caseSyncMessage(id,message)=>{
println(s"$id,$message")
sender !ReplyMessage(id,"我是同步消息的返回值，等到我返回之后才能继续下一步的处理")}}}}}
object MyActor5{
def main(args: Array[String]): Unit ={
val actor: MyActor5 =newMyActor5
actor.start()//发送异步无返回值消息
actor !AsyncMessage(1,"我是一个异步无返回值的消息不要回答")//发送异步有返回值消息
val asyncMessage: Future[Any]= actor !!AsyncMessage(2,"actorSend")
val apply: Any = asyncMessage.apply()println(apply)println("helloworld22222")//同步等待返回值消息
val syncMessage: Any = actor !?SyncMessage(3,"我是同步阻塞消息")println(syncMessage)}}
package cn.itcast.scala_actor
import scala.io.{
BufferedSource, Source}
object Test {
def main(args: Array[String]): Unit ={
val file: BufferedSource = Source.fromFile("E:\\大数据资料\\大数据实时资料\\4、Scala\\3、Scala第三天\\files\\file.txt","GBK")
val lines: Iterator[String]= file.getLines()//法1for(line <- lines){
println(line)}println("===========")//法2while(lines.hasNext){
println(lines.next())}//注意关闭文件
file.close()}}
如果要将文件内容转数组，直接调用toArray即可
9.2 读取词法单元和数字
如果想将以某个字符或某个正则表达式分开的字符成组读取，可以这么做：
def main(args: Array[String]): Unit ={
val file: BufferedSource = Source.fromFile("F:\\scala与spark课件资料教案\\3、scala第三天\\files\\file2.txt","GBK");
val split: Array[String]= file.mkString.split(" ")println(split.mkString("\t"))
file.close()}
9.3 读取网络资源、文件写入、控制台操作
1、读取网络资源
def main(args: Array[String]): Unit ={
val source: BufferedSource = Source.fromURL("http://www.baidu.com")
val string: String = source.mkString
println(string)
source.close()}
2、文件写入操作
def main(args: Array[String]): Unit ={
val writer =newPrintWriter("E:\\大数据资料\\大数据实时资料\\4、Scala\\3、Scala第三天\\filesprintWriterx.txt")for(i <-1 to 100){
writer.println(i)
writer.flush()}
writer.close()}
3、控制台交互操作
def main(args: Array[String]): Unit ={
//控制台交互--老APIprint("请输入内容:")
val consoleLine1 = Console.readLine()println("刚才输入的内容是:"+ consoleLine1)//控制台交互--新APIprint("请输入内容(新API):")
val consoleLine2 = StdIn.readLine()println("刚才输入的内容是:"+ consoleLine2)}
9.4 scala当中的序列化
@SerialVersionUID(1L)classPersonextendsSerializable{
override def toString = name +","+ age
val name ="Nick"
val age =20}
object PersonMain extendsApp{
override def main(args: Array[String]): Unit ={
import java.io.{
FileOutputStream, FileInputStream, ObjectOutputStream, ObjectInputStream}
val nick =newPerson
val out =newObjectOutputStream(newFileOutputStream("Nick.obj"))
out.writeObject(nick)
out.close()
val in =newObjectInputStream(newFileInputStream("Nick.obj"))
val saveNick = in.readObject()
in.close()println(saveNick)}}
9.5 scala当中的正则表达式
我们可以通过正则表达式匹配一个句子中所有符合匹配的内容，并输出：
object Test extendsApp{
override def main(args: Array[String]): Unit ={
import scala.util.matching.Regex
val pattern1 =newRegex("(S|s)cala")
val pattern2 ="(S|s)cala".r
val str ="Scala is scalable and cool"println((pattern2 findAllIn str).mkString(","))println((pattern1 findAllIn str).mkString(","))}}
10.隐式转换和隐式参数
10.1 隐式转换
10.2 隐式参数
10.3 隐式转换作用域与时机
10.4 隐式转换和隐式参数案例
隐式转换案例一（将我们的Double类型的数据自动转换成Int类型）
object Chapter14 {
implicit def ConvertDoubleToInt(first:Double):Int= first.toInt
}
object Convert{
//导入隐式转换的方法import Chapter14._
def main(args: Array[String]): Unit ={
val first:Int =3.5println(first)//3}}
例如我们也可以定义猫和狗，并且让狗学会抓老鼠的技能
object CatAndDog {
implicit def dogCatchMouse(dog:Dog)=newCat()
def main(args: Array[String]): Unit ={
val dog =newDog
dog.catMouse("大黄狗")}}classCat{
def catMouse(name:String): Unit ={
println(name+"catch a mouse")}}classDog{
def wangwangwang(name:String)={
println(name+"看门汪汪汪")}}
参考：http://blog.csdn.net/qingfeilee/article/details/7052736
org.hibernate.NonUniqueResultException: query did not return a unique result: 2
在项目中出现了org.hiber
由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
Spring MVC提供了非常方便的文件上传功能。
1，配置Spring支持文件上传：
DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
the CollabNet user information center http://help.collab.net/
How do I create a new Wiki page?
A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
package beautyOfCoding;
import java.util.Arrays;
import java.util.Random;
public class MaxSubArraySum2 {
/**
* 编程之美 子数组之和的最大值（二维）
*/
private static final int ROW = 5;
private stat
示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了
# include <stdio.h>
void swap_1(int, int);
void swap_2(int *, int *);
void swap_3(int *, int *);
int main(void)
{
int a = 3;
int b =
同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）
闭锁（CountDownLatch）
public class RunMain {
public long timeTasks(int nThreads, final Runnable task) throws InterruptedException {
fin
不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。
我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。
In computer science, bleeding edge is a term that
