1 getitem

https://zhuanlan.zhihu.com/p/27661382

2 all

https://orangleliu.blog.csdn.net/article/details/49848413

3 new

类实例化的时候先调用new生成这个对象， 然后调用init初始化这个对象

https://blog.csdn.net/qq_23183809/article/details/120819491

https://blog.csdn.net/Lq_520/article/details/81712905

4 del

https://blog.csdn.net/BeiisBei/article/details/105723188#_19

https://www.saoniuhuo.com/article/detail-72.html

https://www.dianjilingqu.com/20890.html

https://www.i4k.xyz/article/wjt199866/115184169#ODS__100

1.为什么要分层

1.清晰数据结构：每一个数据分层都有它的作用域，这样我们在使用表的时候能更方便地定位和理解。
2.数据血缘追踪：简单来讲可以这样理解，我们最终给业务呈现的是一张能直接使用的张业务表，但是它的来源有很多，如果有一张来 源表出问题了，我们希望能够快速准确地定位到问题，并清楚它的危害范围。
3.减少重复开发：规范数据分层，开发一些通用的中间层数据，能够减少极大的重复计算。
4.把复杂问题简单化：将一个复杂的任务分解成多个步骤来完成，每一层只处理单一的步骤，比较简单和容易理解。而且便于维护数据的准确性，当数据出现问题之后，可以不用修复所有的数据，只需要从有问题的步骤开始修复。
5.屏蔽原始数据的异常：屏蔽业务的影响，不必改一次业务就需要重新接入数据。

2.分层结构

2.1 ODS层

作用

https://blog.csdn.net/xuebo_911/article/details/8156016#

起到备份数据的作用

构建

1 直接加载原始日志、数据，保持原貌不做处理

2.2 DIM层

dim存放维度表，dwd存放事实表

作用

维度表可以看作是用户来分析数据的窗口，维度表中包含事实数据表中事实记录的特性，有些特性提供描述性信息，有些特性指定如何汇总事实数据表数据，以便为分析者提供有用的信息，维度表包含帮助汇总数据的特性的层次结构。

构建

https://help.aliyun.com/document_detail/137615.html

1 构建维度表，主要是对业务事实的描述信息，例如何人，何时，何地等

2.3 DWD层

作用

保存业务事实明细，一行信息代表一次业务行为，例如一次下单。

构建

1 对ODS层数据进行清洗（去除空值，脏数据，超过极限范围的数据、脱敏等）

2 构建事实表

https://help.aliyun.com/document_detail/114457.html

2.4 DWS

作用

避免重复计算

1）问题引出

两个需求，统计每个省份订单的个数、统计每个省份订单的总金额，都是将省份表和订单表进行join，group by省份，然后计算。同样数据被计算了两次，实际上类似的场景还会更多。

2） 那怎么设计能避免重复计算呢？

针对上述场景，可以设计一张地区宽表，其主键为地区ID，字段包含为：下单次数、下单金额、支付次数、支付金额等。上述所有指标都统一进行计算，并将结果保存在该宽表中，这样就能有效避免数据的重复计算。

构建

https://help.aliyun.com/document_detail/126913.html

0 分主题

1 构建宽表

2 以DWD为基础，按天进行轻度汇总。DWS层存放的所有主题对象当天的汇总行为，例如每个地区当天的下单次数，下单金额等

2.5 DWT

和DWS区别

DWS按天进行轻度汇总，DWT累积汇总

作用

避免重复计算

构建

0 分主题

1 构建宽表

2 以DWS为基础，对数据进行累积汇总。DWT层存放的是所有主题对象的累积行为，例如每个地区最近７天（１５天、３０天、６０天）的下单次数、下单金额等

2.6 ADS层

作用

为各种统计报表提供数据

构建

1 由于这层的数据量不大，所有没有分区，列式存储，压缩

3.构建过程

借助hive，主要就是写SQL，核心步骤就是：

1.建表

2.分区规划

​ 按什么分区，比如说按天，按月

​ 注意数据同步策略，全量，增量等

3.数据装载

​ 注意首日，每日

联系业务和不同层的要求

4.全流程调度

Azkaban

any graph transformation will result in the loss of batch information. for a workaround , you may should use set_batch_num_nodes and set_batch_num_edges

https://www.cnblogs.com/liyinggang/p/13360917.html

https://zhuanlan.zhihu.com/p/406833147

https://blog.csdn.net/wufeil7/article/details/107106299

https://www.douban.com/doulist/1202941/?start=0&sort=seq&playable=0&sub_type=

https://blog.csdn.net/qq_16669583/article/details/106026722

https://blog.csdn.net/u011564172/article/details/70172060

作用

根据rdd的依赖关系构建dag，然后基于dag划分stage

8 Performance Optimization Techniques Using Spark

https://www.syntelli.com/eight-performance-optimization-techniques-using-spark#

Spark性能优化指南（美团）

https://tech.meituan.com/2016/04/29/spark-tuning-basic.html

https://tech.meituan.com/2016/05/12/spark-tuning-pro.html

0 分析web ui

分析时间的消耗

1.多个map合并（？？）

1

rdd1.map().map() ->  rdd1.map() 

2.减少action算子

说白了就是多个action操作，transformation逻辑可以写一起，最后action

3 增加分区 增加并行度

分数是说rdd分区

并行度是说executor num*executor core num

https://zhuanlan.zhihu.com/p/70424613

https://zhuanlan.zhihu.com/p/348024116

https://spark.apache.org/docs/latest/cluster-overview.html

https://www.zhihu.com/question/437293024

https://blog.csdn.net/mzqadl/article/details/104217828

https://www.cnblogs.com/ExMan/p/14358363.html

客户端指的是提交任务的机器

一个worker可以有多个excutor，默认情况下，只会启动一个Executor 一个excutor就是一个进程

一个executor包含多个线程，一个线程执行一个task

3 Java 源文件的命名规则

• 通常情况下，Java 程序源文件的文件名可以任意。
• 但如果其中定义了一个 public 类，则该源文件的文件名必须与该 public 类的类名相同。
• 一个Java 源文件可包含多个类定义，但最多只能包含一个public类定义。

5 package

https://blog.csdn.net/qq_41297896/article/details/90056534

https://www.runoob.com/java/java-package.html

https://www.runoob.com/w3cnote/java-compile-with-package.html

为了更好地组织类，用于区别类名的命名空间

包的命名规范

https://blog.csdn.net/shi779276212/article/details/92795085

使用：

6 重写(Override)与重载(Overload)

https://www.runoob.com/java/java-override-overload.html

重写：是子类对父类同名函数的二次实现

重载：一个类内存在多个重名函数，而参数不同

7 多态

http://c.biancheng.net/view/1001.html#

https://www.runoob.com/java/java-polymorphism.html

多态是同一个行为具有多个不同表现形式或形态的能力。

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象：Parent p = new Child();

分类：

https://blog.csdn.net/zhao_miao/article/details/83750898

1 向上转型

父类 父类对象 = 子类实例

只能调用父特有，子覆盖，不能子特有

2 向下转型

向下转型之前一定要进行向上转型！！

子类 子类对象 = （子类）父类实例

可以父特有，子覆盖，子特有

8 程序入口

https://blog.csdn.net/weixin_29740921/article/details/114249667

入口为main，就和c++的main函数一样，main方法的写法是固定的

1
2

public static void main(String[] args) {}
public static void main(String args[]) {}

一个java文件可以不只有一个main，不同类都可以有自己的main，然后选哪个main呢，也就是选哪个类呢？

选公共类（至多包含一个）；若是没有就选用同名类，和文件同名

9 引用

https://zhulinyin.github.io/2019/01/28/Java%E7%9A%84%E5%9B%9B%E7%A7%8D%E5%BC%95%E7%94%A8%E6%96%B9%E5%BC%8F/

12 数据类型

分类

https://blog.csdn.net/Coding_Zhu/article/details/53096178

本质

https://www.zhihu.com/question/31203609

13 数组

声明

1
2
3
4
5

dataType[] arrayRefVar;   // 首选的方法
 
或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

创建

1
2
3

arrayRefVar=new dataType[arraySize];
或者
arrayRefVar = {value0, value1, ..., valuek};

多维数组

1

type[][] typeName = new type[typeLength1][typeLength2];

14 foreach

和普通for循环比较，在遍历数组、集合方面，foreach为开发人员提供了极大的方便

1
2
3
4
5
6

for(元素类型t 元素变量x : 遍历对象obj){ 
     引用了x的java语句; 
}

1
2
3
4
5
6
7
8
9
10

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

15 从控制台读取数据

1 BufferedReader

1
2
3
4

1 throws IOException
2 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
3 c = (char) br.read();
或者str = br.readLine();

2 Scanner

16 类型转化

http://c.biancheng.net/view/796.html

1自动类型转换

• 两种数据类型彼此兼容
• 目标类型的取值范围大于源数据类型（低级类型数据转换成高级类型数据）

2 强制类型转换

所以当两种数据类型不兼容，或目标类型的取值范围小于源类型时，自动转换将无法进行，这时就需要进行强制类型转换。

1
2
3

int a = 3;
double b = 5.0;
a = (int)b;

17 异常处理

http://c.biancheng.net/view/6751.html

Exception 是异常的基类

1 语句抛出异常

try

1
2
3
4
5
6
7
8
9

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

throw

当 throw 语句执行时，它后面的语句将不执行，此时程序转向调用者程序，寻找与之相匹配的 catch 语句，执行相应的异常处理程序。如果没有找到相匹配的 catch 语句，则再转向上一层的调用程序。这样逐层向上，直到最外层的异常处理程序终止程序并打印出调用栈情况。

1

throw ExceptionObject;

2 方法抛出异常

throws

函数声明异常，但是本身不处理异常，交给调用者处理

1

returnType method_name(paramList) throws Exception 1,Exception2,…{…}

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

import java.io.FileInputStream;
import java.io.IOException;
public class Test04 {
    public void readFile() throws IOException {
        // 定义方法时声明异常
        FileInputStream file = new FileInputStream("read.txt"); // 创建 FileInputStream 实例对象
        int f;
        while ((f = file.read()) != -1) {
            System.out.println((char) f);
            f = file.read();
        }
        file.close();
    }
    public static void main(String[] args) {
        Throws t = new Test04();
        try {
            t.readFile(); // 调用 readFHe()方法
        } catch (IOException e) {
            // 捕获异常
            System.out.println(e);
        }
    }
}

1
2

public static void main(String[] args) throws Exception
异常谁处理，JVM处理

20 final

https://zhuanlan.zhihu.com/p/60889552

21 static

https://zhuanlan.zhihu.com/p/70110497

22 泛型

目的：为了兼容多种数据类型，和c++模板很像

泛型标记符

1
2
3
4
5
6
7
8

E - Element (在集合中使用，因为集合中存放的是元素)；
T - Type（Java 类）；
K - Key（键）；
V - Value（值）；
N - Number（数值类型）；
R - Result （返回结果，多用于函数式编程）；
? - 表示不确定的java类型。
O 

1 泛型函数

1
2

public   void printArray( int [] inputArray ) -》public  < E > void printArray( E[] inputArray )
public  <T extends Comparable<T>> T maximum(T x, T y, T z) //Comparable是一个类

2 泛型类

1

public class Box -》 public class Box<T>

24 正则

java和python正则很像，但不是完全一样

https://blog.csdn.net/weixin_39574708/article/details/114958384

https://blog.csdn.net/henu_xiaohei/article/details/84765678

1 |

或者

2 固定匹配位数

1
2

\d{7,8} //7为或者8为
[A-Z]{1}[0-9]{8}

注意matches()，find（）

match是全部匹配，find是部分匹配

3 转义字符

转义字符\ *：不同于原来的字母含义，比如\n表示换行

java正则为什么要两个斜杆表示转义

https://blog.csdn.net/qq_37325947/article/details/107819945

25 java如何兼容不同类型的输入

1. 函数重载
2. 泛型

26 装饰器

@Override

需要你重写

28 类

this

和python self一样，指的是对象

#

类直接调用方法

https://blog.csdn.net/qq_40136594/article/details/83996659

需要是静态方法

1 创建对象

new

1
2
3
4
5
6
7
8
9
10

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

myPuppy不是指针，是强引用

2 继承

1 extends

1
2
3

class 子类 extends 父类 {
}
//只可以单继承

2 implements

一般用于类继承接口

1
2
3
4
5
6
7
8
9
10
11

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super关键字：当前对象，但是用来调用父类成员

this关键字：当前对象，用来调用子类成员

关于构造函数：

1 进入子类对应的构造函数

2 若是没有显示调用父类的构造函数，则自动调用；若是显示的调用父类的构造函数（super()，必须写第一句，super.SuperClass（） 错误），则显示调用

3 先调用父类，然后调用子类

3 匿名类

https://www.runoob.com/java/java-anonymous-class.html

4 抽象类

作用：抽象类为所有子类提供了一个通用模板，子类可以在这个模板基础上进行扩展，可以避免子类设计的随意性

1 抽象类

特殊的类：抽象类不能实例化对象，会报错

1
2

public abstract class Employee
1 在普通类的基础上加abstract

怎么使用抽象类？

通过类继承的方式使用

2 抽象方法

普通类不能有抽象方法，只有抽象类，或者接口

1
2
3
4

public abstract double computePay();
1. abstract
2. 只有函数声明，没有函数具体实现
3 子类不是抽象类，需要给出抽象类中的抽象方法的具体实现；子类也是抽象类，那么可以不需要

5 接口

接口并不是类，是抽象方法的集合

1
2
3
4
5

[可见度] interface 接口名称 [extends 其他的接口名， 其他的接口名， 其他的接口名] {
        // 声明变量,只能是 public static final 类型的
        // 抽象方法
}
//接口只能继承接口，extends，可以是多继承

怎么使用接口？通过类来实现

1
2
3

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

public class MammalInt implements Animal // Animal是接口

关系：

类和类，继承，只能单继承

类和接口，实现，可以多实现

接口和接口，继承，可以多继承

default

https://blog.csdn.net/qq_35835624/article/details/80196932

配合接口使用

使得接口内的函数可以写方法体，原来全是抽象方法，不能有方法体

29 Lambda表达式

声明的时候需要 ->

https://www.runoob.com/java/java8-lambda-expressions.html

1
2
3
4
5

MathOperation subtraction = (a, b) -> a - b; //声明
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));//调用

一起
 System.out.println("10 - 5 = " + tester.operate(10, 5,  (a, b) -> a - b));

30 systerm.gc()

一般情况不需要写这个，jvm自动gc

写这个，显示的gc

31 {}, static{}

https://blog.csdn.net/weixin_44279798/article/details/104331263

32 jni

1.java 调用 c++

c++代码打成so -> java加载so

test.java 里面的函数实现用c++写

test_jni.h test_jni.cpp

传数据给c++

https://blog.csdn.net/cgwang_1580/article/details/109498438

33 函数传参

按值传递

• 如果参数是基本类型，传递的是基本类型的字面量值的拷贝。
• 如果参数是引用类型，传递的是引用的对象在堆中地址的拷贝。

是否会改变原来的变量，看情况

https://www.zhihu.com/question/31203609

34 so load, so unload

1 load

system.load()

2 unload

The ListNet method grows on the bases of RankNet, they both employ the Cross Entropy function as a loss function and Gradient Descendant as algorithm to train a Neural Network Model. While the ListNet uses document list as instances, RankNet uses document pairs.

We investigated why the listwise method ListNet can outperform the pairwise methods of RankNet, Ranking SVM, and RankBoost.

https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-2007-40.pdf

1.for the pairwise approach the number of document pairs varies largely from query to query

2.The pairwise approach actually employs a ‘pairwise’ loss function, which might be too loose as an approximation of the performance measures