直接上代码
idea安装scala之后直接运行即可
1.基本属性，集合，方法使用
import scala.collection.mutable.ArrayBuffer
import scala.util.Sorting
object ScalaTestDemo extends App {
//引用不可变 内容可以变
println("---------------------------")
val a = Array(1,2,3)
val t=Array("a","b","c")
print(a.zip(t).foreach(i => print(i)))
a(0)=10
print(a(0)+a(1))
println()
//值类型 引用类型
//操作相当于方法调用 无++ --
println("---------------------------")
print(1.+(2))
println()
//表达式 有返回结果
println("---------------------------")
var b=10
val c=if(b>0) 100
print(c)
println()
//循环
println("---------------------------")
for(i <- 1 to 10){print(i)}
for(i <- 1 until 10){print(i)}
val scala="scala"
for(i <- 0 until scala.length){print(scala(i))}
for(i <- 1 to 3;j <- 1 to 3 if(i != j) ) print(i+j)
val w = for(i <- 1 to 3 ) yield i*10
print(w.mkString(" "))
printf("%s占位符测试","aa")
cicle()
def cicle() {
var r = 30
while (r > 0) {
r -= 1
print(r)
}
}
println()
//Array 变长 List 定长
println("---------------------------")
var listq = List(1,2,3)
listq.+:(0)
listq.:+(0)
/**
* Scala的Seq将是Java的List，Scala的List将是Java的LinkedList。
*/
var liste = 0::listq
var list = Array(1,2,3,4)
var list2=list.reverse
var list1=Array.apply(5,6,7)
print(list.mkString(" "))
print(list1.mkString(" "))
print(list2.mkString(" "))
list(1)=100
print(list.mkString(" "))
var arrayBuffer = ArrayBuffer(1,2,3,4,5,6)
arrayBuffer.trimEnd(1)
print(arrayBuffer.mkString(" "))
arrayBuffer.insert(3,100)
print(arrayBuffer.mkString(" "))
arrayBuffer.insert(3,200,300,400)
print(arrayBuffer.mkString(" "))
arrayBuffer.remove(3)
print(arrayBuffer.mkString(" "))
println("--------------aa-------------")
val q = arrayBuffer.toArray
Sorting.quickSort(q)
print(q.mkString(" "))
println()
//Set
println()
println("---------------------------")
var set1 = Set(1,2,3)
set1 += 5
print(set1)
set1.head
print(set1.tail)
var set2 = Set(7,8,9,10)
var set3= set1 ++ set2
print(set3)
println()
//循环遍历Map中的元素
println("---------------------------")
var persons = Map("chinese" -> 6,"english" -> 7)
persons += ("france" -> 4)
for((key,value) <- persons) print(key+value)
persons -= ("france")
for((key,value) <- persons) print(key+value)
print(persons("chinese"))
print(persons.isEmpty)
print(persons.keys)
print(persons.values)
//option 防止返回值为null
val as =persons.getOrElse("aa","")
println()
//定义了一个Tuple，里面有n个不同类型的元素
println("---------------------------")
val tuple =("aa",11,11.23,"bb")
print(tuple._1)
print(tuple._3)
print(tuple._4)
tuple.productIterator.foreach(i => print(i));
println()
//s字符串插值器
val name="hehe"
print("hello"+s"hello,+$name");
//raw 不做转化
print(raw"aaaaa\aaaa/aaaa")
println()
/**
* 函数
*/
println("---------------------------")
say("aa")
def say(name:String){
println(name)
}
println(aa(3))
def aa(i:Int) : Int = i+2
println(bb(3))
def bb(i:Int) : Int = { i+2
i+3
3+4
}
def prininfo(name:String = "hello scala") = print(name)
prininfo()
prininfo("haha")
println("---------------------------")
def fun:(Int,Int)=>Int = (_+_)
val e= fun(1,2)
prininfo(e+"")
/**
* Scala 有方法与函数，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。
* Scala 中的方法跟 Java 的类似，方法是组成类的一部分。
* Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。
* Scala 中使用 val 语句可以定义函数，def 语句定义方法。
*/
/**
* 不同点:
* 1.Array 中的元素值可变，List和Tuple中的元素值不可变
* ２.Array通常是先确定长度，后赋值，而List和Tuple在声明的时候就须要赋值
* ３.Array取单个元素的效率非常高。而List读取单个元素的效率是O(n)
* 4.List和Array的声明不须要newkeyword。而Tuple声明无论有无new 都能够
* 5.Tuple中的元素最多是22
*/
}
2.类，特质，抽象类
import Person.Man
/***
* 在scala中，类名可以和对象名为同一个名字，该对象称为该类的伴生对象，类和伴生对象可以相互访问他们的私有属性，但是
* 他们必须在同一个源文件内。
*
* @param name
* @param age
*/
class Person(val name: String, val age: String) {}
//类
/***
* 为了让所有东西都是对象的目标更加一致，也为了遵循函数式编程的习惯，Scala鼓励你在变量和函数返回值可能不会引用任何值的时候使用Option类型。在没有值的时候，使用None，这是Option的一个子类。如果有值可以引用，就使用Some来包含这个值。Some也是Option的子类。
*/
/***
* 在scala中没有静态方法和静态字段，所以在scala中可以用object来实现这些功能，直接用对象名调用的方法都是采用这种实现方式
*/
object Person {
def apply(name: String, age: String) = new Person(name, age)
def unapply(person: Person): Option[(String, String)] = {
if(person == null) {
None
} else {
Some(person.name, person.age)
}
}
class Man extends Person(name = "aa",age = "123") with animal
{
override def toString = getClass.getName +"name="+name+"age"+age
}
}
//可以相互调用私有方法
object ClassTest extends App {
val a = new Person("aa", "12")
val b = Person("bb", "234")
print(a.name)
print(a.age)
print(b.name)
print(b.age)
print(a.isInstanceOf[Person])
val c= new Man();
print(c.toString)
/***
* apply 传入属性赋值 返回时对象
* unapply 传入的时对象 提取的属性值
*/
val person = Person("aaa", "123")
person match {
case Person(name, "RMB") => println("RMB: " + name)
case _ => println("Not RMB!")
}
var child = Child("aa",123)
print(child.name)
var child1 = child.copy()
print(child1.age)
if (child == child1) print(true)
else print(false)
}
trait animal
{
def speak(): String =
{
print("aa")
"aa"
}
}
/***
* 特质和抽象类区别时 有参构造函数
*/
abstract class animals
{
def aa(age:Int,name:Int)
}
/***
* 样例类节省了get set 默认val 可以改war
* @param name
* @param age
*/
case class Child (var name:String,age :Int)
/***
* 密封类
* 在使用case 类来做模式匹配时，你可能想让编译器帮你确保已经列出了所有可能的选择。那么通常就要将通用超类声明为sealed：
*/
3.match用法，正则用法，文件读取
object Match extends App
{
trait Say {}
case class AA(age:String) extends Say
{
print("aa")
}
case class BB(age:String) extends Say
{
print("BB")
}
case class CC(age:String)extends Say
{
print("CC")
}
def matchclass (say :Say): Unit =
{
say match {
case AA(age:String) => print("aa")
case _ => print("on")
}
}
var ss= AA("11")
matchclass(ss);
val a = "1123"
val b = "11"
val B ="1123"
a match {
//case b => print("ok")
case B => print("big")
case _ => print("on")
}
var list = List(1,2,3)
list match {
case List(_,_,3) => print("ok")
case _ => print("no")
}
}
import scala.util.matching.Regex
object RegexTest extends App{
val patten = new Regex(raw"[0-9]+[a-z]")
val aa = "1000aaa12"
for(i <- patten.findAllIn(aa)) print(i)
val sd = patten.findAllIn(aa)
print(sd.next())
}
import java.io.PrintWriter
import scala.io.Source
object FileTest extends App{
//val source = Source.fromFile("scala/src/test.txt")
/**
* 读取行
*/
/* val lines = source.getLines()
for(line <- lines) {
println(line)
}
source.close()*/
/**
* 读取字符
*/
/* val it = source.buffered
while(it.hasNext)
{
println(it.next())
}
source.close()*/
/**
* 读取网络文件
*/
val source = Source.fromURL("http://www.baidu.com")
val lines = source.getLines()
for(line <- lines) {
println(line)
}
source.close()
//写文件
val out =new PrintWriter("scala/src/write.txt")
out.println("11")
out.close()
}
4.常用函数，高阶函数
object FunctionTest extends App {
/**
* 偏函数
*/
val pf:PartialFunction[Int,String] = {
case 1=>"One"
case 2=>"Two"
case 3=>"Three"
case _=>"Other"
}
pf.isDefinedAt(1)
val onePF:PartialFunction[Int,String] = {
case 1=>"One"
}
val twoPF:PartialFunction[Int,String] = {
case 2=>"Two"
}
val threePF:PartialFunction[Int,String] = {
case 3=>"Three"
}
val otherPF:PartialFunction[Int,String] = {
case _=>"Other"
}
/**
* orElse 组合使用
*/
val newPF = onePF orElse twoPF orElse threePF orElse otherPF
print(newPF(1))
/**
* andThen: 相当于方法的连续调用，比如g(f(x))。
*/
val pf1:PartialFunction[Int,String] = {
case i if i == 1 => "One"
}
val pf2:PartialFunction[String,String] = {
case str if str eq "One" => "The num is 1"
}
val num = pf1 andThen pf2
print(num(1))
/*val onePF:PartialFunction[Int,String] = {
case 1=>"One"
}*/
/**
* 匹配返回前面 不匹配返回后面
*/
print(onePF.applyOrElse(1,{num:Int=>"two"}))
print(onePF.applyOrElse(2,{num:Int=>"two"}))
/**
* 偏应用函数
*/
def add(x:Int,y:Int,z:Int) = x+y+z
def addX = add(1,_:Int,_:Int) // x 已知
addX(2,3)
var list1 = List(1,2,3,45)
list1.min
list1.max
list1.sum
list1.filter( i => i%2==0)
var list2= List(7,8,9)
var list3 = List(list1,list2)
print(list3)
print(list3.flatten)
var list4= list3.flatten.map(t => List(t,t))
print(list4)
var list5=list4.flatten
println()
print(list5)
print(list5.reduce(_+_))
var list6 = List(1,2,3,4,5,6,7)
print(list6.reduceLeft(_-_))
print(list6.reduceRight(_-_))
print(list6.reduce(_-_))
print(list6.foldRight(10)(_-_))
}
object HighFunction extends App{
/**
* 高阶函数 入参和返回值都是函数
*/
val a = Array(1,2,3)
val fun = (x:Int) => x*2
/**
* 传入的是函数
*/
var res= a.map(fun)
print(res.foreach(t =>{print(t)}))
/**
* 返回值是函数 最后一行 方法里面有
*/
def fun1 (a:String,b:String):(String ,String ) =>String =
{
val c = a+b
(a:String,b:String)=>s"$c"+a+b
}
val fun2=fun1("cc","vv")
print(fun2("ee","rr"))
/**
* 闭包 cc vv 就是一个闭包
*/
/**
* 柯里化 n参数 的函数 =》 1个参数 + n-1个参数的函数
*/
//两个参数的函数变成两个函数一个参数
def first(x:Int):Int => Int = (y:Int)=>x+y
val s= first(1)
print(s(2))
}
5.隐式类
/**
* 隐式类
*/
object ImplicitTest extends App
{
print(4.times())
implicit class IntTime(x:Int)
{
def times[A] (f: => A): Unit =
{
def loop (current : Int): Unit =
{
if(current>0)
{
f
loop(current-1)
print("ok")
}
}
loop(x)
}
}
/**
* 隐式转化函数
*/
var a:Int =10
var b:Double =10.55
implicit def doubletoin (x:Double) = x toInt
a = b
b =a
/**
* 隐式对象 就是一个参数
*/
implicit val ea:Int = 10;
def gg(x:Int,y:Int)(implicit ae:Int): Unit = {
print(ae)
}
gg(1,2)
}