运算符

Scala 运算符的使用和 Java 运算符的使用基本相同，只有个别细节上不同。

1. 算术运算符

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4; -b	-4
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取模(取余)	7%5	2
+	字符串相加	"He"+"llo"	"Hello"

对于除号"/"，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
对一个数取模a%b，和Java的取模规则一样。

2. 关系运算符

运算符	运算	范例	结果
==	相等于	4==3	false
!=	不等于	4！=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true

Java和Scala中关于==的区别
Java：

==比较两个变量本身的值，即两个对象在内存中的首地址；
equals比较字符串中所包含的内容是否相同。

Scala：
==更加类似于Java中的equals。

scala

def main(args: Array[String]): Unit = {
    val name = null
    val name1 = "123"
    val name2 = new String("123")
    val name3 = new String("123")
    println(name == name2)
    println(name1 == name2)
    println(name2 == name3)
    // 如果想要比较对象的内存地址, 需要使用eq
    println(name1 eq name2)
    println(name2 eq name3)
}

运行结果：
Alt text 可以看到name1为null时，仍然能够使用==，并没有报NullPointException, 查看反编译源码：
可以看出==底层先做了空值判断，然后在做equals比较。

扩展

在java中双等号==，基本类型数据也是比较内容。如果涉及拆箱装箱(jdk1.5之后支持拆箱装箱特性)的话需要具体问题分析：

java

public static void main(String[] args) {
    Integer a = 100;
    Integer b = 100;
    System.out.println(a==b);

    Integer c = 300;
    Integer d = 300;
    System.out.println(c==d);
}

运行结果：
Alt text 为何第二个判断为false呢？查看反编译代码：
在下图中可以看到基本类型100赋值给Integer类型的a, 使用了装箱操作，实际使用的是Integer.valueOf()方法。
查看Integer.valueOf()方法源代码：
可以看出如果装箱的数据范围在-128~127的话，将会在常量池中拿出。a和b都是常量池中对象的引用，所以相等，而c和d的值超过常量池范围，将各自新建对象, 所以不相等。 Alt text

3. 逻辑运算符

用于连接多个条件(一般来讲就是关系表达式)，最终的结果也是一个Boolean值。

运算符	描述	实例
&&	逻辑与	(A && B) 运算结果为 false
\|\|	逻辑或	(A \|\| B) 运算结果为 true
!	逻辑非	!(A && B) 运算结果为 true

4. 赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量。

运算符	描述	实例
=	简单的赋值运算符，将一个表达式的值赋给一个左值	C = A + B 将 A + B 表达式结果赋值给 C
+=	相加后再赋值	C += A 等于 C = C + A
-=	相减后再赋值	C -= A 等于 C = C - A
*=	相乘后再赋值	C = A 等于 C = C A
/=	相除后再赋值	C /= A 等于 C = C / A
%=	求余后再赋值	C %= A 等于 C = C % A
<<=	左移后赋值	C <<= 2 等于 C = C << 2
>>=	右移后赋值	C >>= 2 等于 C = C >> 2
&=	按位与后赋值	C &= 2 等于 C = C & 2
^=	按位异或后赋值	C ^= 2 等于 C = C ^ 2
\|=	按位或后赋值	C \|= 2 等于 C = C \| 2

提示

Scala 中没有++、--操作符，可以通过+=、-=来实现同样的效果；

5. 位运算符

运算符	描述	实例
&	按位与运算符	(a & b) 输出结果 12 , 二进制解释： 0000 1100
\|	按位或运算符	(a \| b) 输出结果 61 , 二进制解释： 0011 1101
^	按位异或运算符	(a ^ b) 输出结果 49 , 二进制解释： 0011 0001
~	按位取反运算符	(~a ) 输出结果 -61 , 二进制解释： 1100 0011, 在一个有符号二进制数的补码形式。
<<	左移动运算符	a << 2 输出结果 240 , 二进制解释： 0011 0000
>>	右移动运算符	a >> 2 输出结果 15, 二进制解释： 0000 1111
>>>	无符号右移	a >>>2 输出结果 15, 二进制解释: 0000 1111

扩展

java☕中的HashMap的数据如何存放在底层中的？它的里面就应用到了位运算。
key=>key.hashcode=> index
index = hash(key.hashCode()) & (length-1)得到数据存放位置
HashMap的length大小必须是2的N次方，扩容是必须是2倍，原因就在于length-1可以得到所有位置都是1的二进制数据，在进行&运算时，只有1&1才是1，其余情况都是0，意味着任意数 & (length-1) <= length-1, 也就是说hash(key.hashCode()) & (length-1)计算结果是[0, length-1]范围内，可以保证HashMap保存数据能够均匀分散数据到[0, length-1]中，如果length不是2的N次方，length-1的二进制某些位置可能是0，那无论hash(key.hashCode())是何值，计算结果对应的位置都是0，不能是1，就会导致某些index值永久不会出现，从而[0, length-1]范围内数据分散就会不均匀。
Kafka中数据分区如何放置到topic的partition中？
key => 取余 => partition
为何Kafka不采用&运算，原因在于Kafka的分区没有强制要求分区数量是2的N次方。

6. 三元运算符

Scala中没有三元运算符，可以使用if-else代替

6. Scala运算符本质

在Scala中其实是没有运算符的，所有运算符都是方法。

scala

// 标准的加法运算
val i: Int = 1.+(1)
// (1)当调用对象的方法时，.可以省略
val j: Int = 1 + (1)
// (2)如果函数参数只有一个，或者没有参数，()可以省略
val k: Int = 1 + 1

println(1.toString())
println(1 toString())
println(1 toString)

运算符 ​

1. 算术运算符 ​

2. 关系运算符 ​

3. 逻辑运算符 ​

4. 赋值运算符 ​

5. 位运算符 ​

6. 三元运算符 ​

6. Scala运算符本质 ​

运算符