对spark进行字符统计 和java进行一些对比和思考

对spark进行字符统计 和java进行一些对比和思考

以下是表达

1.spark

def main(args: Array[String]): Unit = {

        //1.创建SparkConf并设置App名称
        val conf = new SparkConf().setAppName("WC").setMaster("local[*]")

        //2.创建SparkContext，该对象是提交Spark App的入口
        val sc = new SparkContext(conf)

        //3.读取指定位置文件:hello atguigu atguigu
        val lineRdd: RDD[String] = sc.textFile("input")

        //4.读取的一行一行的数据分解成一个一个的单词（扁平化）(hello)(atguigu)(atguigu)
        val wordRdd: RDD[String] = lineRdd.flatMap(line => line.split(" "))

        
        //切分好完全的词语结构==》列成map结构
        //5. 将数据转换结构：(hello,1)(atguigu,1)(atguigu,1)
        val wordToOneRdd: RDD[(String, Int)] = wordRdd.map(word => (word, 1))

        //根据map结构的key进行聚合(map ,被加后的数值总和)
        //6.将转换结构后的数据进行聚合处理 atguigu:1、1 =》1+1  (atguigu,2)
        val wordToSumRdd: RDD[(String, Int)] = wordToOneRdd.reduceByKey((v1, v2) => v1 + v2)

        //7.将统计结果采集到控制台打印
        val wordToCountArray: Array[(String, Int)] = wordToSumRdd.collect()
        wordToCountArray.foreach(println)

        //一行搞定
        //sc.textFile(args(0)).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).saveAsTextFile(args(1))

        //8.关闭连接
        sc.stop()

2.java

public class MapTest {
    public static void main(String[] args) {

        String s = "ababababcbc";

        Map<Character, Integer> map = new HashMap<>();
        //Map<Character, Integer> map = new HashMap<>();

        int count = 0;
        for (int i = 0; i < s.length() ; i ++ ){

            char c = s.charAt(i);
            //System.out.println(c); //存字符串中 逐个获取char
            map.getOrDefault(c,0) ; //map 如果没有就加默认为0
            count++;
            map.put(c,count); //map结构 统计和设定值
        }

        System.out.println(map);

    }
}
 

1.表达的简易性区别

spark更像是屏蔽了底层(基本逻辑) 而使用高度封装api的形式
而这些高度封装的api 让人着重于逻辑的实现 【比如sql】  
不用描写循环计数累加 map格式类型的表达
而不在乎其底层的实现表达

相对比而言  spark的高度封装 使其靠近了sql的逻辑 
比如对map形式的变化 (k v)
语言的表达 是靠近基本底层的逻辑的
对于java而言 如果要完成类map的运算 需要进行map类型的存储
如代码可以见 java进行的运算都其基本形式和逻辑 map类型 以及for循环的计数相加
而spark提供的api可以直接变化其rdd的个数 以及聚合算子。
~其实底层都是一样的。都需要一个 类似map的表达 计数相加。

2.过度封装对逻辑表达的优缺点
封装的rdd 使得其表达足够简易，同时使用了链式编程和lamada表达式
这只是一种表达方式而已。同理java中也有对表达简化的表达形式.
rdd更像是高度抽象的统计算子。

如果在循环统计中加入大量的逻辑 比如 如果是 a的权值为2  b的权值为3
ab同时出现的权值为4
就需要加入更多的逻辑表达式,而简单的表达形式 其实无法简化复杂的逻辑处理
比如遇到[a,2],[b,3],[ab,4],[ba,4];

rdd的高度抽象map是统一操作 [anything,1]
java由于循环的存在 可以嵌入if表达 对map进行选择赋值
同时也可以嵌入ab 是否相连的表达 因为使用的是基本的语言逻辑处理结构

sql层面做的化  需要嵌入 when then的结构

字段 key a a a a b b ab ba

select `key`,count(*) from (
SELECT 
char_list.`key`,
case
when char_list.`key` = 'a' then 2
when char_list.`key` = 'b' then 3
when char_list.`key` like 'ab' then 4
when char_list.`key` like 'ba' then 4
Else 0 END as value_key
FROM sql_practice.char_list
) rank
GROUP BY value_key

a   3
b   2
ab  2

也是基本的统计也还好了 就是简单的统计逻辑
我觉得sql的表达也是为了统计处理表结构 也就是横向统计

如果出现了 如果第一次出现 那么第二次逻辑的变动
其实会增加sql的复杂度
emmm 假如需要1000次if 或者数据的复杂关联等等
患者多个疾病健康之间的关联

此篇文章这个之后还会再更一下  感觉说的不是很完善

描述一下之后遇到的场景  以及sql处理的局限性
更多的底层表达 对于复杂关系的表达其实是有好处的