前面跟大家交流了scala的入门编程，接下来分享一些关于scala中级应用和代码技巧。
直接上干货吧~
https://blog.csdn.net/myself_ning/article/details/125945435?spm=1001.2014.3001.5501
词频统计并且排序（例）
import java.util
import scala.collection.mutable
import scala.io.Source
object Test1 {
def main(args:Array[String]): Unit ={
//路径
var path = "F:\\scala\\article.txt";
//读取数据为字符串
var article = getArticle(path);
//对字符串内容进行词频统计
articleCount(article);
}
/*读取文本，保存为字符串*/
def getArticle(path:String): String ={
var content = Source.fromFile(path).getLines().mkString
return content
}
/*统计字符串的词频*/
def articleCount(article:String): Unit ={
//将文章拆分为多个词语
var words = article.split(" ").toList //like : List(There, are, momen ...)
//将词语转化为元组。 list(my, name, is, zhangsan) ——> list((my, 1),(name, 1),(is, 1),(zhangsan, 1))
var flatMap = words.map((_, 1));
//将元组进行分组。 以元组的第一个字符（键），来分组。
var wordGroup = flatMap.groupBy(_._1)
//统计每个分组的 元素个数作为词频个数. like Map(forgotten -> 1, you,you -> 1, side -> 1, for -> 2)
var wordCount1 = wordGroup.map(x => (x._1, x._2.size))
//对其排序。先转化为列表，然后排序
var wordCount = wordCount1.toList.sortBy(_._2).reverse;
wordCount.foreach(println)
}
}
mysql AIP
// 如何导入 jdbc驱动包
https://blog.csdn.net/weixin_48185778/article/details/109451759?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.no_search_link&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.no_search_link
//增删改查开发1
https://blog.csdn.net/weixin_48185778/article/details/109451759?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.no_search_link&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.no_search_link
package com.lining
package com.lining.Hotitems
import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}
object mySql {
class MySqlTool(var ip:String= "" ,var port:String= "",var user:String= "",var passwd:String= "",var DB:String = ""){
private val url = s"jdbc:mysql://${ip}:${port}/${DB}?characterEncoding=utf8&useSSL=false"
private var connection:Connection=null
private val driver = "com.mysql.jdbc.Driver"
//Connect to Mysql
def getConnection():Unit={
Class.forName(driver)
connection=DriverManager.getConnection(url,user,passwd)
println("Connect to the Database successfully!")
}
//EXECUTE
def execute(sql:String): Unit ={
val prStamt = connection.prepareStatement(sql)
prStamt.executeUpdate()
}
//INSERT.
def insert(sql:String)={
execute(sql)
}
//DELETE.
//UPDATE.
//SELECT.
def select(sql:String):Unit={
println("SQL："+sql)
val rs: ResultSet=connection.createStatement().executeQuery(sql)
while (rs.next()){
var id = rs.getString("id")
var age = rs.getInt("cnt")
println(id+"\t"+age)
}
}
}
def main(args: Array[String]): Unit = {
val msT = new MySqlTool("139.196.237.231","3306","root","123456","test")
msT.getConnection()
val sql = "insert into tab1(id,cnt) values('a22',22);"
msT.insert(sql)
val sql2 = "select * from tab1;"
msT.select(sql2)
}
}
pgSql API
//不全，自己写，大致框架流程写上了
private var connection: Connection = null
private var ps: PreparedStatement = null
/*------------- 连接-------------- */
val driver = "org.postgresql.Driver"
val url = "jdbc:postgresql://139.196.237.231:5432/jobanalysis"
val username = "ln"
val password = "ning0852"
//1.加载驱动
Class.forName(driver)
//2.创建连接
connection = DriverManager.getConnection(url, username, password)
/*------------- 执行-------------- */
val sql = s"insert into job_data(name,work_link,price,city) values('${value.name}','${value.workLink}','${value.price}','${value.city}'');"
ps = connection.prepareStatement(sql)
ps.executeUpdate()
/*------------- 关闭-------------- */
ps.close()
connection.close()
class PgTool(var ip:String= "139.196.237.231" ,
var port:String= "5432",
var user:String= "ln",
var passwd:String= "ning0852",
var DB:String = "jobanalysis"){
private var connection: Connection = null
private var ps: PreparedStatement = null
private val driver = "org.postgresql.Driver"
private val url = s"jdbc:postgresql://${ip}:${port}/${DB}"
//连接
def getConnection():Unit={
//1.加载驱动
Class.forName(driver)
//2.创建连接
connection=DriverManager.getConnection(url,user,passwd)
println("Connect to the Database successfully!")
}
//断开连接
def close():Unit={
connection.close()
println("数据库连接关闭...")
}
//SELECT
def select(sql:String):List[String]={
//展示sql
println("SQL："+sql)
val rs: ResultSet=connection.createStatement().executeQuery(sql)
val workNameList = ListBuffer[String]()
while (rs.next()){
workNameList += rs.getString("class")
workNameList += rs.getString("name")
}
workNameList.toList
}
}
零散
scala读取文件
读取csv
import scala.io.Source
val sourceFile = Source.fromFile("文件路径"，"编码")
for(i <- sourceFile.getLines){
println(i);
}
String.split()函数
https://www.cnblogs.com/davidhaslanda/p/4050471.html
常用：
S.split("分隔符",-1)
输入
object compute {
def main(args: Array[String]): Unit = {
import scala.io.StdIn
// Scala从控制台读取数据
println("name")
val name = StdIn.readLine()
println("age")
val age = StdIn.readInt()
println("salary")
val salary = StdIn.readDouble()
//Java 从 控制台读取数据
System.out.println("name")
val scanner= new Scanner(System.in)
val nameJ= scanner.next()
System.out.println("age")
val ageJ = scanner.next()
System.out.println("salary")
val salaryJ = scanner.next()
}
}
存在判断 【.contains（） .exists（）】
//学习
https://blog.csdn.net/power0405hf/article/details/50371438
val m=Map(1 -> 1, 2 -> 2, 3 -> 3, 4 -> 4)
// m: scala.collection.immutable.Map[Int,Int]= Map(1 -> 1, 2 -> 2, 3 -> 3, 4-> 4)
val l = List(1,2,3,4)
// l:List[Int] = List(1,2,3,4)
val v = Vector(1,2,3,4)
// v: scala.collection.immutable.Vector[Int] = Vector(1,2,3,4)
val S = "12345"
m.exists(_._1 == 3) //> res0: Boolean = true
m.contains(3) //> res1: Boolean = true
l.exists(_ == 3) //> res2: Boolean = true
l.contains(3) //> res3: Boolean = true
v.exists(_ == 3) //> res4: Boolean = true
v.contains(3) //> res5: Boolean = true
S.contains(3) //> res6: Boolean = true
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ov836vQ8-1658547643165)(scala.assets/image-20211228150811358.png)]
疑问—解答
1.为什么main方法必须写在object里？
/*程序必须以一个函数main作为入口，但因为没有全局函数，所以就必须写在类里面，而且不是通过对象调用进入的，所以要是静态的，但scala没有static这个关键字和这种语义，所以又搞出了obejct伴生对象这种类似的东西。语义上就是这个伴生的单例对象的实例方法，给人感觉就更面向对象了，跟java/C#（都不是纯粹面向对象）那种就不一样了。C++多范式，可以定义全局函数，所以main直接全局函数就可以了，不必绕这种弯。
官方回答：
scala和Java一样，如果要运行一个程序，必须有一个main方法。而在Java中main方法是静态的，而在scala中没有静态方法。在scala中，这个main方法必须放在一个单例对象中。（而scala中单列对象object 就类似java中object.）
2.不可变列表、集、数组…等。不是说不可变吗？为什么会有些操作？如拼接…
/*
答案：是的。对不可变类型进行一些操作的时候，并不是在原变量上操作的，而是生成一个新的变量。
*/
// List列表相加，生成一个新的List
scala> val b = List(1, 2, 3) ++ List(1, 2, 3)
b: List[Int] = List(1, 2, 3, 1, 2, 3)
scala> b
res8: List[Int] = List(1, 2, 3, 1, 2, 3)
//Set集合相加操作，生成一个新的集合
scala> Set(1,2,3,4,5,6) ++ Set(6,7,8)
res13: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
/*综上，可以看出，这种不可变类型 即使有操作，那也是生成一个新的变量，不会再原变量上修改其内容*/
3.可变类型的引用
//不可变类型都在immutable库中，默认已经被引用。如果想引用可变类型，就需要引用mutable库。
import scala.collection.immutable.xxxxx
import scala.collection.mutable.xxxx
//如下 例子展示 不可变集合 与 可变集合的操作。【注意留心如下】
//1.默认引用的是不可变集合
//2.可变集合不可变集的创建方式一致，只不过需要提前导入mutable.set可变集类
//3.不可变类型在操作时候不可被修改，而可变类型可以。
scala> val a = Set(1,2,3,4)
a: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)
scala> a += 1
<console>:13: error: value += is not a member of scala.collection.immutable.Set[Int]
a += 1
^
scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set
scala> val b = Set(1,2,3,4)
b: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> b += 1
res21: b.type = Set(1, 2, 3, 4)
scala> import scala.collection.immutable.Set
import scala.collection.immutable.Set
scala> val c = Set(1,2,3,4)
<console>:13: error: reference to Set is ambiguous;
it is imported twice in the same scope by
import scala.collection.immutable.Set
and import scala.collection.mutable.Set
val c = Set(1,2,3,4)
4.实例成员、静态成员
/*
回答1：
静态成员归类所有，实例成员归对象所有！
回答2：
JAVA的类中可以包括2种成员：实例成员和类成员（静态成员）
实例成员时属于对象的，实例成员包括成员变量和实例成员方法。只有创建了对象之后，才能通过对象访问实例成员变量和调用实例成员方法。
类成员时属于类的，类成员需要用关键字static标示，也称为静态成员，类成员包括类成员变量和类成员方法。通过类名可以直接访问类成员变量和调用类成员方法，即使没有创建对象，也能够引用类成员。类成员也可以通过对象引用。
回答3：
*/
至此，scala中级简单学习到此结束。
.
.
.
血染江山的画，
怎敌你眉间一点朱砂，
负了天下也罢，
始终不过一场繁华。
3602
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
