小菜鸟

java菜鸟号正在起航

0%

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 198 阅读时长 ≈ 1 分钟

redis性能优化

redis提供了一个性能测试工具redis-benchmark，可以使用redis-benchmark命令来了解redis的性能

1
2
3
4
5
6
redis-benchmark -q -c 50

---------------------
-q 表示简化输出结果
-c 50 表示有五十个客户端
-n <requests> 客户端请求总量

运行结果展示了一些常用redis命令在1秒内可以执行的次数

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 3k 阅读时长 ≈ 3 分钟

scala构造器

scala与java相似，也存在构造器，且同样的一个类可以有多个构造器，支持构造器的重载，在构造对象时需要调用构造器，但是与java不同的是scala分为主构造器和辅助构造器

语法

1
2
3
4
5
6
7
8
9
10
11
// 这里的形参列表可以用var|val来修饰，默认是val的,即只读,不过一般没有必要用var
class 类名(形参列表) { // 主构造器 
  // 类体 
  // 可以有多个辅助构造器，函数名称都为this，根据不同的参数来区分(java的构造器重载)
  def this(形参列表) { // 辅助构造器 
    // 辅助构造器必须在第一行显式(直接或间接)的调用主构造器
  }
  def this(形参列表) { //辅助构造器
    // 辅助构造器必须在第一行显式(直接或间接)的调用主构造器
  } 
}
阅读全文 »

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 1.6k 阅读时长 ≈ 1 分钟

scala类和对象

scala是面向对象的语言，且比java更加的面向对象，而且更加简洁，很多东西都是在编译期间生成的。在scala中，类并不声明为public。scala源文件中可以包含多个类，所有这些类都具有公有可见性。

声明类的语法

1
2
3
4
// 默认就是public的
[修饰符] class 类名{
  类体
}

一个源文件中可以有多个类

声明一个类

1
2
3
4
5
6
7
8
class Cat{
  // 属性语法  [访问修饰符] var 属性名称 [：类型] = 属性值
  // _表示赋默认值，如果使用_来给默认值，则必须指定类型
  var name:String = _
  var color:String = _
  // 如果属性声明为val则必须赋一个明确值，且只会生成getter方法不会生成setter方法
  val life:Int = 10
}

类的声明默认是public的，且在同一个源文件中可以包含多个类

类中的属性必须进行显式的初始化，如果暂时不想赋值，可以使用_来赋默认值

阅读全文 »

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 695 阅读时长 ≈ 1 分钟

scala异常处理

在scala中也要使用异常处理，与java类似，也是使用try…catch来进行异常处理和捕获，但是语法上有些地方是不同的，scala中只能包含一个catch，但是一个catch中可以使用case来操作匹配异常

1
2
3
4
5
6
7
8
9
10
11
12
13
try {
  var a = 10 / 0
} catch {
  // 采用的是模式匹配的方式
  // case可以匹配异常类型进行处理
  // => 后为匹配后所执行的操作
  case e: ArithmeticException => println("操作出错了" + e.getMessage)
  case e: Exception => {
    println("出现了不知道的异常")
  }
} finally {
  println("不管报没报错，总得干点啥")
}

catch中case是从上到下依次匹配的，所以推荐将小异常放在上面，大异常放在下边

scala中没有编译期异常，全是运行期异常

声明一个抛出异常的方法

返回类型使用Nothing，因为Nothing是所有类型的子类

1
2
3
def test() : Nothing = {
  throw new UnsupportedOperationException("非法操作")
}

可以使用@throws注解来表明该函数将会抛出的异常

1
2
3
4
@throws(classOf[ArithmeticException])
def myFun() = {
  var a = 10 / 0
}

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 484 阅读时长 ≈ 1 分钟

scala惰性函数

在使用hibernate的时候是有懒加载的，就是先生成一个代理对象，此时是没有真正去查询数据的，只有当用到该数据的时候才会去真正的查询获取数据，在scala中的惰性函数就与之相似，使用lazy来修饰
当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数

举例

1
2
3
4
5
6
7
8
9
10
11
12
13
def main(args: Array[String]): Unit = {
  // 声明惰性函数
  lazy val sum = add(10,20)
  println("-------计算结果------")
  // 在使用函数结果的时候才会真正的去执行函数
  println(sum)
}

def add(a: Int, b: Int) :Int = {
  printf("%d与%d相加",a,a)
  println()
  return a+b
}

lazy只能修饰val类型的变量，不可以修饰var类型的变量。

如果在声明变量时使用lazy来修饰，那么变量值分配也会被延迟到变量被使用时