原因

​ 最近的情绪一直都很低落，做什么事情都提不起一点点兴趣，对于刷到的事情都漠不关心，就连最喜欢的吃有时候也感觉到难受，慢慢有种竟然有种厌世的感觉，脑子里自从有了这种想法，感觉不能这样了，一定要改变，去找心理学的书籍，去找关于思考的书籍，去找关于认知的书籍，一定要摆脱自己这种状态。发现了一本评论还不错的书《认知觉醒》，就拿过来看看，结果内容还不错，读了两遍之后我应该反馈一点东西，结合自身就写了这篇文章

关于焦虑认知

​ 书中关于焦虑有几种现象：选择焦虑，定位焦虑，完成焦虑，环境焦虑，难度焦虑。总结了：想同时做很多事情，又想立即看到效果，自己的欲望大于能力，又极度缺乏耐心。回想自己现在的状态也许焦虑是幕后最大的推手，对于现在的工作有点不满意同时对于外面的工作又缺乏勇气去寻找，每天都在应付着当前的工作又对远方的充满着憧憬，迟迟不迈出现在的环境圈。情绪的支出远远超过自己的每天极限，有时候需要玩上几局游戏，在空虚的世界找到一点点存在感，只需要不停地操作游戏中小人，找到那个绝对的掌控感心里才感觉好一点。对于当前的状况，我要慢慢充实自己，每天让自己增长一点，自信也会增加一点点，等到好的时机就会离开这个地方，慢慢打开这个心结，同时又找到事情做，感觉心里好受一点。

成长

​ 在合适的时机到来之前，需要不断学习，不是报多少课，也不是听了多少小时的时长，这些都是表面的努力。要学会在拉伸区的练习，要做稍微有点难度的练习，而不是在熟悉区学习，不是在听课的时候去想着打游戏，也不是在看书的时候满脑子里面想的在读一章就完成任务，也不是时间到点就给自己的心里打卡结束。如果出现这种情况，都是无效的学习，都是看似努力，实际没有什么用。打卡到点都是一种欺骗大脑的行为，实际内心的根本没有改变，游戏和电影的诱惑一直存在，要想改变这种情况，就要从根本上改变。从玩游戏玩的差不多必须要学习到学习完之后奖励自己玩游戏，看似没有变化，实际上有变化。第一种情况就像汽车发动状态改变，汽车本身的状态没有变化，就会出现玩游戏–>必须办作业–>结束。当没有作业就只有玩游戏。第二种情况：做作业–>奖励自己玩游戏。顺序改变，本质不同，这种情况就像汽车想变成轮船这种改变，第一种情况就是从静到动的改变，汽车没有变化。

​ 第二种情况也有一个好处：正向反馈，当你学习的时候感觉到有成就感的时候，这种感觉会可能会让你不自觉继续学习，碰到困难的知识点的时候也会去积极的去解决，然后继续获得成就感。学习结束之后，也没有完成焦虑，可能反馈自己做一点别的有意义的事情。想办法在学习中获得乐趣，才是最高级的快乐，继续保持着这种强大的力量，我们会变得优秀。

​ 我们想要变得优秀，也要有耐心。耐心是一个克服天性的法宝。面对诱惑，及时享乐是人的本性，学会延迟满足，对待延迟满足我们要学会沟通，坦然接受自己本身就有这个天性，相信一点点延迟满足，一点点慢慢变好，在这期间保持足够的耐心相信时间的复利。成长就是克服天性的过程，小时候我希望自己是一个孙悟空，能够千变万化，无所不能。长大一点，发现自己实际一点，不会变成孙悟空。希望自己变成一个“成功”的人，天天想着有一本“武林秘籍”，读完之后变成专家，在某个领域无所不知，没有困难。现在发现这些都没有，有的只是每天努力，每天增长一点点。消灭孙悟空，打破秘籍幻想，踏踏实实地去走好每一步，这也许就是所谓成长吧。

学习

专注

​ 学习要做到专注，高手都会做到沉浸式的学习，屏蔽外界的打扰，对于信息专注下去，有些人会主动在嘈杂吵闹环境训练这种能力，为了就是获取能够获得随时进入阅读和思考的能力。分心和走神本质还是对当前所做的事情的逃避，无非当前太痛苦找点舒服的事情做或者是当下太无聊找点有意思的事情。这就是需要在拉伸区的练习，有点难度，但不是痛苦。这样学会了一个，就会产生成就感获得快乐，这样就会形成一个闭环。学习–>成就感–>快乐–>学习，这样就会能够继续学习。这样你就更能专注。这就有两个前提：在拉伸区练习，这样可以获得成功还不至于太痛苦或者太无聊。

输出

​ 学习如果仅仅停留的听讲，阅读或者视听。通常会出现当时感觉听懂了，或者当真正用到的时候，觉得是这样的，也感觉那样也行，出现知识不牢的情况，如果再加上时间久了，很快就能忘的很干净。最好的方法就是输出，可以讲给别人听，当你能够给别人讲明白的时候，你才是真正的会了。当你要分享知识很多人的时候，为了避免自己尴尬，就会准备很长时间，想到别人可能遇到的问题，就会不停的补充知识，可能讲一页PPT，但是这张PPT可能会问到很多问题，你要准备两三天才能讲。还有就是讲的时候，需要用自己的话去讲，为了用词更准确，你必然要理解其中的内涵，不断反复捶打，也加深了印象。还有一种就是把你看到的写成文章或者一段话，讲的自己的理解和感受，这也是一种输出。

学习方式

​ 书中提到关联和触动学习，看到之后恍然大悟。发现自己以前很多时候读书的时候都是错误的。之前读书的时候，总是想全盘接受作者的知识，因为阅历，能力等等差别让自己很痛苦，根本不可能全盘接受，有些因为理解不同，发出为什么这样写，还会冲击一些固有的意识。所以不必一定要全盘接受，只需要关注那些让自己触动的点，关联自己的想法或者生活阅历，还可以迁移到这个点还用到什么地方。人不断的阅读，不断吸收各家触动点，形成自己的认知体系。同事不同的触动点慢慢关联在一起，就会扩大自己的认知范围，反过来也会让我们遇到事情更容易判断和决策，触动点越多，关联的越多，看待事情就会越全面。这也许就是阅读的意义

jar包顺序

因为在包中要使用http请求外部接口获取数据。而本身spark就自带http的请求的包。因为版本不一致，导致方法不一样或者某些方法没有而报错

解决方法

1

--conf spark.driver.userClassPathFirst=true

Detected implicit cartesian product for LEFT OUTER join问题

先看代码

1
2

spark.sql("select count(1) as wnum from A").createOrReplaceTempView("temp")
spark.sql("select wnum,1 as type from temp")

上面的代码第一句查询总数，第二段加一个type字段值为1，用于left join的判断条件

然后这段代码产生的df会给别的df进行关联查询，就用报一个错误：

1
2

Exception in thread "main" org.apache.spark.sql.AnalysisException: Detected implicit cartesian product for LEFT OUTER join between logical plans
Aggregate [count(1) AS wnum#429L, 1 AS type#432]

解决方法：

1

spark.conf.set("spark.sql.crossJoin.enabled", "true")

两数之和

1.题目

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the sameelement twice.

Example:

1
2
3
4

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

分析：

就是给定一个数，在列表中找到两个数的和是这个，把下标输出出来。最简单的方式就是用for循环，比如下面的代码：

1
2
3
4
5
6
7
8
9

list=[]
numsLen = len(nums)
for i in range(numsLen):
    for k in range(i+1,numsLen):
        if nums[i]+nums[k]==target:
            list.append(i)
            list.append(k)
            return list
 return None

这个最好理解的，就是for循环，从第一个开始循环，然后再循环剩下的数入，如果两个数加起来是目标数值，就返回。在一个从小到大有序的数组是非常快。但是如果这个数组中数值是无序就比较慢了（只能跑赢20%左右的python代码）。

下面给出一个无序比较快的一段查找代码：
​

1
2
3
4
5
6
7
8

a={}
for i,value in enumerate(nums):
    if target-value in a:
        return [a[target-value],i]
    else:
        a[value] = i
 
return None

这个代码的思路，一次循环就能做出来，用了字典，key是数组的值，value是数组的下标。然后利用字典的查询特点快速找到值，取出下标(跑赢100%)。

两个列表之和

题目

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example:

1
2
3

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.

分析：

就是把两个链表上的数值相加，最终得到一个链表的值。有点像竖式运算。所以就只能循环链表，把数值相加。注意，超过9的话会进1。简单的代码如下：

1
2
3
4
5
6
7
8
9
10

cur = result =ListNode(0)
 a=0
 while l1 or l2 or a != 0:
     k = (l1.val if l1 else 0) + (l2.val if l2 else 0) + a
     a = k / 10
     cur.next = ListNode(k % 10)
     cur = cur.next
     l1 = l1.next if l1 else None
     l2 = l2.next if l2 else None
 return result.next

这个里面就是有很多判断条件，只能跑赢40%左右的python代码，下面又做了一些改进

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

cur = result =ListNode(0)
      carry=0
      a=0
      while l1 and l2:
          k = l1.val+l2.val+carry
          carry=k//10
          cur.next=ListNode(k%10)
          cur = cur.next
          l1 = l1.next
          l2 = l2.next
      while l1:
          k = carry+l1.val
          carry=k//10
          cur.next=ListNode(k%10)
          cur = cur.next
          l1 = l1.next
      while l2:
          k = carry+l2.val
          carry=k//10
          cur.next=ListNode(k%10)
          cur = cur.next
          l2 = l2.next
      if carry!=0:
          cur.next=ListNode(carry)
          cur = cur.next
      return root.next

这个代码比上一个代码只能提升一点点，怎么能跑赢超过一半的python代码，不知道大家有没有比较好的想法，可以交流一下

上次利用poi导出Excel，写了一个Excel的工具类，感觉还是挺好用的。但是有一个问题，Excel的头部是白色和下面的内容的颜色是一样的。这看着怎么可以。于是想着添加一下背景色

掉坑

Excel的处理逻辑从大到小，首先创建一个工作簿（sheet），然后创建里面的行（row），在行中创建单元格（cell），然后在cell中赋值这样Excel中的值就来。

所以我认为cell对象中直接设置背景颜色的方法setcolor这个方法。然而没有。只有一个setCellStyle的方法，传入的对象XSSFCellStyle，那只能创建这个对象。注意这个对象是用XSSFWorkbook创建的。

找到这个对象之后，看一下有没有关于颜色的方法，找到两个setFillForegroundColor和setFillBackgroundColor，看到方法肯定用setFillBackgroundColor，但是万万没有想到，直接把cell中内容覆盖了。所以使用setFillForegroundColor这个方法试一下，最后成功了，然后看api中介绍，发现api中介绍：many cells are actually filled with a foreground fill。

看到这个方法用的是XSSFColor对象，那就再new一下，看一下XSSFColor的对象和方法：发现一个public XSSFColor(Color clr)构造方法，注意这里面的Color对象是java.awt.Color而不是org.apache.poi.ss.usermodel.Color，可以直接用Color.RED设置红色。我调色的时候喜欢用rgb的数值来确定颜色，于是找到XSSFColor有setRGB方法，感觉离成功不远了，下面贴一下代码供大家参考

1
2
3
4
5
6

val style = xssf.createCellStyle()
val color =new XSSFColor()
color.setRGB(Array(189.toByte,183.toByte,107.toByte))
style.setFillForegroundColor(color)
style.setFillPattern(FillPatternType.SOLID_FOREGROUND)
cell.setCellStyle(style)

垃圾回收器

1.串行回收器

串行回收器是指使用单线程进行垃圾回收的回收器，每次回收只有一个线程，专注性和独占性有更好的性能表现，可以在新生代和老年代使用，所以可以分为新生代串行回收器和老年代串行回收器

1.1新生代串行回收器

特点：

单线程进行垃圾回收，独占式的垃圾回收。新生代串行回收器采用复制算法，实现简单，处理高兴，没有线程切换开销。在某些场景下超越并行回收器和并发回收器（比如单cpu等）

当串行回收器进行垃圾回收，java中的所有线程都会暂停，所以实时性要求高的应用场景，不能被接收

使用-XX:+UseSerialGC可以指定新生代串行回收器或者老年代串行回收器，当虚拟机在Client模式下，默认的垃圾回收器

1.2老年代串行回收器

特点：

老年代串行回收器使用的标记压缩算法，也是一个串行独占的垃圾回收器，由于老年代垃圾回收时间一般比新生代要长，所以停顿时间也可以比较长

-XX:+UseSerialGC：新生代和老年代都使用串行回收器

-XX:+UseParNewGC：新生代使用ParNew回收器，老年代都使用串行回收器

-XX:+UseParallelGC：新生代使用Parallel回收器，老年代都使用串行回收器

2.并行回收器

并行回收器在串行基础上做了改进，使用多个线程同时进行垃圾回收，对于并行能力较强的计算，可以有效缩短垃圾回收所需的实际时间

2.1新生代ParNew回收器

ParNew回收器是用于新生代垃圾回收，它只是简单地将串行回收器多线程化，回收策略，算法和参数和新生代串行回收器一样。ParNew也是一个独占式的回收器，所以应用程序会全部暂停，但是在并发能力较强的机器上，回收时间要短于串行回收器

-XX:+UseConcMarkSweepGC：新生代使用ParNew回收器，老年代使用CMS

-XX:ParallelGCThreads：ParNew回收器线程数量。

2.2新生代ParallelGC回收器

从表面上看和ParNew回收器一样，使用复制算法，多线程和独占式的收集器。它有一个很重要的特点就是关注系统的吞吐量。有两个重要的参数：

-XX:MaxGCPauseMills:设置最大垃圾回收的停顿时间

-XX:GCTimeRatio: 设置吞吐量的大小，默认值是99，就是1%(1/(1+99))的时间用于垃圾收集

-XX:UseAdaptiveSizePolicy 是一种自适应的GC调节策略，在这种模式下，新生代的大小，end和survivior的比例，晋升老年代的对象年龄参数都会自动调整已达到堆大小，吞吐量和停顿之间的平衡点。

注意：-XX:MaxGCPauseMills和-XX:GCTimeRatio是两个互相矛盾的参数。

2.3老年代ParallelOldGC回收器

老年代ParallelOldGC回收器也是多线程并发的收集器，关注吞吐量的一个回收器。用的是比较压缩算法，其余参数和ParallelGC回收器类似，一个用于新生代一个用于老年代。

3.CMS回收器

CMS是Concurrent Mark Sweep的缩写，意思是并发标记清除，它使用的标记清除算法，同时又是一个多线程并行回收的垃圾回收器。

回收步骤

1. 初始标记：独占资源，标记跟对象
2. 并发标记：标记所有对象
3. 预清理：清理准备以及控制停顿时间
4. 重新标记：独占资源，修正并发标记对象
5. 并发清理：清理垃圾
6. 并发重置

根据标记清除算法：初始标记，并发标记和重新标记都是标记清除的对象。并发清理则是正式回收垃圾对象，并发重置是在垃圾回收完成后，重新初始化cms数据结构和数据

主要参数

-XX:+UseConcMarkSweepGC 启用cms垃圾回收器

-XX:ConcMarkThreads 并发线程数

-XX:+CMSInitiatingOccupancyFraction 内存空间使用阈值，默认68%，达到阈值时会进行垃圾回收

-XX:+UseFullGCsBeforeCompaction:回收多少次后，进行内存压缩

-XX:+UseCMSCompactAtFullCollection 使CMS垃圾回收之后进行内存碎片整理，注意内存碎片整理不是并发的

4.G1回收器

G1回收器是从jdk7开始正式使用的回收器，回收还是分年轻代和老年代。但是它使用分区算法，其特点如下：

并行性： 垃圾回收期间，可以多个GC线程同时进行

并发性：程序和GC交替进行，所以不会完全阻塞程序

分代GC：G1依然是一个分代回收器，兼顾年轻代和老年代。

空间整理：在回收过程中会进行适当的空间移动，有效的复制对象，减少空间碎片

可预见性：由于分区的原因，可以选择部分区域进行回收，所以全局停顿可以得到很好的控制

注意：并行：程序会停顿，多线程同时进行，并发：程序和回收交替进行。

G1的回收过程可能有4个阶段：

新生代GC，并发标记周期，混合收集，可能会进行full GC

1.新生代GC

新生代GC是主要工作是回收eden区和survivor区，一旦eden区被占满，新生代GC就会启动。新生代GC只处理eden区和survivor区，回收之后所有eden区都应该被清空，survivor区清除一部分。还有一个变化就是年老代会增多

2.并发标记周期

并发标记周期可以分为以下步骤：

初始标记：标记从根节点可以直接到达的对象，它伴随着一次新生代GC,会产生停顿，应用程序在这个线程中会停顿

根区域扫描：这个可以跟应用程序一起运行

并发标记：查找整个堆的存活对象，并做好标记

重新标记：并发过程中程序依然进行，结果可能需要修正，重新标记，对上次结果进行补充，为了加快标记速度，会创建一个快照。

独占清理：这个阶段会引起停顿，它计算各个区域存活对象和GC回收比例进行排序，识别可供回收的区域。会标记可以混合回收区域，混合回收阶段会需要这些信息

并发清理阶段：识别并清理完全空闲区域，并发清理，不会引起停顿

3.混合回收：

在并发标记周期中会回收一部分对象，但是总体来说还是比例相当低。在并发标记周期中已经知道哪些可以区域可以混合回收，这个阶段就是对这些区域进行回收。会优先回收垃圾比例比较高的区域因为这些区域性价比比较高。它会回收年轻大和老年代区域。

4.必要时full GC

并发收集和应用程序交替运行，这样就不能避免在特别繁忙的场合出现回收过程中内存不足情况。当遇到这种情况G1就会进行full GC

今天做了scala把数据库的数据按照需求导出Excel中，遇到一些问题和坑，记录下来遇到的大家分享。首先一个贴上一个粗糙的demo，大家可以借鉴一下。

利用Apache poi包进行处理，用的是4.0.1，依赖包：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 <dependency>
     <groupId>org.apache.poi</groupId>
     <artifactId>poi</artifactId>
     <version>4.0.1</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>4.0.1</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml-schemas</artifactId>
    <version>4.0.1</version>
</dependency>

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

//创建file
    val file = new File("/Users/xk/Desktop/a.xlsx")
    //val ps = new POIFSFileSystem(new BufferedInputStream(new FileInputStream("/Users/xk/Desktop/a.xlsx")))
    //判断file是否存在，不存在创建
    if(!file.exists()){
      try{
        file.createNewFile()
       // WorkbookFactory.create(new FileInputStream("/Users/xk/Desktop/a.xlsx"))
      }catch {
        case ex:IOException=>{
          println("error")
        }

      }
    }

    //excel处理Excel的类
    val hssf = new XSSFWorkbook()
    //创建一个工作簿
    val sheet = hssf.createSheet("student")
    //创建第一行，一般都是的头部
    val firstRow = sheet.createRow(0)
    //设置行头
    val heads = Array[String]("名字","年龄","班级")
    //设置头部
    for(i<- 0 until heads.length){
      val cell = firstRow.createCell(i)
      cell.setCellValue(new XSSFRichTextString(heads(i)))
    }


    val rowlist = parkDF.collect().toList

    for(i <- 0 until rowlist.length){
      val erow = sheet.createRow(i+1)
      val xlsDot = rowlist(i)


      val sortCell = erow.createCell(0)
      sortCell.setCellValue(xlsDot.getString(0))

      val sortCell1 = erow.createCell(1)
      sortCell1.setCellValue(xlsDot.getString(1))

      val sortCell2 = erow.createCell(2)
      sortCell2.setCellValue(xlsDot.getString(2))

    }

    val out = new FileOutputStream("/Users/xk/Desktop/a.xlsx")
    hssf.write(out)
    out.close()
    //in.close()
    hssf.close()

遇到的坑：

org.apache.poi.poifs.filesystem.NotOLE2FileException

之前用的HSSFWorkbook类处理Excel，发现这个类只处理2007版之前的Excel，可以看成后缀是xls的Excel文件，后缀为xlsx需要用XSSFWorkbook，这个类不在poi包，需要引用poi-ooxml和poi-ooxml-schemas包

org.apache.poi.EmptyFileException: The supplied file was empty (zero bytes long)

看到网上例子，创建XSSFWorkbook的时候，有用fileInputStream参数创建的。我就用了val hssf = new XSSFWorkbook(new FileInputStream(“/Users/g2/Desktop/a.xlsx”))的方式报错，结果一直报这个错误，去掉流的参数就可以了

####

垃圾回收算法

1引用计数法

思想：

对象A引用了就加1，引用失效了就减1，当引用数为0时，就可以回收

缺点：

1、无法处理循环引用情况（对象A引用对象B，对象B引用对象A，但是A和B都没有别的对象引用）

2、引用计数器要求每次引用产生和消除的时候，都伴随着加法和减法的操作，对系统有一定的影响。

2标记清除算法

标记清除算法是现代回收算法的基础思想，在介绍之前先解释两个名词：

可达对象：通过根对象进行引用搜索，最终可以搜索到的对象

不可达对象：通过根对象进行搜索，最终没有被引用的对象

新生代：存放年轻的对象堆空间，年轻的对象指刚刚创建或者经理回收次数不多的对象

老年代：存放老年的对象的堆空间，老年对象指经历过多次垃圾回收依然存货的对象

思想：

分为两个阶段，标记和清除。标记阶段：标记所有根对象可到达对象，未被标记的对象就是垃圾对象，清除阶段：系统回收不可到达的空间

缺点：

回收后空间是不连续的。当再分配空间时，特别是大对象的时候，不连续的空间要低于连续的空间。

3.复制算法

思想：

将原有的内存空间分成两块，每次只使用其中一块，在垃圾回收的时候，将正在使用的对象复制到未使用的内存中

优点：

如果系统中垃圾对象比较多，需要复制存活的比较少，效率比较高。还有就是复制对象到新的内存空间空间是连续的

在java中新生代串行垃圾回收器中使用这个算法。新生代有分为eden区，from区和to区。其中from和to是两个相同大小的空间。

适用于：

使用在新生代中，因为新生代中垃圾对象通常会多于存活对象

4标记压缩算法

思想：

标记压缩算法，标记也是从根节点开始，对所有的可达对象进行标记。然后把所有存活对象压缩到内存的一段，清理边界外的空间。这样空间是连续的，没有碎片产生。所以看成标记清除算法+空间整理

适用于：

年老代通常使用这种算法，年老代对象大多情况下都是存活对象，如果在使用复制算法，复制成本比较高。

5分代算法

思想：

由于复制，标记压缩，标记清除各有优缺点。根据回收垃圾对象的特性，使用不同的算法这样比较好。基于这种思想，内存空间根据对象的特点分成不通的区间，对应不同的算法。

一般内存分代，分成老年代和年轻代。老年代用于标记压缩算法和标记清除算法，新生代用于复制算法。老年代回收频率比较低，新生代回收频率比较高。

6分区算法

思想：

分代算法是根据对象的存活时间，分区则是把堆空间分成连续不同的小区间，每个区间独立使用，独立回收。

优点

一般来说，堆空间越大一次回收越多，从而产生的停顿越长。可以根据目标的停顿时间，每次回收若干个合理的区间，而不是整个空间。

上周利用spark sql统计mysql数据库中数据然后导入mysql的报表库中，遇到了一些时间处理的问题，记录一下mysql和spark sql处理不同。

最近30天处理

在spark sql中处理：

1

date_sub(now(),30) <=create_time

在mysql处理:

1

DATE_SUB(CURDATE(), INTERVAL 30 DAY) <=create_time

时间相差几天

在spark sql处理（和mysql一直）：

1

datediff(start_time,end_time)<1(天数)

相差多少分钟

在spark sql先把两个时间转换时间戳，然后再除以60.利用unix_timestamp函数进行处理,下面是转换为秒

1

unix_timestamp(a.depart_time)-unix_timestamp(a.enter_time)

转换为年月日

在spark sql用date_format进行处理，注意想要####-##-##模式，格式一定要y-MM-dd,这样用时间排序才没有问题，如果是y-M-d，出现的日期格式，排序会有问题

1

DATE_FORMAT(create_time, 'y-MM-dd')

spark的视图

spark的视图创建非常方面，一般使用createOrReplaceTempView方法，创建视图，比如可以这样使用

1
2

spark.sql("select * from 
A where deleted=0").createOrReplaceTempView("a_view")

利用视图可以把复杂嵌套的sql分解一个个视图，最后得到想要的结果

注意：视图不能全部数字，会报错。视图如果被使用过，需要重新创建。

终于利用github+hexo搭建完博客，现在聊一下搭建博客历程和遇到的坑。

github创建工程

工程的名字一定要是{你的名字}.github.io，这样你的项目访问的路径才是{你的名字}.github.io,要不然会带上github的域名和普通的项目没有区别

hexo使用

hexo init 如果没有指定目录，会在当前目录下建立网站。如果当前目录不为会报错，也可以指定目录

一般使用的hexo指令

hexo new 新建一篇文章

hexo clean 清除缓存

hexo generate 生成静态文件 可以简写成hexo g

hexo deploy 部署之前生成的静态文件 简写成 hexo d

我一般改写完之后，都是 hexo g -d