scala基础篇笔记 （一）
文章目录
- 编译与反编译
- 注释
- 变量
- Java静态代码块
- 语法
- 变量初始化
- 变量连续赋值问题
- 标识符
- String
- Java—Scala
- 输入
- 输出
- web
- 数据类型
- AnyVal
- AnyRef
- Null
- 自动转换与强制转换
- 字符串
- 运算符
- ==和equals的区别
- 赋值运算符
- ++,--
- 逻辑运算符
- 位运算符
- 运算符本质
- 流程控制
- if -else
- scala都有返回值
- 三元运算
- 循环控制
- 循环嵌套
- yield
- while循环
- 循环中断
scala（scalable language）
更灵活 ，大数据更关注变化
跨平台、垃圾回收 ——基于java
java=> pizza-〉JDK1.5
java=> scala-〉JDK1.8
Java 更适合业务开发
scala更适合数据处理 函数编程
vanas@VanasdeMacBook-Pro ~ % javap
用法: javap <options> <classes>
其中, 可能的选项包括:
-help --help -? 输出此用法消息
-version 版本信息
-v -verbose 输出附加信息
-l 输出行号和本地变量表
-public 仅显示公共类和成员
-protected 显示受保护的/公共类和成员
-package 显示程序包/受保护的/公共类
和成员 (默认)
-p -private 显示所有类和成员
-c 对代码进行反汇编
-s 输出内部类型签名
-sysinfo 显示正在处理的类的
系统信息 (路径, 大小, 日期, MD5 散列)
-constants 显示最终常量
-classpath <path> 指定查找用户类文件的位置
-cp <path> 指定查找用户类文件的位置
-bootclasspath <path> 覆盖引导类文件的位置
package com.vanas.bigdata.java.chapter01;
/**
* scala语言是一个完全面向对象的编程语言
* Java语言不是一个完全面向对象的编程语言
* object：scala语言中没有静态的语法
*
* @author Vanas
* @create 2020-05-18 10:12 上午
*
*/
public class HelloScala {
public static void main(String[] args) {
System.out.println("hello scala");
HelloScala.test();
}
public static void test(){
System.out.println("test");
}
}
package com.vanas.bigdata.chapter01
/**
*
* scala语言是一个完全面向对象的编程语言
* Java语言不是一个完全面向对象的编程语言
* object：scala语言中没有静态的语法,采用object方式模仿java中静态语法通过类名访问方法
* def：define缩写，表示声明方法的关键字
* args: Array[String]：参数声明=》参数名:参数类型
* => 名称:类型
* 农业文明 & 工业文明
* java => String[] args => 强类型语言 => 类型 名称
* 认为谁更重要就谁在前
*
* Array：scala中的数组，类似于java中的中括号
* [String]：表示泛型
*
* scala =》 main：Unit =》方法名：类型
* java =》void main =》类型 方法名
* Unit（类型） 《==》void（关键字）
*
* =：赋值，方法也是对象，可以赋值
*
* scala语言是基于java语言开发的，所以可以直接嵌入java代码执行
*
* scala语言中默认会导入一些对象，那么这些对象的方法可以直接使用
* 类似于java中import java.long
*
* @author Vanas
* @create 2020-05-18 9:39 上午
*/
object scala01_Hello {
// public static void main(String[] args)
def main(args: Array[String]): Unit = {
// 方法体
System.out.println("Hello Scala")
// 打印
println("hello scala")
}
}
package com.vanas.bigdata.chapter01
/**
* @author Vanas
* @create 2020-05-18 10:43 上午
*/
object Scala02_Test {
// 声明方法def
// 名称(参数列表)：类型
// 参数名：参数类型
// 方法赋值
def main(ages: Array[String]): Unit = {
// 方法体
print("hello test")
// 调用方法
println(Scala02_Test.test())
}
def test(): String = {
return "test"
}
}
编译与反编译
package com.vanas.bigdata.chapter01
/**
* 使用class关键字声明的类，在编译时，只会产生一个类文件，并且不能模仿静态语法操作
* @author Vanas
* @create 2020-05-18 11:00 上午
*/
class Scala03_Class {
def main(args: Array[String]): Unit = {
}
}
反编译
Scala03_Class
package com.vanas.bigdata.chapter01;
import scala.reflect.ScalaSignature;
@ScalaSignature(bytes = "\006\00152Aa\001\003\001\033!)A\003\001C\001+!)\001\004\001C\0013\ti1kY1mCB\032tl\0217bgNT!!\002\004\002\023\rD\027\r\035;feB\n$BA\004\t\003\035\021\027n\0323bi\006T!!\003\006\002\013Y\fg.Y:\013\003-\t1aY8n\007\001\031\"\001\001\b\021\005=\021R\"\001\t\013\003E\tQa]2bY\006L!a\005\t\003\r\005s\027PU3g\003\031a\024N\\5u}Q\ta\003\005\002\030\0015\tA!\001\003nC&tGC\001\016\036!\ty1$\003\002\035!\t!QK\\5u\021\025q\"\0011\001 \003\021\t'oZ:\021\007=\001#%\003\002\"!\t)\021I\035:bsB\0211E\013\b\003I!\002\"!\n\t\016\003\031R!a\n\007\002\rq\022xn\034;?\023\tI\003#\001\004Qe\026$WMZ\005\003W1\022aa\025;sS:<'BA\025\021\001")
public class Scala03_Class {
public void main(String[] args) {}
}
package com.vanas.bigdata.chapter01
/**
* scala 中使用object关键字声明类，在编译时会产生2个class文件，可以模仿静态语法操作
* @author Vanas
* @create 2020-05-18 11:03 上午
*/
object Scala04_Object {
def main(args: Array[String]): Unit = {
}
}
Scala04_Object$
package com.vanas.bigdata.chapter01;
public final class Scala04_Object$ {
public static Scala04_Object$ MODULE$;
public void main(String[] args) {}
private Scala04_Object$() {
MODULE$ = this;
}
}
Scala04_Object
package com.vanas.bigdata.chapter01;
import scala.reflect.ScalaSignature;
@ScalaSignature(bytes = "\006\001=:Q\001B\003\t\00291Q\001E\003\t\002EAQ\001G\001\005\002eAQAG\001\005\002m\tabU2bY\006\004DgX(cU\026\034GO\003\002\007\017\005I1\r[1qi\026\024\b'\r\006\003\021%\tqAY5hI\006$\030M\003\002\013\027\005)a/\0318bg*\tA\"A\002d_6\034\001\001\005\002\020\0035\tQA\001\bTG\006d\027\r\r\033`\037\nTWm\031;\024\005\005\021\002CA\n\027\033\005!\"\"A\013\002\013M\034\027\r\\1\n\005]!\"AB!osJ+g-\001\004=S:LGO\020\013\002\035\005!Q.Y5o)\tar\004\005\002\024;%\021a\004\006\002\005+:LG\017C\003!\007\001\007\021%\001\003be\036\034\bcA\n#I%\0211\005\006\002\006\003J\024\030-\037\t\003K1r!A\n\026\021\005\035\"R\"\001\025\013\005%j\021A\002\037s_>$h(\003\002,)\0051\001K]3eK\032L!!\f\030\003\rM#(/\0338h\025\tYC\003")
public final class Scala04_Object {
public static void main(String[] paramArrayOfString) {
Scala04_Object$.MODULE$.main(paramArrayOfString);
}
}
package com.vanas.bigdata.chapter01
/**
*
*使用object关键字声明类：
* 1。编译时会产生2个类文件
* 当前类名.class
* =》普通类+final
* 当前类名$.class
* =》私有构造方法：静态属性= 当前对象
* =》静态返回本类型的属性
* =》静态代码块：创建当前类的对象 javap可以看到new
*
* =》
* 在加载类的时候，创建类的实例并进行了赋值，形成了单例对象
*
* 2.当添加main方法时
* 当前类名.class 会自动添加public static void main方法
* 当前类名$.class 会自动添加 public void main 方法
* 在静态的main方法中会调用类名$中的普通main方法
*
* 3.当添加打印语句时:
* 当前类名$.class 会自动添加 打印语句
*
* 类名.class => static main =》 类名$.main =》println
* @author Vanas
* @create 2020-05-18 11:32 上午
*/
object Scala05_Decompile {
// 如果想要scala执行，main方法是一个固定的写法
// 1.object类中声明
// 2.参数就一个，而且是Array[String]
// 3.无返回值Unit
def main(args: Array[String]): Unit = {
println("hello ");
}
}
Scala05_Decompile
package com.vanas.bigdata.chapter01;
import scala.reflect.ScalaSignature;
@ScalaSignature(bytes = "\006\001=:Q\001B\003\t\00291Q\001E\003\t\002EAQ\001G\001\005\002eAQAG\001\005\002m\t\021cU2bY\006\004Tg\030#fG>l\007/\0337f\025\t1q!A\005dQ\006\004H/\032:1c)\021\001\"C\001\bE&)
public final class Scala05_Decompile {
public static void main(String[] paramArrayOfString) {
Scala05_Decompile$.MODULE$.main(paramArrayOfString);
}
}
Scala05_Decompile$
package com.vanas.bigdata.chapter01;
public final class Scala05_Decompile$ {
public static Scala05_Decompile$ MODULE$;
public void main(String[] args) {
scala.Predef$.MODULE$.println("hello ");
}
private Scala05_Decompile$() {
MODULE$ = this;
}
}
注释
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 11:53 上午
* 文档注释
*/
object Scala01_Comment {
def main(args: Array[String]): Unit = {
// 注释：scala中的注释和java的一致
//单行注释
/*
多行注释
*/
//文档注释
}
}
变量
Java静态代码块
不一定执行
package com.vanas.bigdata.java.chapter01;
/**
* @author Vanas
* @create 2020-05-18 2:05 下午
*/
public class User01 {
public static int age = 20;
static {
System.out.println("usr01...");
}
}
package com.vanas.bigdata.java.chapter01;
/**
* @author Vanas
* @create 2020-05-18 2:09 下午
*/
public class Emp01 {
public final static int age = 20;
static {
System.out.println("emp01...");
}
}
package com.vanas.bigdata.java.chapter01;
/**
* @author Vanas
* @create 2020-05-18 2:06 下午
*/
public class Test01_StaticBlock {
public static void main(String[] args) {
System.out.println(Emp01.age);
}
}
//结果
20
Process finished with exit code 0
反编译
user01
{
public static int age;
descriptor: I
flags: ACC_PUBLIC, ACC_STATIC
public com.vanas.bigdata.java.chapter01.User01();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
LineNumberTable:
line 7: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/vanas/bigdata/java/chapter01/User01;
static {};
descriptor: ()V
flags: ACC_STATIC
Code:
stack=2, locals=0, args_size=0
0: bipush 20
2: putstatic #2 // Field age:I
5: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
8: ldc #4 // String usr01...
10: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
13: return
LineNumberTable:
line 9: 0
line 12: 5
line 13: 13
}
Emp01
{
public static final int age;
descriptor: I
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
ConstantValue: int 20
public com.vanas.bigdata.java.chapter01.Emp01();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
LineNumberTable:
line 7: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/vanas/bigdata/java/chapter01/Emp01;
static {};
descriptor: ()V
flags: ACC_STATIC
Code:
stack=2, locals=0, args_size=0
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String emp01...
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 11: 0
line 12: 8
}
语法
//静态语言
运行前就确定类型
//动态语言
变量的类型随着运行时候改变 javascript
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 2:28 下午
*/
object Scala02_Variable {
def main(args: Array[String]): Unit = {
// scala -变量
// 声明变量
// 1.var 变量名称：变量类型= 变量值
var name: String = "张三"
// 如果可以通过语法推断出来变量类型，那么变量在声明时可以省略类型
// scala时静态类型语言，在编译时必须要确定类型的
// 2.var变量名称=变量值
var username = "zhangsan"
println(name)
println(username)
}
}
变量2种关键字 var 、val（使用更多）
val声明后不可以改变
不可变变量 不是常量
可以通过 反编译 看到自动推断出类型
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 2:28 下午
*/
object Scala03_Variable {
def main(args: Array[String]): Unit = {
// final不能直接修饰变量
// scala为了让变量声明后不能发生修改，并且不能使用final关键字的场合
// 产生了新的关键字（val）声明变量，声明后的变量无法修改
val username = "zhangsan"
//name="list"
// val比var使用的场景更多,更广
val list = "list"
}
}
变量初始化
Java 中的变量
可以先声明 在使用前初始化
package com.vanas.bigdata.java.chapter01;
/**
* @author Vanas
* @create 2020-05-18 2:47 下午
*/
public class Test02_Variable {
public static void main(String[] args) {
// TODO 局部变量在使用之前必须初始化
int i ;
// System.out.println(i);
}
}
Scala 中变量
必须初始化
切记：能声明和能使用时2码事
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 2:28 下午
*/
object Scala04_Variable {
def main(args: Array[String]): Unit = {
// 变量初始化
// 变量必须显示的初始化，不能省略
val name = "name"
println(name)
}
}
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 2:56 下午
*/
object Scala05_Variable {
def main(args: Array[String]): Unit = {
}
}
变量连续赋值问题
package com.vanas.bigdata.java.chapter04;
/**
* @author Vanas
* @create 2020-05-19 4:31 下午
*/
public class Java_TestOper1 {
public static void main(String[] args) {
int i =10;
int j = i = 20;
System.out.println(j);
Thread.yield();
}
}
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala09_Loop {
def main(args: Array[String]): Unit = {
var a = 10
//表达式都是有返回值的
val b = (a = 20) //()
//Unit=>()
print(b)
}
}
标识符
避免$开始的标识符
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala06_Identifier {
def main(args: Array[String]): Unit = {
// 标识符（起名）
// 默认情况下，scala标识符和java一致
val name = "zhangsn"
val na_me = "zhangsn"
val na$me = "zhangsn"
val name1 = "zhangsn"
// val 4name = "zhangsn" //error
val _name = "zhangsn"
val $name = "zhangsn"
// val class = "zhangsn" //error
val Class = "zhangsn"
}
}
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala07_Identifier {
def main(args: Array[String]): Unit = {
// 标识符 scala标识符可以使用符号
// scala 在起名的时候，随便起 ，报错就不用了
// 常见用于语法操作的符号时不能用的
// ""，{},(),[],''
val + = "zhangsn"
val - = "zhangsn"
val * = "zhangsn"
val / = "zhangsn"
// val # = "zhangsn" //error
val ## = "zhangsn" //error
val % = "zhangsn"
val & = "zhangsn"
val ~ = "zhangsn"
val ^ = "zhangsa"
// val ( = "zhangsan" //error
// val (( = "zhangsan" //error
val $ = "zhangsan"
val @@ = "zhangsan"
}
}
:-> c o l o n colon colonminus$greater 来表示这个符号
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala08_Identifier {
def main(args: Array[String]): Unit = {
// 标识符（起名）
Scala08_Identifier.:->()
}
def :->(): Unit = {
println("test")
}
}
转义后
package com.vanas.bigdata.chapter02;
public final class Scala08_Identifier$ {
public static Scala08_Identifier$ MODULE$;
public void main(String[] args) {
$colon$minus$greater();
}
public void $colon$minus$greater() {
scala.Predef$.MODULE$.println("test");
}
private Scala08_Identifier$() {
MODULE$ = this;
}
}
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala10_Identifier {
def main(args: Array[String]): Unit = {
val `private` = "zhangsan"
println(`private`)
}
}
String
Java
所谓的不可变 是指向的内存的地址不可变
package com.vanas.bigdata.java.chapter01;
import java.lang.reflect.Field;
/**
* @author Vanas
* @create 2020-05-18 3:17 下午
*/
public class Test03_String {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
//不可变字符串 String
// StringBuilder StringBuffer
// final 修饰变量，一旦初始化后，值（内存地址）无法发生改变
// String类一旦初始化后没有提供任何方法来改变字符串的内容
// 而是提供产生新的字符串的方法
String s = " a b ";
// ，,
// s = s.trim();//去掉收尾半角空格 不能去掉中文和日文的空格
// System.out.println("!" + s + "!");
// 反射
Class<? extends String> aClass = s.getClass();
Field f = aClass.getDeclaredField("value");
// 获取属性的值
f.setAccessible(true);
char[] cs = (char[]) f.get(s);
cs[2] = 'd';
System.out.println(s);
}
}
Scala
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala11_String {
def main(args: Array[String]): Unit = {
// 字符串
// scala中没有字符串类型，它的字符串来自于Java
// String是不可变字符串
val name: String = "zhangsan"
val age = 20
val str: String = name.substring(0, 1)
println(str)
// 字符串拼接
val hello = "hello" + name
println(hello)
println("name=" + name + "\tage=" + age)
// 传值字符串
printf("name = %s,age = %s", name, age)
// 插值字符串 (前面加s 说明$是引用）
println(s"name = $name,age = $age")
// JSON => JavaScript Object Notation
// {"username":"zhangsan","age":20}
// JSON字符串，将对象转换为符合JSON个事的字符串
// 相同类型的引号不能嵌套使用
// val json = "{\"username\":\"" + name + "\",\"age\":" + age + "}"
// println(json)
// 多行字符串 """..."""
// 竖线 表示顶格符
val json =
s"""
|{"username":"$name","age":$age}
|zhangsan
|lisi
|""".stripMargin
println(json)
val sql =
s"""
|select *
|from user
|where name =$name
|""".stripMargin
}
}
Java—Scala
java访问scala
package com.vanas.bigdata.java.chapter01;
import com.vanas.bigdata.chapter02.Scala08_Identifier;
import com.vanas.bigdata.chapter02.Scala08_Identifier$;
/**
* @author Vanas
* @create 2020-05-18 4:01 下午
*/
public class Test04_AccessScala {
public static void main(String[] args) {
// 访问scala
Scala08_Identifier.$colon$minus$greater();
Scala08_Identifier$.MODULE$.$colon$minus$greater();
}
}
scala访问Java
package com.vanas.bigdata.chapter02
import com.vanas.bigdata.java.chapter01.User01
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala09_AccessJava {
// scala是基于java语言开发的，所以可以直接访问
// 只是语法风格发生了改变
def main(args: Array[String]): Unit = {
val user0 = new User01
User01.age
}
}
输入
package com.vanas.bigdata.chapter02
import scala.io.StdIn
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala12_In {
def main(args: Array[String]): Unit = {
// 输入
// 从控制台获取输入转换为int值
val age: Int = StdIn.readInt()
println("学生的年龄=" + age)
}
}
package com.vanas.bigdata.chapter02
import scala.io.{Source, StdIn}
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala13_In {
def main(args: Array[String]): Unit = {
// 输入-文件
//从相对路径中读取文件数据
//idea中的相对路径 以Project的根（root）路径为基准
//project + /input/word.txt
val string: Iterator[String] = Source.fromFile("input/word.txt").getLines()
while (string.hasNext) {
println(string.next())
}
}
}
输出
package com.vanas.bigdata.chapter02
import java.io.{FileWriter, PrintWriter}
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala14_Out {
def main(args: Array[String]): Unit = {
// 输出
val out = new PrintWriter(
new FileWriter("output/text.txt")
)
out.println("zhangsan")
out.flush()
out.close()
}
}
web
客户端
package com.vanas.bigdata.java.chapter01;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author Vanas
* @create 2020-05-19 8:56 上午
*/
public class Test05_Net_Client {
public static void main(String[] args) throws IOException {
// 客户端
Socket socket = new Socket("localhost", 9999);
// 输出
socket.getOutputStream().write(10);
System.out .println("客户端发送的数据为10");
socket.close();
}
}
服务器
package com.vanas.bigdata.java.chapter01;
import sun.jvm.hotspot.debugger.ThreadAccess;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author Vanas
* @create 2020-05-19 8:56 上午
*/
public class Test05_Net_Server {
public static void main(String[] args) throws IOException {
// 服务器 占用端口阻塞
ServerSocket server = new ServerSocket(9999);
//
// 创建线程进行数据处理
while (true) {
final Socket client = server.accept();
// 创建线程进行数据处理
new Thread(
new Runnable() {
public void run() {
try {
int data = client.getInputStream().read();
System.out.println("服务器：" + data);
} catch (Exception e) {
e.printStackTrace();
}
}
}
).start();
}
}
}
序列化对象
package com.vanas.bigdata.java.chapter01;
import java.io.Serializable;
/**
* @author Vanas
* @create 2020-05-19 9:09 上午
*/
public class User05 implements Serializable {
public String name;
}
客户端
package com.vanas.bigdata.java.chapter01;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
/**
* @author Vanas
* @create 2020-05-19 8:56 上午
*/
public class Test05_Net_Client2 {
public static void main(String[] args) throws IOException {
// 客户端
Socket socket = new Socket("localhost", 9999);
// 输出
User05 user = new User05();
user.name = "zhangsan";
// 序列化对象
ObjectOutputStream objOut = new ObjectOutputStream(socket.getOutputStream());
objOut.writeObject(user);
System.out.println("客户端发送对象数据");
socket.close();
}
}
服务端
package com.vanas.bigdata.java.chapter01;
import com.vanas.bigdata.chapter03.User;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author Vanas
* @create 2020-05-19 8:56 上午
*/
public class Test05_Net_Server2 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 服务器 占用端口阻塞
ServerSocket server = new ServerSocket(9999);
//
// 创建线程进行数据处理
Socket client = server.accept();
// input反序列化
ObjectInputStream objInput = new ObjectInputStream(client.getInputStream());
User05 user = (User05) objInput.readObject();
System.out.println("服务器读取的用户数据为：" + user.name);
}
}
数据类型
scala不存在基本数据类型，
任意值对象类型AnyVal 与java中基本类型对应
任意引用对象类型AnyRef 与java中引用基本类型对应
AnyVal
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala15_DataType {
def main(args: Array[String]): Unit = {
// 数据类型 AnyVal
val b: Byte = 10
val s: Short = 10
val i: Int = 10
val l: Long = 10L
val f: Float = 1.0f
val d: Double = 1.0
val ii = 20
println(ii) //省略类型，整形默认是Int
val dd = 2.0
println(dd) //省略类型，浮点类型默认为Double
val c: Char = 'A'
val flg: Boolean = true
// unit 是一个类型，对象只有一个()
val u: Unit = test()
println(u) //()
}
def test(): Unit = {
}
}
AnyRef
package com.vanas.bigdata.chapter02
import java.util
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala16_DataType {
def main(args: Array[String]): Unit = {
// 数据类型 -AnyRef
val a = new Array[String](5)
val b = new util.ArrayList()
// val u = new User()
}
}
//class User{
//
//}
Null
Null 类 => null对象
User => new User（）
Option =>None(对象)
Unit. => ()对象
Nothing =>throw new Exception
List =>Nil(空集合对象)
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala17_DataType {
def main(args: Array[String]): Unit = {
//Unit（没有返回值）（void）=> Nothing（无值）（exception）
// Unit一般在函数中使用
// NUll
val s = null
// scala将null作为一个特殊对象进行处理，类型就是NULL
val ss: String = null
// anyVal类型是不能使用null赋值的
// val i: Int = null error
// Nothing,没有值 Nil 空集合
val nil: List[Nothing] = Nil
// any ，anyRef
// any 不确定数据类型 可以用any 像object但不是
// object 是引用类型的父类 基本类型与object无关
// any anyref anyval
val a: Any = "123"
val r: AnyRef = "123"
val v: AnyVal = 1
}
// 没特殊含义 一般在异常和集合中使用
def test(): Nothing = {
throw new Exception
}
}
自动转换与强制转换
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala18_DataType {
def main(args: Array[String]): Unit = {
// scala - 自动转换
val b: Byte = 10
val s: Short = b
//byte类型和short类型没有任何关系，但是scala通过隐式转换的规则将byte类型自动变为short类型
val i: Int = s
// 如果将精度大的类型转为精度小的类型
// java：截取
// scala：方法转换
val bb: Byte = i.toByte
}
}
思考：
package com.vanas.bigdata.java.chapter01;
/**
* @author Vanas
* @create 2020-05-19 10:25 上午
*/
public class Test06_DataType {
public static void main(String[] args) {
// 常量，在编译的时候可以运行
char c ='A'+1;
// 不可变变量，常量
// char cc = c+1; error 变量不确定类型
System.out.println(c);
}
}
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala19_DataType {
def main(args: Array[String]): Unit = {
// 常量运算，在编译的时候就可以运行 (虽报错但可以运行)
// val c: Char = 'A' + 1
// 不可变变量，常量
// val cc: Char = c + 1 //和jiava完全相同 变量就会报错
// println(c)
}
}
字符串
package com.vanas.bigdata.chapter02
/**
* @author Vanas
* @create 2020-05-18 3:38 下午
*/
object Scala20_DataType {
def main(args: Array[String]): Unit = {
// Scala ——字符串
val i: Int = 10
//都有i.toString 但是 最好用拼接 不然会很奇怪
"" + i
val builder = new StringBuilder
builder.toString()
}
}
运算符
package com.vanas.bigdata.java.chapter03;
/**
* @author Vanas
* @create 2020-05-19 10:44 上午
*/
public class Java_TestOper {
public static void main(String[] args) {
String a = new String("abc");
String b = new String("abc");
System.out.println((a == b)); //false
System.out.println(a.equals(b)); //true
}
}
package com.vanas.bigdata.chapter03
/**
* @author Vanas
* @create 2020-05-19 10:43 上午
*/
object Scala01_Operator {
def main(args: Array[String]): Unit = {
val a = new String("abc")
val b = new String("abc")
// scala 中的String的 ==其实就是equals
// println(a == b) //true
// println(a.equals(b)) //true
// scala中eq用于比较啊字符串的内存
println(a eq b) //false
}
}
==和equals的区别
eq
package com.vanas.bigdata.chapter03
/**
* @author Vanas
* @create 2020-05-19 10:43 上午
*/
object Scala02_Operator {
def main(args: Array[String]): Unit = {
val user1 = new User
val user2 = new User
// println(user1==user2)
println(user1.equals(user2))
// scala 中eq一般用于比较对象的内存地址
// 而==比较内容，类似于equals，并且进行了非空判断
}
}
反编译
//==
public void main(final String[] args) {
var10000;
boolean var10001;
label17: {
label16: {
User user1 = new User();
User user2 = new User();
var10000 = .MODULE$;
if (user1 == null) {
if (user2 == null) {
break label16;
}
} else if (user1.equals(user2)) {
break label16;
}
var10001 = false;
break label17;
}
var10001 = true;
}
var10000.println(BoxesRunTime.boxToBoolean(var10001));
}
//equal
public void main(final String[] args) {
User user1 = new User();
User user2 = new User();
.MODULE$.println(BoxesRunTime.boxToBoolean(user1.equals(user2)));
}
赋值运算符
++,–
package com.vanas.bigdata.java.chapter03;
/**
* @author Vanas
* @create 2020-05-19 10:44 上午
*/
public class Java_TestOper1 {
public static void main(String[] args) {
int i = 0;
// int j = i++;
// System.out.println("i=" + i + ",j=" + j);
// 什么叫赋值 将等号的右边的计算结果给左边
// ++放在变量的后面，先赋值，再加一
// ++放置在变量的前面，先加一，再赋值
// 1)_a=i++
// 1.1) _a=i
// 1.2) i=i+1
// 2)i=_a
i = i++;
System.out.println("i=" + i);
}
}
public class Java_TestOper1 {
public Java_TestOper1() {
}
public static void main(String[] args) {
int i = 0;
byte var10000 = i;
int var2 = i + 1;
i = var10000;
System.out.println("i=" + i);
}
}
反编译
stack=3, locals=2, args_size=1
0: iconst_0
1: istore_1
2: iload_1
3: iinc 1, 1
6: istore_1
7: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
10: new #3 // class java/lang/StringBuilder
13: dup
14: invokespecial #4 // Method java/lang/StringBuilder."":()V
17: ldc #5 // String i=
19: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
22: iload_1
23: invokevirtual #7 // Method java/lang/StringBuilder.append:(I)Ljava/lang/Strin gBuilder;
26: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
29: invokevirtual #9 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
32: return
LineNumberTable:
line 9: 0
line 15: 2
line 19: 7
line 22: 32
LocalVariableTable:
Start Length Slot Name Signature
0 33 0 args [Ljava/lang/String;
2 31 1 i I
scala中没++、–
package com.vanas.bigdata.chapter03
/**
* @author Vanas
* @create 2020-05-19 10:43 上午
*/
object Scala03_Operator {
def main(args: Array[String]): Unit = {
//scala中没有++，--
// 因为++，--有歧义
//scala 中用+=1 来代替++
}
}
package com.vanas.bigdata.java.chapter03;
/**
* @author Vanas
* @create 2020-05-19 10:44 上午
*/
public class Java_TestOper2 {
public static void main(String[] args) {
// 阶乘：1个大于1的阶乘等于这个数乘以它-1的阶乘
//5！=5*4！=5*4*3*2*1
System.out.println(test(5));
}
public static int test(int num) {
if (num <= 1) {
return 1;
} else {
return num * test(num - 1);// num-- java.lang.StackOverflowError
}
}
}
逻辑运算符
package com.vanas.bigdata.java.chapter03;
/**
* @author Vanas
* @create 2020-05-19 10:44 上午
*/
public class Java_TestOper3 {
public static void main(String[] args) {
String s = "";
// String s = null 不会空指针异常 因为短路与 && 到不了后面
System.out.println(isNotEmpty(s));
}
public static boolean isNotEmpty(String s) {
return s != null && !s.trim().equals("");
}
}
位运算符
框架底层源码用的多
package com.vanas.bigdata.java.chapter03;
/**
* @author Vanas
* @create 2020-05-19 10:44 上午
*/
public class Java_TestOper4 {
public static void main(String[] args) {
byte b = 127;
b = (byte) (b + 1);
System.out.println(b);
// 0111 1111 =>127
// 1
// 0000 0000 0000 0000 0000 0000 1000 0000 => int (32)
// 把多余的截断 1000 0000 => -128
// 1111 1111 => ？-1
// -128+1=>-127 =>10000001
// 1 + 111 1111
// 负数 + 7位最大值
// 8位中负数的最大值=-1
// 1000 0000
// 负数 +7位最小值
// 8位中负数的最小值 =-128
// 负数的二进制表现方式
// 补码 ：绝对值 按位取反加一
// -1
// 1 => 0000 0001 => 1111 1110 => 1111 1111
}
}
Tips:
有什么用？ 看源码是有帮助的
面试题
（与位运算有关 也和大数据相关）
JDK 1.8后HashMap极限情况下，放多少条数据会形成红黑二叉树？
极限情况下 HashMap放置11条数据，会变成红黑二叉树
1.当HashMap的链表数据超过8个的时候，会尝试转换为二叉树
-9
2.判断容量是否足够，如果容量不够，会扩容 16*2=>32
3.当HashMap的链表数据超过8个的时候，会尝试转换为二叉树
-10
4.判断容量是否足够，如果容量不够，会扩容 32*2=>64
5.当HashMap的链表数据超过8个的时候，会尝试转换为二叉树
-11
6.转换数据结构
hashmap:hash(key.hashCode)&(length-1)
redis:crc16(key,keylen) & 0x3FFF (16384-1)
以hashmap为例，上面不论怎么变，只要下面固定，就可以确定范围（0-15）
01010101
00001111
---------&
00000101 =>5
00001101 =>13
00001111 =>15
00000000 =>0
大数据 数据存储是非常有问题
如果往一个里面存 会造成数据倾斜 解决方式 扩容
2.为什么hashmap扩容必须为2倍
只有2的n次方-1 可以保证后面都为1 才可以确保每一个位置是可以得到的，使分配更均匀
以5为例：（0，，，，4）
01010101
00000100
---------
如果不能保证格子个数是2的n次方的时候 不可以使用位运算 只能取余
3.为什么要一块重写hashCode和equlas？
因为HashMap：
往里放数据的时候判断是否重复，hashCode和equals有连贯调用过程
hashCode =>内存地址
equals =>比较
一致性
User uer1 = new User()
User uer1 = new User()
User1.equals(user2)
运算符本质
scala是没有运算符的，所有运算符都是方法
当调用对象的方法时 ，点可以省略
如果函数参数只有一个 ，或者没有参数，()可以省略
package com.vanas.bigdata.chapter03
/**
* @author Vanas
* @create 2020-05-19 10:43 上午
*/
object Scala04_Operator {
def main(args: Array[String]): Unit = {
//scala是一个完全面向对象的语言
// 万物皆对象
// 数字其实是数值类型的对象
// 1.to(2)
1 to 2
// +是一个方法
val i = 1.+(1)
println(i)
val j = 2.-(2)
println(j)
// 字符串
val str = "abc".*(2)
println(str)
}
}
当有歧义的时候点不要省略 +.+(1)
package com.vanas.bigdata.chapter03
/**
* @author Vanas
* @create 2020-05-19 10:43 上午
*/
object Scala05_Operator {
def main(args: Array[String]): Unit = {
//scala是一个完全面向对象的语言
val user = new User()
// user.++("+++++")
// user.++("zhangsan")
user ++ "zhangsan"
user toString
1.to(2)
1 to 2
}
}
package com.vanas.bigdata.chapter03
/**
* @author Vanas
* @create 2020-05-19 11:19 上午
*/
class User {
def ++(s: String): Unit = {
println("user..." + s)
}
}
关于输出小问题
package com.vanas.bigdata.chapter05
/**
* @author Vanas
* @create 2020-05-20 11:09 上午
*/
object Scala07_Function {
def main(args: Array[String]): Unit = {
//函数编程
val name = "zhangsan"
val password = "123123"
println("name=" + name, "password=" + password)
println("name=" + name + ",password=" + password)
//()=>集合
//函数如果只有一个参数或者没有参数，那么调用时，小括号可以省略
}
}
流程控制
if -else
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala01_Flow {
def main(args: Array[String]): Unit = {
// scala -分支
// 单分支
val age = 20
if (age < 30) {
println(age)
}
println("age ...")
// 双分支
if (age < 20) {
println("age<20")
} else {
println("age>=20")
}
// 多分支
if (age < 18) {
println("少年")
} else if (age < 30) {
println("青年")
} else if (age < 55) {
println("中年")
} else {
println("老年")
}
}
}
scala都有返回值
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala02_Flow {
def main(args: Array[String]): Unit = {
// scala -分支
// 单分支
val age = 20
//scala中表达式都有返回值
// 这个返回值取决于满足条件的最后一行代码的结果
// 多分支
val result = if (age < 18) {
"少年"
} else if (age < 30) {
//println("青年")
"青年"
} else if (age < 55) {
"中年"
} else {
"老年"
}
// result =>"青年" 100 unit //有这3种就时Any
// Unit=>() //都是println 就是()
// 都是字符串就是String
println("结果：" + result)
}
}
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala03_Flow {
def main(args: Array[String]): Unit = {
// scala -分支
// 单分支
val age = 20
//scala中表达式有返回值
//这个返回值取决于满足条件的最后一行代码的结果
// 多分支
val result = if (age < 40) {
20
} else {
// throw new Exception //result 是int
"abc" //resulet是 any
}
result
// 没有else 满足 int 不满足 unit（）
// 所以result是 Anyval
println("结果：" + result)
}
}
三元运算
package com.vanas.bigdata.java.chapter04;
/**
* @author Vanas
* @create 2020-05-19 4:31 下午
*/
public class Java_TestOper {
int age = 20;
String s = age > 20 ? "zhangsan" : "list";
}
scala中没有三元运算符 if -else代替
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala04_Flow {
def main(args: Array[String]): Unit = {
// scala 没有三元运算符
// 使用if else来代替
// 如果大括号中代码逻辑只有一行，那么可以省略
val age = 20
val s: String = if (age < 20) {
"zhangsan"
} else {
"lisi"
}
// 简化
val ss = if (age < 20) "zhangsan" else "lisi"
// 如果一行代码中只有一段逻辑，那么可以省略分号，若果有多段逻辑，分号不能省
// 用分号和换行都能区分逻辑代码块
println("zhangsan"); println("lisi")
}
}
循环控制
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala05_Loop {
def main(args: Array[String]): Unit = {
/*
for(int 9 = 0;i<10;i++){
循环体
}
for(Object obj :List){
循环体
}
*/
// 1. => 1 to 5 1.to(5) => [1、2、3、4、5]
// 2. => <- 指向赋值
// 3. i 没有声明类型，因为可以自动推断
for (i <- 1 to 5) {
println("i=" + i)
}
// 1. =>1 until 5 => 1.until(5) =>[1,2,3,4,5)
for (i <- 1 until 5) {
println("i=" + i)
}
// Range(1,5) => 1 until 5
for (i <- Range(1, 5)) {
println("i=" + i)
}
// for循环默认情况下是一个一个循环
// Range可以传递三个参数：start、end（until），step
for (i <- Range(1, 5, 2)) {
println("i=" + i)
}
for (i <- 1 to 5 by 2) {
println("i=" + i)
}
}
}
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala06_Loop {
def main(args: Array[String]): Unit = {
//循环守卫：条件 ;有没有都行 可以根据关键字区分逻辑
for (i <- Range(1, 5); if i != 3) {
}
for (i <- Range(1, 5)) {
if (i != 3) {
println("i=" + i)
}
}
}
}
循环嵌套
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala07_Loop {
def main(args: Array[String]): Unit = {
//循环
for (i <- Range(1, 5)) {
//可添加其他语句
for (j <- Range(1, 4)) {
println("i = " + i + ",j = " + j)
}
}
//必须加;号
//用的少 因为 外部循环里也会写代码
for (i <- Range(1, 5); j <- Range(1, 4)) {
println("i+=" + i + ",j=" + j)
}
for (i <- Range(1, 5); j = i - 1) {
// j=j -1 相当于放这里
println("i+=" + i + ",j=" + j)
}
}
}
9层妖塔
重要是 用一次for循环
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala08_Loop {
def main(args: Array[String]): Unit = {
//一次循环 实现九层妖塔
//step2
//layer 9
// 1,3,5,7,9
val num = 9
for (i <- 1 to 2 * num by 2; j = (18 - i) / 2) {
println(" " * j + "*" * i)
}
}
}
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala10_Loop {
def main(args: Array[String]): Unit = {
// for循环的表达式的返回值就是unit （这是规则 不是条件）
// 如果需要获取for循环表达式的具体值，使用yield关键字
// 这种操作可以将一个集合转换为另外一个集合 (开发中不使用）
val result = for (i <- 1 to 5) yield {
//i //Vector{1,2,3,4,5}向量集合
"*" * i
}
println("resulet= " + result)
}
}
yield
yield在java中是方法，在scala中是关键字
package com.vanas.bigdata.java.chapter04;
/**
* @author Vanas
* @create 2020-05-19 4:31 下午
*/
public class Java_TestOper1 {
public static void main(String[] args) {
int i =10;
int j = i = 20;
System.out.println(j);
Thread.yield();
}
}
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala11_Loop {
def main(args: Array[String]): Unit = {
//scala yield是关键字所以需要``来包上
Thread.`yield`()
}
}
while循环
package com.vanas.bigdata.chapter04
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala12_Loop {
def main(args: Array[String]): Unit = {
// scala
while (true) {
println("xxxx")
}
do {
print("xxxxx")
} while (false)
}
}
循环中断
Scala 没有continue
package com.vanas.bigdata.chapter04
import scala.util.control.Breaks
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala13_Loop {
def main(args: Array[String]): Unit = {
// scala 循环-中断
//scala中没有break关键字
//scala 采用对象.方法的方式实现中断操作,使用抛异常的方式来中断循环
//scala将需要中断的循环放置在一个"代码块"中，可以处理异常
Breaks.breakable { //中断循环继续执行后续
for (i <- 1 to 5) {
if (i == 3) {
//中断循环
Breaks.break()
}
println("i=" + i)
}
}
println("yyyyyyy")
}
}
package com.vanas.bigdata.chapter04
//导包后加_使代码更简洁
import scala.util.control.Breaks._
/**
* @author Vanas
* @create 2020-05-19 3:53 下午
*/
object Scala14_Loop {
def main(args: Array[String]): Unit = {
// scala 循环-中断
//breakable 是一个方法，{}其实是参数列表
//将一段代码作为参数传给一个方法
breakable {
for (i <- 1 to 5) {
if (i == 3) {
//中断循环
break
}
println("i=" + i)
}
}
println("yyyyyyy")
}
}