1. Scala基础练习
-
不使用str.toLong，str.toInt/Integer.valueOf()/Long.valueOf/Integer.parseInt()等,将字符串"123456789" 转化成数字123456789
def method3(): Unit = {
val str = "123456789"
var sum = 0L
for(ch <- str) {//字符串本身就是一个字符数组
sum = sum * 10 + (ch - '0')
}
println(sum)
str.toCharArray.map(ch => ch - '0').reduce((v1, v2) => v1 * 10 + v2)
} -
使用scala完成选择排序
def main(args: Array[String]): Unit = {
val array = Array(1, 5, 3, 5, 6, 7, 2, 9)
println("排序前的数组：" + array.mkString("[", ", ", "]"))
selectSort(array)
println("排序后的数组：" + array.mkString("[", ", ", "]"))
}
/**选择排序
*
*/
def selectSort(arr:Array[Int]): Unit = {
for(i <- 0 until arr.length) {
for (j <- i until arr.length) {
if(arr(i) > arr(j)) {
swap(arr, i, j)
}
}
}
}
/*
位运算 ^ 相同为0，反之为1
a=3 b=5
a=0011
b=0101
a= a^b =0110
0101
b= a^b =0011=3
0110
a= a^b= 0101=5
这里没有使用第三方变量完成两个数字的交换，其中使用^与那孙效率最高
*/
def swap(arr:Array[Int], i:Int, j:Int): Unit = {
/*arr(i) = arr(i) ^ arr(j)
arr(j) = arr(i) ^ arr(j)
arr(i) = arr(i) ^ arr(j)*/
arr(i) = arr(i) + arr(j)
arr(j) = arr(i) - arr(j)
arr(i) = arr(i) - arr(j)
} -
使用scala完成二分查找
在一个有序数组中找到某一个值，如果存在，返回索引，没有返回-1或者返回如果存在，应该在的位置
def binarySearch(arr:Array[Int], key:Int):Int = {
var start = 0
var end = arr.length - 1
while(start < end) {
val mid = (start + end) / 2
if (key < arr(mid)) {
//左边
end = mid - 1
} else if (key > arr(mid)) {
//又变
start = mid + 1
} else {
return mid
}
}
return -(start + 1)
}
2. scala面向对象
2.1. 类的基本操作
2.1.1. 类的创建与对象的构造
* 定义scala中的类使用关键字class
* 1、定义scala中的任意一种结构，都不可以使用public关键字修饰，因为scala中没有public关键字
* 不加任何访问权限修饰符就相当于java中的public
* 2、类中可以定义成员信息
* 成员变量
* 成员方法
* 3、创建类的实例--对象
* 在scala中和java中是一样，都使用关键字new来构建类的实例
object ClassOps {
def main(args: Array[String]): Unit = {
val p:Person = new Person()
p.name = "刘梦男"
p.age = 18
p.show()
}
}
class Person {
var name:String = _
var age:Int = _
def show(): Unit = {
println(s"name: ${name}\tage: ${age}")
}
}
2.1.2. 成员变量的封装getter和setter
* 4、scala没法直接为成员变量提供getter和setter方法，只能自己编写
* scala做了一种尝试，通过注解(
object ClassOps {
def main(args: Array[String]): Unit = {
val p:Person = new Person()
// p.name = "liumengn"
// p.age = 18
p.setName("liwei")
p.setAge(-2)
p.setSalary(123.0f)
p.show()
}
}
class Person {
private var name:String = _
private var age:Int = _
2.1.3. case class模拟javabean
/*
在scala中一般不用这些普通的class类进行封装数据、传递数据，那用什么呢？
* case class样例类
* 作用就相当于java bean
* case class的定义非常简单，在class关键字的前面加上另外一个关键字case即可
*
* 样例类的定义必须要有一个参数列表---->构造器，
* case class的应用是非常广泛的，但凡数据的传递，一般都用case class
*/
object _02CaseClassOps {
def main(args: Array[String]): Unit = {
val category = Category(1, "手机")
println(category.id)
println(category.name)
}
}
//定义了一个case class Category
case class Category(id:Int, name:String)
2.1.4. scala类的构造器
* 2、构造器：
* 按照java中的知识，val stu = new Student是使用Student类的无参构造器创建对象
* 在一个类中，如果局部变量和成员变量名发生冲突，便通过给成员变量加this关键字进行区分
* 3、如何定义构造器：
* 尝试使用def Student(name:String, age:Int)定义构造器，
* 调用的时候：
* new Student("陈达", 20) too many arguments to constructor报错
* 所以该方法就不是scala中的构造器
* 4、scala的构造，分为主构造器和辅助构造器，
* 主构造器的定义和类的定义交织在一起，如何去定义一个主构造器
* class Xxx(参数列表) {
* }
* 类名后面的内容就是主构造器，如果参数列表为空的话，()可以省略
* 主构造器的函数体，就是类体的内容，所以如果我们使用主构造器创建对象
* 5、scala的类有且仅有一个主构造器，要想提供更加丰富的构造器，就需要使用辅助构造器
* def this(参数列表)
* scala中的辅助构造器，在函数体的第一行，必须以调用其它辅助构造器或者主构造器开始
* 也就是说要使用this(参数列表)去调用其它构造器
* 但是归根到底，一个辅助构造器最终还是要从主构造器的调用开始
* 6、scala和java的构造器的区别
* java的构造器没有主构造器和辅助构造器之分，但是有默认的无参构造器和有参构造器之分
* scala中默认的构造器就是类名后面的构造器，被称之为主构造器，同时还拥有辅助构造器
* java的构造器名称和类名一直，而scala中的构造器名称就是this，其余和java一模一样
class Student(n:String, a:Int) {
private var name:String = _
private var age:Int = _
def Student(name:String, age:Int): Unit = {
this.name = name
this.age = age
}
//辅助构造器
def this() {
this("张钟方", 18)
println("---辅助构造器def this()-----")
}
def this(age:Int) {
this()
this.age = age
println("---辅助构造器def this(age:Int)-----")
}
def show(): Unit = {
println(s"name: ${n}\tage: ${a}")
}
println("如果这是构造器的方法体的话，这句话应该会被调用！")
}
2.1.5. 嵌套类
scala中称之为嵌套类，在java中称之为内部类
java中的成员内部类实例
public class InnerClassOps {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
class Outer {
class Inner {
public void show() {
System.out.println("inner show");
}
}
}
为啥要有内部类？
从业务逻辑上理解，定义复杂是否在外部类内部定义更加合理，这样便有了内部类，比如，定义一个类Person，类有心脏，Heart优势一个复杂的抽象事物，显然应该把Heart定义在Person内部更加的准确与合理。
scala的内部类如何定义
object _03InnerOps {
def main(args: Array[String]): Unit = {
val outer = new Outer
val inner = new outer.Inner()
inner.show()
}
}
class Outer { oo => //外部类的引用
var x = 5
class Inner {
var x = 6
def show(): Unit = {
var x = 7
println("Inner: x=" + x)//7
println("Inner: x=" + this.x)//6
println("Inner: x=" + Outer.this.x)//5
println("Inner: x=" + oo.x)//5 简写方式
}
}
}
2.1.6. 对象object
scala并没有像java中的静态，所以按照java中的观点的话，主函数是没有办法被执行public static void main(xxx)
scala为了来模拟java中的static这个关键字，设计出了object这一结构，它是和class平级。
在object定义的方法我们可以理解为函数，class中的行为称之为方法，而且在object中定义的变量和函数都是可以当做java中的静态来进行调用。
object _04ObjectOps {
def main(args: Array[String]): Unit = {
val ret = Tool.add(13, 14)//相当于java的静态方法
}
}
object Tool {
val x = 5
def add(a:Int, b:Int) = a + b
}
如何在scala中去定义单例对象呢？
java中的单例(必须掌握)
/**
* 单例
* 恶汉式
* 懒汉式
* 一个类只能创建一个对象，
* 定义的步骤：
* 恶汉式：
* 1、私有构造器
* 2、提供一个public的static的返回值为本类引用的方法
* 3、为了给第2步中提供实例，创建一个private的static的成员变量
* 懒汉式：
* 1、私有构造器
* 2、创建一个private的static的成员变量，没有初始化
* 3、提供一个public的static的返回值为本类引用的方法
*/
恶汉式：
class Singleton {//恶汉式
private Singleton(){}
//成员位置
{//构造代码块
}
private static Singleton instance = new Singleton();
// static {
// instance = new Singleton();
// }
public static Singleton getInstance() {
return instance;
}
}
懒汉式：
class Singleton {
private Singleton(){}
private static Singleton instance;
public static Singleton getInstance() {
if(instance == null) {
synchronized (Singleton.class) {
if(instance == null)
instance = new Singleton();
}
}
return instance;
}
}
scala中的单例
object _05SingletonOps {
def main(args: Array[String]): Unit = {
val s1 = Singleton
val s2 = Singleton
println("s2.x=" + s2.x)//1
s1.x = 5
println("s1 == s2? " + (s1 == s2))//true 单例
println("s2.x=" + s2.x)//5
}
}
object Singleton {
var x = 1
}
2.1.7. 伴生对象和伴生类
为什么要有伴生对象？
我们都知道，在scala中是没有静态这个概念，而在java中一个类是既可以有非静态的成员，也可以有静态成员，表达非常丰富。scala由于没有静态的概念，类只能拥有非静态成员。所以scala为了弥补这个缺憾，定义这么一个和该类同名的object结构，而且该object结构必须要和该类在同一个.scala源文件中被定义。
这样我们就可以让该类拥有了静态和非静态的成员。
把这个和类同名的object称之为该类的伴生对象，反过来，该类称之为该object的伴生类。
object _06CompanionOps {
def main(args: Array[String]): Unit = {
val worker = new Worker("old李", 38)
worker.show()
println("-----------------------------")
val w1 = Worker()
w1.show()
println("静态属性：" + Worker.x)
val w2 = Worker("蔡金廷", 13)
w2.show()
// val arr = new Array[Int](5)
// val arr1 = Array(1, 2, 3, 4)
}
}
class Worker /*private ()*/ {
private var name:String = _
private var age:Int = _
def this(name:String, age:Int) {
this()
this.name = name
this.age = age
}
def show(): Unit = {
println(s"name:${name}, age:${age}")
}
}
object Worker {
var x = 123
//apply方法必须要重写
def apply(): Worker = new Worker()
def apply(name: String, age: Int): Worker = new Worker(name, age)
}
2.1.8 没有main函数如何执行scala程序
object _07AppOps extends App {
/*def main(args: Array[String]): Unit = {
println("xxxxxx")
}*/
println(args.mkString("[", ",", "]"))
println("yyyyyyyyyyyy")
}
extends：扩展
trait：特质