作者的github地址

GitHub:https://github.com/bumptech/glide

1.添加依赖

1
2
3
4
5

dependencies {
    compile 'com.github.bumptech.glide:glide:4.0.0-RC0'
    compile 'com.android.support:support-v4:25.3.1'
    annotationProcessor 'com.github.bumptech.glide:compiler:4.0.0-RC0'
}

2.添加网络权限

1

<uses-permission android:name="android.permission.INTERNET"/>

3.使用

简单使用

1
2
3
4
5

@Override 
public void onCreate(Bundle savedInstanceState) {
      ImageView imageView = (ImageView)findViewById(R.id.my_image_view);
      GlideApp.with(this).load("https://www.baidu.com/img/bd_logo1.png").into(imageView);
}

.with(this) 上下文
.load() 加载的图片地址
.into() 加载到那个控件上

第1章 算法和实现算法的Java语法

1.1 建立算法初步概念
1.1.1 什么是算法
1.1.2 算法的发展历史
1.1.3 算法的分类
1.2 算法相关概念的区别
1.2.1 算法与公式的关系
1.2.2 算法与程序的关系
1.2.3 算法与数据结构的关系
1.3 算法的表示
1.3.1 自然语言表示
1.3.2 流程图表示
1.3.3 N-S图表示
1.3.4 伪代码表示
1.4 算法的性能评价
1.4.1 时间复杂度
1.4.2 空间复杂度
1.5 一个算法实例
1.5.1 查找数字
1.5.2 创建项目
1.5.3 编译执行
1.6 Java程序的基本结构
1.6.1 类是一个基本单元
1.6.2 main方法
1.6.3 自定义方法
1.6.4 System.out.println的使用
1.6.5 一个简单而完整的程序
1.7 顺序结构
1.8 分支结构
1.8.1 if…else分支结构
1.8.2 if…else嵌套
1.8.3 switch语句
1.8.4 编程实例
1.9 循环结构
1.9.1 while循环
1.9.2 do…while循环
1.9.3 for循环
1.9.4 编程实例
1.10 跳转结构
1.10.1 break
1.10.2 continue
1.10.3 编程实例
1.11 小结

第2章 数据结构

2.1 数据结构概述
2.1.1 什么是数据结构
2.1.2 数据结构中的基本概念
2.1.3 数据结构的内容
2.1.4 数据结构的分类
2.1.5 数据结构的几种存储方式
2.1.6 数据类型
2.1.7 常用的数据结构
2.1.8 选择合适的数据结构解决实际问题
2.2 线性表
2.2.1 什么是线性表
2.2.2 线性表的基本运算
2.3 顺序表结构
2.3.1 准备数据
2.3.2 初始化顺序表
2.3.3 计算顺序表长度
2.3.4 插入结点
2.3.5 追加结点
2.3.6 删除结点
2.3.7 查找结点
2.3.8 显示所有结点
2.3.9 顺序表操作实例
2.4 链表结构
2.4.1 什么是链表结构
2.4.2 准备数据
2.4.3 追加结点
2.4.4 插入头结点
2.4.5 查找结点
2.4.6 插入结点
2.4.7 删除结点
2.4.8 计算链表长度
2.4.9 显示所有结点
2.4.10 链表操作实例
2.5 栈结构
2.5.1 什么是栈结构
2.5.2 准备数据
2.5.3 初始化栈结构
2.5.4 判断空栈
2.5.5 判断满栈
2.5.6 清空栈
2.5.7 释放空间
2.5.8 入栈
2.5.9 出栈
2.5.10 读结点数据
2.5.11 栈结构操作实例
2.6 队列结构
2.6.1 什么是队列结构
2.6.2 准备数据
2.6.3 初始化队列结构
2.6.4 判断空队列
2.6.5 判断满队列
2.6.6 清空队列
2.6.7 释放空间
2.6.8 入队列
2.6.9 出队列
2.6.10 读结点数据
2.6.11 计算队列长度
2.6.12 队列结构操作实例
2.7 树结构
2.7.1 什么是树结构
2.7.2 树的基本概念
2.7.3 二叉树
2.7.4 准备数据
2.7.5 初始化二叉树
2.7.6 添加结点
2.7.7 查找结点
2.7.8 获取左子树
2.7.9 获取右子树
2.7.10 判断空树
2.7.11 计算二叉树深度
2.7.12 清空二叉树
2.7.13 显示结点数据
2.7.14 遍历二叉树
2.7.15 树结构操作实例
2.8 图结构
2.8.1 什么是图结构
2.8.2 图的基本概念
2.8.3 准备数据
2.8.4 创建图
2.8.5 清空图
2.8.6 显示图
2.8.7 遍历图
2.8.8 图结构操作实例
2.9 小结

第3章 基本算法思想

3.1 常用算法思想概述
3.2 穷举算法思想
3.2.1 穷举算法基本思想
3.2.2 穷举算法实例
3.3 递推算法思想
3.3.1 递推算法基本思想
3.3.2 递推算法实例
3.4 递归算法思想
3.4.1 递归算法基本思想
3.4.2 递归算法实例
3.5 分治算法思想
3.5.1 分治算法基本思想
3.5.2 分治算法实例
3.6 概率算法思想
3.6.1 概率算法基本思想
3.6.2 概率算法实例
3.7 小结

第4章 排序算法

4.1 排序算法概述
4.2 冒泡排序算法
4.2.1 冒泡排序算法
4.2.2 冒泡排序算法实例
4.3 选择排序算法
4.3.1 选择排序算法
4.3.2 选择排序算法实例
4.4 插入排序算法
4.4.1 插入排序算法
4.4.2 插入排序算法实例
4.5 Shell排序算法
4.5.1 Shell排序算法
4.5.2 Shell排序算法实例
4.6 快速排序算法
4.6.1 快速排序算法
4.6.2 快速排序算法实例
4.7 堆排序算法
4.7.1 堆排序算法
4.7.2 堆排序算法实例
4.8 合并排序算法
4.8.1 合并排序算法
4.8.2 合并排序算法实例
4.9 排序算法的效率
4.10 排序算法的其他应用
4.10.1 反序排序
4.10.2 字符串数组的排序
4.10.3 字符串的排序
4.11 小结

第5章 查找算法

5.1 查找算法概述
5.2 顺序查找
5.2.1 顺序查找算法
5.2.2 顺序查找操作实例
5.3 折半查找
5.3.1 折半查找算法
5.3.2 折半查找操作实例
5.4 数据结构中的查找算法
5.4.1 顺序表结构中的查找算法
5.4.2 链表结构中的查找算法
5.4.3 树结构中的查找算法
5.4.4 图结构中的查找算法
5.5 小结

第6章 基本数学问题

6.1 判断闰年
6.2 多项式计算
6.2.1 一维多项式求值
6.2.2 二维多项式求值
6.2.3 多项式乘法
6.2.4 多项式除法
6.3 随机数生成算法
6.3.1 Java语言中的随机方法
6.3.2 [0，1]之间均匀分布的随机数算法
6.3.3 产生任意范围的随机数
6.3.4 [m，n]之间均匀分布的随机整数算法
6.3.5 正态分布的随机数生成算法
6.4 复数运算
6.4.1 简单的复数运算
6.4.2 复数的幂运算
6.4.3 复指数运算
6.4.4 复对数运算
6.4.5 复正弦运算
6.4.6 复余弦运算
6.5 阶乘
6.5.1 使用循环来计算阶乘
6.5.2 使用递归来计算阶乘
6.6 计算π的近似值
6.6.1 割圆术
6.6.2 蒙特卡罗算法
6.6.3 级数公式
6.7 矩阵运算
6.7.1 矩阵加法
6.7.2 矩阵减法
6.7.3 矩阵乘法
6.8 方程求解
6.8.1 线性方程求解——高斯消元法
6.8.2 非线性方程求解——二分法
6.8.3 非线性方程求解——牛顿迭代法
6.9 小结

第7章 数据结构问题

7.1 动态数组排序
7.1.1 动态数组的存储和排序
7.1.2 动态数组排序实例
7.2 约瑟夫环
7.2.1 简单约瑟夫环算法
7.2.2 简单约瑟夫环求解
7.2.3 复杂约瑟夫环算法
7.2.4 复杂约瑟夫环求解
7.3 城市之间的最短总距离
7.3.1 最短总距离算法
7.3.2 最短总距离求解
7.4 最短路径
7.4.1 最短路径算法
7.4.2 最短路径求解
7.5 括号匹配
7.5.1 括号匹配算法
7.5.2 括号匹配求解
7.6 小结

第8章 数论问题

8.1 数论概述
8.1.1 数论概述
8.1.2 数论的分类
8.1.3 初等数论
8.1.4 本章用到的基本概念
8.2 完全数
8.2.1 什么是完全数
8.2.2 计算完全数算法
8.3 亲密数
8.3.1 什么是亲密数
8.3.2 计算亲密数算法
8.4 水仙花数
8.4.1 什么是水仙花数
8.4.2 计算水仙花数算法
8.5 自守数
8.5.1 什么是自守数
8.5.2 计算自守数算法
8.6 最大公约数
8.6.1 计算最大公约数算法——辗转相除法
8.6.2 计算最大公约数算法——Stein算法
8.6.3 计算最大公约数示例
8.7 最小公倍数
8.8 素数
8.8.1 什么是素数
8.8.2 计算素数算法
8.9 回文素数
8.9.1 什么是回文素数
8.9.2 计算回文素数算法
8.10 平方回文数
8.10.1 什么是平方回文数
8.10.2 计算平方回文数算法
8.11 分解质因数
8.12 小结

第9章 算法经典趣题

9.1 百钱买百鸡
9.1.1 百钱买百鸡算法
9.1.2 百钱买百鸡求解
9.2 五家共井
9.2.1 五家共井算法
9.2.2 五家共井求解
9.3 鸡兔同笼
9.3.1 鸡兔同笼算法
9.3.2 鸡兔同笼求解
9.4 猴子吃桃
9.4.1 猴子吃桃算法
9.4.2 猴子吃桃求解
9.5 舍罕王赏麦
9.5.1 舍罕王赏麦问题
9.5.2 舍罕王赏麦求解
9.6 汉诺塔
9.6.1 汉诺塔算法
9.6.2 汉诺塔求解
9.7 窃贼问题
9.7.1 窃贼问题算法
9.7.2 窃贼问题求解
9.8 马踏棋盘
9.8.1 马踏棋盘算法
9.8.2 马踏棋盘求解
9.9 八皇后问题
9.9.1 八皇后问题算法
9.9.2 八皇后问题求解
9.10 寻找假银币
9.10.1 寻找假银币算法
9.10.2 寻找假银币求解
9.11 青蛙过河
9.11.1 青蛙过河算法
9.11.2 青蛙过河求解
9.12 三色旗
9.12.1 三色旗算法
9.12.2 三色旗求解
9.13 渔夫捕鱼
9.13.1 渔夫捕鱼算法
9.13.2 渔夫捕鱼求解
9.14 爱因斯坦的阶梯
9.14.1 爱因斯坦的阶梯算法
9.14.2 爱因斯坦的阶梯求解
9.15 兔子产仔
9.15.1 兔子产仔算法
9.15.2 兔子产仔求解
9.16 常胜将军
9.16.1 常胜将军算法
9.16.2 常胜将军求解
9.17 新郎和新娘
9.17.1 新郎和新娘算法
9.17.2 新郎和新娘求解
9.18 三色球
9.18.1 三色球算法
9.18.2 三色球求解
9.19 小结

第10章 游戏中的算法

10.1 洗扑克牌算法
10.1.1 洗扑克牌算法
10.1.2 洗扑克牌实例
10.2 取火柴游戏算法
10.2.1 取火柴游戏算法
10.2.2 取火柴游戏实例
10.3 十点半算法
10.3.1 十点半算法
10.3.2 十点半游戏实例
10.4 生命游戏
10.4.1 生命游戏的原理
10.4.2 生命游戏的算法
10.4.3 生命游戏实例
10.5 小结

第11章 简单Java上机面试题

11.1 打印九九乘法口诀表
11.2 获得任意一个时间的下一天的时间
11.3 将某个时间以固定格式转化成字符串
11.4 怎样截取字符串
11.5 怎样实现元素互换
11.6 怎样实现元素排序
11.7 怎样实现Singleton模式编程
11.8 怎样实现金额转换
11.9 如何判断回文数字
11.10 小结

第12章 逻辑推理类面试题

12.1 脑筋急转弯
12.1.1 中国有多少辆汽车
12.1.2 下水道的盖子为什么是圆形的
12.1.3 分蛋糕
12.2 逻辑推理
12.2.1 哪个开关控制哪盏灯
12.2.2 戴帽子
12.2.3 海盗分金
12.2.4 罪犯认罪
12.2.5 找出质量不相同的球
12.2.6 有多少人及格
12.2.7 他说的是真话吗
12.3 计算推理
12.3.1 倒水问题
12.3.2 骗子购物
12.3.3 求最大的连续组合值（华为校园招聘笔试题）
12.3.4 洗扑克牌（乱数排列）
12.3.5 字符移动（金山笔试题）
12.4 小结

第13章 数学能力测试

13.1 100盏灯
13.2 用一笔画出经过9个点的4条直线
13.3 时针、分针和秒针重合问题
13.4 怎样拿到第100号球
13.5 烧绳计时
（注：以下内容读者可在附赠光盘中阅读学习。）

第14章 算法面试题

14.1 基础算法
14.1.1 字符串匹配
14.1.2 哥德巴赫猜想的近似证明
14.1.3 将一个正整数分解质因数
14.1.4 怎样实现金额转换
14.1.5 数字排列
14.1.6 数字拆解
14.1.7 数字组合
14.2 思维扩展算法
14.2.1 蛇形打印
14.2.2 24点算法
14.2.3 双色球随机摇号
14.2.4 巧妙过桥
14.2.5 猴子吃桃
14.2.6 天平称物
14.2.7 掷骰子游戏
14.3 小结

数字

Kotlin 的基本数值类型包括 Byte、Short、Int、Long、Float、Double 。不同于Java的是，字符不属于数值类型，是一个独立的数据类型。
Kotlin 处理数字和Java差不多，但也不完全相同。比如Java中的int 可以饮式转换成long。

三种进制表示方法：

1. 十进制：123
   Long类型用大写 L 标记：123L
2. 十六进制：0x0F
3. 二进制：0b0001011

注意：不支持八进制

Kotlin 同样支持浮点数的常规表示方法 ：
默认double:123.5 、123.5e10
Float用f或者F标记：123.5f

数字中的下划线（自1.1起）

可以使用下划线使数字常量更易读：

1
2
3
4
5

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

比较两个数字

Kotlin 中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实 Kotlin 帮你封装了一个对象，这样可以保证不会出现空指针。数字类型也一样，所有在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别了。
在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。

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

fun main(args: Array<String>) {
    val a: Int = 10000
    println(a === a) // true，值相等，对象地址相等
    //经过了装箱，创建了两个不同的对象
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a
    //虽然经过了装箱，但是值是相等的，都是10000
    println(boxedA === anotherBoxedA) //  false，值相等，对象地址不一样
    println(boxedA == anotherBoxedA) // true，值相等
}

类型转换

由于不同的表示方式，较小类型并不是较大类型的子类型。 如果它们是的话，就会出现下述问题：

1
2
3
4

// 假想的代码，实际上并不能编译：
val a: Int? = 1 // 一个装箱的 Int (java.lang.Integer)
val b: Long? = a // 隐式转换产生一个装箱的 Long (java.lang.Long)
print(a == b) // 惊！这将打印 "false" 鉴于 Long 的 equals() 检测其他部分也是 Long

所以同一性还有相等性都会在所有地方悄无声息地失去。

因此较小的类型不能隐式转换为较大的类型。 这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋给一个 Int 变量。

1
2

val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b // 错误

Kotlin没有隐士转换，我们只能手动强制类型转换了。

1

val i: Int = b.toInt() // OK: 显式转换

每个数字类型支持如下的转换:

• toByte(): Byte
• toShort(): Short
• toInt(): Int
• toLong(): Long
• toFloat(): Float
• toDouble(): Double
• toChar(): Char

缺乏隐式类型转换并不显著，因为类型会从上下文推断出来，而算术运算会有重载做适当转换，例如：

1

val l = 1L + 3 // Long + Int => Long

运算

Kotlin支持数字运算的标准集，运算被定义为相应的类成员（但编译器会将函数调用优化为相应的指令）。
对于位运算，没有特殊字符来表示，而只可用中缀方式调用命名函数，例如:

1

val x = (1 shl 2) and 0x000FF000

这是完整的位运算列表（只用于 Int和 Long）：

1
2
3
4
5
6
7

shl(bits) – 有符号左移 (Java 的 <<)
shr(bits) – 有符号右移 (Java 的 >>)
ushr(bits) – 无符号右移 (Java 的 >>>)
and(bits) – 位与
or(bits) – 位或
xor(bits) – 位异或
inv() – 位非

字符

字符用 Char
类型表示。它们不能直接当作数字

1
2
3
4
5

fun check(c: Char) {
    if (c == 1) { // 错误：类型不兼容
        // ……
    }
}

字符字面值用单引号括起来: ‘1’。 特殊字符可以用反斜杠转义。 支持这几个转义序列：\t、 \b、\n、\r、\’、\”、\和 \$。 编码其他字符要用 Unicode 转义序列语法：’\uFF00’。

我们可以显式把字符转换为 Int 数字：

1
2
3
4
5

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // 显式转换为数字
}

当需要可空引用时，像数字、字符会被装箱。装箱操作不会保留同一性。

布尔

布尔用 Boolean类型表示，它有两个值：true 和 false。
若需要可空引用布尔会被装箱。
内置的布尔运算有：

1
2
3

|| – 短路逻辑或
&& – 短路逻辑与
! - 逻辑非

数组

数组在 Kotlin 中使用 Array类来表示，它定义了 get和 set 函数（按照运算符重载约定这会转变为 []）和 size属性，以及一些其他有用的成员函数：

1
2
3
4
5
6
7
8

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit
    operator fun iterator(): Iterator<T>
    // ……
}

我们可以使用库函数 arrayOf()来创建一个数组并传递元素值给它，这样 arrayOf(1, 2, 3)创建了 array [1, 2, 3]。 或者，库函数 arrayOfNulls()可以用于创建一个指定大小、元素都为空的数组。
另一个选项是用接受数组大小和一个函数参数的工厂函数，用作参数的函数能够返回 给定索引的每个元素初始值：

1
2

// 创建一个 Array<String> 初始化为 ["0", "1", "4", "9", "16"]
val asc = Array(5, { i -> (i * i).toString() })

如上所述， [] 运算符代表调用成员函数 get()和 set()。

注意: 与 Java 不同的是，Kotlin 中数组是不型变的（invariant）。这意味着 Kotlin 不让我们把 Array赋值给 Array，以防止可能的运行时失败（但是你可以使用 Array）。

Kotlin 也有无装箱开销的专门的类来表示原生类型数组: ByteArray、ShortArray、IntArray等等。这些类和 Array 并没有继承关系，但是 它们有同样的方法属性集。它们也都有相应的工厂方法:

1
2

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

字符串

字符串用 String类型表示。字符串是不可变的。 字符串的元素——字符可以使用索引运算符访问: s[i]。 可以用 for 循环迭代字符串:

1
2
3

for (c in str) {
    println(c)
}

字符串字面值

Kotlin 有两种类型的字符串字面值: 转义字符串可以有转义字符，以及原生字符串可以包含换行和任意文本。转义字符串很像 Java 字符串:

1

val s = "Hello, world!\n"

转义采用传统的反斜杠方式。参见上面的 字符]查看支持的转义序列。
原生字符串 使用三个引号（”””）分界符括起来，内部没有转义并且可以包含换行和任何其他字符:

1
2
3
4

val text = """
    for (c in "foo")
        print(c)
"""

你可以通过 trimMargin函数去除前导空格：

1
2
3
4
5
6

val text = """
    |Tell me and I forget.
    |Teach me and I remember.
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()

默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比如 trimMargin(“>”)。

字符串模板

字符串可以包含模板表达式 ，即一些小段代码，会求值并把结果合并到字符串中。 模板表达式以美元符（$）开头，由一个简单的名字构成:

1
2

val i = 10
val s = "i = $i" // 求值结果为 "i = 10"

或者用花括号扩起来的任意表达式:

1
2

val s = "abc"
val str = "$s.length is ${s.length}" // 求值结果为 "abc.length is 3"

原生字符串和转义字符串内部都支持模板。 如果你需要在原生字符串中表示字面值 $字符（它不支持反斜杠转义），你可以用下列语法：

1
2
3

val price = """
${'$'}9.99
"""

创建分支

1

git branch <分支名>

然后切换到分支

1

git checkout <分支名>

可以把这两个语句用一条语句完成

1

git checkout -b <>

查看分支

1

git branch

合并分支

1

git merge <分支名>

这里的分支是把创建的分支合并到主分支。

删除分支

1

git branch -d <分支名>

查看远程分支

1

git remote

或者使用以下指令查看详细信息

1

git remote

推送分支

git push origin <分支名>