Kotlin知识点整理

2020-06-09

一、基础

1. 基础语法

1. 变量

var表示一个变量

val表示不可变的变量（不是常量）

如果编译器可以识别出变量类型，那么变量的类型可以不用写

var age: Int = 18
val name: String = "Sun Jie"

// 因为可以识别，也可以省略变量类型
var age = 18
val name = "Sun Jie"

// 如果声明的时候没有赋值，那么变量类型不能省略
val name: String

kotlin具有空安全类型的，如果不确定是否为空，需要在类型后面加上？

String 和String?是完全不同的两种类型

1	val name2: String? = null

如果确定不会为空，需要将带问号的类型赋值给不带问号的类型，则需要进行强转，加!!可以进行强转

1	name = name2!!

如果是不带问号的类型赋值给带问号的类型，不需要强转，直接赋值就行

1	name2 = name

2. 函数

通过fun 进行申明函数，kotlin中如果方法可以写在类外部，通过包名.方法名调用，要注意同一个包中，方法名字防止重名

fun  [方法名] ( [参数名] : [参数类型] ) : [返回类型]{
    ...
    return [返回值]
}

参数后面跟参数的类型

如果函数有返回值，在方法后面跟返回值类型

fun printLen(str: String): String {
    println("这个字符串是：$str")
    return str
}

//如果只有一行执行代码可以这样写
fun getLen1(str: String): Int = str.length
//或者换成lambda写法
var getLen2 = {str: String -> str.length}

如果函数没有返回值，类型用Unit代替，一般可以省去

fun printStr(str: String): Unit {
  	println("这个字符串是：$str")
}
//可以省略Unit
fun printStr1(str: String) {
  	println("这个字符串是：$str")
}

普通方法：通过对象.方法名调用

fun main(args: Array<String>) {
    Test().method()
}

class Test{
    fun method(){
        print("hello")
    }
}

静态方法：通过类名.方法名调用

fun main(args: Array<String>) {
    Test.method()
}

class Test{
    companion object{
        fun method(){
            print("hello")
        }
    }
}

顶级方法：通过包名.方法名调用

package com.xumao.kotlindemo

fun method(){
    print("method")
}

fun main(args: Array<String>) {
    com.xumao.kotlindemo.method()
}

3. 条件和循环控制(if、when、for、while、return、break、continue)

if：用法雷同java，与java不同的是可以有返回值

// 传统用法
var max = a 
if (a < b) max = b

// 使用 else 
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}
 
// 作为表达式
val max = if (a > b) a else b

// 有返回值的用法
val max = if (a > b) {
    print("Choose a")
  	// 返回值需要放到最后
    a
} else {
    print("Choose b")
    b
}

// 实现三元操作符
val c = if (condition) a else b

// 用in运算符来检测数字是否在区间内，区间格式为x..y
if (a in 1..8) {
		println("a 在区间内")
}

when：类似于java的switch

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
  
  	// 多个分支需要相同处理时，可以合并条件，用,隔开
  	3, 4 - > print("x == 3 or x == 4")
  
  	in 5..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
  
  	is String -> print("x is String")
  
  	// when中，else等同于switch中的default
    else -> { // 如果只有一行可以不用{}，直接把语句写后面
        print("x 不是 1 ，也不是 2")
    }
}

// 可以用when实现if,else的效果
when {
		a > b -> print("a>b")
    b > c -> print("b>c")
    else -> print("else")
}

for：可以对任何提供迭代器（iterator）的对象进行遍历

for (item: Type in collection) {
		// ......
}

var list=arrayListOf("a","b","c")
for(item in list){
    println(item)
}

// 根据下标遍历
for (i in list.indices) {
    println(list[i])
}

// 用区间遍历
for (i in 0..list.size - 1) {
    println(list[i])
}

//从1到10(不包括10)，步长为1
for (i in 1 until 10) {
    println(i)
}

//从1到10，步长为2
for (i in 1..10 step 2) {
    println(i)
}

//从10到0倒数，步长为3
for (i in 10 downTo(0) step 3) {
    println(i)
}

while：和java中用法相同

while( 布尔表达式 ) {
		//TODO
}

// do...while循环至少会执行一次
do {
		//TODO
}while(布尔表达式);

返回和跳转：kotlin有三种结构化跳转表达式

return：默认从最直接包围它的函数或者匿名函数返回
break：终止最直接包围它的循环
continue：继续下一次最直接包围它的循环

fun main(args: Array<String>) {
    for (i in 1..10) {
        if (i == 3) continue  // i 为 3 时跳过当前循环，继续下一次循环
        println(i)
        if (i > 5) break   // i 为 6 时 跳出循环
    }
}

多重循环用@标记：在多重循环中可用 “标记名+@”在循环体外做标记，跳转时添加“@+标记名”跳到对应的位置

fun main(args: Array<String>) {
    flag1@
    for (i in 0..3) {
        println()
        flag2@
        for (j in 0..3) {
            if (i > 2) {
                break@flag1
            }
            if (j % 2 == 0) {
                continue@flag2
            }
            print("[$i : $j]  ")
        }
    }
}

//输出结果为
[0 : 1]  [0 : 3]  
[1 : 1]  [1 : 3]  
[2 : 1]  [2 : 3]

4.复合符号

?. foo?.bar：对象不为空，返回相应的成员变量，对象为空，返回null

//等同于下面代码
if (foo != null) {
  	return foo.bar()
} else {
  	return null
}

?: foo?:bar：对象不为空，返回对象，为空，返回冒号后面的

//等同于下面代码
if (foo != null) {
  	return foo
} else {
  	return bar
}

as? foo as? Type

//等同于下面代码
if (foo is Type) {
  	return foo as Type
} else {
  	return null
}

!! foo!!

//等同于下面代码
if (foo != null) {
  	return foo
} else {
  	throw NullPointerException
}

2. 与Java代码互调

kotlin里面的函数可以直接写在文件里面，不需要写在类里
1
2
3
4
//Utils.kt
fun echo(name: String){
println("$name")
}
在Java中调用这个函数时，在文件名后面加Kt，然后就可以直接调用函数
1
2
3
public static void main(String[] args){
UtilsKt.echo("hello");
}

匿名内部类（单例）

object Test{
    fun sayMessage(msg: String){
        println(msg)
    }
}

//在kotlin中调用
Test.sayMessage("hello")

//在java中调用
Test.INSTANCE.sayMessage("hello")

kotlin中class文件是KClass，例如有JavaMain和KotlinMain两个类

fun main(args: Array<String>){
    testClass(JavaMain::class.java)
    testClass(KotlinMain::class)
}

fun testClass(clazz: Class<JavaMain>){
    println(clazz.simpleName)
}

fun testClass(clazz: KClass<KotlinMain>){
    println(clazz.simpleName)
}

如果java中变量和kotlin关键字发生冲突，引用该变量时，用两个反引号`转义

1
2
3

class JavaMain{
    public static final String in = "in";
}

1 2	//在kotlin中引用的的时候，因为in在kotlin中是关键字，需要用反引号转义 println(JavaMain.`in`)

kotlin中没有封装类

kotlin调用java返回值可能为空的方法时，尽量用空安全类型，在类型后面加？

// java中方法
class A{
    public static String format(String str){
        return str.isEmpty()?null:str;
    }
}

1	val fmt: String? = A.format("")

kotlin没有静态变量和静态方法，可以通过使用注解@JvmStatic

object Test{
    @JvmStatic
    fun sayMessage(msg: String){
        println(msg)
    }
}

//在java中调用
Test.sayMessage("hello")

3.函数与Lambda

1. 函数参数–默认参数和可变参数

vararg用于修饰可变参数

fun print(name: String = "Sun Jie"): String{
    println("$name")
    return name;
}

fun prints(vararg strs: String){
  	for (str in strs){
      	println("$str")
    }
}

fun main(args: Array<String>){
    print()//输出"Sun Jie"
    print("hello")//输出"hello"
  	prints("aaa","bbb","ccc")
}

2. 如果一个函数只有一个语句，可以直接将语句赋值给函数

1	fun echo(name: String) = println("$name")

3. 函数可以嵌套（不推荐使用）

用于在某些条件下触发递归的函数或者不希望被外部函数访问到的函数

fun function(){
    val str = "hello!"
    
    fun say(count: Int = 10){
        println(str)//内部函数可以直接访问外部函数的变量
        if (count > 0){
            say(count - 1)
        }
    }
    say()
}

4. 扩展函数

为三方库，或者不能控制的类中添加函数，可以使用扩展函数

// 在FileReadWrite.kt中为File添加一个函数readText
public fun File.readText(charset: Charset = Charsets.UTF_8): String = reader(charset).use { it.readText() }

// kotlin中调用时可以直接调用
fun main(args: Array<String>) {
    val file = File("KotlinDemo.iml")
    print(file.readText())
}

// java中调用
public static void main(String[] args) {
    File file = new File("KotlinDemo.iml");
  	// java调用方法时，第一参数需要传递本身对象，默认参数也不能省略
    String content = FilesKt.readText(file, Charsets.UTF_8);
    System.out.println(content);
}

5. Lambda闭包

Kotlin中lambda参数最多只能有22个参数，不过Kotlin1.3后参数没有限制了

//java中lambda语法
Thread thread = new Thread(() -> {
  	//TODO
});

val thread = Thread({
    //参数
    ->
	  //TODO
})

// 如果lambda没有参数可以省略->
val thread = Thread({
	  //TODO
})

// 如果lambda是函数的最后一个参数，可以将大括号放在小括号外面
val thread = Thread(){
	  //TODO
}

// 如果函数只有一个参数且这个参数是Lambda，则可以省略小括号
val thread = Thread{
    //TODO
}

6. 高阶函数：函数的参数也是函数

// 函数作为参数时候，Unit不能省略
fun onlyif(isDebug: Boolean,block: () -> Unit) {
    if (isDebug) block()
}

fun main(args: Array<String>) {
  	// 当lambda作为函数最后一个参数时，可以将大括号写到小括号外面
    onlyif(true){
        println("打印日志")
    }
}

val runnable = Runnable {
  	println("Runnable::run")
}

val function: () -> Unit
// ::后面跟方法表示引用这个函数，不执行
function = runnable::run

lambda在编译时候，会编译成匿名内部类对象，可以通过在lambda函数前面加上inline，这样当方法在编译时会拆解方法的调用为语句调用，减少创建不必要的对象

inline通常只会用于修饰高阶函数

1
2
3

inline fun onlyif(isDebug: Boolean,block: () -> Unit) {
    if (isDebug) block()
}

4. 类与对象

1. 父类与继承

kotlin中所有的类都继承Any类，它是所有类的超类

继承类的写法

1	class MainActivity : AppCompatActivity()

如果当前类需要能够被继承，那么需要添加open关键字，kotlin默认给类添加public final关键字，方法如果需要被重写也需要添加open关键字
1
open class MainActivity : AppCompatActivity()

实现接口可以直接跟着类名后面，和继承的父类没有先后关系顺序

class MainActivity : AppCompatActivity(),OnClickListener

// 没有先后顺序的要求，也可以用如下写法
class MainActivity : OnClickListener,AppCompatActivity()

2. 构造函数

如果需要给Kotlin的主构造函数添加参数，需要在类名后面添加，如果需要在主构造函数中执行语句，需要在init里面执行

类内部的init模块和变量的初始化顺序按照他们出现的顺序进行，并且都在次构造函数之前执行

成员变量和init模块在初始化时可以直接使用主构造方法中的参数
1
2
3
4
5
6
open class MainActivity(var int: Int) : AppCompatActivity(), View.OnClickListener {
init {
// TODO
println("===log===")
}
}
主构造函数通过再类名后面添加constructor和参数实现，如果没有注解和可见的修饰符，constructor关键字可以省略
1
2
3
class User private constructor(name: String) {}

class User(name: String) {}

如果在kotlin的类中有多个构造函数的话，需要显式声明次级构造函数，次级构造函数必须直接或者间接的继承主构造函数，构造函数关键字constructor

class TestView : View {
		constructor(context: Context) : super(context) {
				println("constructor") 
    }
  
		constructor(context: Context, attrs: AttributeSet?) : this(context, attrs, 0)

  	constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr)
}

3. 访问修饰符

private：表示类的成员都是这个类私有的
protected：表示只有这个类和它的继承类才能访问
public：表示这个类和所有其他类都能访问
internal：表示一个模块中的类都可以访问到这个对象，跨模块则不能访问

4. 伴生对象

伴生对象通过companion object两个关键字组合起来声明

public class StringUtils {
  	public static boolean isEmpty(String str) {
      	return "".equals(str);
    }
}

用kotlin伴生对象实现如下

class StringUtils{
  	companion object {
      	fun isEmpty(str: String): Boolean {
          	return "" == str
        }
    }
}

// 调用方法
fun main(args: Array<String>) {
  	StringUtils.isEmpty("abc")
}

如果在java中调用，需要类名后面调用.Companion，然后再调用方法

1	StringUtils.Companion.isEmpty("aabc");

用伴生对象可以声明一个单例，常用写法如下

class Single private constructor() {
  	companion object {
      	fun get(): Single {
          	return Holder.instance
        }
    }
  
  	private object Holder {
      	val instance = Single()
    }
}

5. 动态代理

interface Developer {
  	fun code()
}

class JavaDeveloper : Developer {
  	override fun code() {
      	println("javaDeveloper is coding")
    }
}

// by关键字表示该类中的方法直接调用developer对象的方法
class Company(developer: Developer) : Developer by developer

// 程序执行最后正常输出：javaDeveloper is coding
fun main(args: Array<String>) {
  	Company(JavaDeveloper()).code()
}

如果在动态代理中重写了方法，则会直接输出重写的结果

class Company(developer: Developer) : Developer by developer 	{
  	// 方法重写后不会再去调用代理的对象的方法
  	override fun code() {
        println("Company is working")
    }
}

// 程序执行最后正常输出：Company is working
fun main(args: Array<String>) {
  	Company(JavaDeveloper()).code()
}

6. 数据类

数据类会将该类中的成员变量自动生成getter()和setter()方法，以及toString()，hashCode()，equals()，copy()，数据类是final类型的，不能用open，也不能被继承

数据类前面用data修饰，如果变量是val的，则只会生成get方法

getter/setter方法无法被直接调用，不过对它的操作本质上都是通过调用方法实现的

1	data class User(var id: Int, var name: String)

7.密闭类–kotlin中更加强大的枚举类

枚举类

enum class Command {
  	A, B, C, D
}

//如果有成员属性时
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}
print(Color.RED.rgb)

密闭类：通过sealed关键字修饰，sealed类自身是抽象类，子类不能是抽象类，子类必须和它在同一个文件中，与when搭配使用非常方便

sealed class SuperCommand { 
  object A : SuperCommand() 
  object B : SuperCommand() 
  class C(var id: Int) : SuperCommand()
}

fun exec(superCommand: SuperCommand) = when (superCommand) { 
		SuperCommand.A -> {}
		SuperCommand.B -> {}
  	is SuperCommand.C -> {}
}

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

fun eval(expr: Expr): Double = when(expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
}

8. object

可以用来实现单例模式

object A

// 可以反编译得到的java代码如下
public final class A {
    public static final A INSTANCE;
    static {
        A a = new A();
        INSTANCE = a;
    }
}

简单的用法如下

fun main(args: Array<String>) {
    O.test()
    O.name = "hello"
}

object O {
    var name = "mao"
    fun test() {
        print("test")
    }
}

可以用来实现匿名内部类

fun main(args: Array<String>) {
    var btn = Btn()
    btn.onClickLsn = object : Btn.OnClickLsn {
        override fun click() {
            print("click")
        }
    }
    btn.callClick()

}


class Btn() {

    var onClickLsn: OnClickLsn? = null

    fun callClick() {
        onClickLsn?.click()
    }

    interface OnClickLsn {
        fun click()
    }
}

可以继承一个类和多个接口，当父类有构造方法时，应传入对应的参数。

interface A
open class B(age: Int) {
    var mAge = age
}

var c: A = object : B(18), A {}

二、高级特性

1. 解构

展开全文 >>

算法和数据结构

2020-03-09

第1章算法概述

1.1 算法和数据结构

1.1.1 算法

算法（algorithm）是用于解决某一类问题的公式和思想

计算机中的算法是一系列程序指令，用于解决待定的运算和逻辑问题

衡量算法好坏的重要标准有两个：

时间复杂度
空间复杂度

算法的应用领域：

运算
查找
排序
最优决策

1.1.2 数据结构

数据结构的组成方式有如下几种

线性结构
树
图
其他数据结构，如：跳表、哈希链表、位图

1.2 时间复杂度

若存在函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常熟，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称为O(f(n))，O为算法的渐进时间复杂度，简称为时间复杂度

常见的复杂度按照从低到高的顺序，包括O(1)、O(logn)、O(n)、O(nlogn)、O(n²)等

推导时间复杂度常用原则

如果运行时间是常数量级，则用常熟1表示
只保留时间函数中的最高阶项
如果最高阶项存在，则省去最高阶项前面的系数

例：

T(n) = 3n，最高项为3n，省去系数3，时间复杂度为：T(n) = O(n)
T(n) = 5logn，最高阶项为5logn，省去系数5，时间复杂度为：T(n)= O(logn)
T(n) = 2，只有常数量级，时间复杂度为：T(n) = O (1)
T(n) = 0.5n²+0.5n，最高阶项为0.5n²，省去系数，时间复杂度为：T(n) = O(n²)

1.3 空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度，用大O表示，记作S(n)=O(f(n))

常见的空间复杂度按照从低到高的顺序，包括O(1)、O(n)、O(n²)等，递归算法的空间复杂度和递归深度成正比

第2章数据结构基础

2.1 数组

数组是有限个相同类型的变量所组成的有序集合，数组中的每一个变量被称为元素。

数组是最简单、常用的数据结构，物理存储方式是顺序存储，访问方式是随机访问，利用下标查找元素时间复杂度为O(1)，中间插入删除元素的时间复杂度是O(n)

数组特点：

数组中的每一个元素也有着自己的下标，只不过这个下标从0开始，一直到数组长度-1
数组在内存中顺序存储，因此可以很好的实现逻辑上的顺序表

数组的基本操作：

读取元素：由于数组在内存中顺序存储，所以只要给出一个数组的下标，就可以读取到对应的数组元素
更新元素：要把数组中某一个元素的值替换为一个新值，只需要利用下标，直接把新值赋给该元素
插入元素：插入元素分为三种基本的情况
- 尾部插入：直接把元素放在数组的尾部空闲位置
- 中间插入：需要把插入位置以及后面的元素向后移动，然后再插入元素到对应的位置
- 超范围插入：如果插入的下标小于0或者大于等于数组长度，会抛出异常，如果需要插入，需要自己对数组金星秀扩容处理
删除元素：数组删除和插入相反，末尾直接删除，如果在中间或者开头，需要把删除元素后面的元素都向前挪动1位

ArrayList是java基于数组实现的一个类，在中间插入和删除元素都涉及到当前位置到末尾需要进行后移或者前移一位，在新增元素的同时还需要判断数组长度是否足够，不够会进行数组扩充*2，然后进行数组的拷贝操作，所以在ArrayList中不建议进行大量的添加和删除操作，查找的时间复杂度为O(1),添加删除的时间复杂度为O(n);

2.2 链表

链表是一种在物理上非连续、非顺序的数据结构，由若干节点(node)组成，每个节点包含指向下一个节点的指针。

链表的物理存储方式是随机存储，访问方式是顺序访问，查找链表节点的时间复杂度是O(n)，中间插入、删除节点的时间复杂度是O(1)。

单链表：每个节点包含两个部分，一部分是存放数据的变量data，另一部分是指向下一个节点的指针next

双向链表：每个节点除了data和next指针，还有指向前置节点的prev指针

循环链表：最后一个节点的next指针，指向第一个节点

链表的基本操作：

查找节点：链表中的数据只能按顺序进行访问，最坏的时间复杂度为O(n)
更新节点：在不考虑查找节点的过程情况下，链表更新过程只需要直接把旧数据替换成新数据就行
插入节点：和数组类似，分为三种基本情况
- 尾部插入：直接把最后一个节点的next指针指向新插入的节点就可以
- 头部插入：1. 把新节点的next指针指向原先的头节点 2. 把新节点变成链表的头节点
- 中间插入：1. 新节点的next指针指向插入位置的节点 2.插入位置前置节点的next指针，指向新节点
删除元素：删除同样分为三种情况
- 尾部删除：把倒数第二个节点的next指针置空
- 头部删除：把链表的头节点设置为原先头节点的next指针
- 中间删除：把要删除节点的前置节点的next指针，指向要删除元素的下一个节点

	查找	更新	插入	删除
数组	O(1)	O(1)	O(n)	O(n)
链表	O(n)	O(1)	O(1)	O(1)

LinkList的元素一般是定义的一个Node，同时Node内会分别有字段指向该节点的后面一位和前面一位，Java中LinkList是双向链表,查找的时间复杂度为O(n),添加和删除的时间复杂度为O(1)

2.3 栈(Stack)

栈是一种线性逻辑结构，可以用数组实现，也可以用链表实现

栈包含入栈和出栈操作，遵循先入后出的原则（FILO）

第一个进入的元素存放的位置叫做栈底（bottom），最后进入的元素存放的位置叫做栈顶（top）

入栈（push）：将新的元素放入栈中，只允许从栈顶一侧放入元素，新元素的位置会成为新的栈顶

出栈（pop）：把元素从栈中弹出，只有栈顶元素才允许出栈，出栈元素的前一个元素将会成为新的栈顶

栈的输出顺序和输入顺序相反，所以栈通常用于对“历史”的回溯，一般递归逻辑可以用栈来代替

2.4 队列(Queue)

队列也是一种线性逻辑结构，可以用数组实现，也可以用链表实现

队列包含入队和出队操作，遵循先入先出的原则（FIFO）

队列的出口端叫做队头（front），队列的入口端叫做队尾（rear）

入队（enqueue）：把新元素放入队列中，只允许在队尾的位置放入元素，新元素的下一个位置将会成为新的队尾

出队（dequeue）：把元素移出队列，只允许在队头一侧移出元素，出队元素的后一个元素将会成为新的队头

队列输出顺序和输入顺序相同，所以队列通常用于对历史的回放，也就是按照历史的顺序，把历史重演一遍

特殊队列

循环队列⚠️

循环队列的队尾指针指向的位置永远空一位，所以最大容量会比数组长度小1

当循环队列储存满时，(队尾下标 + 1) % 数组长度 = 队头下标
双端队列

通过结合队列和栈的特点，实现可以从对头一端入队或出队，从队尾一端也可以入队或出队
优先队列

该队列不属于线性数据结构，是基于二叉堆来实现的

2.5 散列表（哈希表）

散列表也叫哈希表，是存储key-value映射的集合。对于某一个key，散列表可以在接近O(1)的时间内进行读写操作。散列表通过哈希函数实现key和数组下标的转换，通过开放寻址法和链表法来解决哈希冲突

散列表中会用一个哈希函数来实现key和数组下标的转换，最简单的方法如下

index = HashCode(Key) % Array.length

散列表的常用操作：

写操作（put）：写操作就是在散列表中插入新的键值对
1. 通过哈希函数，把key转化成数组下标
2. 如果数组下标n对应的位置没有元素，就把这个entry填充到数组下标n的位置，如果下标n位置有元素，则会产生哈希冲突，可以通过开放寻址法和链表法解决
  - 哈希冲突 ：因为数组长度有限，当插入的Entry越来有越多时，不同的key通过哈希函数获得的下标可能相同的情况
  - 开放寻址法：当一个key通过哈希函数获得对应的数组下标已被占用时，可以根据某种规则寻找下一个空挡位置
  - 链表法：HashMap数组的每一个元素不仅是一个Entry对象，还是一个链表的头节点。每一个Entry对象通过next指针指向它的下一个Entry节点。当新来的Entry映射到与之冲突的数组位置时，只需要插入到对应的链表中即可。
读操作（get）
1. 通过哈希函数，把Key转化成数组下标
2. 找到数组下标所对应的元素，如果这个元素的Key为查找的Key，那么就找到了，如果Key不是查找的Key，由于每个元素都与一个链表对应，可以顺着链表往下找

第3章树

3.1 树和二叉树

树（tree）是n（n>=0）个节点的有限集。当n=0时，称为空树。在任意一个非空树中，有如下特点。

有且仅有一个特定的称为根的节点
当n>1时，其余节点可分为m（m>0）个互不相交的有限集，没一个集合本身又是一个树，并称为根的子树

二叉树：二叉树是树的一种特殊形式，每个节点最多有两个子节点

满二叉树：一个二叉树的所有与非叶子节点都存在左右孩子节点，并且所有叶子节点都在同一层级上

完全二叉树：对一个有n个节点的二叉树，按层级顺序编号，则所有节点的编号从1到n。这个树所有节点和同样深度的满二叉树的编号为从1到n的节点位置相同。完全二叉树只需要保证最后一个节点之前的节点都齐全。

二叉树常用存储结构

链式存储结构：没一个节点最多指向左右两个孩子节点，所以二叉树的每一个节点包含3部分
- 存储数据的data变量
- 指向左孩子的left指针
- 指向右孩子的right指针
数组：数组存储时，会按照层级顺序把二叉树的节点放到数组中对应的位置上，如果某一个节点的左孩子或右孩子空缺，则数组的对应位置也空出来
- 假设一个父节点的下标是parent，那么它的左孩子节点下标就是2*parent+1;右孩子节点下标是2*parent+2
- 假设一个左孩子节点的下标是leftChild，那么它的父节点下标就是(leftChild-1)/2

二叉树的应用

查找

二叉查找树（节点分部相对比较均衡的二叉查找树，如果节点总数是n，那么搜索节点的时间复杂度就是O(logn)）在二叉树的基础上增加了以下几个条件：
- 如果左子树不为空，则左子树上所有节点的值均小于根节点的值
- 如果右子树不为空，则右子树上所有节点的值均大于根节点的值
- 左、右子树也是二叉查找树
维持相对顺序

二叉查找树要求左子树小于父节点，右子树大于父节点，这样可以保证二叉树的有序性

通过二叉树的自平衡可以优化树，如红黑树、AVL树、树堆

除了二叉查找树，二叉堆也维持着相对的顺序

3.2 二叉树的遍历

从节点之间位置关系的角度来看，二叉树的遍历分为4种

前序遍历：按照根–>左孩子–>右孩子的顺序遍历（根左右，根在前面）
中序遍历：按照左孩子–>根–>右孩子的顺序遍历（左根右，根在中间）
后序遍历：按照左孩子–>右孩子–>根的顺序遍历（左右根，根在后面）
层序遍历

从宏观的角度来看，二叉树的遍历归结为两大类

深度优先遍历（前序、中序、后序）：
- 深度优先遍历可以通过递归方法实现，只需要调整三者的顺序
- 也可以通过栈来实现，栈实现遍历，可以通过将遍历过的节点放入栈中，依次遍历，没有后续的节点可以通过接节点回溯，依次出栈，找到有后续的节点，然后继续操作（已经遍历完成的节点可以直接出栈，无需继续放在栈中）
广度优先遍历（层序）：层序遍历可以通过队列实现，从根节点依次放入队列，每次节点出队后，将该节点的左右孩子节点入队，重复操作至遍历结束

3.3 二叉堆

二叉堆本质上是一种完全二叉树，可以分为两个类型

最小堆（小顶堆）：任意一个父节点的值，都小于或等于它左右孩子节点的值

最大堆（大顶堆）：任意一个父节点的值，都大于或等于它左右孩子节点的值

二叉堆的根节点叫作堆顶，大顶堆的堆顶是整个堆中最大元素，小顶堆的堆顶是整个堆中最小的元素

二叉堆的操作

插入节点：直接插入完全二叉树的最后一个位置，然后依次和父节点对比和交换位置，直到和当前父节点对比满足堆的条件或者已经成为根节点后，不再交换位置
删除节点：二叉堆删除的是处于堆顶的节点，删除堆顶的节点后，把堆最后一个节点临时补充到原本堆顶的位置，然后依次和左右孩子对比，小顶堆与小的孩子节点交换位置（大顶堆与大的孩子节点交换位置），直到成为叶子节点，或者满足堆的条件后结束
构建二叉堆：将一个无序的完全二叉树调整为二叉堆，本质就是让所有的非叶子节点依次”下沉“

二叉堆的代码实现

二叉堆的存储方式不是链式存储，而是链式存储，所有的节点都存储在数组中。

如果父亲节点的下标是parent，那么左孩子的下标就是2*parent +1，右孩子的下标是2*parent +2

如果一个孩子的节点下标是child，那么它的父亲节点的下标是(child-1)/2

展开全文 >>

透视HTTP协议

2020-02-27

一.HTTP的前世今生

HTTP 协议始于三十年前蒂姆·伯纳斯 - 李的一篇论文；
1. HTTP/0.9 是个简单的文本协议，只能获取文本资源；
2. HTTP/1.0 确立了大部分现在使用的技术，但它不是正式标准；
3. HTTP/1.1 是目前互联网上使用最广泛的协议，功能也非常完善；
4. HTTP/2 基于 Google 的 SPDY 协议，注重性能改善，但还未普及；
5. HTTP/3 基于 Google 的 QUIC 协议，是将来的发展方向。

二.HTTP是具体含义

HTTP是超文本传输协议例：普通文件协议FTP,电子邮件协议SMTP,POP3

HTTP 是一个用在计算机世界里的协议。它使用计算机能够理解的语言确立了一种计算机之间交流通信的规范，以及相关的各种控制和错误处理方式。–>
HTTP 是一个在计算机世界里专门用来在两点之间传输数据的约定和规范–>
HTTP 是一个在计算机世界里专门在两点之间传输文字、图片、音频、视频等超文本数据的约定和规范
HTTP 是构建互联网的重要基础技术，它没有实体，依赖许多其他的技术来实现，但同时许多技术也都依赖于它。

在互联网世界里，HTTP 通常跑在 TCP/IP 协议栈之上，依靠 IP 协议实现寻址和路由、TCP 协议实现可靠数据传输、DNS 协议实现域名查找、SSL/TLS 协议实现安全通信。此外，还有一些协议依赖于 HTTP，例如 WebSocket、HTTPDNS 等

三.与HTTP相关的各种概念

网络世界 :互联网世界更像是由数不清的大小岛屿组成的“千岛之国”。
1. 浏览器：浏览器本质上是一个 HTTP 协议中的请求方，使用 HTTP 协议获取网络上的各种资源
2. Web 服务器：服务器是 HTTP 协议里的应答方，常用的有 Apache 和 Nginx
3. CDN：全称是“Content Delivery Network”，翻译过来就是“内容分发网络”。它应用了 HTTP 协议里的缓存和代理技术，代替源站响应客户端的请求。位于浏览器和服务器之间，主要起到缓存加速的作用。
4. 爬虫：实际上是一种可以自动访问 Web 资源的应用程序。
5. HTML/WebService/WAF：
- HTML 是 HTTP 协议传输的主要内容之一，它描述了超文本页面，用各种“标签”定义文字、图片等资源和排版布局，最终由浏览器“渲染”出可视化页面。
- Web Service是一个基于 Web（HTTP）的服务架构技术
- WAF是应用层面的“防火墙”，专门检测 HTTP 流量，是防护 Web 应用的安全技术。

四.与HTTP相关的各种协议

TCP/IP:TCP 属于“传输层”，IP 属于“网际层”，TCP/IP 是网络世界最常用的协议，HTTP 通常运行在 TCP/IP 提供的可靠传输基础上

IP 协议是“Internet Protocol”的缩写，主要目的是解决寻址和路由问题，以及如何在两点间传送数据包。
TCP 协议是“Transmission Control Protocol”的缩写，意思是“传输控制协议”，它位于 IP 协议之上，基于 IP 协议提供可靠的、字节流形式的通信，是 HTTP 协议得以实现的基础。

DNS:“域名系统”（Domain Name System），DNS 域名是 IP 地址的等价替代，需要用域名解析实现到 IP 地址的映射

但想要使用 TCP/IP 协议来通信仍然要使用 IP 地址，所以需要把域名做一个转换，“映射”到它的真实 IP，这就是所谓的“域名解析”。

URI/URL:URI 是用来标记互联网上资源的一个名字，由“协议名 + 主机名 + 路径”构成，俗称 URL

URI（Uniform Resource Identifier），中文名称是统一资源标识符，使用它就能够唯一地标记互联网上资源。
URI 另一个更常用的表现形式是 URL（Uniform Resource Locator），统一资源定位符，也就是我们俗称的“网址”，它实际上是 URI 的一个子集，不过因为这两者几乎是相同的，差异不大，所以通常不会做严格的区分。

HTTPS:全称是“HTTP over SSL/TLS”,HTTPS 相当于“HTTP+SSL/TLS+TCP/IP”，为 HTTP 套了一个安全的外壳

SSL 的全称是“Secure Socket Layer”，由网景公司发明，当发展到 3.0 时被标准化，改名为 TLS，即“Transport Layer Security”，但由于历史的原因还是有很多人称之为 SSL/TLS，或者直接简称为 SSL。

代理：代理是 HTTP 传输过程中的“中转站”，可以实现缓存加速、负载均衡等功能

代理常见种类：匿名台历、透明代理、正向代理、反向代理
代理可以做的事：负载均衡、内容缓存、安全防护、数据处理

五.网络分层

1. TCP/IP 网络分层模型

MAC 层的传输单位是帧（frame），IP 层的传输单位是包（packet），TCP 层的传输单位是段（segment），HTTP 的传输单位则是消息或报文（message）。但这些名词并没有什么本质的区分，可以统称为数据包。

 1. **链接层（link layer）**：负责在以太网、WiFi 这样的底层网络上发送原始数据包，工作在网卡这个层次，使用 MAC 地址来标记网络上的设备，所以有时候也叫 MAC 层。
 2. **网际层（internet layer）**：IP 协议就处在这一层。因为 IP 协议定义了“IP 地址”的概念，所以就可以在“链接层”的基础上，用 IP 地址取代 MAC 地址，把许许多多的局域网、广域网连接成一个虚拟的巨大网络，在这个网络里找设备时只要把 IP 地址再“翻译”成 MAC 地址就可以了。
 3. **传输层（transport layer）**：这个层次协议的职责是保证数据在 IP 地址标记的两点之间“可靠”地传输，是 TCP和UDP 协议工作的层次。
 * TCP 的数据是连续的“字节流”，有先后顺序
 * UDP 则是分散的小数据包，是顺序发，乱序收
4. **应用层（application layer）**:有各种面向具体应用的协议。例如 Telnet、SSH、FTP、SMTP 等等，当然还有我们的 HTTP。

2. OSI 网络分层模型

全称是“开放式系统互联通信参考模型”（Open System Interconnection Reference Model）

物理层，网络的物理形式，例如电缆、光纤、网卡、集线器等等；
1. 数据链路层，它基本相当于 TCP/IP 的链接层；
2. 网络层，相当于 TCP/IP 里的网际层；
3. 传输层，相当于 TCP/IP 里的传输层；
4. 会话层，维护网络中的连接状态，即保持会话和同步；
5. 表示层，把数据转换为合适、可理解的语法和语义；
6. 应用层，面向具体的应用传输数据。

六.域名

域名使用字符串来代替 IP 地址，方便用户记忆，本质上一个名字空间系统；
1. DNS 就像是我们现实世界里的电话本、查号台，统管着互联网世界里的所有网站，是一个“超级大管家”；
2. DNS 是一个树状的分布式查询系统，但为了提高查询效率，外围有多级的缓存；
3. 使用 DNS 可以实现基于域名的负载均衡，既可以在内网，也可以在外网。

七.HTTP结构

1.TCP报文结构

TCP头部至少20字节，包含：发起方端口，接收方端口，其他数据（序号、标志位、窗口大小等）

实际传输的数据通常大小是1460字节

2.HTTP协议的请求报文和响应报文结构

起始行：描述请求或响应的基本信息
1. 头部字段集合：使用key-value形式更详细的说明报文
2. 消息正文：实际传输的数据，它不一定是纯文本，可以是图片、视频等二进制数据

3.请求行—-客户端想要如何操作服务器端的资源

请求方法：是一个动词，如 GET/POST，表示对资源的操作；
1. 请求目标：通常是一个 URI，标记了请求方法要操作的资源；
2. 版本号：表示报文使用的 HTTP 协议版本。

4.状态行—-服务器响应的状态

1. 版本号：表示报文使用的 HTTP 协议版本；
2. 状态码：一个三位数，用代码的形式表示处理的结果，比如 200 是成功，500 是服务器错误；
3. 原因：作为数字状态码补充，是更详细的解释文字，帮助人理解原因。

5.头部字段

请求头和响应头的结构是基本一样的，唯一的区别是起始行

1. 字段名不区分大小写，例如“Host”也可以写成“host”，但首字母大写的可读性更好；
2. 字段名里不允许出现空格，可以使用连字符“-”，但不能使用下划线“_”。例如，“test-name”是合法的字段名，而“test name”“test_name”是不正确的字段名；
3. 字段名后面必须紧接着“:”，不能有空格，而“:”后的字段值前可以有多个空格；
4. 字段的顺序是没有意义的，可以任意排列不影响语义；
5. 字段原则上不能重复，除非这个字段本身的语义允许，例如 Set-Cookie。

6.常用头字段

通用字段：在请求头和响应头里都可以出现；
请求字段：仅能出现在请求头里，进一步说明请求信息或者额外的附加条件；
响应字段：仅能出现在响应头里，补充说明响应报文的信息；
实体字段：它实际上属于通用字段，但专门描述 body 的额外信息。

Host字段属于请求字段，只能出现在请求头里面，必须出现

User-Agent只出现在请求头里，它使用一个字符串来描述发起 HTTP 请求的客户端，服务器可以依据它来返回最合适此浏览器显示的页面。

Date字段是一个通用字段，但通常出现在响应头里，表示 HTTP 报文创建的时间，客户端可以使用这个时间再搭配其他字段决定缓存策略。

Server字段是响应字段，只能出现在响应头里。它告诉客户端当前正在提供 Web 服务的软件名称和版本号,也不是必须要出现的，因为这会把服务器的一部分信息暴露给外界。

Content-Length在实体字段中，它表示报文里 body 的长度，也就是请求头或响应头空行后面数据的长度。

八.请求方法

HTTP/1.1 规定了八种方法，单词都必须是大写的形式

GET：获取资源，可以理解为读取或者下载数据；
HEAD：获取资源的元信息；
POST：向资源提交数据，相当于写入或上传数据；
PUT：类似 POST；
DELETE：删除资源；
CONNECT：建立特殊的连接隧道；
OPTIONS：列出可对资源实行的方法；
TRACE：追踪请求 - 响应的传输路径。

GET/HEAD
——从服务器获取资源
HEAD和GET类似，也是从服务器获取资源，但是不会返回请求的实体数据，只有响应头（元信息），是GET的简易版，如果不需要资源的话，可以避免传输body数据的浪费。

POST/PUT
——向服务器提交数据，数据在body里
PUT和POST作用类似，有微妙不同，通常POST标识新建，PUT标识修改

DELETE
——删除资源，危险性大，很少用

CONNECT
——要求服务器为客户端和另一台远程服务器建立一条特殊的链接，这时Web服务器充当代理的角色

OPTIONS
——要求服务器列出可对资源实行的操作方法，在响应头Allow字段里返回。功能有限，用处不大。Nginx没支持

TRACE
——用于对HTTP链路的测试或诊断，可以显示出请求 - 响应的传输路径。存在漏洞，会泄露网站的信息，所以通常也是禁止使用

安全与幂等

安全：在HTTP协议里，所谓的安全，是指请求方法不会对服务器上的资源造成实质的修改，so 只有GET和HEAD是安全的，因为是只读操作。

幂等：多次执行相同的操作，结果也都是相同的。so GET和HEAD 即是安全的也是幂等的，DELETE可以多次删除同一个资源，效果都是“资源不存在”，所以也是幂等。POST是新增或提交数据，多次提交会创建多个资源，所以不是幂等的。PUT是替换或更新数据，多次更新一个资源，资源还是第一次更新的状态。所以是幂等的。

幂等：GET、HEAD、DELETE、PUT
非幂等：POST

九.网址格式

1.URI格式

URI 本质上是一个字符串，这个字符串的作用是唯一地标记资源的位置或者名字。URI 最常用的形式，由 scheme、host:port、path 和 query 四个部分组成，但有的部分可以视情况省略。

2.URI 的基本组成

URI 第一个组成部分叫 scheme，翻译成中文叫“方案名”或者“协议名”，表示资源应该使用哪种协议来访问。

在 scheme 之后，必须是三个特定的字符“://”，它把 scheme 和后面的部分分离开。

在“://”之后，是被称为“authority”的部分，表示资源所在的主机名，通常的形式是“host:port”，即主机名加端口号。

有了协议名和主机地址、端口号，再加上后面标记资源所在位置的 path，浏览器就可以连接服务器访问资源了。

3.URI的查询参数

URI 后面还有一个“query”部分，它在 path 之后，用一个“?”开始，但不包含“?”，表示对资源附加的额外要求。这是个很形象的符号，比“://”要好的多，很明显地表示了“查询”的含义。

查询参数 query 有一套自己的格式，是多个“key=value”的字符串，这些 KV 值用字符“&”连接，浏览器和服务器都可以按照这个格式把长串的查询参数解析成可理解的字典或关联数组形式。

4.URI的完整格式

第一个多出的部分是协议名之后、主机名之前的身份信息“user:passwd@”，表示登录主机时的用户名和密码，但现在已经不推荐使用这种形式了（RFC7230），因为它把敏感信息以明文形式暴露出来，存在严重的安全隐患。

第二个多出的部分是查询参数后的片段标识符“#fragment”，它是 URI 所定位的资源内部的一个“锚点”或者说是“标签”，浏览器可以在获取资源后直接跳转到它指示的位置。但片段标识符仅能由浏览器这样的客户端使用，服务器是看不到的。

5.URI 的编码

URI 引入了编码机制，对于 ASCII 码以外的字符集和特殊字符做一个特殊的操作，把它们转换成与 URI 语义不冲突的形式。这在 RFC 规范里称为“escape”和“unescape”，俗称“转义”。URI 转义的规则有点“简单粗暴”，直接把非 ASCII 码或特殊字符转换成十六进制字节值，然后前面再加上一个“%”。

十.响应状态码

1××：提示信息，表示目前是协议处理的中间状态，还需要后续的操作；
2××：成功，报文已经收到并被正确处理；
3××：重定向，资源位置发生变动，需要客户端重新发送请求；
4××：客户端错误，请求报文有误，服务器无法处理；
5××：服务器错误，服务器在处理请求时内部发生了错误。

小结

状态码在响应报文里表示了服务器对请求的处理结果；
状态码后的原因短语是简单的文字描述，可以自定义；
状态码是十进制的三位数，分为五类，从 100 到 599；
2××类状态码表示成功，常用的有 200、204、206；
3××类状态码表示重定向，常用的有 301、302、304；
4××类状态码表示客户端错误，常用的有 400、403、404；
5××类状态码表示服务器错误，常用的有 500、501、502、503。

十一.HTTP特点

HTTP 协议是一个“灵活可扩展”的传输协议，可以任意添加头字段实现任意功能；
HTTP 协议是一个“可靠”的传输协议，基于 TCP/IP 协议“尽量”保证数据的送达；
HTTP 协议是一个应用层的协议，比 FTP、SSH 等更通用功能更多，能够传输任意数据；
HTTP 协议使用的是请求 - 应答通信模式，客户端主动发起请求，服务器被动回复请求；
HTTP 协议是无状态的，每个请求都是互相独立、毫无关联的，协议不要求客户端或服务器记录请求相关的信息。

十二.HTTP的优缺点

HTTP 最大的优点是简单、灵活和易于扩展；
HTTP 拥有成熟的软硬件环境，应用的非常广泛，是互联网的基础设施；
HTTP 是无状态的，可以轻松实现集群化，扩展性能，但有时也需要用 Cookie 技术来实现“有状态”；
HTTP 是明文传输，数据完全肉眼可见，能够方便地研究分析，但也容易被窃听；
HTTP 是不安全的，无法验证通信双方的身份，也不能判断报文是否被窜改；
HTTP 的性能不算差，但不完全适应现在的互联网，还有很大的提升空间。

展开全文 >>

Android设计模式解析

2019-11-01

面向对象的六大原则

1.单一职责原则——SRP(Single Responsibility Principle)

一个类中应该是一组相关性很高的函数、数据的封装

2.开闭原则——OCP(Open Close Principle)

软件中的对象（类、模块和函数等）应该对于扩展是开放的，但是对于修改是封闭的

3.里氏替换原则——LSP(Lisdow Substitution Principle)

如果对没一个类型为S的对象O₁，都有类型为T的对象O₂，使得以T定义的所有程序P在所有的对象O₁替换为O₂时，程序P的行为没有发生变化，那么类型S就是类型T的子类型

4.依赖倒置原则——DIP(Dependence Inversion Principle)

指代了一种特定的解耦形式，使得高层次的模块不依赖于低层次的模块的实现细节的目的，依赖模块被颠倒了

5.接口隔离原则——ISP(InterfaceSegregation Principles)

客户端不应该依赖它不需要的接口

6.迪米特原则——LOD(Law of Demeter)

一个对象应该对其他对象有最少的了解

创建型模式：5个

单例模式、Builder、原型模式、工厂方法、抽象工厂

行为型模式： 11个

策略模式、状态模式、观察者模式、中介者模式、访问者模式、迭代器模式、模板方法、备忘录模式、命令模式、解释器模式、职责链模式

结构型模式：7个

组合模式、代理模式、装饰模式、外观模式、享元模式、享元模式、桥接模式、适配器模式

1.单例模式

定义：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例

使用场景：

确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象只应该且只有一个，例如访问IO和数据库等资源

单例模式的主要关键点：

构造函数不对外开放，一般为private
通过一个静态方法或者枚举返回单例类对象
确保单例类的对象有且只有一个，尤其在多线程环境下
确保单例类对象在反序列化时不会重新构建对象

单例模式常用的实现方式

饿汉单例——在声明静态对象时就已经初始化

public class Singleton {
    private static final Singleton instance = new Singleton();
  
    private Singleton() {}
}

懒汉单例——声明静态对象，在用户第一次调用getInstance时进行初始化

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Double CheckLock(DCL)实现单例——既能在需要时才初始化，又能保证线程安全，并且单例对象初始化后调用getInstance不进行同步锁

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类单例模式——建议用于解决DCL在某些情况下出现失效的问题

public class Singleton {
    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
}

枚举单例

public enum SingletonEnum {
    INSTANCE;

    public void doSomething() {
        System.out.println("do sth");
    }
}

使用容器实现单例模式

public class SingletonManager {
    private static Map<String, Object> objMap = new HashMap<>();

    private SingletonManager() {}

    public static void registerService(String key, Object instance) {
        if (!objMap.containsKey(key)) {
            objMap.put(key, instance);
        }
    }

    public static Object getService(String key) {
        return objMap.get(key);
    }
}

优点

由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显
由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式
单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作
单例模式可以在系统设置全局的访问点，优化和共享资源访问

缺点

单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现
单例对象如果持有Context，很容易内存泄露，传递时最好用Application Context

2.Builder模式

定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

使用场景：

相同的方法，不同的执行顺序，产生不同的事件结果时
多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时
产品类非常复杂，或者产品类中调用顺序不同产生了不同的作用，这个时候使用建造者模式非常适合
当初始化一个对象特别复杂，如参数多，且很多参数都具有默认值

优点

良好的封装性，使用建造者模式可以使客户端不必知道产品内部组成的细节
建造者独立，容易扩展

缺点

会产生多余的Builder对象以及Director对象，消耗内存

简单实现

public class Phone {
    private String cpu;
    private String camera;
    private String screen;
    private String battery;

    public Phone(Builder builder) {
        this.cpu = builder.cpu;
        this.camera = builder.camera;
        this.screen = builder.screen;
        this.battery = builder.battery;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getCamera() {
        return camera;
    }

    public void setCamera(String camera) {
        this.camera = camera;
    }

    public String getScreen() {
        return screen;
    }

    public void setScreen(String screen) {
        this.screen = screen;
    }

    public String getBattery() {
        return battery;
    }

    public void setBattery(String battery) {
        this.battery = battery;
    }

    public static class Builder {
        private String cpu;
        private String camera;
        private String screen;
        private String battery;

        public Builder() {

        }

        public Builder setCpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder setCamera(String camera) {
            this.camera = camera;
            return this;
        }

        public Builder setScreen(String screen) {
            this.screen = screen;
            return this;
        }

        public Builder setBattery(String battery) {
            this.battery = battery;
            return this;
        }

        public Phone build() {
            return new Phone(this);
        }
    }
}

3.原型模式

定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象

使用场景：

类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗
通过new产生一个对象需要非常频繁的数据准备或者访问权限，这时可以使用原型模式
一个对象需要提供给其他对象访问，而且各个调用者都可能需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用

优点

原型模式是在内存中二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量对象时，原型模式可以更好地体现其有点

缺点

直接在内存中拷贝，构造函数不会执行，在实际应用开发中需要注意这个潜在的问题
使用浅拷贝操作副本时可能会影响原始对象

简单实现

public class WordDocument implements Cloneable {

    private String text;
    private ArrayList<String> imgs = new ArrayList<>();

    public WordDocument() {
        System.out.println("----------构造函数----------");
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        try {
            WordDocument doc = (WordDocument) super.clone();
            doc.text = this.text;
            //1.浅拷贝
            doc.imgs = this.imgs;
            
            //2.深拷贝--对imgs对象也调用clone()函数，进行深拷贝，正常建议使用深拷贝
            doc.imgs = (ArrayList<String>) this.imgs.clone();
            return doc;
        } catch (Exception ignored) {
        }
        return null;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public ArrayList<String> getImgs() {
        return imgs;
    }

    public void setImgs(ArrayList<String> imgs) {
        this.imgs = imgs;
    }
}

4.工厂方法模式

定义：定义一个用于创建对象的接口，让子类决定实例化哪个类

使用场景：

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就可以完成创建的对象无需使用工厂模式

简单实现：

public abstract class BaseFactory {
    public abstract void showInfo();
}

public class A extends BaseFactory {
    @Override
    public void showInfo() {
        System.out.println("这是A");
    }
}

public class B extends BaseFactory {
    @Override
    public void showInfo() {
        System.out.println("这是B");
    }
}

5.抽象工厂模式

定义：为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定它们的具体类

使用场景：

一个对象族有相同的约束时可以使用抽象工厂模式

优点

分离接口与实现，客户端使用抽象工厂来创建需要的对象，而客户端根本不知道具体的实现是谁，客户端只是面向产品的接口编程，使其从具体的产品实现中解耦，同时基于接口与实现的分离，使抽象工厂方法模式在切换产品类时更加灵活、容易

缺点

对类文件的爆炸性增加
不太容易扩展新的产品类，因为每当我们增加一个产品类就需要修改抽象工厂，那么所有的具体工厂类都会被修改

简单实现

//抽象产品A接口
public interface IProductA {
    void method();
}

//具体产品类A1和A2
public class ProductA1 implements IProductA {
    @Override
    public void method() {
        System.out.println("产品A1");
    }
}
public class ProductA2 implements IProductA {
    @Override
    public void method() {
        System.out.println("产品A2");
    }
}

//抽象产品B接口
public interface IProductB {
    void method();
}

//具体产品类B1和B2
public class ProductB1 implements IProductB {
    @Override
    public void method() {
        System.out.println("产品B1");
    }
}
public class ProductB2 implements IProductB {
    @Override
    public void method() {
        System.out.println("产品B2");
    }
}

//抽象工厂类
public abstract class AbstractFactory {
    public abstract IProductA getProductA();
    public abstract IProductB getProductB();
}

//具体工厂类A和具体工厂类B
public class ConcreteFactoryA extends AbstractFactory {
    @Override
    public IProductA getProductA() {
        return new ProductA1();
    }

    @Override
    public IProductB getProductB() {
        return new ProductB2();
    }
}
public class ConcreteFactoryB extends AbstractFactory {
    @Override
    public IProductA getProductA() {
        return new ProductA2();
    }

    @Override
    public IProductB getProductB() {
        return new ProductB1();
    }
}

6.策略模式

定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化

使用场景：

针对同一类型问题的多重处理方式，仅仅是具体行为有差别时
需要安全地封装多种同一类型的操作时
出现同一抽象类有多个子类，而又需要使用if-else或者switch-case来选择具体子类时

优点

结构清晰明了、使用简单直观
耦合度相对而言较低，扩展方便
操作封装也更为彻底，数据更为安全

缺点

随着策略的增加，子类也会变得繁多

简单实现

//创建一个接口
public interface Strategy {
   public int doOperation(int num1, int num2);
}

//创建实现接口的实体类
public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}
public class OperationSubstract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}
public class OperationMultiply implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}

//创建Context类
public class Context {
   private Strategy strategy;
 
   public Context(){}

   public SetStrategy(Strategy strategy){
      this.strategy = strategy;
   }

   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

//使用 Context 来查看当它改变策略 Strategy 时的行为变化。
public static void main(String[] args) {
  	Context context = new Context();    
    context.SetStrategy(new OperationAdd());    
    System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
    context.SetStrategy(new OperationSubstract());    
    System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
    context.SetStrategy(new OperationMultiply());          
  	System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
}

7.状态模式

定义：当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类

使用场景

一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为
代码中包含大量与对象状态有关的条件语句，例如，一个操作中含有庞大的多分支语句（if-else或switch-case），且这些分支依赖于该对象的状态

优点

State模式将所有与一个特定的状态相关的行为都放入一个状态对象中，它提供了一个更好的方法来组织与特定状态相关的代码，将烦琐的状态结构判断转换成结构清晰的状态类族，在避免代码膨胀的同时也保证了可扩展性和可维护性

缺点

状态模式的使用必然会增加系统类和对象的个数

简单实现

//创建一个接口
public interface State {
    public void start(Context context);
    public void close(Context context);
}

//创建实现接口的实体类
public class StartState implements State {
    public void start(Context context) {
    }
    public void close(Context context) {
        context.setState(new CloseState());//注意状态的切换
        System.out.println("close State");
    }
}

public class CloseState implements State {
    public void start(Context context) {
    		context.setState(new StartState());//注意状态的切换
        System.out.println("start State");
    }
    public void close(Context context) {
    }
}

//创建 Context 类
public class Context {
    private State state;
    public void setState(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }

    public void start() {
        getState().start(this);
    }

    public void close() {
        getState().close(this);
    }
}

//使用 Context 来查看当状态 State 改变时的行为变化
public class StatePatternDemo {
    public static void main(String... args) {
        Context context = new Context();
        
        // 初始为开始状态
        context.setState(new StartState());
        // 切换为关闭状态
        context.close();
        // 切换为开始状态
        context.start();
    }
}

8.责任链模式

定义：使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止

使用场景

多个对象可以处理同一请求，但具体由哪个对象处理则在行动时动态决定
在请求处理者不明确的情况下向多个对象中的一个提交一个请求
需要动态指定一组对象处理请求

优点

可以对请求者和处理者关系解耦，提高代码的灵活性

缺点

对链中请求处理者的遍历，如果处理者太多那么遍历必定会影响性能，特别是在一些递归调用中

简单实现

//创建抽象的请求者
public abstract class AbstractRequest {
    private Object obj;

    public AbstractRequest(Object obj) {
        this.obj = obj;
    }

    public Object getContent() {
        return obj;
    }

    public abstract int getRequestLevel();
}

//创建请求者实体类
public class Request1 extends AbstractRequest{
    public Request1(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestLevel() {
        return 1;
    }
}
public class Request2 extends AbstractRequest{
    public Request2(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestLevel() {
        return 2;
    }
}
public class Request3 extends AbstractRequest{
    public Request3(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestLevel() {
        return 3;
    }
}

//创建抽象的处理者
public abstract class AbstractHandler {
    protected AbstractHandler nextHandler;

    public final void handleRequest(AbstractRequest request) {
        if (getHandleLevel() == request.getRequestLevel()) {
            handle(request);
        } else {
            if (nextHandler != null) {
                nextHandler.handle(request);
            } else {
                System.out.println("无法处理请求");
            }
        }
    }

    protected abstract int getHandleLevel();

    protected abstract void handle(AbstractRequest request);
}

//创建处理者实体类
public class Handler1 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 1;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler1 handle request:" + request.getRequestLevel());
    }
}
public class Handler2 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 2;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler2 handle request:" + request.getRequestLevel());
    }
}
public class Handler3 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 3;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler3 handle request:" + request.getRequestLevel());
    }
}

//客户端调用
public class Client {

    public static void main(String[] args) {
        AbstractHandler handler1 = new Handler1();
        AbstractHandler handler2 = new Handler2();
        AbstractHandler handler3 = new Handler3();

        //形成责任链
        handler1.nextHandler = handler2;
        handler2.nextHandler = handler3;

        AbstractRequest request1 = new Request1("Request1");
        AbstractRequest request2 = new Request1("Request2");
        AbstractRequest request3 = new Request1("Request3");

        //正常从链式的首端发起请求
        handler1.handle(request1);
        handler1.handle(request2);
        handler1.handle(request3);
    }
}

9.解释器模式

定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来结算语言中的句子

使用场景

如果某个简单的语言需要解释执行而且可以将该语言中的语句表示为一个抽象语法树时可以考虑使用
在某些特定领域出现不断重复的问题时，可以将该领域的问题转化为一种语法规则如下的语句，然后构建解释器来解释该语句

优点

具有灵活的扩展性，当我们相对文法规则进行扩展延伸时，只需要增加相应的非终结符解释器，并在构建抽象语法树时，使用到新增的解释器对象进行具体的解释即可

缺点

对于每一条文法都可以对应至少一个解释器，会生产大量的类，导致维护困难
对于过于复杂的文法，构建其抽象语法树会显得异常繁琐，甚至可能会出现需要构建多棵抽象语法树的情况，因此，对于复杂的文法并不推荐使用解释器模式

简单实现

//创建一个接口表达式
public interface Expression {
   public boolean interpret(String context);
}

//创建实现了上述接口的实体类
public class TerminalExpression implements Expression {
   
   private String data;
 
   public TerminalExpression(String data){
      this.data = data; 
   }
 
   @Override
   public boolean interpret(String context) {
      if(context.contains(data)){
         return true;
      }
      return false;
   }
}
public class OrExpression implements Expression {
    
   private Expression expr1 = null;
   private Expression expr2 = null;
 
   public OrExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) || expr2.interpret(context);
   }
}
public class AndExpression implements Expression {
    
   private Expression expr1 = null;
   private Expression expr2 = null;
 
   public AndExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) && expr2.interpret(context);
   }
}

//InterpreterPatternDemo 使用 Expression 类来创建规则，并解析它们
public class InterpreterPatternDemo {
 
   //规则：Robert 和 John 是男性
   public static Expression getMaleExpression(){
      Expression robert = new TerminalExpression("Robert");
      Expression john = new TerminalExpression("John");
      return new OrExpression(robert, john);    
   }
 
   //规则：Julie 是一个已婚的女性
   public static Expression getMarriedWomanExpression(){
      Expression julie = new TerminalExpression("Julie");
      Expression married = new TerminalExpression("Married");
      return new AndExpression(julie, married);    
   }
 
   public static void main(String[] args) {
      Expression isMale = getMaleExpression();
      Expression isMarriedWoman = getMarriedWomanExpression();
 
      System.out.println("John is male? " + isMale.interpret("John"));
      System.out.println("Julie is a married women? " 
                         + isMarriedWoman.interpret("Married Julie"));
   }
}

10.命令模式

定义：将一个请求封装为一个对象，从而让用户使用不同的请求把客户端参数化；对请求排队或者记录请求日志，以及支持可撤销的操作

使用场景

某一对象有一系列的事物操作
具有抽象行为的动作,支持多种类型的操作

优点

更弱的耦合性、更灵活的控制性以及更好的扩展性

缺点

容易有类的膨胀，大量衍生类的创建，简单的行为命令反而复杂

简单实现

//创建一个命令接口
public interface Order {
   void execute();
}

//创建一个请求类
public class Stock {
   
   private String name = "ABC";
   private int quantity = 10;
 
   public void buy(){
      System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] buy");
   }
   public void sell(){
      System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] sell");
   }
}

//创建实现了 Order 接口的实体类
public class BuyStock implements Order {
   private Stock abcStock;
 
   public BuyStock(Stock abcStock){
      this.abcStock = abcStock;
   }
 
   public void execute() {
      abcStock.buy();
   }
}
public class SellStock implements Order {
   private Stock abcStock;
 
   public SellStock(Stock abcStock){
      this.abcStock = abcStock;
   }
 
   public void execute() {
      abcStock.sell();
   }
}

//创建命令调用类
public class Broker {
   private List<Order> orderList = new ArrayList<Order>(); 
 
   public void takeOrder(Order order){
      orderList.add(order);      
   }
 
   public void placeOrders(){
      for (Order order : orderList) {
         order.execute();
      }
      orderList.clear();
   }
}

//使用 Broker 类来接受并执行命令
public class CommandPatternDemo {
   public static void main(String[] args) {
      Stock abcStock = new Stock();
 
      BuyStock buyStockOrder = new BuyStock(abcStock);
      SellStock sellStockOrder = new SellStock(abcStock);
 
      Broker broker = new Broker();
      broker.takeOrder(buyStockOrder);
      broker.takeOrder(sellStockOrder);
 
      broker.placeOrders();
   }
}

11.观察者模式

定义：定义对象见一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并更新

使用场景：

关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系
事件多级触发场景
跨系统的消息交换场景，如消息队列、事件总线的处理机制

优点

观察者和被观察者之间是抽象耦合，应对业务变化
增强系统灵活性、可扩展性，建立一套触发机制

缺点

如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化

简单实现

//观察者
public class Coder implements Observer {
    private String name;

    public Coder(String name) {
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Hi," + name + ",网站更新内容了：" + arg);
    }
}

//被观察者
public class Website extends Observable {
    public void callCoder(String content) {
        setChanged();
        notifyObservers(content);
    }
}


//测试调用
public class Test {
    public static void main(String[] args) {
        Website website = new Website();

        Coder xiaoMing = new Coder("小明");
        Coder xiaoHong = new Coder("小红");
        Coder xiaoFang = new Coder("小芳");

        website.callCoder("出了最新的技术了");
    }
}

12.备忘录模式

定义：在不破坏封闭的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样，以后就可以将该对象恢复到原先保存的状态

使用场景

需要保存一个对象在某一个时刻的状态或部分状态
如果用一个接口来让其他对象得到这些状态，将会暴露对象的实现细节并破坏对象的封装性，一个对象不希望外界直接访问其内部状态，通过中间对象可以间接访问其内部状态

优点

给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态
实现了信息的封装，使得用户不需要关心状态的保存细节

简单实现

@Override
public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
		super.onSaveInstanceState(outState, outPersistentState);
}

@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
}

13.迭代器模式

定义：提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示

使用场景

遍历一个容器对象时

优点

它支持以不同的方式遍历一个聚合对象。
迭代器简化了聚合类。
在同一个聚合上可以有多个遍历。
在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

简单实现

//迭代器接口
public interface Iterator {
    boolean hasNext();

    Object next();
}
//具体迭代器
public class ConcreteIterator implements Iterator {

    private int position;
    private List list = new ArrayList();

    public ConcreteIterator(List list){
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        if (position == list.size()) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public Object next() {
        Object obj = null;
        if(this.hasNext()){
            obj = this.list.get(position++);
        }
        return obj;
    }
}
//容器接口
public interface Aggregate {
    void add(Object obj);

    void remove(Object obj);

    Iterator iterator();
}
//具体容器
public class ConcreteAggregate implements Aggregate {

    private List list = new ArrayList();

    public void add(Object obj) {
        list.add(obj);
    }

    public Iterator iterator() {
        return new ConcreteIterator(list);
    }

    public void remove(Object obj) {
        list.remove(obj);
    }

}
//测试调用
public class Test {
    public static void main(String[] args) {
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("1");
        aggregate.add("2");
        aggregate.add("3");
        aggregate.add("4");
        aggregate.add("5");
        aggregate.add("6");
        Iterator iterator = aggregate.iterator();
        while (iterator.hasNext()) {
            System.out.println("\n" + iterator.next());
        }
    }
}

14.模板方法模式

定义：定义一个操作中的算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构可重定义该算法的某些特定步骤

使用场景

多个子类有公有方法，并且逻辑基本相同时
重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能由各个子类实现
重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类，然后通过钩子函数约束其行为

优点

封装不变部分，扩展可变部分
提取公共部分代码，便于维护

缺点

模板方法会带来代码阅读的难度，会让用户觉得难以理解

简单实现

//创建一个抽象类，它的模板方法被设置为 final。
public abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    //模板
    public final void play(){

        //初始化游戏
        initialize();

        //开始游戏
        startPlay();

        //结束游戏
        endPlay();
    }
}

//创建扩展了上述类的实体类。
public class Cricket extends Game {
 
   @Override
   void endPlay() {
      System.out.println("Cricket Game Finished!");
   }
 
   @Override
   void initialize() {
      System.out.println("Cricket Game Initialized! Start playing.");
   }
 
   @Override
   void startPlay() {
      System.out.println("Cricket Game Started. Enjoy the game!");
   }
}
public class Football extends Game {
 
   @Override
   void endPlay() {
      System.out.println("Football Game Finished!");
   }
 
   @Override
   void initialize() {
      System.out.println("Football Game Initialized! Start playing.");
   }
 
   @Override
   void startPlay() {
      System.out.println("Football Game Started. Enjoy the game!");
   }
}

//使用 Game 的模板方法 play() 来演示游戏的定义方式。
public class TemplatePatternDemo {
   public static void main(String[] args) {
 
      Game game = new Cricket();
      game.play();
      System.out.println();
      game = new Football();
      game.play();      
   }
}

15.访问者模式

定义：封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作

使用场景

对象结构比较稳定，但经常需要在此对象结构上定义新的操作
需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免这些操作“污染”这些对象的类，也不希望再增加新操作时修改这些类

优点

各角色职责分离，符合单一职责原则
具有优秀的扩展性
使得数据结构和作用于结构上的操作解耦，使得操作集合可以独立变化
灵活性

缺点

具体原生对访问者公布细节，违反了迪米特原则
具体元素变更时导致修改成本大
违反了依赖倒置原则，为了达到“区别对待”而依赖了具体类，没有依赖抽象

简单实现

//定义一个表示元素的接口
public interface ComputerPart {
   public void accept(ComputerPartVisitor computerPartVisitor);
}

//创建扩展了上述类的实体类。
public class Keyboard  implements ComputerPart {
 
   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}
public class Monitor  implements ComputerPart {
 
   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}
public class Mouse  implements ComputerPart {
 
   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}
public class Computer implements ComputerPart {
   
   ComputerPart[] parts;
 
   public Computer(){
      parts = new ComputerPart[] {new Mouse(), new Keyboard(), new Monitor()};      
   } 
 
 
   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      for (int i = 0; i < parts.length; i++) {
         parts[i].accept(computerPartVisitor);
      }
      computerPartVisitor.visit(this);
   }
}

//定义一个访问者接口
public interface ComputerPartVisitor {
   public void visit(Computer computer);
   public void visit(Mouse mouse);
   public void visit(Keyboard keyboard);
   public void visit(Monitor monitor);
}

//创建实现了上述类的实体访问者。
public class ComputerPartDisplayVisitor implements ComputerPartVisitor {
 
   @Override
   public void visit(Computer computer) {
      System.out.println("Displaying Computer.");
   }
 
   @Override
   public void visit(Mouse mouse) {
      System.out.println("Displaying Mouse.");
   }
 
   @Override
   public void visit(Keyboard keyboard) {
      System.out.println("Displaying Keyboard.");
   }
 
   @Override
   public void visit(Monitor monitor) {
      System.out.println("Displaying Monitor.");
   }
}

//使用 ComputerPartDisplayVisitor 来显示 Computer 的组成部分。
public class VisitorPatternDemo {
   public static void main(String[] args) {
 
      ComputerPart computer = new Computer();
      computer.accept(new ComputerPartDisplayVisitor());
   }
}

16.中介者模式

定义：中介者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使它们可以松散耦合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。中介者模式将多对多的相互作用转化为一对多的相互作用。中介者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理

使用场景

多个类相互耦合，形成了网状结构。

优点

如果类的依赖关系如网状般错综复杂，适当使用中介者模式可以对这种依赖关系进行解耦使逻辑结构清晰

缺点

如果类之间的依赖关系不复杂，使用中介者反而会使得原本的逻辑结构变得复杂

简单实现

//创建User类
public class User {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public User(String name) {
        this.name = name;
    }

    public void sendMessage(String message) {
        ChatRoom.showMessage(this, message);
    }
}

//创建中介类
public class ChatRoom {
    public static void showMessage(User user, String message){
        System.out.println(new Date().toString()
                + " [" + user.getName() +"] : " + message);
    }
}

//使用 User 对象来显示他们之间的通信。
public class MediatorPatternDemo {
    public static void main(String[] args) {
        User robert = new User("Robert");
        User john = new User("John");

        robert.sendMessage("Hi! John!");
        john.sendMessage("Hello! Robert!");
    }
}

17.代理模式

定义：为其他对象提供一种代理以控制对这个对象的访问

使用场景

当无法或不想直接访问某个对象或者访问某个对象存在困难时可以通过一个代理对象来间接访问，为了保证客户端使用的透明性，委托对象与代理对象需要实现相同的接口

优点

职责清晰。
高扩展性。
智能化。

缺点

由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。
实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

简单实现

//创建一个接口。
public interface Image {
   void display();
}

//创建实现接口的实体类。
public class RealImage implements Image {
 
   private String fileName;
 
   public RealImage(String fileName){
      this.fileName = fileName;
      loadFromDisk(fileName);
   }
 
   @Override
   public void display() {
      System.out.println("Displaying " + fileName);
   }
 
   private void loadFromDisk(String fileName){
      System.out.println("Loading " + fileName);
   }
}
public class ProxyImage implements Image{
 
   private RealImage realImage;
   private String fileName;
 
   public ProxyImage(String fileName){
      this.fileName = fileName;
   }
 
   @Override
   public void display() {
      if(realImage == null){
         realImage = new RealImage(fileName);
      }
      realImage.display();
   }
}

//当被请求时，使用 ProxyImage 来获取 RealImage 类的对象。
public class ProxyPatternDemo {
   
   public static void main(String[] args) {
      Image image = new ProxyImage("test_10mb.jpg");
 
      // 图像将从磁盘加载
      image.display(); 
      System.out.println("");
      // 图像不需要从磁盘加载
      image.display();  
   }
}

18.组合模式

定义：将对象组合成树形结构以表示是‘’部分-整体“的层次结构，使得用户对单个对象和组合对象的使用具有一致性

使用场景

表示对象的部分-整体层次结构时
从一个整体中能独立出部分模块或功能的场景

优点

高层模块调用简单。
节点自由增加。

简单实现

//创建 Employee 类，该类带有 Employee 对象的列表
public class Employee {
   private String name;
   private String dept;
   private int salary;
   private List<Employee> subordinates;
 
   //构造函数
   public Employee(String name,String dept, int sal) {
      this.name = name;
      this.dept = dept;
      this.salary = sal;
      subordinates = new ArrayList<Employee>();
   }
 
   public void add(Employee e) {
      subordinates.add(e);
   }
 
   public void remove(Employee e) {
      subordinates.remove(e);
   }
 
   public List<Employee> getSubordinates(){
     return subordinates;
   }
 
   public String toString(){
      return ("Employee :[ Name : "+ name 
      +", dept : "+ dept + ", salary :"
      + salary+" ]");
   }   
}

//使用 Employee 类来创建和打印员工的层次结构
public class CompositePatternDemo {
   public static void main(String[] args) {
      Employee CEO = new Employee("John","CEO", 30000);
 
      Employee headSales = new Employee("Robert","Head Sales", 20000);
 
      Employee headMarketing = new Employee("Michel","Head Marketing", 20000);
 
      Employee clerk1 = new Employee("Laura","Marketing", 10000);
      Employee clerk2 = new Employee("Bob","Marketing", 10000);
 
      Employee salesExecutive1 = new Employee("Richard","Sales", 10000);
      Employee salesExecutive2 = new Employee("Rob","Sales", 10000);
 
      CEO.add(headSales);
      CEO.add(headMarketing);
 
      headSales.add(salesExecutive1);
      headSales.add(salesExecutive2);
 
      headMarketing.add(clerk1);
      headMarketing.add(clerk2);
 
      //打印该组织的所有员工
      System.out.println(CEO); 
      for (Employee headEmployee : CEO.getSubordinates()) {
         System.out.println(headEmployee);
         for (Employee employee : headEmployee.getSubordinates()) {
            System.out.println(employee);
         }
      }        
   }
}

19.适配器模式

定义：适配器模式把一个类的接口变成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作

使用场景

系统需要使用现有的类，而此类接口不符合系统的需要，即接口不兼容
想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作
需要一个统一的输出接口，而输入端的类型不可预知

优点

更好的复用性

系统需要使用现有的类，而此类的接口不符合系统的需要。使用适配器模式就可以让这些功能得到更好的复用
更好的扩展性

在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能

缺点

过多使用适配器会让系统非常凌乱，不容易整体把握
由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。

简单实现

//为媒体播放器和更高级的媒体播放器创建接口。
public interface MediaPlayer {
   public void play(String audioType, String fileName);
}
public interface AdvancedMediaPlayer { 
   public void playVlc(String fileName);
   public void playMp4(String fileName);
}

//创建实现了 AdvancedMediaPlayer 接口的实体类。
public class VlcPlayer implements AdvancedMediaPlayer{
   @Override
   public void playVlc(String fileName) {
      System.out.println("Playing vlc file. Name: "+ fileName);      
   }
 
   @Override
   public void playMp4(String fileName) {
      //什么也不做
   }
}
public class Mp4Player implements AdvancedMediaPlayer{
 
   @Override
   public void playVlc(String fileName) {
      //什么也不做
   }
 
   @Override
   public void playMp4(String fileName) {
      System.out.println("Playing mp4 file. Name: "+ fileName);      
   }
}

//创建实现了 MediaPlayer 接口的适配器类。
public class MediaAdapter implements MediaPlayer {
 
   AdvancedMediaPlayer advancedMusicPlayer;
 
   public MediaAdapter(String audioType){
      if(audioType.equalsIgnoreCase("vlc") ){
         advancedMusicPlayer = new VlcPlayer();       
      } else if (audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer = new Mp4Player();
      }  
   }
 
   @Override
   public void play(String audioType, String fileName) {
      if(audioType.equalsIgnoreCase("vlc")){
         advancedMusicPlayer.playVlc(fileName);
      }else if(audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer.playMp4(fileName);
      }
   }
}

//创建实现了 MediaPlayer 接口的实体类。
public class AudioPlayer implements MediaPlayer {
   MediaAdapter mediaAdapter; 
 
   @Override
   public void play(String audioType, String fileName) {    
 
      //播放 mp3 音乐文件的内置支持
      if(audioType.equalsIgnoreCase("mp3")){
         System.out.println("Playing mp3 file. Name: "+ fileName);         
      } 
      //mediaAdapter 提供了播放其他文件格式的支持
      else if(audioType.equalsIgnoreCase("vlc") 
         || audioType.equalsIgnoreCase("mp4")){
         mediaAdapter = new MediaAdapter(audioType);
         mediaAdapter.play(audioType, fileName);
      } else {
         System.out.println("Invalid media. "+
            audioType + " format not supported");
      }
   }   
}

//使用 AudioPlayer 来播放不同类型的音频格式。
public class AdapterPatternDemo {
   public static void main(String[] args) {
      AudioPlayer audioPlayer = new AudioPlayer();
 
      audioPlayer.play("mp3", "beyond the horizon.mp3");
      audioPlayer.play("mp4", "alone.mp4");
      audioPlayer.play("vlc", "far far away.vlc");
      audioPlayer.play("avi", "mind me.avi");
   }
}

20.装饰模式

定义：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活

使用场景

需要透明且动态地扩展类的功能时

优点

装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

缺点

多层装饰比较复杂。

简单使用

//创建一个接口
public interface Shape {
   void draw();
}

//创建实现接口的实体类
public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Shape: Rectangle");
   }
}
public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Shape: Circle");
   }
}

//创建实现了 Shape 接口的抽象装饰类
public abstract class ShapeDecorator implements Shape {
   protected Shape decoratedShape;
 
   public ShapeDecorator(Shape decoratedShape){
      this.decoratedShape = decoratedShape;
   }
 
   public void draw(){
      decoratedShape.draw();
   }  
}

//创建扩展了 ShapeDecorator 类的实体装饰类
public class RedShapeDecorator extends ShapeDecorator {
 
   public RedShapeDecorator(Shape decoratedShape) {
      super(decoratedShape);     
   }
 
   @Override
   public void draw() {
      decoratedShape.draw();         
      setRedBorder(decoratedShape);
   }
 
   private void setRedBorder(Shape decoratedShape){
      System.out.println("Border Color: Red");
   }
}

//使用 RedShapeDecorator 来装饰 Shape 对象
public class DecoratorPatternDemo {
   public static void main(String[] args) {
 
      Shape circle = new Circle();
      ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
      ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());
      //Shape redCircle = new RedShapeDecorator(new Circle());
      //Shape redRectangle = new RedShapeDecorator(new Rectangle());
      System.out.println("Circle with normal border");
      circle.draw();
 
      System.out.println("\nCircle of red border");
      redCircle.draw();
 
      System.out.println("\nRectangle of red border");
      redRectangle.draw();
   }
}

21.享元模式

定义：使用共享对象可有效地支持大量的细粒度的对象

使用场景

系统中存在大量的相似对象
细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份
需要缓冲池的场景

优点

大大减少对象的创建，降低系统的内存，使效率提高。

缺点

使得系统更加复杂，为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化
将享元对象的状态外部化，而读取外部状态使时间稍微边长

简单使用

//创建一个接口。
public interface Shape {
   void draw();
}

//创建实现接口的实体类。
public class Circle implements Shape {
   private String color;
   private int x;
   private int y;
   private int radius;
 
   public Circle(String color){
      this.color = color;     
   }
 
   public void setX(int x) {
      this.x = x;
   }
 
   public void setY(int y) {
      this.y = y;
   }
 
   public void setRadius(int radius) {
      this.radius = radius;
   }
 
   @Override
   public void draw() {
      System.out.println("Circle: Draw() [Color : " + color + ", x : " + x +", y :" + y +", radius :" + radius);
   }
}

//创建一个工厂，生成基于给定信息的实体类的对象。
public class ShapeFactory {
   private static final HashMap<String, Shape> circleMap = new HashMap<>();
 
   public static Shape getCircle(String color) {
      Circle circle = (Circle)circleMap.get(color);
 
      if(circle == null) {
         circle = new Circle(color);
         circleMap.put(color, circle);
         System.out.println("Creating circle of color : " + color);
      }
      return circle;
   }
}

//使用该工厂，通过传递颜色信息来获取实体类的对象。
public class FlyweightPatternDemo {
   private static final String colors[] = 
      { "Red", "Green", "Blue", "White", "Black" };
   public static void main(String[] args) {
 
      for(int i=0; i < 20; ++i) {
         Circle circle = 
            (Circle)ShapeFactory.getCircle(getRandomColor());
         circle.setX(getRandomX());
         circle.setY(getRandomY());
         circle.setRadius(100);
         circle.draw();
      }
   }
   private static String getRandomColor() {
      return colors[(int)(Math.random()*colors.length)];
   }
   private static int getRandomX() {
      return (int)(Math.random()*100 );
   }
   private static int getRandomY() {
      return (int)(Math.random()*100);
   }
}

22.外观模式

定义：要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行，外观模式提供一个高层次的接口，使得子系统更易于使用

使用场景

为复杂的模块或子系统提供外界访问的模块。
子系统相对独立。
预防低水平人员带来的风险。

优点

对客户程序隐藏子系统细节，因而减少了客户对于子系统的耦合，能够拥抱变化
外观类对子系统的接口封装，使得系统更易于使用

缺点

外观类接口膨胀。由于子系统的接口都有外观类统一对外暴露，使得外观类的API接口较多，在一定程度上增加了用户使用成本
外观类没有遵循开闭原则，当业务出现变更时，可能需要直接修改外观类

简单实现

/** * 电脑接口 */
public interface Computer {
    void open();
}

/** * CPU类 */
class Cpu implements Computer {
    @Override
    public void open() {
        System.out.println("启动CPU");
    }
}

/** * 内存类 */
class Ddr implements Computer {
    @Override
    public void open() {
        System.out.println("启动内存");
    }
}

/** * 硬盘类 */
class Ssd implements Computer {
    @Override
    public void open() {
        System.out.println("启动硬盘");
    }
}
/** * 外观类 */
public class Facade {
    private Computer cpu;
    private Computer ddr;
    private Computer ssd;

    /** * 启动cpu */
    public void onCPU() {
        cpu = new Cpu();
        cpu.open();
    }

    /** * 启动内存 */
    public void onDDR() {
        ddr = new Ddr();
        ddr.open();
    }

    /** * 启动硬盘 */
    public void onSSD() {
        ssd = new Ssd();
        ssd.open();
    }
}

public class FacadeTest34 {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.onSSD();
    }
}

23.桥接模式

定义：将抽象部分与实现部分分离，使它们都可以独立地进行变化

使用场景

如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。
对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用。
一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。

优点

抽象和实现的分离。
优秀的扩展能力。
实现细节对客户透明。

缺点

桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。

简单实现

//创建桥接实现接口。
public interface DrawAPI {
   public void drawCircle(int radius, int x, int y);
}

//创建实现了 DrawAPI 接口的实体桥接实现类。
public class RedCircle implements DrawAPI {
   @Override
   public void drawCircle(int radius, int x, int y) {
      System.out.println("Drawing Circle[ color: red, radius: "
         + radius +", x: " +x+", "+ y +"]");
   }
}
public class GreenCircle implements DrawAPI {
   @Override
   public void drawCircle(int radius, int x, int y) {
      System.out.println("Drawing Circle[ color: green, radius: "
         + radius +", x: " +x+", "+ y +"]");
   }
}

//使用 DrawAPI 接口创建抽象类 Shape。
public abstract class Shape {
   protected DrawAPI drawAPI;
   protected Shape(DrawAPI drawAPI){
      this.drawAPI = drawAPI;
   }
   public abstract void draw();  
}

//创建实现了 Shape 接口的实体类。
public class Circle extends Shape {
   private int x, y, radius;
 
   public Circle(int x, int y, int radius, DrawAPI drawAPI) {
      super(drawAPI);
      this.x = x;  
      this.y = y;  
      this.radius = radius;
   }
 
   public void draw() {
      drawAPI.drawCircle(radius,x,y);
   }
}

//使用 Shape 和 DrawAPI 类画出不同颜色的圆。
public class BridgePatternDemo {
   public static void main(String[] args) {
      Shape redCircle = new Circle(100,100, 10, new RedCircle());
      Shape greenCircle = new Circle(100,100, 10, new GreenCircle());
 
      redCircle.draw();
      greenCircle.draw();
   }
}

展开全文 >>

Android群英传

2019-07-20

五、AndroidScroll分析

1.滑动效果如何产生的

1).Android 坐标系

含义： 将屏幕最左上角的顶点作为Android坐标系的远点，这个点向右是X轴正方向，这个点向下是Y轴正方向。

系统提供了getLocationOnScreen(int location[])的方法来获取Android 坐标系中点的位置，另外在触控事件中使用getRawX()、getRawY()方法获得的坐标统一是Android 坐标系中的坐标

2).视图坐标系

含义： 描述了子视图在父视图中的位置关系

在触控事件中，通过getX(),getY()所获得的坐标就是视图坐标系中的坐标

3).触控事件——MotionEvent

通常情况下，我们会在onTouchEvent(MotionEvent event)方法中通过event.getAction()方法来获取触控事件的类型

View提供的获取坐标的方法

getTop()：获取到的是View自身的顶点到其父布局顶边的距离

getLeft()：获取到的是View自身的左边到其父布局左边的距离

getRight()：获取到的是View自身的右边到其父布局左边的距离

getLeft()：获取到的是View自身的底边到其父布局顶边的距离
MotionEvent提供的方法

getX()：获取点击事件距离控件左边的距离，即视图坐标

getY()：获取点击事件距离控件顶边的距离，即视图坐标

getRawX()：获取点击事件距离整个屏幕左边的距离，即绝对坐标

getRawY()：获取点击事件距离整个屏幕顶边的距离，即绝对坐标

2.实现滑动的七种方法

1).layout方法

在每次回调onTouchEvent的时候，我们都获取下触摸点的坐标
在ACTION_DOWN事件中记录触摸点的坐标
最后，在ACTION_MOVE事件中计算偏移量，并将偏移量作用到Layout方法中，在目前Layout的left，top,right,bottom基础上，增加计算出来的偏移量

@Override
public boolean onTouchEvent(MotionEvent event){
  int x = (int)event.getX();
  int y = (int)event.getY();
  switch(event.getAction()){
    case MotionEvent.ACTION_DOWN:
      //记录触摸点坐标
      lastX = x;
      lastY = y;
      break;
    case MotionEvent.ACTION_MOVE:
     	//计算偏移量
      int offsetX = x - lastX;
      int offsetY = y - lastY;
      //在当前left,top,right,bottom的基础上加上偏移量
      layout(getLeft() + offsetX,
            getTop() + offsetY,
            getRight() + offsetX,
            getBottom() + offsetY);
      break;
  }
  return true;
}

注意点： 如果使用绝对坐标系，在每次执行完ACTION_MOVE的逻辑后一定要重新设置初始坐标系，这样才能准确的获取偏移量

2).offsetLeftAndRight()与offsetTopAndBottom()

这个方法相当于系统提供的一个对左右、上下移动的API的封装

//同时对left和right进行偏移
offsetLeftAndRight(offsetX)
//同时对left和right进行偏移
offsetTopAndBottom(offsetY)

3).LayoutParams

必须要有一个父布局，系统才能获取LayoutParams,通过getLayoutParams()获取时，需要根据View所在的父布局的类型来设置不同的类型，例如在LinearLayout中使用LinearLayout.LayoutParams,在RelativeLayout中用RelativeLayout.LayoutParams

也可以直接使用ViewGroup.MarginLayoutParams,这样不需要考虑父布局的类型

LinearLayout.LayoutParams params = (LinearLayout.LayoutParams)getLayoutParams();
params.leftMargin = getLeft() + offsetX;
params.topMargin = getTop() +offsetY;
setLayoutParams(layoutParams);

4).scrollTo与scrollBy

scrollTo(x,y)表示移动到一个具体的坐标点(x,y)

scrollBy(dx,dy)表示移动的增量未dx,dy

这两个方法移动的是View的content,如果需要实现跟随手指的移动而滑动的效果，必须将偏移量设置为负值

5).Scroller

初始化Scroller

重写computeScroll()方法，实现模拟滑动，这个方法实际上就是使用的scrollTo方法

@Override
public void computeScroll(){
  super.computeScroll();
  //判断Scroller是否执行完毕
  if(mScroller.computeScrollOffset()){
    ((View)getParent()).scrollTo(
    				mScroller.getCurrX(),
    				mScroller.getCurrY());
    //通过重绘来不断调用computeScroll
    invalidate();
  }
}

startScroll开启模拟过程,有两个重载方法，一个带时间，其他的参数表示起始坐标和偏移量

startScroll(int startX,int startY,int dx,int dy,int duration)

startScroll(int startX,int startY,int dx,int dy)

6).属性动画

具体直接参考第七章

7).ViewDragHelper

初始化ViewDragHelper

通常定义在一个VIewGroup的内部，并且通过其静态工厂方法进行初始化，第一个参数是要监听的view,通常需要的就是一个ViewGroup,即parentView，第二个参数就是一个Callback回调
1
mViewHelper = ViewDragHelper.create(this,callback);

拦截事件

@Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        return mViewHelper.shouldInterceptTouchEvent(ev);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        //将触摸事件传递给ViewDragHelper，此操作必不可少
        mViewHelper.processTouchEvent(event);
        return true;
    }

处理computeScroll()

ViewDragHelper内部也是用Scroller来实现平滑移动的，同样需要重写computeScroll()方法

@Override
    public void computeScroll() {
        if (mViewHelper.continueSettling(true)) {
            ViewCompat.postInvalidateOnAnimation(this);
        }
    }

处理Callback

private ViewDragHelper.Callback mCallback = new ViewDragHelper.Callback() {
       //何时开始检测触摸事件
       @Override
       public boolean tryCaptureView(@NonNull View child, int pointerId) {
           //如果当前触摸的child是mMainView时开始检测
           return mMainView = child;
       }
  
       @Override
       public int clampViewPositionVertical(@NonNull View child, int top, int dy) {
           return 0;
       }
  
       @Override
       public int clampViewPositionHorizontal(@NonNull View child, int left, int dx) {
           return left;
       }
  
   		//拖动结束后调用
       @Override
       public void onViewReleased(@NonNull View releasedChild, float xvel, float yvel) {
           super.onViewReleased(releasedChild, xvel, yvel);
           //手指抬起后缓慢移动到指定位置
           if (mMainView.getLeft() < mWidth / 2) {
               //关闭菜单
               //相当于Scroller的startScroll方法
               mViewHelper.smoothSlideViewTo(mMainView, 0, 0);
               ViewCompat.postInvalidateOnAnimation(DragViewGroup.this);
           } else {
               //打开菜单
               mViewHelper.smoothSlideViewTo(mMainView, mWidth, 0);
               ViewCompat.postInvalidateOnAnimation(DragViewGroup.this);
           }
       }
   };

六、绘图机制与处理技巧

1.屏幕的尺寸信息

1).屏幕参数

屏幕大小：指屏幕对角线的长度
分辨率：指手机屏幕的像素点的个数
PPI：每英寸像素，又被称为DPI

2).系统屏幕密度

密度	dpi	mdpi	hdpi	xhdpi	xxhdpi
密度值	120	160	240	320	480
分辨率	240*320	320*480	480*800	720*1280	1080*1920

3).独立像素密度dp

Android系统使用mdpi的屏幕作为标准，在这个屏幕上1px=1dp,在各种密度的屏幕上按照比例换算,比例如下

ldpi:mdpi:hdpi:xhdpi:xxhdpi = 3:4:6:8:12

4).单位转换

context.getResources().getDisplayMetrics().density可以获取到换算比例

也可以使用TypedValued类进行转换

public int dp2px(int dp){
  return (int)TypedValue.applyDimension(
    													TypedValue.COMPLEX_UNIT_DIP,
                              dp,
    													getResources().getDisplayMetrics());
}

2.2D绘图基础

Paint的属性和对应的功能：

setAntiAlias(); //设置画笔的锯齿效果
setColor(); //设置画笔的颜色
setARGB(); //设置画笔的A，R，G，B值
setAlpha(); //设置画笔的Alpha值
setTextSize(); //设置字体的尺寸
setStyle(); //设置画笔空心还是实心
setStrokeWidth(); //设置空心边框的宽度

Canvas的方法

DrawPoint，绘制点
DrawLine，绘制一条直线
DrawLines，绘制多条直线
DrawRect，绘制矩形
DrawRoundRect，绘制圆角矩形
DrawCircle，绘制圆
DrawArc，绘制弧形，扇形
DrawOval，绘制椭圆
DrawText，绘制文本
DrawPosText，在指定位置绘制文本
DrawPath,绘制路径

3.Android XML绘图

1).Bitmap

2).Shape

通过Shape可以在xml中绘制各种形状

3).Layer

可以通过layer，layer-list实现Photo中的图层效果，图片会依次叠加

4).Selector

作用在于实现静态绘图中的事件反馈，通过给不同的时间设置不同的图像，从而在程序中根据用户输入，返回不同的效果

4.Android绘图技巧

1).Canvas

Canvas.save();将之前所有已经绘制的图像保存起来
Canvas.restore();将在save()之后绘制的所有图像与save()之前的图像进行合并
Canvas.translate();将原点移动到(x,y)，之后的绘图操作都将以(x,y)为原点执行，x,y代表的也是位移差，不是绝对坐标，也就是说如果之前是（10,10），那么translate(20,20)后不是移动到了（20,20）处，而是移动到了（30，30）处，位移累加效果
Canvas.rotate();旋转画布

2).Layer图层

通过saveLayer()方法、saveLayerAlpha()方法将一个图层入栈，使用restore()、restoreToCount()方法将一个图层出栈

5.图像处理之色彩特效处理

色调——物体传播的颜色
饱和度——颜色的纯度，从0（灰）到100%（饱和）来进行描述
亮度——颜色的相对明暗程度

1).色彩矩阵分析

在Android 中，系统使用一个颜色矩阵——ColorMatrix，来处理图像的这些色彩斑斓的效果。
$$
\left| \begin{matrix} a & b & c & d & e\ f & g & h & i & j \ k & l & m & n & o \ p & q & r & s & t \end{matrix} \right|
\left| \begin{matrix}R\G\B\A\1\end{matrix}\right|
=
\left| \begin{matrix} aR & bG & cB & dA & e\ fR & gG & hB & iA & j \ kR & lG & mB & nA & o \ pR & qG & rB & sA & t \end{matrix} \right|
=
\left|\begin{matrix}R1\G1\B1\A1\end{matrix}\right|
$$

第一行的abcde值用来决定新的颜色值中的R–红色
第二行的fghij值用来决定新的颜色值中的G–绿色
第三行的klmno值用来决定新的颜色值中的B–蓝色
第四行的pqrst值用来决定新的颜色值中的A–透明度
矩阵中第五列ejot值分别用来决定每个分量中的offset,即偏移量

初始的矩阵正常如下显示
$$
\left|\begin{matrix}1&0&0&0&0\0&1&0&0&0\0&0&1&0&0\0&0&0&1&0\end{matrix}\right|
$$

常用到的方法

a.改变偏移量

例如红色和绿色各自增加100，最后图片显示偏黄
$$
\left|\begin{matrix}1&0&0&0&100\0&1&0&0&100\0&0&1&0&0\0&0&0&1&0\end{matrix}\right|
$$

b.改变颜色系数

例如绿色系数调为2倍，最后图片偏绿
$$
\left|\begin{matrix}1&0&0&0&0\0&2&0&0&0\0&0&1&0&0\0&0&0&1&0\end{matrix}\right|
$$

c.改变光属性

色调

ColorMartix提供了setRotate(int axis,float degree)来帮助我们设置颜色的色调，第一参数，系统分别用0，1，2来表示RGB三种颜色的处理，第二个参数就是需要处理的值
饱和度

ColorMartix提供了setSaturatuin(float sat)方法来设置颜色的饱和度，参数即代表设置颜色的饱和度的值，当饱和度为0时，图像就变成灰度图像了
亮度

当三原色以相同的比例进行混合时，就会显示出白色，当亮度为0时，图像就变成全黑的了

2).Android颜色矩阵——ColorMatrix

调整颜色矩阵可以改变一幅图像的色彩效果，图像处理很大程度上就是在寻找处理图像的颜色矩阵

3).常用图像颜色矩阵处理效果

灰度效果
$$
\left|\begin{matrix}0.33F&0.59F&0.11F&0&0\0.33F&0.59F&0.11F&0&0\0.33F&0.59F&0.11F&0&0\0&0&0&1&0\end{matrix}\right|
$$
图像反转
$$
\left|\begin{matrix}-1&0&0&0&0\0&-1&0&0&0\0&0&-1&0&0\0&0&0&1&0\end{matrix}\right|
$$
怀旧效果
$$
\left|\begin{matrix}0.393F&0.769F&0.189F&0&0\0.349F&0.686F&0.168F&0&0\0.272F&0.534F&0.131F&0&0\0&0&0&1&0\end{matrix}\right|
$$
去色效果
$$
\left|\begin{matrix}1.5F&1.5F&1.5F&0&-1\1.5F&1.5F&1.5F&0&-1\1.5F&1.5F&1.5F&0&-1\0&0&0&1&0\end{matrix}\right|
$$
高饱和度
$$
\left|\begin{matrix}1.438F&-0.122F&-0.016F&0&-0.03F\-0.062F&1.378F&-0.016F&0&0.05F\-0.062F&-0.122F&1.438F&0&-0.02F\0&0&0&1&0\end{matrix}\right|
$$

4).像素点分析

系统提供了Bitmap.getPixels()方法来帮助我们提取整个Bitmap中的像素点，并保存到一个数组中，如下

1	bitmap.getPixels(pixels,offset,stride,x,y,width,height)

pixels——接收位图颜色值的数组
offset——写入到pixels[]中的第一个像素索引值
stride——pixels[]中的行间距
x——从位图中读取的第一个像素的x坐标值
y——从位图中读取的第一个像素的y坐标值
width——从每一行中读取的像素宽度
height——读取的行数

bitmap.getPixels(oldPx,0,bm.getWidth(),0,0,width,height);
color = oldPx[i];
r = Color.red(color);
g = Color.green(color);
b = Color.blue(color);
a = Color.alpha(color);

可以对每个点进行颜色处理合成新像素点

最后将处理之后的像素点数组调用setPixels方法重新set给我们的Bitmap,达到处理图像的目的

5).常用图像像素点处理效果

底片效果：对应的颜色分别用255减去初始值后再赋值

老照片效果

1
2
3

r1 = (int)(0.393*r + 0.769*g + 0.189*b);
g1 = (int)(0.349*r + 0.686*g + 0.168*b);
b1 = (int)(0.272*r + 0.534*g + 0.131*b);

浮雕效果:若存在ABC三个像素点，要对B点对应的浮雕效果，代码如下
1
2
3
B.r = C.r - B.r + 127;
B.g = C.g - B.g + 127;
B.b = C.b - B.b + 127;

6.图像处理之图形特效处理

1).Android变形矩阵——Matrix

默认的图像变换矩阵初始为
$$
\left|\begin{matrix}1&0&0\0&1&0\0&0&1\end{matrix}\right|
$$

矩阵变换规律：
$$
\left|\begin{matrix}Scale_X&Skew_X&Trans_X\Scale_Y&Skew_Y&Trans_Y\0&0&1\end{matrix}\right|
$$

A和E控制Scale——缩放变换
B和D控制Skew——错切变换
C和F控制Trans——平移变换
A、B、C、D共同控制Rotate——旋转变换

a.平移变换：将每个像素点都进行平移交换

$$
\left|\begin{matrix}X_1\Y_1\1\end{matrix}\right|=\left|\begin{matrix}1&0&△x\0&1&△y\0&0&1\end{matrix}\right|\left|\begin{matrix}X_0\Y_0\1\end{matrix}\right|
$$

b.旋转变换：指一个点围绕一个旋转中心旋转到一个新的点

$$
\left|\begin{matrix}X_1\Y_1\1\end{matrix}\right|=\left|\begin{matrix}cosθ&-sinθ&0\sinθ&cosθ&0\0&0&1\end{matrix}\right|\left|\begin{matrix}X_0\Y_0\1\end{matrix}\right|
$$

如果以任意点O为旋转中心来进行旋转变换，通常需要下面三步骤：

将坐标原点平移到O点
使用前面讲的以坐标原点为中心的旋转方法进行旋转变换
将坐标原点还原

c.缩放变换：将每个点的坐标都进行相同比例的缩放，最终就会形成让整个图像缩放的效果

$$
\left|\begin{matrix}X_1\Y_1\1\end{matrix}\right|=\left|\begin{matrix}K_1&0&0\0&K_2&0\0&0&1\end{matrix}\right|\left|\begin{matrix}X_0\Y_0\1\end{matrix}\right|
$$

d.错切变换：将所有点的X坐标（或者Y坐标）保持不变，对应的Y坐标（或者X坐标）按照比例进行平移，且平移的大小和该点到X轴（或者Y轴）的垂直距离成正比

$$
\left|\begin{matrix}X_1\Y_1\1\end{matrix}\right|=\left|\begin{matrix}1&K_1&0\K_2&1&0\0&0&1\end{matrix}\right|\left|\begin{matrix}X_0\Y_0\1\end{matrix}\right|
$$

2).像素块分析

1
2
3

drawBitmapMesh(@NonNull Bitmap bitmap, int meshWidth, int meshHeight,
        @NonNull float[] verts, int vertOffset, @Nullable int[] colors, int colorOffset,
        @Nullable Paint paint)

该方法的关键参数如下：

bitmap：将要扭曲的图像
meshWidth：需要的横向网格数目
meshHeight：需要的纵向网格数目
verts：网格交叉点坐标数组
vertOffset：verts数组中开始跳过的(x,y)坐标对的数目

7.图像处理之画笔特效处理

1).PorterDuffXfermode

类似于数学中的交集和并集，控制的是两个图像间的混合显示模式，dst是先画的图形，src是后画的图形

mBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.test1);
mOut = Bitmap.createBitmap(mBitmap.getWidth(), mBitmap.getHeight(), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(mOut);
mPaint = new Paint();
mPaint.setAntiAlias(true);
canvas.drawRoundRect(0, 0, mBitmap.getWidth(), mBitmap.getHeight(), 180, 180, mPaint);
mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
canvas.drawBitmap(mBitmap,0,0,mPaint);

2).Shader

BitmapShaper——位图Shader
LinearGradient——线性Shader
RadialGradient——光束Shader
SweepGradient——梯度Shader
ComposeShader——混合Shader

除了BitmapShader，其余的都是渐变渲染效果。BitmapShader产生的是一个图像，通过Paint对画布进行指定Bitmap填充，填充有以下几种模式可以选择

CLAMP拉伸——拉伸的是图片最后的一个像素，不断重复
REPEAT重复——横向、纵向不断重复
MIRROR镜像——横向不断翻转重复，纵向不断翻转重复

3).PathEffect

CornerPathEffect

CornerPathEffect则可以将路径的转角变得圆滑，CornerPathEffect的构造方法只接受一个参数radius，意思就是转角处的圆滑程度
DiscretePathEffect

DiscretePathEffect（离散路径效果）相对来说则稍微复杂点，其会在路径上绘制很多“杂点”的突出来模拟一种类似生锈铁丝的效果。其构造方法有两个参数：

第一个参数指定这些突出的“杂点”的密度，值越小杂点越密集；

第二个参数则是“杂点”突出的大小，值越大突出的距离越大反之反之。
DashPathEffect

DashPathEffect可以用来绘制虚线，主要有两个参数

第一个参数为数组用来设置各个点之间的间隔，按照实线虚线交叉设置，后面绘制虚线会重复这样的间隔

第二个参数phase用来控制绘制时数组的一个偏移量，可以通过这个设置来实现路径的动态效果
PathDashPathEffect

PathDashPathEffect和DashPathEffect类似，不过功能更多，可以设置点的图形，比如方形点和圆形点
ComposePathEffect和SumPathEffect

ComposePathEffect和SumPathEffect都可以用来组合两种路径效果，就是把两种效果二合一。唯一不同的是组合的方式：

ComposePathEffect(PathEffect outerpe, PathEffect innerpe)会先将路径变成innerpe的效果，再去复合outerpe的路径效果，即：outerpe(innerpe(Path))；

SumPathEffect(PathEffect first, PathEffect second)则会把两种路径效果加起来再作用于路径。

8.View之孪生兄弟——SurfaceView

1).SurfaceView与View的区别

View主要适用于主动更新的情况下，而SurfaceView主要适用于被动更新，比如频繁刷新
View在主线程中对画面进行刷新，SurfaceView通常会通过一个子线程来进行页面的刷新
View在绘图时没有使用双缓冲机制，SurfaceView在底层就已经实现了双缓冲机制

2).SurfaceView的使用

创建SurfaceView

创建自定义的SurfaceView需要继承自SurfaceView ，并且需要实现两个接口SurfaceHolder.Callback(分别对应创建、改变和销毁)和Runnable
初始化SurfaceView

在自定义SurfaceView的构造方法中，需要进行初始化，通常需要定义以下三个成员变量
1
2
3
4
5
6
//SurfaceHolder
private SurfaceHolder mHolder;
//用于绘图的Canvas
private Canvas mCanvas;
//子线程标志位
private boolean mIsDrawing;
初始化方法就是对SurfaceHolder进行初始化，可以通过以下代码初始化一个SurfaceHolder对象，并注册SurfaceHolder的回调方法
1
2
mHolder = getHolder();
mHolder.addCallback(this);
使用SurfaceView

在SurfaveView回调方法surfaceCreated方法中开启子线程进行绘制，子线程使用一个while(mIsDrawing)来循环不停的进行绘制，在绘制的具体逻辑中，通过lockCanvas()方法获得Canvas对象进行绘制（该对象还是继续上次的Canvas对象，如果需要擦除，可以调用drawColor()方法进行清屏操作），并通过unlockCanvasAndPost(mCanvas)方法对画布内容进行提交

七、动画机制与使用技巧

1.Android View 动画框架

动画框架产生的动画不能改变事件相应的位置

1).透明度动画

为视图增加透明度的变换动画

1
2
3

AlphaAnimation aa = new AlphaAnimation(0,1);
aa.setDuration(1000);
view.startAnimation(aa);

2).旋转动画

为视图增加旋转的变换动画,参数分别为旋转的起始角度和旋转中心点的坐标

RotateAnimation ra1 = new RotateAnimation(0,360,100,100);
ra1.setDuration(1000);
view.startAnimation(ra1);

//设置旋转参考系为自身中心点
RotateAnimation ra2 = new RotateAnimation(0,360,
                                          RotateAnimation.RELATIVE_TO_SELF,0.5F,
                                          RotateAnimation.RELATIVE_TO_SELF,0.5F);
ra2.setDuration(1000);
view.startAnimation(ra2);

3).位移动画

为视图移动时增加位移动画

1
2
3

TranslateAnimation ta = new TranslateAnimation(0,200,0,300);
ta.setDuration(1000);
view.startAnimation(ta);

4).缩放动画

为视图的缩放增加动画效果

ScaleAnimation sa = new ScaleAnimation(0,2,0,2);
sa.setDuration(1000);
view.startAnimation(sa);

//设置以自身中心为缩放的中心点
ScaleAnimation sa2 = new ScaleAnimation(0,1,0,1
                                       Animation.RELATIVE_TO_SELF,0.5F,
                                       Animation.RELATIVE_TO_SELF,0.5F);
sa2.setDuration(1000);
view.startAnimation(sa2);

5).动画集合

通过AnimationSet,可以将动画以组合的形式展现出来，通过设置AnimationListener,可以针对动画的开始，结束和重复事件作出不同的处理

2.Android属性动画分析

在Animator框架中使用最多的就是AnimatorSet和ObjectAnimator配合，使用ObjectAnimator进行更精细化控制，只控制一个对象的一个属性值，使用多个ObjectAnimator组合AnimatorSet形成一个动画。

1).ObjectAnimator

创建一个ObjectAnimator对象只需要通过他的静态工厂类之间返回一个ObjectAnimator对象。参数包括一个对象和对象的属性名字，这个属性必须有get和set函数，内部会通过反射机制来调用set函数修改对象属性值

1
2
3

ObjectAnimator anim = ObjectAnimator.ofFloat(view,"translationX",300);
anim.setDuration(300);
anim.start();

常用的可以直接使用属性动画的属性值：

translationX和translationY:这两个属性作为一种增量来控制着View对象从它布局容器的左上角坐标开始的位置
rotation、rotationX和rotationY:这三个属性控制着View对象围绕支点进行2D和3D旋转
scaleX和scaleY:这两个属性控制着View对象围绕它的支点进行2D缩放
piovtX和pivotY:这两个属性控制着View对象的支点位置，围绕这个支点进行旋转和缩放变换处理。默认情况下，支点的位置就是View对象的中心点
x和y:这是两个简单实用的属性，描述了View对象在它的容器中的最终位置，是最初的左上角坐标和translationX、translationY值的累计和
alpha:它表示View对象的alpha透明度。默认值是1（不透明），0代表完全透明

2).PropertyValuesHolder

类似视图动画中的AnimationSet，在属性动画中，如果针对同一个对象的多个属性，要同时作用多种动画，可以使用PropertyValuesHolder来实现。

PropertyValuesHolder pvh1 = PropertyValuesHolder.ofFloat("tanslationX",300f);
PropertyValuesHolder pvh2 = PropertyValuesHolder.ofFloat("scaleX",1f,0,1f);
PropertyValuesHolder pvh3 = PropertyValuesHolder.ofFloat("scaleY",1f,0,1f);
ObjectAnimator.ofPropertyValuesHolder(view,pvh1,pvh2,pvh3).setDuration(1000).start()

3).ValueAnimator

ValueAnimator本身不提供任何动画效果，更像是一个数值发生器，用来产生具有一定规律的数字，从而让调用者来控制动画的实现过程。在AnimatorUpdateListener中监听数值的变换，从而完成动画的变换

4).动画事件的监听

一个完整的动画具有Start、Repeat、End、Cancel四个过程，通过Android提供了接口，可以很方便的监听四个事件

ObjectAnimator anim = ObjectAnimator.ofFloat(view,"alpha",0.5f);
        anim.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {
            }
            @Override
            public void onAnimationEnd(Animator animation) {
            }
            @Override
            public void onAnimationCancel(Animator animation) {
            }
            @Override
            public void onAnimationRepeat(Animator animation) {
            }
        });
        anim.start();

如果只对部分过程监听，可以使用AnimatorListenerAdapter进行监听

5).AnimatorSet

AnimatorSet可以通过playTogether()、playSequentially()、animSet.play().with()、play().with()、play().before()、play().after()这些方法控制多个动画的协同工作方式，从而做到对动画播放顺序的精确控制。

6).在XML中使用属性动画

属性动画同视图动画一样，也可以直接写在XML文件中,在res/animator目录下，如下

<?xml version="1.0" encoding="utf-8"?>
<objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
    android:duration="1000"
    android:propertyName="scaleX"
    android:valueFrom="1.0"
    android:valueTo="2.0"
    android:valueType="floatType">
</objectAnimator>

在程序中使用方式如下：

public void scaleX(View view){
  Animator anim = AnimatorInflater.loadAnimator(this,R.animator.scalex);
  anim.setTarget(mView);
  anim.start();
}

7).View的animate方法

可以认为是属性动画的简写方式，如下

view.animate()
                .alpha(0)
                .y(300)
                .setDuration(500)
                .withStartAction(new Runnable() {
                    @Override
                    public void run() {
                        
                    }
                })
                .withEndAction(new Runnable() {
                    @Override
                    public void run() {
                        
                    }
                })
                .start();

3.Android布局动画

在ViewGroup的XML中，可以用一下代码打开布局动画，显示默认的过渡效果，无法替换

1	android:animateLayoutChanges="true"

也可以通过使用LayoutAnimationController类来自定义一个子View的过渡效果

LinearLayout ll = findViewById(R.id.ll);
ScaleAnimation sa = new ScaleAnimation(0, 1, 0, 1);
sa.setDuration(2000);
LayoutAnimationController lac = new LayoutAnimationController(sa, 0.5F);
lac.setOrder(LayoutAnimationController.ORDER_NORMAL);
ll.setLayoutAnimation(lac);

第一个参数是需要作用的动画，第二个参数，是每个子View显示的delay时间，时间不为0时，可以设置子View显示的顺序：

LayoutAnimationController.ORDER_NORMAL——顺序
LayoutAnimationController.ORDER_RANDOM——随机
LayoutAnimationController.ORDER_REVERSE——反序

4.Interpolators（插值器）

在ValueAnimator中使用插值器可以直接调用setInterpolator(TimeInterpolator value)函数，可以根据需求自己定义插值器，只需要实现TimeInterpolator接口就行

public class MyInterpolator implements TimeInterpolator {
    @Override
    public float getInterpolation(float input) {
        return 1 - input;
    }
}

5.自定义动画

自定义动画需要继承Animation类，然后实现applyTransformation(float interpolatedTime, Transformation t)方法就可以，正常情况下还需要覆盖父类的initialize来实现一些初始化工作

第一个参数interpolatedTime就是插值器的时间因子，这个因子是由动画当前完成的百分比和当前时间所对应的插值所计算得到的，取值范围为0到1.0
第二个参数Transformation是矩阵的封装类，一般可以使用这个类来获得当前的矩阵对象
1
final Matrix matrix = t.getMatrix();

例如实现电视机的关闭效果

1 2	//mCenterWidth,mCenterHeight是缩放点的中心 matrix.preScale(1,1-interpolatedTime,mCenterWidth,mCenterHeight);

6.SVG矢量动画机制

可伸缩矢量图形（Scalable Vector Graphics）
定义用于网络的基于矢量的图形
使用XML格式定义图形
图像在放大或者改变尺寸的情况下其图形质量不会有所损失
万维网联盟的标准
与诸如DOM和XSL之类的W3C标准是一个整体

1).<path>标签

标签pathData属性支持的指令有以下几种

M=moveto(M X,Y)：将画笔移动到指定的坐标位置，但未发生绘制
L=lineto(L X,Y)：画直线到指定的坐标位置
H=horizontal lineto(H X)：画水平线到指定的X坐标位置
V=vertical lineto(V Y)：画垂直线到指定的Y坐标位置
C=curveto(C X1,Y1,X2,Y2,ENDX,ENDY)：三次贝塞曲线
S=smooth curveto(S X2,Y2,ENDX,ENDY)：三次贝塞曲线（将上一条的指令终点作为这条指令的起始点）
Q=quadratic Belzier curve(Q X,Y,ENDX,ENDY)：二次贝塞曲线
T=smooth quadratic Belzier curveto(T ENDX,ENDY)：映射前面路径后的终点
A=elliptical Arc(A RX,RY,XROTATION,FLAG1,FLAG2,X,Y)：弧线
Z=closepath()：关闭路径

使用时需要注意，指令可以大小写，大写表示绝对定位，参照全局坐标系，小写表示相对定位，参照父容器的坐标系；指令和数据间的空格可以省略；同一个指令出现多次可以只用一个

八、Activity与Activity调用栈分析

1.Activity

Activity的形态

Active/Running

这时候，Activity处于Activity 栈的最顶层，可见并与用户进行交互
Paused

Activity失去焦点时为Paused状态，只是失去了与用户交互的能力，所有状态信息，成员变量都还保持着
Stopped

此时不再可见，依然保持了所有状态信息和成员变量
Killed

被系统回收掉或者没有创建的时候就是这个状态

Activity生命周期如下：

2.Android任务栈

当一个App启动时，如果当前环境中不存在该App的任务栈，那么系统就会创建一个任务栈。此后，这个App所启动的Activity都将在这个任务栈中你那个被管理，这个栈也被称为一个Task

3.Activity启动模式

1).standard

未指定的Activity都以这个模式启动，每次都会创建新的实例

2).singleTop

在启动时，系统会判断当前启动的Activity是否处于栈顶，如果在，不创建新的，直接引用这个Activity，如果不处于则创建新的Activity

3).singleTask

检测整个Activity栈中是否存在当前需要启动的Activity,如果存在，则将该Activity置于栈顶，以上的Activity全部销毁,会调用该Activity的on new Intent()方法，只有一个实例

4).singeInstance

单独一个栈，并且只有单独一个实例

4.Intent Flag启动模式

通过设置Intent的Flag来设置一个Activity的启动模式，常用的有：

Intent.FLAG_ACTIVITY_NEW_TASK

使用一个新的Task来启动一个Activity,但启动的每个Activity都将在一个新的Task中，通常用于从Service启动Activity
Intent.FLAG_ACTIVITY_SINGLE_TOP

与指定launchMode为singleTop效果相同
Intent.FLAG_ACTIVITY_CLEAR_TOP

与指定launchMode为singleTask效果相同
Intent.FLAG_ACTIVITY_NO_HISTORY

使用这种模式启动Activity，当该Activity启动其他Activity后，就会消失，不会保留在栈中

5.清空任务栈

可以在AndroidMainifest文件的<activity>标签中使用以下几种属性来清理任务栈

clearTaskOnLaunch：每次返回该Activity时，都将之上的所有Activity清除
finishOnTaskLaunch：离开该Activity所处的Task，那么用户再返回时，该Activity会被finish掉
alwaysRetainState：如果将Activity的这个属性设置为True，那么该Activity所在的Task将不接受任何清理命令，一直保持当前Task状态

九、Android系统信息与安全机制

1.Android系统信息获取

1).android.os.Build

Build.BOARD // 主板
Build.CPU_ABI // cpu指令集
Build.DEVICE // 设备参数
Build.DISPLAY // 显示屏参数
Build.FINGERPRINT // 硬件名称
Build.HOST // Host值
Build.ID // 修订版本列表
Build.MANUFACTURER // 硬件制造商
Build.MODEL // 版本
Build.PRODUCT // 手机制造商
Build.TAGS // 描述build的标签
Build.TIME // 编译时间
Build.TYPE // builder类型
Build.USER // User名

2).SystemProperty

通过System.getProperty(“XXX”)可以获取许多系统配置属性值和参数，常用的如下

os.version // OS版本
os.name // OS名称
os.arch // OS架构
user.home // Home属性
user.name // Name属性
user.dir // Dir属性
user.timezone // 时区
path.separator // 路径分隔符
line.separator // 行分隔符
file.separator // 文件分隔符
java.vendor.url //Java vendor URL 属性
java.class.path // Java Class 路径
java.class.version // Java Class 版本
java.vendor // Java 版本
java.home // Java Home 属性

3).Android 系统信息实例

在system/build.prop文件中，包含很多RO属性值，在/proc目录下，可以看到更多的系统信息

2.Andoird Apk 应用信息获取之PackageManager

1).PackageManager

在上图中，最里面的框代表整个Activity信息，系统提供了ActivityInfo类进行封装

最外面的框代表这个整个Mainifest文件中节点的信息，系统提供了PackageInfo来进行封装

Android系统提供了PackaaageManager来负责管理所有已安装的App

ActivityInfo

封装了在Mainifest文件中<activity><\activity>和<receiver><\receiver>之间的所有信息，包括name、icon、label、launchmod等
ServiceInfo

ServiceInfo与ActivityInfo类似，它封装了<service><\service>之间的所有信息
ApplicationInfo

封装了<application><\application>之间的信息，而且还包含很多Flag,FLAG_SYSTEM表示为系统应用，FLAG_EXTERNAL_STORAGE表示为安装在SDCard上的应用，通过这些Flag，可以很方便的判断应用的类型
PackageInfo

封装Mainifest文件的相关节点信息，还包含了所有的Activity、Service等信息
ResolveInfo

封装的是包含<intent>信息的上一级信息，可以返回ActivityInfo、ServiceInfo等包含<intent>的信息，经常用来帮助我们找的那些包含特定Intent条件的信息

PackageManager可以通过调用各种方法，返回不同类型的Bean对象，经常使用以下方法

getPackageManager：通过调用这个方法返回一个PackageManager对象
getApplicationInfo：以getApplicationInfo的形式返回指定包名的ApplicationInfo
getApplicationIcon：返回指定包名的Icon
getInstalledApplications：以ApplicationInfo的形式返回安装的应用
getInstalledPackages：以PackageInfo的形式返回安装的应用
queryIntentActivities：返回指定intent的ResolveInfo对象、Activity集合
queryIntentServices：返回指定intent的ResolveInfo对象、Service集合
resolveActivity：返回指定intent的Activity
resolveService：返回指定intent的Service

3.Android Apk应用信息获取之ActivityManaager

ActivityManager封装了不少Bean对象

ActivityManager.MemoryInfo

MemoryInfo有几个非常重要的字段：availMem–系统可用内存，totalMem–总内存，thresold–低内存的阈值，即区分是否低内存的临界值，lowMemory–是否处于低内存
Debug.MemoryInfo

用于统计进程下的内存信息
RunningAppProcessInfo

运行进程的信息，存储的字段是进程相关的信息，processName–进程名，pid–进程pid，uid–进程uid，pkgList–该进程下的所有包
RunningServiceInfo

用于封装运行的服务信息，包含了一些服务进程的信息，同时还有一些其他信息，activiteSince–第一次被激活的时间，方式，foreground–服务是否在后台执行

4.解析Packages.xml获取系统信息

在系统初始化的时候，packageManager的底层实现类PackageManagerService会去扫描系统中的一些特定的目录，并解析其中的Apk文件。同时，Android把获得的应用信息保存到XML文件中，当系统中的apk安装，删除，升级时，也会被更新，位于/data/system/目录下的–packages.xml文件

<permissions>标签

定义了目前系统中的所有权限，并分为两类：系统定义的（package属性为Android)和Apk定义的（package属性为Apk的包名）
<package>标签

package标签代表了一个Apk的属性，各节点的含义如下所示

name：Apk的包名

codePath：Apk的安装路径，主要有/system/app（存放系统Apk或者是厂商定制Apk）和/data/app/（存放用户安装的第三方Apk）两种

userId：用户ID

version：版本号
<perms>标签

对应Apk的AndroidMainifest文件中的<uses-permission>标签，记录Apk的权限信息

5.Android安全机制

1).Android安全机制简介

代码安全机制——代码混淆proguard
应用接入权限控制——AndroidMainifest文件权限声明、权限检查机制
应用签名机制——数字证书
Linux内核层安全机制——Uid、访问权限控制
Android虚拟机沙箱机制——沙箱隔离

2).Android系统安全隐患

代码漏洞
Root风险
安全机制不健全
用户安全意识
Android开发原则与安全

3).Android Apk 反编译

apktool

进入到apktool目录下，通过指令apktool d XX.apk，可以获得解压的文件夹，可以查看相关的反编译的代码，也可以再使用apktool b XX可以对文件夹重新打包生成apk
Dex2jar、jd-gui

在apktool反编译后有一个dex文件，复制到dex2jar根目录下，然后执行如下命令：d2j-dex2jar.bat classes.dex，会在当前目录下生成一个jar文件，然后打开jd-gui，并选择file-open file，选择刚刚生成的classes-dex2jar.jar文件，就可以查看相关的源代码了

十、Android性能优化

1.布局优化

1).Android UI渲染机制

系统如果每次渲染的时间都在16ms之内，也就是60帧（1000/16）画面，这样UI界面会非常流畅

2).避免Overdraw

可以通过开启开发者选项中的检测工具查看，尽量增大蓝色的区域，减少红色区域

3).优化布局层级

Android中，系统对View进行测量、布局和绘制时，都是通过对View树的遍历来进行操作的，如果一个View树的高度太高，就会严重影响测量、布局和绘制的速度，因此优化布局的方法就是降低View树的高度

4).避免嵌套过多无用布局

使用<include>标签重用Layout
使用<ViewStub>实现View的延迟加载

布局中的ViewStub默认不显示，通过findViewById找到后，然后调用setVisibility(View.VISIBLE)来显示，也可以调用ViewStub的inflate()来显示，两种显示效果一样，不同的是inflate()方法可以返回引用的布局，一旦ViewStub被设置为可见或者被inflate了，那么ViewStub就不存在了(调用两次inflate()方法将会报错)，取而代之的是被inflate的布局，并将这个布局的ID重新设置为<ViewStub>中通过android:inflatedId属性指定的ID

2.内存优化

1).什么是内存

内存是指手机的RAM，包含以下几个部分

寄存器（Registers）

速度最快的存储场所，程序无法控制
栈（Stack）

存放基本类型的数据和对象引用，但对象本身不存在栈中，存放在堆中
堆（Heap）

堆内存用来存放由new创建的对象和数组，在堆中分配的内存，由Java虚拟机的自动垃圾回收器(GC)来管理
静态存储区域(Static Field)

静态存储区域就是指在固定的位置存放应用程序运行时一直存在的数据，Java在内存中专门划分了一个静态存储区域来管理一些特殊的数据变量如静态的数据变量
常量池

JVM虚拟机必须为每个被装载的类型维护一个常量池，常量池就是该类型所用到常量的一个有序集合，包括直接常量（基本类型，String）和对其他类型、字段和方法的符号引用。

2).获取Android系统内存信息

直接用AS自带的Profiler可以查看

3).内存回收

Java创建了垃圾收集器线程来自动进行资源的管理，方便了开发人员的工作，但是容易造成内存泄露

4).内存优化实例

Bitmap优化
- 使用适当分辨率和大小的图片
- 及时回收内存
- 使用图片缓存
代码优化
- 对常量使用static修饰符
- 使用静态方法，静态方法会比普通方法提高15%左右的访问速度
- 减少不必要的成员变量，可以使用Android Lint工具检测
- 减少不必要的对象，使用基础类型比使用对象更加节省资源，同时避免频繁创建短作用域的变量
- 尽量不要使用枚举，少用迭代器
- 对Cursor、Receiver、Sensor、File等对象，要非常注意对它们的创建、回收与注册、解注册
- 避免使用IOC框架，大量使用反射会带来性能的下降
- 使用RenderScript、OpenGL来进行非常复杂的绘图操作
- 使用SurfaceView来替代View进行大量、频繁的绘图操作
- 尽量使用视图缓存

3.Lint工具

Android Studio自带的Android代码提示工具

4.使用Android Studio的Profiler工具

在Android Studio3.6.2及以上版本可以使用自带的Profiler工具可以查看实时内存和网络请求等分析

5.使用TraceView工具优化App性能

1).生产TraceView日志的两种方法

通过代码生成精确范围的TraceView日志

通过调用Debug.startMethodTracing()方法开启监听，调用Debug.stopMethodTracing()方法结束监听,可以使用这两个方法来包围要监听的代码块，TraceView的日志将会保存到“/sdcard/dmtrace.trace”目录下，因此需要在Mainifest文件中增加WRITE_EXTRRNAL_STORAGE权限

监听的内容执行完毕后，通过ADB命令将日志文件导出到本地：

adb pull /sdcard/trace_log.trace/local/LOG/
通过Android Studio查看TraceView日志

2).打开TraceView日志

对于导出的TraceView文件，可以使用SDK中的sdk\tools\traceview.bat工具来打开，或者通过ADM工具打开

3).分析TraceView日志

时间轴区域：时间在走区域显示了不同线程在不同的时间段内的执行情况，在时间轴中，每一行都代表了一个独立的线程
Profile区域：
- Incl CPU Time——某方法占用CPU的时间
- Excl CPU Time——某方法本身（不包含子方法）占用CPU的时间
- Incl Real Time——某方法真正执行的时间
- Excl Real Time——某方法本身（不包括子方法）真正执行的时间
- Calls+RecurCalls——调用次数+递归回调的次数

展开全文 >>

第六章爬虫

2019-07-03

第6章爬虫

1.网络库

urllib库：http协议常用库

from urllib import request, parse
from io import BytesIO
import gzip

url = 'http://httpbin.org/post'
headers = {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
    "Accept-Encoding": "gzip, deflate, sdch",
    "Accept-Language": "zh-CN,zh;q=0.8",
    "Connection": "close",
    "Cookie": "_gauges_unique_hour=1; _gauges_unique_day=1; _gauges_unique_month=1; _gauges_unique_year=1; _gauges_unique=1",
    "Referer": "http://httpbin.org/",
    "Upgrade-Insecure-Requests": "1",
    "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36 LBBROWSER"
}
dict = {
    'name': 'value'
}
data = bytes(parse.urlencode(dict), encoding='utf8')
req = request.Request(url=url, data=data, headers=headers, method='POST')
response = request.urlopen(req)
htmls = response.read()
buff = BytesIO(htmls)
f = gzip.GzipFile(fileobj=buff)
print(f.read().decode('utf-8'))

requests库：http协议常用库
BeautifulSoup库：xml格式处理库

2.requests库

# get请求
import requests
url = 'http://httpbin.org/get'
data = {'key': 'value', 'abc': 'xyz'}
# .get是使用get方法请求url，字典类型的data不用进行额外处理
response = requests.get(url, data)
print(response.text)	# 打印的为格式化后的数据

# post请求
import requests
url = 'http://httpbin.org/post'
data = {'key': 'value', 'abc': 'xyz'}
# .post表示为post方法
response = requests.post(url, data)
# 返回类型为json格式
print(response.json()) # 打印的数据只有一整行

3.Beautiful Soup的安装和使用

安装命令：pip3 install bs4

展开全文 >>

第五章机器学习库

2019-06-13

第5章机器学习库

机器学习算法的通用步骤：

数据采集，数据预处理，数据清洗，建模，测试

[TOC]

1.Numpy库

用于高性能科学计算和数据分析，是常用的高级数据分析库的基础包

A.numpy的安装

输入命令：pip3 install numpy
在终端中输入：which python3可以获取到系统python的位置
在PyCharm中设置Preferences->Project->Project Interpreter->设置->Add,添加python地址
在PyCharm中设置Run->Edit Configurations,解释器选择刚刚添加的解释器

B.numpy的使用

numpy.array(?)传入一个列表，返回一个被numpy封装过的列表，计算的效率远远高于python自带的列表
numpy.array(?).dtype返回列表中的数据类型
numpy.array(?) + numpy.array(?)可以实现列表的累加

import numpy as np

arr1 = np.array([2, 3, 4])
print(arr1)
print(arr1.dtype)
arr2 = np.array([1.2, 2.3, 3.4])
print(arr2.dtype)
print(arr1 + arr2)
"""
输出结果
[2 3 4]
int64
float64
[3.2 5.3 7.4]
"""

C.numpy数组和标量的计算

numpy数组可以直接和标量进行计算
numpy.zeros((3,4))定义一个3行4列全部为0的矩阵
numpy.ones((4,5))定义一个4行5列的全部为1的矩阵
numpy.empty((2,3,2))定义一个3维矩阵，矩阵全部设置为空值对程序计算是不安全的，会随机填入空值

import numpy as np

arr2 = np.array([1.2, 2.3, 3.4])
print(arr2 * 10)
print(np.zeros((3, 4)))
print(np.ones((4, 5)))
print(np.empty((2, 3, 2)))
"""
输出结果
[12. 23. 34.]
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]
[[[0. 0.]
  [0. 0.]
  [0. 0.]]
 [[0. 0.]
  [0. 0.]
  [0. 0.]]]
"""

D.numpy数组的索引和切片

numpy.arange(start,stop,step)，和python的range()功能相似，产生一个数组，下标索引从0开始计算

import numpy as np

arr = np.arange(10, 30, 2)
arr[5:8] = 11
print(arr)
arr_slice = arr[5:8].copy()
print(arr_slice)
arr_slice[:] = 13
print(arr_slice)
print(arr)
"""
输出结果
[10 12 14 16 18 11 11 11 26 28]
[11 11 11]
[13 13 13]
[10 12 14 16 18 11 11 11 26 28]
"""

2.Pandas库

用于进行数据的预处理和数据的清洗

A.pandas的安装

在终端中输入:pip3 install pandas

B.Series

Series就是对numpy的array进行了封装，自动添加了索引
单独取出索引可以用Series.index
单独取出值可以用Series.value

from pandas import Series

obj = Series([4, 5, 6, -7])
print(obj)
print(obj.index)
print(obj.values)
"""
输出结果
0    4
1    5
2    6
3   -7
dtype: int64
RangeIndex(start=0, stop=4, step=1)
[ 4  5  6 -7]
"""

可以自定义索引值，而且pandas
可以通过索引进行赋值

from pandas import Series

obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'c', 'd'])
print(obj2)
obj2['d'] = 6
print(obj2)
print('a' in obj2)
"""
输出结果
d    4
b    7
c   -5
d    3
dtype: int64
d    6
b    7
c   -5
d    6
dtype: int64
False
"""

索引可以进行相应的修改

from pandas import Series

sdata = {'beijing': 35000, 'shanghai': 71000, 'guangzhou': 16000,'shenzhen': 5000}
obj3 = Series(sdata)
print(obj3)
obj3.index = ['bj', 'sh', 'gz', 'sz']
print(obj3)
"""
输出结果
beijing      35000
shanghai     71000
guangzhou    16000
shenzhen      5000
dtype: int64
bj    35000
sh    71000
gz    16000
sz     5000
dtype: int64
"""

Series.reindex(index,fill_value,method=”ffill,bfill”)index表示索引，fill_value表示用于填充缺失值的数，ffill用前面的值填充，bfill表示用后面的值进行填充

from pandas import Series

obj4 = Series([4.5, 7.2, -5.3, 3.5], index=['b', 'd', 'c', 'a'])
obj5 = obj4.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)
print(obj5)
obj6 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
print(obj6.reindex(range(6), method='bfill'))
"""
输出结果
a    3.5
b    4.5
c   -5.3
d    7.2
e    0.0
dtype: float64
0      blue
1    purple
2    purple
3    yellow
4    yellow
5       NaN
dtype: object
"""

Series.dropna()可以删除缺失值

from numpy import nan as NA

data = Series([1, NA, 2])
print(data.dropna())
"""
输出结果
0    1.0
2    2.0
dtype: float64
"""

C.DataFrame

多维数组的处理

DataFrame()添加参数columns=可以对列进行位置排序(列的位置替换，非列里面进行排序)
DataFrame[‘key’]或者DataFrame.key可以根据key值获取到对应列的数据
DataFrame[‘newkey’]=?可以添加新的列

from pandas import DataFrame

data = {'city': ['shanghai', 'shanghai', 'beijing', 'beijing'],
        'year': [2016, 2017, 2017, 2018],
        'pop': [1.5, 1.7, 2.4, 2.9]}
frame = DataFrame(data)
frame2 = DataFrame(data, columns=['year', 'pop', 'city'])
print(frame)
print(frame2)
print(frame2['city'])
print(frame2.year)
frame2['new'] = 100
print(frame2)
frame2['cap'] = frame2.city == 'beijing'
print(frame2)
"""
输出结果

       city  year  pop
0  shanghai  2016  1.5
1  shanghai  2017  1.7
2   beijing  2017  2.4
3   beijing  2018  2.9
   year  pop      city
0  2016  1.5  shanghai
1  2017  1.7  shanghai
2  2017  2.4   beijing
3  2018  2.9   beijing
0    shanghai
1    shanghai
2     beijing
3     beijing
Name: city, dtype: object
0    2016
1    2017
2    2017
3    2018
Name: year, dtype: int64
   year  pop      city  new
0  2016  1.5  shanghai  100
1  2017  1.7  shanghai  100
2  2017  2.4   beijing  100
3  2018  2.9   beijing  100
   year  pop      city  new    cap
0  2016  1.5  shanghai  100  False
1  2017  1.7  shanghai  100  False
2  2017  2.4   beijing  100   True
3  2018  2.9   beijing  100   True
"""

DataFrame.T可以将数据的行和列进行反转

from pandas import DataFrame

pop = {'beijing': {2008: 1.5, 2009: 2.0},
       'shanghai': {2008: 2.0, 2009: 3.6}}

frame3 = DataFrame(pop)
print(frame3)
print(frame3.T)
"""
输出结果
      beijing  shanghai
2008      1.5       2.0
2009      2.0       3.6
          2008  2009
beijing    1.5   2.0
shanghai   2.0   3.6
"""

DataFrame.dropna()可以删除多维数组的缺失值
1. 添加参数how=’all’只删除整行都是缺失值的数据，部分缺失值的可以保留
2. 添加参数axis=1，删除一整列都是缺失值的数据

from pandas import DataFrame
from numpy import nan as NA

data2 = DataFrame([[1, 2, 3], [5, 6, NA], [NA, NA, NA]])
print(data2.dropna())
print(data2.dropna(how='all'))
data2[4] = NA
print(data2)
print(data2.dropna(axis=1, how='all'))
"""
输出结果
     0    1    2
0  1.0  2.0  3.0
     0    1    2
0  1.0  2.0  3.0
1  5.0  6.0  NaN
     0    1    2   4
0  1.0  2.0  3.0 NaN
1  5.0  6.0  NaN NaN
2  NaN  NaN  NaN NaN
     0    1    2
0  1.0  2.0  3.0
1  5.0  6.0  NaN
2  NaN  NaN  NaN
"""

DataFrame.fillna(x)将数据中所有的缺失值都用x进行填充，如果需要直接修改的话，需要添加inplace=True,如果不添加直接填充的副本

from pandas import DataFrame
from numpy import nan as NA

data2 = DataFrame([[1, 2, 3], [5, 6, NA], [NA, NA, NA]])
data2.fillna(3)
print(data2)
data2.fillna(4, inplace=True)
print(data2)
"""
输出结果
     0    1    2
0  1.0  2.0  3.0
1  5.0  6.0  NaN
2  NaN  NaN  NaN
     0    1    2
0  1.0  2.0  3.0
1  5.0  6.0  4.0
2  4.0  4.0  4.0
"""

3.层次化索引

Series.unstack()，可以将数据转换为DataFrame
DataFrame.stack(),可以将数据转换为Series

import numpy as np
from pandas import Series, DataFrame

data = Series(np.random.randn(10),
              index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'],
                     [1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])
print(data)
print(data['b':'c'])

print(data.unstack())
print(data.unstack().stack())
"""
输出结果
a  1    0.959932
   2   -0.308277
   3   -0.677998
b  1   -0.632334
   2   -0.776489
   3   -0.201669
c  1   -0.014423
   2    0.364285
d  2   -0.124033
   3    0.228125
dtype: float64
b  1   -0.632334
   2   -0.776489
   3   -0.201669
c  1   -0.014423
   2    0.364285
dtype: float64
          1         2         3
a  0.959932 -0.308277 -0.677998
b -0.632334 -0.776489 -0.201669
c -0.014423  0.364285       NaN
d       NaN -0.124033  0.228125
a  1    0.959932
   2   -0.308277
   3   -0.677998
b  1   -0.632334
   2   -0.776489
   3   -0.201669
c  1   -0.014423
   2    0.364285
d  2   -0.124033
   3    0.228125
dtype: float64
"""

4.Matplotlib的安装与绘图

在终端输入：pip3 install matplotlib进行安装

然后再py文件中引入：import matplotlib.pyplot as plt

1.plt.plot()绘制一条曲线

1 2	plt.plot([1, 3, 5], [5, 8, 9]) plt.show()

2.Matplotlib绘制numpy和pandas里面的数据

1
2
3

x = np.linspace(-np.pi, np.pi, 100)#定义域为-π到π，平均取100个点
plt.plot(x, np.sin(x))
plt.show()

3.绘制多条曲线

y = np.linspace(-np.pi * 2, np.pi * 2, 100)
plt.figure(2, dpi=50)  # 创建图表2，精度为50,dpi越大文件越大，杂志要300以上
for i in range(1, 5):
    plt.plot(y, np.sin(y / i))
plt.show()

4.绘制直方图（hist）

plt.figure(1, dpi=50)  # 创建图表1，精度50
data = [1, 2, 3, 4, 5, 2, 3, 1, 1, 4, 2, 4, 2]
plt.hist(data)  # 只要传入数据，直方图就会统计出数据出现的次数
plt.show()

5.绘制散点图(scatter)

x = np.arange(1, 10)
y = x
plt.scatter(x, y, c='r', marker='o')  # c='r'表示颜色为红色，marker表示形状为圆形
plt.show()

4.Pandas和Matplotlib结合使用

1	warnings.filterwarnings('ignore')#可以忽略运行时的warning

1.pandas读取csv并绘制散点图

iris = pd.read_csv("./iris_training.csv")
#打印csv的前五行数据
print(iris.head())
# 绘制散点图，120和4分别为csv中数据的列名
iris.plot(kind='scatter', x='120', y='4')
# 让pandas的plot()方法在PyCharm上显示
plt.show()
"""
输出结果
   120    4  setosa  versicolor  virginica
0  6.4  2.8     5.6         2.2          2
1  5.0  2.3     3.3         1.0          1
2  4.9  2.5     4.5         1.7          2
3  4.9  3.1     1.5         0.1          0
4  5.7  3.8     1.7         0.3          0
"""

2.seaborn安装和使用

安装方法：pip3 install seaborn

导入方法：import seaborn as sns

seabrorn可以直接使用的主题：darkgrid，whitegrid，dark，white，和ticks,默认为darkgrid

iris = pd.read_csv("./iris_training.csv")
# 设置样式
sns.set(style='white', color_codes=True)
# 设置绘制格式为散点图,size表示图标的大小
sns.jointplot(x='120', y='4', data=iris, size=5)
# distplot绘制曲线
sns.distplot(iris['120'])

plt.show()

iris = pd.read_csv("./iris_training.csv")
# 设置样式
sns.set(style='white', color_codes=True)
sns.FacetGrid(iris, hue='virginica', size=5).map(plt.scatter, 'setosa', 'versicolor').add_legend()

plt.show()

5.Tensorflow库

安装方法：pip3 install tensorflow

展开全文 >>

第四章 Python标准库

2019-06-04

第4章 Python标准库

[TOC]

1. 文字处理的 re

A.re相关方法（正则表达式对象Pattern相关方法）

字符串前面加 r 表示去掉 \ (反斜杆)的转义机制
字符串前面加 u 表示以Unicode 格式进行编码
字符串前面加 b 表示后面的字符串是bytes类型
comiple(),传入参数表示要匹配的字符串
match()，如果字符串开始位置能够找到这个正则样式的任意个匹配，就返回一个相应的匹配对象。
group()，取出匹配后的分组，分组可以通过小括号实现，传入参数int，表示第几组，如果不传参，表示取出所有的部分

groups(),取出所有的组合

import re

p = re.compile(r'(\d+)-(\d+)-(\d+)') 
print(p.match('2018-05-10'))
print(p.match('20180510'))
print(p.match('2018-05-10').group())
print(p.match('2018-05-10').group(1))
print(p.match('2018-05-10').groups())

"""
输出结果
<_sre.SRE_Match object; span=(0, 10), match='2018-05-10'>
None
2018-05-10
2018
('2018', '05', '10')
"""

search()扫描整个字符串寻找第一个匹配的位置，如果有匹配返回一个相应的匹配对象。

import re

p = re.compile(r'(\d+)-(\d+)-(\d+)') 
print(p.match('aa2018-05-10bb'))
print(p.match('2018-05-10bb'))
print(re.match(r'(\d+)-(\d+)-(\d+)', '2018-05-10bb'))
print(p.search('aa2018-05-10bb'))
print(re.search(r'(\d+)-(\d+)-(\d+)', 'aa2018-05-10bb'))

"""
输出结果
None
<_sre.SRE_Match object; span=(0, 10), match='2018-05-10'>
<_sre.SRE_Match object; span=(0, 10), match='2018-05-10'>
<_sre.SRE_Match object; span=(2, 12), match='2018-05-10'>
<_sre.SRE_Match object; span=(2, 12), match='2018-05-10'>
"""

sub()将字符串中符合正则表达式的全部替换

from re import sub

phone = '123-456-789 # 这是电话号码'
p2 = sub(r'#.*$', '', phone)
print(p2)
p3 = sub(r'\D', '', phone)
print(p3)
p4 = sub(r'\d', '', phone)
print(p4)

"""
输出结果
123-456-789 
123456789
-- # 这是电话号码
"""

findall() 对字符串返回一个不重复的符合正则的匹配列表，字符串从左到右进行扫描，匹配按找到的顺序返回

import re

p = re.compile(r'(\d+)-(\d+)-(\d+)')
print(re.findall(r'(\d+)-(\d+)-(\d+)', 'a2018-05-10b2018-05-10c2018-05-10d'))
print(p.findall('a2018-05-10b2018-05-10c2018-05-10d'))
"""
输出结果
[('2018', '05', '10'), ('2018', '05', '10'), ('2018', '05', '10')]
[('2018', '05', '10'), ('2018', '05', '10'), ('2018', '05', '10')]
"""

B.常用元字符

‘.’在默认模式，匹配除了换行的任意字符。如果指定了标签DOTALL ，它将匹配包括换行符的任意字符
‘^’匹配字符串的开头，并且在MULTILINE 模式也匹配换行后的首个符号
‘$’匹配字符串尾或者换行符的前一个字符，在MULTILINE 模式匹配换行符的前一个字符
‘*’对它前面的正则式匹配0到任意次重复，尽量多的匹配字符串
‘+’对它前面的正则式匹配 1 到任意次重复
‘?’对它前面的正则式匹配 0 到 1 次重复。
在修饰符之后添加?将使样式以非贪婪方式或者最小方式进行匹配;尽量少的字符将会被匹配
‘{m}’对其之前的正则式指定匹配 m 个重复;少于 m 的话就会导致匹配失败
‘{m,n}’对正则式进行 m 到 n 次匹配，在 m 和 n 之间取尽量多
‘[]’用于表示一个字符集合。在一个集合中:
- 字符可以单独列出，比如 [amk] 匹配 ‘a’，’m’，或者 ‘k’
- 可以表示字符范围，通过用 ‘-‘ 将两个字符连起来。比如 [a-z] 将匹配任何小写 ASCII 字符，[0-5][0-9] 将匹配从 00 到 59 的两位数字，[0-9A-Fa-f] 将匹配任何十六进制数位。如果 - 进行了转义(比如 [a-z])或者它的位置在首位或者末尾(如 [-a] 或 [a-])，它就只表示普通字符 ‘-‘
- 特殊字符在集合中，失去它的特殊含义。比如 [(+)] 只会匹配这几个文法字符 ‘(‘, ‘+’, ‘‘, or ‘)’
- 字符类如 \w 或者 \S (如下定义) 在集合内可以接受，它们可以匹配的字符由ASCII 或者LOCALE 模式决定
- 不在集合范围内的字符可以通过取反来进行匹配。如果集合首字符是 ‘^’ ，所有不在集合内的字符将会被匹配，比如 [^5] 将匹配所有字符，除了 ‘5’，[^^] 将匹配所有字符，除了 ‘^’. ^ 如果不在集合首位，就没有特殊含义
- 在集合内要匹配一个字符 ‘]’，有两种方法，要么就在它之前加上反斜杠，要么就把它放到集合首位。比如，[()[]{}] 和 [{}] 都可以匹配括号
‘|’A|B，A 和 B 可以是任意正则表达式，创建一个正则表达式，匹配 A 或者 B. 任意个正则表达式可以用 ‘|’ 连接
‘\d’匹配数字，等同于[0-9]
‘\D’匹配非数字
‘\s’匹配一个字符串，只包括a-z
‘()’表匹配括号内的任意正则表达式，并标识出组合的开始和结尾

2. 日期类型的time、datetime

A.time一般用于日期和时间的查看

epoch是时间开始的点，并且取决于平台，一般是1970年1月1日00:00:00
UTC 是协调世界时(以前称为格林威治标准时间，或 GMT)
DST 是夏令时，在一年中的一部分时间(通常)调整时区一小时
time()返回浮点数从epoch到当前时间的秒
gmtime()从epoch到当前的时间转换为UTC的struct_time
localtime()从epoch到当前的时间转换为UTC的struct_time

time.struct_time返回的时间值序列的类型为gmtime()、localtime()和strptime()。它是一个带有named tuple 接口的对象:可以通过索引和属性名访问值。存在以下值:

索引	属性	值
0	tm_year	(例如，1993)
1	tm_mon	range [1, 12]
2	tm_mday	range [1, 31]
3	tm_hour	range [0, 23]
4	tm_min	(range [0, 59]
5	tm_sec	range [0, 61]
6	tm_wday	range [0, 6] ，周一为 0
7	tm_yday	range [1, 366]
8	tm_isdst	0, 1 或 -1
N/A	tm_zone	时区名称的缩写
N/A	tm_gmtoff	以秒为单位的 UTC 以东偏离

strftime(format[, t ])转换一个元组或struct_time表示的由gmtime()或localtime()返回的时间到由format参数指定的字符串。如果未提供t，则使用由localtime()返回的当前时间。format必须是一个字符串。如果t中的任何字段超出允许范围，则引发ValueError。

指令	意义
%Y	十进制数表示的带世纪的年份。
%y	十进制数 [00,99] 表示的没有世纪的年份。
%m	十进制数 [01,12] 表示的月。
%d	十进制数 [01,31] 表示的月中日。
%H	十进制数 [00,23] 表示的小时(24 小时制)。
%M	十进制数 [00,59] 表示的分钟。
%S	十进制数 [00,61] 表示的秒。
%w	十进制数 [0(星期日),6] 表示的周中日。
%c	本地化的适当日期和时间表示。
%W	十进制数 [00,53] 表示的一年中的周数(星期一作为一周的第一天)作为。在第一个星期一之前的新年中的所有日子被认为是在第 0 周。
%%	字符%

import time

print(time.time())
print(time.gmtime())
print(time.localtime())
print(time.strftime('%Y-%m-%d %H:%M:%S'))
print(time.strftime('%c'))
"""
输出结果
1577195541.8666182
time.struct_time(tm_year=2019, tm_mon=12, tm_mday=24, tm_hour=13, tm_min=52, tm_sec=21, tm_wday=1, tm_yday=358, tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=12, tm_mday=24, tm_hour=21, tm_min=52, tm_sec=21, tm_wday=1, tm_yday=358, tm_isdst=0)
2019-12-24 21:52:21
Tue Dec 24 21:52:21 2019
"""

B.datetime一般用于日期和时间的修改

datetime.date 年月日
datetime.time 时分秒微秒
datetime.datetime 年月日时分秒微秒

datetime.timedelta(days=0,seconds=0,microseconds=0,milliseconds=0,minutes=0,hours=0,weeks=0)

import datetime

print(datetime.datetime.now())
new_time = datetime.timedelta(minutes=10)
print(datetime.datetime.now() + new_time)
one_day = datetime.datetime(2016, 4, 26)
new_date = datetime.timedelta(days=-2)
print(one_day + new_date)
"""
输出结果
2019-12-24 22:12:45.037225
2019-12-24 22:22:45.037280
2016-04-24 00:00:00
"""

3. 数字和数学类型的math、random

A.math数学相关的库

用于机器学习以及深度学习当中，比如计算正弦值等

B.random生成伪随机数

random.random()返回 [0.0, 1.0) 范围内的下一个随机浮点数
random.randint(a, b)返回随机整数N满足a <= N <= b。相当于randrange(a, b+1)。

random.choice(seq)从非空序列 seq 返回一个随机元素。如果 seq 为空，则引发IndexError。

import random

print(random.random())
print(random.randint(1, 5))
print(random.choice(['aa', 'bb', 'cc']))
"""
输出结果
0.05640301910553813
2
bb
"""

4. 文件和目录访问的pathlib、os.path

A.Linux和MacOS下常用的文件操作命令

ls 查看文件夹里面内容
ls -l 显示文件夹里面内容包括详情，第一个字符是-表示是文件，第一个字符是d表示是文件夹
pwd 显示当前文件夹的绝对路径
cd+文件夹绝对路径进入对应的文件夹
cd+相对路径进入当前路径对应的目录文件夹中
cd .. 返回上级目录
mkdir+绝对路径(相对路径) 新建对应的文件夹，如果中间目录不存在可以通过mkdir -p 绝对路径(相对路径)创建
rmdir+路径删除文件夹，如果文件下还有文件需要使用rm -rf 路径删除
cp 路径A 路径B ：把路径A拷贝到路径B中
mv 文件名新文件名：给文件重新命名
mv 文件名目录名：将文件移动到目标目录
mv 目录名目录名：目标目录已存在，将源目录移动到目标目录；目标目录不存在则改名

B.os.path库

os.path.abspath() 传入路径，会返回文件对应的绝对路径
os.path.exists() 传入路径，如果文件存在返回True,不存在就返回False
os.path.isdir() 传入路径，判断是否是目录
os.path.join() 传入多个路径，可以拼接在一起

import os

print(os.path.abspath('..'))	#一个点表示当前文件的绝对路径，两个点表示上级目录的绝对路径
print(os.path.exists('/Users'))
print(os.path.isdir('/Users'))
print(os.path.join('/tmp/a/', 'b/c/'))
"""
输出结果
/Users/xumao/Desktop/Python/Project
True
True
/tmp/a/b/c/
"""

C.os.pathlib库

from pathlib import Path

p = Path('..')
print(p.resolve())  # 得到当前相对路径对应的绝对路径
print([x for x in p.iterdir() if x.is_dir()])
print(p.is_dir())
q = Path('/tmp/a/b/c')
Path.mkdir(q, parents=True)	# 新建一个目录，parents设置为True，可以自动创建不存在的上级目录
"""
输出结果
/Users/xumao/Desktop/Python/Project
[PosixPath('../NumPy'), PosixPath('../wisdom1'), PosixPath('../geekbangpython-master')]
True
"""

5. 数据压缩和归档的tarfile

6. 通用操作系统的os、logging、argparse

7. 多线程的 threading、queue

8. Internet数据处理的 base64 、json、urllib

9. 结构化标记处理工具的 html、xml

10. 开发工具的unitest

11. 调试工具的 timeit

12. 软件包发布的venv

13. 运行服务的main

展开全文 >>

第三章多线程编程

2019-05-18

第3章多线程编程

python中多线程的库为threading
threading.Thread()
- target参数传入需要进行多线程的方法
- args参数传入方法所需要的参数
- 方法实现后不会立即启动线程，需要调用start()方法才能启动线程
- join()方法可以加入到主线程

import threading
import time
from threading import current_thread

def my_thread(arg1, arg2):
    print(current_thread().getName(), 'start')
    print('%s %s' % (arg1, arg2))
    time.sleep(1)
    print(current_thread().getName(), 'stop')

for i in range(1, 6, 1):
    t1 = threading.Thread(target=my_thread, args=(i, i + 1))
    t1.start()

print(current_thread().getName(), 'end')

queue.Queue(),先进先出
global表示申明全局变量，一般在函数内部申明
- queue.Queue(5)表示队列的长度为5，表示只能容纳5个队列
- put(元素)表示添加一个元素到队列
- get()从队列中取出一个元素
- join()阻塞调用线程，知道队列中的所有任务被处理掉
- empty()返回True表示为空，返回False表示不为空
- full()返回Ture表示满了，返回False表示没满
- qsize()返回队列里元素个数
- task_done()在完成一项任务后，向任务已经完成的队列发送一个信号

展开全文 >>

第二章面向对象编程

2019-05-04

第2章面向对象编程

类的实例、属性、方法和继承

方法后面第一个参数一定是self
super().init()父类初始化属性后，子类不需要重复初始化，直接调用该方法

class Player:      #定义一个类
    def __init__(self,name,hp):
        self.__name = name    #变量被称作属性,属性前面加双下划线表示不可被直接调用
        self.hp = hp
    def print_role(self):   #定义一个方法
        print('%s的血量为%s' %(self.__name,self.hp))

user1 = Player('sun',100) #类的实例化
user1.print_role

class Monster:
    '定义怪物类'
    def __init__(self, hp=100): #参数后面带值为默认值
        self.hp = hp
    def run(self):
        print('移动到某个位置')
    def who_am_i(self):
        print('我是怪物父类')

class Animals(Monster):
    '普通怪物'
    def __init__(self, hp=10):
        super().__init__(hp)

class Boss(Monster):
    'Boss类怪物'
    def __init__(self, hp=1000):
        super().__init__(hp)
    def who_am_i(self):     #和父类重名的方法会覆盖
        print('我是Boss')

自定义with语句

自定义with语句时需要实现两个方法

enter(self)

exit(self, exc_type, exc_val, exc_tb)

class TestWith:
    def __enter__(self):    
        print('run')
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_tb is None:
            print('正常结束')
        else:
            print('has error %s' % exc_tb)

with TestWith():
    print('test is running')
    raise NameError('test nameError')

作为程序执行

该结构表示如果当前文件用python运行，中间的语句就会执行，如果当做模块导入，语句就不会执行

1 2	if __name__ == '__main__': #语句

展开全文 >>

一、基础

1. 基础语法

1. 变量

2. 函数

3. 条件和循环控制(if、when、for、while、return、break、continue)

4.复合符号

2. 与Java代码互调

3.函数与Lambda

1. 函数参数–默认参数和可变参数

2. 如果一个函数只有一个语句，可以直接将语句赋值给函数

3. 函数可以嵌套（不推荐使用）

4. 扩展函数

5. Lambda闭包

6. 高阶函数：函数的参数也是函数

4. 类与对象

1. 父类与继承

2. 构造函数

3. 访问修饰符

4. 伴生对象

5. 动态代理

6. 数据类

7.密闭类–kotlin中更加强大的枚举类

8. object

二、高级特性

1. 解构

第1章 算法概述

1.1 算法和数据结构

1.1.1 算法

1.1.2 数据结构

1.2 时间复杂度

1.3 空间复杂度

第2章 数据结构基础

2.1 数组

2.2 链表

2.3 栈(Stack)

2.4 队列(Queue)

特殊队列

2.5 散列表（哈希表）

第3章 树

3.1 树和二叉树

二叉树常用存储结构

二叉树的应用

3.2 二叉树的遍历

3.3 二叉堆

二叉堆的操作

一.HTTP的前世今生

二.HTTP是具体含义

三.与HTTP相关的各种概念

四.与HTTP相关的各种协议

五.网络分层

1. TCP/IP 网络分层模型

2. OSI 网络分层模型

六.域名

七.HTTP结构

1.TCP报文结构

2.HTTP协议的请求报文和响应报文结构

3.请求行—-客户端想要如何操作服务器端的资源

4.状态行—-服务器响应的状态

5.头部字段

6.常用头字段

八.请求方法

九.网址格式

1.URI格式

2.URI 的基本组成

3.URI的查询参数

4.URI的完整格式

5.URI 的编码

十.响应状态码

小结

十一.HTTP特点

十二.HTTP的优缺点

面向对象的六大原则

1.单一职责原则——SRP(Single Responsibility Principle)

2.开闭原则——OCP(Open Close Principle)

3.里氏替换原则——LSP(Lisdow Substitution Principle)

4.依赖倒置原则——DIP(Dependence Inversion Principle)

5.接口隔离原则——ISP(InterfaceSegregation Principles)

6.迪米特原则——LOD(Law of Demeter)

创建型模式：5个

行为型模式： 11个

第1章算法概述

第2章数据结构基础

第3章树