ZoeyWoohoo

Android 渐变色昵称实现探索

Tue, 24 Oct 2023 13:51:00 +0000

需求场景

想要对拥有特定特权用户增加昵称渐变的权益，以彰显个性化的昵称标识。这个场景历史上也讨论过，但因为昵称换行不好处理，所以就搁置了，如今产品和设计同学又提出了这个想法。于是调研了市面上的竞品，却也没有发现哪家竞品有渐变昵称，最多的是单色的高亮昵称。难道就真的无法实现吗？实现的难点在哪里？

设计中的渐变色

我们可以先从设计师的视角看看渐变色文本是怎么实现的，打开 Figma 添加一段文本，在文本的颜色填充中选择渐变色，而通过调整控制点「起点」和「终点」位置，可调整渐变的范围，甚至可以添加多个中途点实现多色渐变：

可以看出 Figma 中对于文本渐变色的处理，不管是「整个段落级别」还是「指定某段文本级别」，都可以看做是在文本上层绘制了一个渐变色矩形块，然后与文本混合渲染：

而在超出控制点范围外的区域，其策略是使用控制点处的单色延伸填充：

如果出现文本换行，这里有简单的两种策略：「另起一行时重头开始渐变」、「另起一行时连续渐变」。重头开始渐变好理解一点，就是每行的文本单独渐变处理：

但是作为选中的一段文本，换行后的连续渐变又如何实现？符合直觉的逻辑是对选中的文本单行铺平，渐变后再进行换行，那 Figma 里如何去实现呢？其实可以按照直觉的逻辑做一些特殊的处理，同样理解成文本单行铺平，对另起一行的文本实现同样一段渐变着色：

Android 中的渐变色

文本画笔着色器

Android 中想要实现文本的渐变，可以通过 TextPaint 指定着色器来实现：

val gradientColors = intArrayOf(
    Color.parseColor("#32C1FE"),
    Color.parseColor("#AB1EED")
)
textView.paint.shader = LinearGradient(
    0F, 0F, 100.dpFloat, 100.dpFloat,
    gradientColors, null, Shader.TileMode.CLAMP
)

需要注意的是：对画笔设置着色器 Shader 后，通过 setShadowLayer() 方法设置的文字投影效果将失效

这里创建了一个线性渐变着色器，指定了：

渐变范围坐标，「起点」和「终点」的坐标位置为 (0, 0) 到 (100dp, 100dp)
渐变颜色数组，可传入多个颜色的数组实现多色渐变
渐变颜色位置数组，与颜色数组对应，范围 [0, 1.0]，为空时默认均分，如两色为 [0, 1.0]，三色为 [0, 0.5, 1.0]
渐变渲染模式，有四种模式: CLAMP、REPEAT、MIRROR、DECAL

四种模式下 Android 的最终渲染效果如下：

对四种模式的定义为：

CLAMP：超出范围外，以边界颜色填充（与 Figma 相同）
REPEAT：超出范围外，重复渐变
MIRROR：超出范围外，重复渐变但颜色方向会镜像交替替换
DECAL：超出范围外，不绘制，透明处理

可能描述不够直白，这里结合真机渲染效果，模拟上层渐变色块的四种模式状态（色块按模式无限延伸）：

也就是说，这里针对画笔设置着色器实现渐变，是对整个 TextView 文本内容生效的，而不能指定某一段文本，这个时候会想到用 Span 去实现指定文本的渐变效果。

自定义 Span

在 Android 中 Span 可以用来修改「字符级」或「段落级」的文本样式，其一般都是通过操作 TextPaint 和 Canvas 来达成想要的效果样式。在渐变昵称的这个场景下，使用的是「字符级」的样式修改，就如同我们常用的前景色 ForegroundColorSpan 一样，继承 CharacterStyle 类及实现 UpdateAppearance 接口，在 updateDrawState() 回调方法中我们可以获取到文本绘制的画笔，设置相应的渐变着色器就可以了：

class GradientColorSpan : CharacterStyle(), UpdateAppearance {

    private val gradientColors = intArrayOf(
        Color.parseColor("#32C1FE"),
        Color.parseColor("#AB1EED")
    )
    
    override fun updateDrawState(tp: TextPaint?) {
        tp?.shader = LinearGradient(
            0F, 0F, 100.dpFloat, 100.dpFloat,
            gradientColors, null, Shader.TileMode.REAPEAT
        )
    }
}

我们尝试给其中一段文本应用上 Span：

content.text = buildSpannedString {
    append("渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐")
    inSpans(GradientColorSpan()) {
        append("渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐")
    }
    append("渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐渐")
}

同样一段文本，我们可以看看直接给 TextView 设置着色器和 Span 里设置着色器的区别：

其实从这里可以看出，Android 中的渐变着色器与设计软件 Figma 中的渐变实现，基本上如出一辙，其原理也是相同的，也就是说这里最关键的点，就是渐变着色器中指定的「起点」和「终点」坐标，如果想要实现从指定文本头开始渐变（假设是从左上角到右下角的渐变），就需要把起点设置在指定文本开始第一个字符的左上角，但是终点又应该在哪呢？

如果指定的文本段落在同一行，那么终点坐标设置在最后一个字符右下角即可
如果指定的文本段落不在同一行，产生了换行行为，单靠这个方法我们的预期效果无法实现

实现难点

呼应文章开头，这里结合场景及实现效果，总结下目前实现的难点：

设置着色器后，通过 setShadowLayer() 方法设置的文字投影会失效，而现有场景下需要对昵称设置投影
设置着色器的起点终点坐标，需要知道确切的文本段落起始、终止的坐标信息
因为昵称前面会有一些装扮标签，昵称难以避免会有换行行为，而目前单一的 Span 处理方式不能解决换行问题

实现探索

实现方案

对于换行的渐变处理，回过头来重新看设计视角分析的渐变色实现，其实已经给出了解决方案，对于换行的文本段落，无论是重新渐变还是连续渐变，都需要将换行后的文本片段单独处理，重新设置新的着色器：如果是重新渐变，重新指定起点、终点为片段头尾字符的坐标即可；如果是连续渐变，则需要计算出片段前后文本占据的空间，将起点、终点设置为同行情况下文本头尾字符坐标。

此外，还有投影问题的处理，既然 TextView 对这两个效果不可兼得，那如果绘制两个一模一样的文本，投影文本在下，渐变文本在上叠加起来呢？这好像是一个解决的方法，既然需要对换行后的文本分段处理，那只需将每段文本都使用双层叠加绘制就好了。方向有了，思路也就清晰了，目前需要解决的是，如何通过指定的 Span 获取换行后的文本片段，以及各文本片段在 TextView 中的起点、终点位置坐标。

实现方式

基于以上总结的实现方案，这里给出了一种解法。总的来说，需要一个用于指定文本范围位置的渐变标记 Span，记录了渐变的参数信息，其中换行策略包括重新渐变和连续渐变：

class LiveGradientColorTagSpan @JvmOverloads constructor(
    val gradientColor: IntArray,
    val gradientPositions: FloatArray? = null,
    val gradientStrategy: GradientBreakStrategy = GradientBreakStrategy.BREAK_RESTART
) : CharacterStyle(), UpdateAppearance {

    init {
        require(gradientColor.size > 1) {
            "gradient color array length must great than 1"
        }

        require(!(gradientPositions != null && gradientPositions.size != gradientColor.size)) {
            "color and position arrays must be of equal length"
        }
    }

    override fun updateDrawState(tp: TextPaint?) {
        // no-op
    }
}

其次还需要一个对换行分段后的片段文本绘制的 Span，而这里选择使用 Canvas 绘制双层文本实现，创建出 Drawable 后用 ImageSpan 去替换原本的文本片段，其伪代码如下：

class LiveGradientColorSpanDrawable @JvmOverloads constructor(
    private val text: String, specificWidth: Int = 0
) : Drawable() {

    /**
     * 绘制文本的宽
     */
    private val textMeasureWidth: Int = if (specificWidth > 0) {
        specificWidth
    } else {
        sourcePaint.measureText(text).toInt()
    }

    // ...

    override fun draw(canvas: Canvas) {
        // ...

        // 绘制文本及阴影
        canvas.save()
        canvas.drawText(text, x, y, shadowPaint)
        canvas.restore()

        // 绘制文本及渐变
        canvas.save()
        canvas.drawText(text, x, y, gradientPaint)
        canvas.restore()
    }
}

而 ImageSpan 作为一个整体，当一行剩余空间不够时，会被整体换行，所以这里对于 Drawable 的尺寸大小需要非常精确，确保不会绘制出来后比原有占位文本宽度还大。Android 中 TextView 之所以复杂，其中一个原因是因为它有不同的折行策略，比如最简单的规则：符号不能置于行首、英文单词不能被换行分割等。甚至有些软件，还对中文方块字的排版进行了优化，会自动调整字间距以尽量满足两端对齐。所以使用 TextPaint 的 measureText() 方法，并不一定能准确的获得其真实绘制的宽度。其次由于换行规则的存在，我们又要获得准确的换行文本分段信息，那这些都需要在文本被布局完成后再获取，这里选择自定义 TextView，在布局后获取渐变标记 Span 信息，再进行渐变处理，其代码如下：

open class LiveGradientTextView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyle: Int = 0
) : AppCompatTextView(context, attrs, defStyle) {

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        // 每次重新布局前，先清空渐变 Span，因为内部实现为 drawable 替换，可能影响换行逻辑
        clearGradientColorSpan()

        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
    }

    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
        super.onLayout(changed, left, top, right, bottom)

        // 布局完成后通过渐变标记 Span 获取位置信息，并填充渐变 Span
        (text as? Spannable)?.also { spannable ->
            spannable.getSpans(0, spannable.length, LiveGradientColorTagSpan::class.java).forEach {
                inflateGradientColorSpan(spannable, it)
            }
        }
    }

    private fun clearGradientColorSpan() {
        (text as? Spannable)?.also {
            it.getSpans(0, it.length, LiveGradientColorSpan::class.java).forEach { span ->
                it.removeSpan(span)
            }
        }
    }

    private fun inflateGradientColorSpan(spannable: Spannable, tagSpan: LiveGradientColorTagSpan) {
        // ...
    }
}

这里对每个渐变标记 Span 的具体处理代码如下：

open class LiveGradientTextView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyle: Int = 0
) : AppCompatTextView(context, attrs, defStyle) {

    // ...

    private fun inflateGradientColorSpan(spannable: Spannable, tagSpan: LiveGradientColorTagSpan) {
        // 得到标记 Span 的起始和终止位置坐标
        val startIndex = spannable.getSpanStart(tagSpan)
        val endIndex = spannable.getSpanEnd(tagSpan) - 1
        val gradientColor = tagSpan.gradientColor
        val gradientPositions = tagSpan.gradientPositions
        val gradientBreakStrategy = tagSpan.gradientStrategy

        try {
            layout?.also {
                // 计算渐变文本头尾字符所在行号，用于计算文本折行分段
                val startLine = it.getLineForOffset(startIndex)
                val endLine = it.getLineForOffset(endIndex)
                // 渐变分段信息
                val gradientSlices = mutableListOf<GradientSliceInfo>()
                // 渐变文本的总长度
                var gradientTotalWidth = 0

                for (line in startLine..endLine) {
                    val lineStartIndex = it.getLineStart(line)
                    val lineEndIndex = it.getLineEnd(line) - 1

                    // 获取当前行的渐变文本内容并设置渐变 Span
                    val sliceStart = max(startIndex, lineStartIndex)
                    val sliceEnd = min(endIndex, lineEndIndex)

                    val sliceContent = spannable.slice(sliceStart..sliceEnd).toString()

                    // 因为文本刚好置于行尾，使用 measureText() 计算的宽度不一定准确，可能导致换行，所以需要精准计算当前布局后的宽度
                    val specificWidth: Int = if (endIndex >= lineEndIndex) {
                        min(
                            paint.measureText(sliceContent).toInt(),
                            (measuredWidth - it.getPrimaryHorizontal(sliceStart)).toInt()
                        )
                    } else {
                        it.getPrimaryHorizontal(sliceEnd + 1) - it.getPrimaryHorizontal(sliceStart)
                    }.toInt().also { sliceWidth ->
                        gradientTotalWidth += sliceWidth
                    }

                    gradientSlices.add(
                        GradientSliceInfo(
                            sliceContent, sliceStart, sliceEnd, specificWidth,
                            gradientColor, gradientPositions, null
                        )
                    )
                }

                /**
                 * 根据换行渐变策略计算出最后的渐变色和渐变位置，正确设置渐变效果
                 */
                var preTotalWidth = 0
                gradientSlices.forEach { slice ->
                    when (gradientBreakStrategy) {
                        GradientBreakStrategy.BREAK_RESTART -> {}
                        GradientBreakStrategy.BREAK_CONTINUE -> {
                            slice.updateGradientColorPosition(preTotalWidth, gradientTotalWidth)
                            preTotalWidth += slice.specificWidth
                        }
                    }

                    spannable.setGradientColorSpan(slice)
                }
            }
        } catch (e: Exception) {
            Logger.e("LiveGradientTextView", "Layout Error: ${e.printStackTrace()}")
        }
    }

    /**
     * 根据当前 slice 文本前面的文本总长度 [preTotalWidth] 和所有文本总长度 [totalWidth] 计算出渐变色值位置并更新
     */
    private fun GradientSliceInfo.updateGradientColorPosition(preTotalWidth: Int, totalWidth: Int) {
        val startPoint = Point(-preTotalWidth, 0)
        val endPoint = Point(totalWidth - preTotalWidth, 0)
        points = Pair(startPoint, endPoint)
    }

    private fun Spannable.setGradientColorSpan(gradientSlice: GradientSliceInfo) {
        setSpan(
            LiveGradientColorSpan.make(
                gradientSlice.sliceContent, paint,
                gradientSlice.gradientColor, gradientSlice.gradientPositions,
                gradientSlice.points, gradientSlice.specificWidth
            ),
            gradientSlice.startIndex, gradientSlice.endIndex + 1,
            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
        )
    }

    /**
     * 渐变文本分片信息
     */
    @Suppress("ArrayInDataClass")
    data class GradientSliceInfo(
        val sliceContent: String, val startIndex: Int, val endIndex: Int,
        val specificWidth: Int, var gradientColor: IntArray, var gradientPositions: FloatArray?,
        var points: Pair<Point, Point>?
    )
}

这里涉及的关键方法为 Layout 下：getLineForOffset() 获取 index 处字符所处行号、getPrimaryHorizontal() 获取 offset 处字符偏移距离。记录每一段的分片信息，在不同策略下设置不同的着色器「起点」和「终点」坐标。最终实现的效果：

可能会遇到的问题：给 TextView 的内容设置一个 SpannableStringBuilder 时，其内部默认会创建一个副本对象，如果外部持有这个 SpannableStringBuilder 并更新，重新设置后会丢失渐变信息，必须确保重新触发布局。

利用 GitHub 搭建个人私有 Maven 仓库

Sun, 24 Oct 2021 06:21:47 +0000

起因

之前 Google Cloud 白嫖的服务器到期了，导致自己部署的 Maven 仓库也用不了了，想搭一个私有的 Maven 仓库，又不想买服务器，怎么办呢？想到 GitHub 能不能办成这件事，搜索之后发现 GitHub 已经提供了一个 GitHub Packages 的功能，同时支持 Maven 仓库，不过这项服务只有对公开的仓库是全免费的，私人的仓库则是有额度限免，具体的收费标准可查看官方链接。不过对于个人使用，好像已经绰绰有余了？但是担心后续付费规则的修订，这里选择了另一种方式曲线救国。

原理

当我们项目中依赖一个三方库时，需要从 Maven 仓库拉取下载，而最关键的一步则是 POM 文件，依赖于 POM 文件的读取，解析并下载对应结构路径下的包，从而集成进我们的项目中。而如 Nexus 提供的服务，只不过是帮你在服务器上跑通这一流程，提供依赖包的发布存储及拉取下载。

既然是这样就好办了，我们都知道，GitHub 是可以引用一个 raw 链接直接下载文件的:

https://raw.githubusercontent.com/<Username>/<RepoName>/<BranchName>/<PathToFile>

具体的规则是: 用户名/仓库名/分支名/文件路径，而且只能引用文件，不能引用文件夹 (否则 404)。那岂不是可以直接把 Maven 发布生成的包文件直接放到仓库中，然后用 raw 链接作为 Maven 仓库地址，这样就可以了。经过一番试验，最终也证明确实可行，下面则是搭建的流程记录。

流程

新建一个私人仓库

在 GitHub 上新建一个私人仓库，用于统一存放我们生成发布的三方库包，不同于一个仓库放一个三方库包，统一存放到一个仓库里，在项目中只需引入一个 Maven 仓库地址即可。下面将以我的仓库 Barn 为例。

本地发布 release 包

这里我假设你已经有了一个待发布的三方库，并懂得怎么利用 maven 插件进行发布，如果还不了解相关知识的话，可以参考 Google 的官方文档及其他资料。这里唯一特殊的是，我们配置 Maven 仓库地址时，引用的是本地的路径，对应于上面新建的私有仓库本地文件地址。

publishing {
    repositories {
        maven {
            // 这里更改为你自己的本地仓库路径，对应于 GitHub 上的仓库
            url "/Users/ZoeyWoohoo/NeoStudio/Barn/maven"
        }
    }
}

下面就是生成发布包了，我们在 Android Studio 的 Gradle 任务下找到 publish 任务运行即可，或者直接命令行运行：

./gradlew publish

运行结束后，可以在文件夹下看到生成的包，结构大致如下：

➜ pwd
/Users/ZoeyWoohoo/NeoStudio/Barn

➜ tree ./
./
├── maven
    └── com
        └── neostudio
            └── neotoast
                └── neotoast
                    ├── 1.0
                    │   ├── neotoast-1.0-sources.jar
                    │   ├── neotoast-1.0-sources.jar.md5
                    │   ├── neotoast-1.0-sources.jar.sha1
                    │   ├── neotoast-1.0-sources.jar.sha256
                    │   ├── neotoast-1.0-sources.jar.sha512
                    │   ├── neotoast-1.0.aar
                    │   ├── neotoast-1.0.aar.md5
                    │   ├── neotoast-1.0.aar.sha1
                    │   ├── neotoast-1.0.aar.sha256
                    │   ├── neotoast-1.0.aar.sha512
                    │   ├── neotoast-1.0.module
                    │   ├── neotoast-1.0.module.md5
                    │   ├── neotoast-1.0.module.sha1
                    │   ├── neotoast-1.0.module.sha256
                    │   ├── neotoast-1.0.module.sha512
                    │   ├── neotoast-1.0.pom
                    │   ├── neotoast-1.0.pom.md5
                    │   ├── neotoast-1.0.pom.sha1
                    │   ├── neotoast-1.0.pom.sha256
                    │   └── neotoast-1.0.pom.sha512
                    ├── maven-metadata.xml
                    ├── maven-metadata.xml.md5
                    ├── maven-metadata.xml.sha1
                    ├── maven-metadata.xml.sha256
                    └── maven-metadata.xml.sha512

5 directories, 25 files

将发布的包推送到仓库中

万事俱备只欠推送，进入仓库文件夹地址，初始化 git，配置远程仓库地址，创建提交。当然，为了政治正确，改一下默认的分支名 master 为 main 吧 (:dog:)，然后将其推到 GitHub 远程仓库中就行了。

➜ cd /Users/ZoeyWoohoo/NeoStudio/Barn
➜ git init
➜ git add *
➜ git commit -m "init maven"

// 这里修改为你自己的 GitHub 仓库地址
➜ git remote add origin git@github.com:ZoeyWoohoo/Barn.git

// 需要注意本地生成提交后 master 分支才会生效，此前修改分支名会报错
➜ git branch -m master main

➜ git push origin main -u

项目中引用自己的三方库

现在我们就可以在项目中引用自己的三方库包了，不过在此之前，还需做一件事。公开的仓库是可以直接拉取的，但是私人仓库就需要身份认证了，直接用账号密码肯定是不推荐的，这里我们需要生成一个 GitHub 的 Personal Access Token，点击这里可以直接跳转设置，其设置位置在于：

Settings -> Developer settings -> Personal access tokens

新建一个 Token，有效期按自己需要设置一个时长，GitHub 官方不建议设为永久，这里笔者选了个自定义一年时间，权限只需勾选 repo 项就可以了，然后点击生成，并将其复制下来备份一下，因为为了安全，之后 GitHub 将不允许在这个页面上查看 Token 了。

然后在项目的 build.gradle 文件中配置 maven 仓库地址：

buildscript {
    // ...
    repositories {
        google()
        // ...

        maven {
            // 填写你自己的仓库地址
            url "https://raw.githubusercontent.com/ZoeyWoohoo/Barn/main/maven/"
            credentials(HttpHeaderCredentials) {
                name "Authorization"
                // 填写你获取到的 Token
                value "Bearer <Your Personal Access Token>"
            }
            authentication {
                header(HttpHeaderAuthentication)
            }
        }
    }
}

allprojects {
    // ...
    repositories {
        google()
        // ...

        maven {
            // 填写你自己的仓库地址
            url "https://raw.githubusercontent.com/ZoeyWoohoo/Barn/main/maven/"
            credentials(HttpHeaderCredentials) {
                name "Authorization"
                // 填写你获取到的 Token
                value "Bearer <Your Personal Access Token>"
            }
            authentication {
                header(HttpHeaderAuthentication)
            }
        }
    }
}

不过安全起见，万一哪天你不小心把代码推到公开仓库，这个 token 就泄漏了，所以我们还是将其配置在本地吧：

// 修改 gradle.properties 文件
➜ vim ~/.gradle/gradle.properties

// 在其中加入下面这行配置，填入自己的 token
github.personal.access.token=<Your Personal Access Token>

而引入仓库地址时，则对应的修改为：

// ...
maven {
    // ...
    credentials(HttpHeaderCredentials) {
        name "Authorization"
        value "Bearer " + project.findProperty("github.personal.access.token")
    }
    // ...
}

在 module 下 build.gradle 文件中正常地引入包依赖即可：

dependencies {
    // ...
    implementation 'com.neostudio.neotoast:neotoast:1.0'
}

最后的最后 (Last but not least)，项目 gradle sync 的时候记得需要代理，因为库已经托管在 GitHub 上了，因为这个问题浪费了我一晚上的时间 :)

(入门指南) 在 Google Cloud 上部署 Maven 私服

Wed, 16 Dec 2020 06:32:07 +0000

创建服务器

首先需要注意的一点是，当你创建一个新的项目时，谷歌云默认防火墙策略是不允许有外来流量的，所以我们需要添加一些防火墙规则，开放一些端口，并应用到你的虚拟机实例配置上，这样后续我们才能访问。

这里以 Nexus 服务默认 8081 端口为例，选择我们创建的项目，然后在 VPC 网络 -> 防火墙 里添加一个 8081 端口的防火墙规则:

这里目标可以不用选择 网络中的所有实例，只需要填写指定一个目标标记，并在相应的虚拟机实例配置里指定这个目标即可。另外，可以添加默认的 http/https 端口，名称为 default-allow-http/default-allow-https 目标标记为 http-server/https-server，端口可以自己指定，比如常见默认的 80 端口。因为后续配置域名后，我们可以把服务 8081 端口映射到 80 端口，这样访问时就不需要指定端口名了，当然或者你也可以使用 Nginx 反向代理。

在 Google Cloud Platform -> Compute Engine 上创建一个虚拟机实例，因为后续我们选取使用 Docker 来部署，所以选择系统版本时，可以先参考 Docker 安装包所提供的版本，这里选取了当前最新的 Ubuntu Groovy 20.10。其他按需配置，再看到防火墙这个部分，当我们勾选上 允许 HTTP 流量 及 允许 HTTPS 流量 时，就会为我们添加上面配置的默认目标规则：http-server/https-server 的 80/443 端口。然后在网络部分添加上我们创建的 8081 端口规则，输入之前指定的目标标记名 nexus-server 回车即可。

在 Compute Engine -> 设置 -> 元数据 -> SSH 密钥 里配置好我们的 SSH 密钥，后续通过 ssh 连接服务器。

为了后续域名解析的方便，我们不妨在 VPC 网络 -> 外部 IP 地址 里给我们的虚拟机实例设置一个静态的外部 IP 地址。

连接服务器

使用 ssh 命令连接服务器:

$ ssh -i /path/to/your/ssh/key/.ssh/id_rsa_google_cloud [用户名]@[虚拟机实例外部 IP 地址]

安装 Docker

连上服务器后，我们就可以在终端跟着官方教程来安装 Docker 了。首先更新源及安装一些库以允许使用 HTTPS 服务：

$ sudo apt-get update
$ sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

接着添加 Docker 官方的公钥：

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

搜索验证一下，会输出如下信息：

$ sudo apt-key fingerprint 0EBFCD88

pub   rsa4096 2017-02-22 [SCEA]
      9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid           [ unknown] Docker Release (CE deb) <docker@docker.com>
sub   rsa4096 2017-02-22 [S]

添加仓库源地址：

$ sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

安装 Docker：

$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io

运行一下 Hello World，验证有没有安装成功：

$ sudo docker run hello-world

接着可以添加 docker 用户组授予相应权限，以便后续无需输入 sudo：

$ sudo groupadd docker
$ sudo usermod -aG docker $USER
$ newgrp docker

运行 Nexus 容器服务

我们使用 Nexus 的 Docker 容器服务，直接就可部署在服务器上了。为了数据的持久化存储，我们指定一个 Docker 储存盘符映射到服务器本地文件，并在运行 Nexus 服务时使用这个盘来存储我们的数据。

$ docker volume create --name nexus-data
$ docker run -d -p 80:8081 --name nexus -v nexus-data:/nexus-data sonatype/nexus3

这里我们指定了本机的 80 端口，映射到容器的 8081 端口，运行 Nexus 服务可能需要少许时间，访问我们的服务器 IP 地址，应该就能看见 Nexus 的初始页面了。这时候登录账号应该会提示你登录初始化账号名及密码的地址。

所以需要查看 Nexus 服务容器内的文件，我们需要使用以下 Docker 命令：

$ docker exec -it nexus bash

进入容器内部 bash 后，可以使用 cat 密码文件地址来查看初始密码，登录后要求你更新密码，输入新的密码即可。有域名的话添加一个解析到服务器的 IP 地址。It’s all done!

Android 图标设计 & 使用指南

Thu, 21 Mar 2019 20:31:51 +0000

前言

图标分几种，包括产品图标、系统图标、应用快捷图标、动效图标等 (当一个人说到等字的时候，就是他列举不下去了)，本文要讲的则是其中的产品图标 (Product icons)，也是我们常说的应用图标或启动图标。

而说到官方设计就不得不提到 Material Design 了，近几年不管是设计还是开发，Google 都更新的很快，图标的设计也不例外。从拟物化变为扁平，再到 Material Design 的推出，这种质感设计也逐渐流行开来，这段时期的图标设计，在 Android 上现在被称之为传统启动图标 (Legacy launcher icons) 设计。

这里还要插一句，即使是 Material Design 时期的图标设计，早期的时候依然没有完全摆脱拟物化时期的风格影响，可能主要还是在用色方面上，后期的用色鲜艳凸显活力，更多的是汲取了扁平化设计 (Flat Design) 的优点。

这个时期，大家都力图追求独特的外形，与众不同的设计能够让自己的应用有足够高的辨识度，让自己的图标在一众图标中脱颖而出。如下拿 Roman 的 Plaid 作品中的一个图标来说：

在也正如同拟物化设计时期一样，这种开放自由式的设计，在后期，各个应用的图标为了提高辨识度，以牺牲用户体验为代价，让自己的图标尽可能显得独特，这使得图标界面整体失去了统一性。(下图：理想 VS 现实)

也正如 Nick Butcher 所说：

When everything is unique, nothing is unique.

(当一切都变得独特的时候，也就没有了独特)

这个时候，想要让各个应用自觉地在设计上以用户体验为主几乎是不可能了，所以各个 OEM (原始设备制造商) 为了让自己的「系统」界面更加统一以提高自家用户体验，开始限制桌面启动图的显示，包括缩放填充，以及强制性的统一外形背景包裹。这个相信在座的各位都深有体会，这种图标背景多以圆角矩形和圆形为主。以下拿三星 Galaxy S7 为例 (图源)：

而 Google 也曾在 Android 7.1 的时候介绍过 RoundIcon，以试图获得这种图标的统一性，但是在 OEM 的各种限制下，效果不是很好。直至 Android O (8.0 API 26)，Google 终于出手了，推出了自适应图标 (Adaptive Icon)。

自适应图标在设计层面来说，主要由三个概念构成，即：背景、前景和遮罩。背景就是整个图标的背景，多以纯色填充背景为主；前景就是你的图标设计，其中设计时会有一个安全区域，图标设计时，大小最好限制在安全区域内，已防止遮罩裁切后显示不全或大小比例位置失调；遮罩就是各个 OEM 桌面图标显示形状的一个「裁剪区域」。用一张动图来解释就很明了了：

不同的手机设备厂商会采用不同的遮罩，自适应图标会根据其遮罩自动显示相应的效果：

而从效果层面来看，这种图标设计之所以被称之为自适应，除了在不同形状遮罩下，都能获得一致的体验外，在图标的动效方面，使得图标变得更加灵动，因为原生的 Android 桌面加入了手势响应的各种动效设计，包括了点击及各方向的拉拽的弹性效果。同样的，一图胜千言：

但是一码归一码，国内环境大家都清楚，目前自用小米手机默认的遮罩就是圆角矩形，可以的话还是用 Nova Launcher 吧，至少能够获得和原生近乎一致的体验，还能够自定义遮罩形状。(下图为左小米，中 Nova Launcher，右自定义遮罩形状设置)

不过好像直到现在，Google 自家的好些应用图标也没遵循这些规范，大概是各个团队都太忙了吧 :) 虽然我也挺喜欢一些如 CandyCons 图标包里的图标设计，但这些居多都还是未遵循这种设计规范，希望未来会有越来越多的应用能够采用这种自适应图标设计，我相信一个好的设计师，应该不会被其「束缚」住吧 :p

设计规范

随着 Material Design 的更新，文档也随之迭代更新，老的文档会被归档，而有的时候还是需要老的文档做一些信息补充，你可以通过这两个链接访问：老的设计规范、新的设计规范。

因为 Android 8.0 以上才开始支持 Adaptive icons，而我们不可能最低才兼容到 8.0，最起码 minSDK 21 (Android 5.0) 还是要支持的。所以在设计的时候，整体设计以自适应设计为主，依据两套规范输出两套图标，在 8.0 以上的手机使用自适应图标，以下则使用传统图标。

如果有条件，推荐观看 YouTube 上的一个教学视频以跳过下文设计规范部分：(YouTube) Design Adaptive Icons using Google Material Design Guidelines - Illustrator CC 2018 Tutorial

下面是收集整理的一些参考线模板资源：

设计工具	传统图标参考线模板下载地址	自适应图标参考线模板下载地址
Adobe Illustrator	AI Legacy	AI Adaptive
Sketch	@null	Sketch Adaptive
Figma	@null	Figma Adaptive
Affinity Designer	@null	Affinity Designer Adaptive
Adobe XD	@null	Adobe XD Adaptive

传统图标

传统图标设计的网格及参考线如下所示，以 AI 中为例，创建画板宽高为 192px，参考形状分四种，宽高均为 152px 的圆角矩形、宽高为 176px 和 128px 的水平或垂直圆角矩形、直径为 176px 的圆形，其中圆角矩形的圆角为 12px，同时底层有 4px 大小的网格线。根据参考形状与图标几何形状对比做出选择，并在规定区域内进行图标的设计。如下图所示：

一般地，我们选择圆角正方形及圆形输出一套标准的传统图标，圆角正方形在应用里为正常图标 (icon)，圆形在应用里为圆形图标 (round icon)，在应用中进行相应的设置即可。

而根据规范，图标结构分以下 5 层：

1: Finish (一个最后的遮罩层，与自适应图标里的遮罩不是同一个概念)

2: Material background (背景层)

3: Material foreground (前景层)

4: Color (色块层，可以理解为 logo 上某一元素)

5: Shadow (阴影层)

下面我们依据自适应图标设计风格来进行设计，以在 AI 上为例，首先选择一个参考形状圆角正方形，进行一个背景色填充，再给其加上一个 Drop Shadow (或者可能称其为 Contact Shadow)，参数如下：

这个阴影源自 Material Design 中一个正上方左上角的光源投影，阴影比较柔和。下面是图标正体设计，也是图标的前景，在此之后，Material Design 为了体现出材质的厚度感 (把你的图标想象成是一张纸)，为其增加了一个顶部的着色边缘和一个底部的阴影边缘，如下图 Hangouts 图标效果所示：

注意这里环聊使用的还是传统图标设计的风格，虽然它也提供了自适应图标，但这两种风格有种不协调感，可能也是因为 Android 8.0 以下本身就不支持自适应图标这个原因，Google 觉得对于低版本，还要啥自行车。下图左边为魅族 MX4 Android 5.0 的手机，右边为小米 6 Android 8.0，左边图标采用一致性的自适应设计风格，右边环聊图标在 8.0 以下采用的是传统设计风格 (自行感受一下，个人还是推荐采用一致的自适应设计风格)：

图标前景设计好后，还可以为其加一个经典的长投影，以其图标中心为起点，右下方 45° 角径向渐变投影，如下图所示：

这个投影可以用钢笔工具勾勒出来，然后设置渐变填充，用以模仿投影效果，其渐变各点处参数如下：

AI 渐变工具	位置	透明度
滑块 1	32%	15%
滑块 2	62%	2%
滑块 3	100%	0%

但是我发现加完后效果根本不行，所以直接用填充加透明度 10% 来替代 (我也只能安慰自己，规范也仅仅是规范，不是死的，我们要灵活变通)：

最后是一个 finish 图层，它是一个白色透明渐变图层作为遮罩至于前景上方，也被称为精加工层 🤨。与长投影类似它也是一个 45° 角的径向渐变，其中间点在 33% 的位置：

其渐变各点处参数如下：

AI 渐变工具	位置	透明度
滑块 1	0%	10%
滑块 2	100%	0%

这个精加工层可能只有隐藏和查看之前切换你才能看出那细微的差别，毕竟是精加工嘛 :p

最后就是导出操作了，如下图所示先点击 Android 按钮用以输出一套 Android 下的图标文件 (SVG 格式可以取消勾选)，修改缩放为指定宽度，文件名后缀和前缀都去除，输出完后，修改背景图层为圆形，同样地再次输出一套图标图片，这里记得改默认文件名，后面加上 round，这样我们就得到了一套完整地传统图标资源。

而其中不同尺寸对应的 mipmap 资源文件夹如下表所示：

尺寸	文件夹
48px	mipmap-mdpi
72px	mipmap-hdpi
96px	mipmap-xhdpi
144px	mipmap-xxhdpi
192px	mipmap-xxxhdpi

或者其实这里的导出可以省略，后面我们利用导出的自适应图标 SVG 文件，生成矢量文件后，再利用 Android Studio 的 Asset Studio 自动生成两套图标 (推荐做法)，具体请参考下文一键生成部分。

自适应图标

因为秉承着自适应图标设计风格，有了之前的传统图标设计，自适应图标就比较简单了，直接拿过来修改一下。自适应图标画板长宽为 108px，其中一个直径为 72px 的最大边界圆为内容限制区域，也是遮罩剪裁区域，图标一定不能超出这个范围。四周保留的 18px 空白是为了给图标的一些动效所留出的空间，比如拉扯的回弹。也正是因为其动效特征，故其又有了一个图标的安全区域，为 66px 直径的圆，图标大小不超过安全区域能最大程度的保证你的图标在动效过程中不会脱离视野边界。

具体的操作就是把背景层复制粘贴过来，去除阴影效果，填充满整个画板，再将前景内容 (包括长投影) 复制粘贴过来，调整位置和大小 (主要是要在安全区域内)，如下图所示：

做完这些工作后，我们可以利用 Marius Claret (也是 Google Design) 制作的在线预览工具检查体验一下图标是否合理，并作出相应修改，地址为 Adapticon，使用方法如下 (你需要先导出一份前、背景图片资源)：

最后，觉得图标已经没有问题后，只要将背景层和前景层分别导出为 SVG 格式文件就可以了。之后我们可以利用 Android Studio 的 Asset Studio 工具将 SVG 文件转化为矢量图标资源文件，这种方式不仅比直接输出图片资源高效，而且文件更小，矢量图也具有不失真的特点。我们右键 drawable -> new -> Vector Asset 之后，如下图所示导入之前输出的 SVG 文件进行转换就可以了：

将前、背景分别转换完成后，设计工作就结束啦！

图标使用

传统图标

现在我们已经得到了一套完整的传统图标资源，如下图所示 (暂时忽略自适应图标的两个 xml 文件，那个是下面将要创建的)：

在 AndroidManifest 文件中设置传统图标，即 icon 及 roundIcon 项：

<application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">

        <activity
            android:name=".MainActivity"
            android:theme="@style/AppTheme.SplashScreen">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
</application>

自适应图标

自适应图标需要编译版本在 26 以上，而自适应图标的资源类型是新的独有的一种资源类型，被称之为 AdaptiveIconDrawable ，whatever，前面我们已经得到了由 SVG 转成矢量图的前景和背景资源，位于 drawable 目录下，例如：

- drawable
  - xxxxxx
  - ic_launcher_background.xml
  - ic_launcher_foreground.xml

接着在 mipmap-anydpi-v26 文件夹下创建两个图标资源文件，以同样的命名方式，只不过由图片格式变成了 xml 格式，即之前提到的这两个文件：

两个文件相同，内容如下：

<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@drawable/ic_launcher_background"/>
    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
</adaptive-icon>

Asset Studio 一键生成

我们可以利用 Android Studio 的 Asset Studio 工具一键生成两套图标并直接使用，非常方便，利用之前转换来的矢量文件资源：

- drawable
  - xxxxxx
  - ic_launcher_background.xml
  - ic_launcher_foreground.xml

具体操作如下，右键 mipmap 文件 new -> Image Asset：

图标类型选择传统和自适应两套，然后再将下面的前景层和后景层替换成上面我们转换来的矢量文件，这里有个小技巧，因为打开时默认位置是 AS 内置默认图标资源的位置，这里点击项目路径按钮能快速切换到项目路径：

之后直接生成替换，你会发现，这样就完成了两套图标资源的生成，与上面单独操作生成的效果是一样的，方面又快捷 :)

参考文档

Material Design - icons (archive)

Material Design - Product icons

Material Design - Keyline shapes

Developer guides - Adaptive icons

Understanding Android Adaptive Icons

Designing Adaptive Icons

Implementing Adaptive Icons

What Google missed in their guidelines for Material Design iconography

(YouTube) Design Adaptive Icons using Google Material Design Guidelines - Illustrator CC 2018 Tutorial

Windows 10 快速配置指南

Mon, 14 Jan 2019 15:11:19 +0000

告别

在此先向用了一年多的 Arch 道个别，谢谢你让我体验了 Linux 世界的美好。

系统篇

Windows 10 镜像下载，当然是 I tell you 网站了，首选英文版。安装完成后，更新系统及驱动至最新，之后登录微软账号同步一些个性化配置，这里你可能会想修改系统默认的用户名，参见在知乎上的回答。

对于桌面的个性化，个人不喜欢桌面留任何快捷方式图标，回收站放在开始页面的磁贴里，任务栏自动隐藏，时钟的话，使用 Rainmeter 写个插件就行了。Windows 上字体可能是吐槽的比较多的一点(MacType 试了一下，没有理想中的效果就作罢了)，因为很喜欢 Monaco 字体，这个字体也当然是必装的啦，在 Github 上有几个仓库可以参考一下 (推荐安装 Monaco 和 HeyMona)。其实想想，换个高清屏电脑，Windows 的体验也不至于太差，谁让 MacBook 贵还不好说它坏话呢 🙂 。

清除桌面上的回收站快捷方式如下图所示：

安装 Mac 风格的鼠标光标主题，这个网上还是挺多的，综合试用后，推荐 Capitaine 这款，因为其他的文本光标是全黑没有白边，一碰到黑色背景，你就不知道你在玩啥了 🙃 。下载后右键安装就完事了。

之后在主题设置中选择这款鼠标指针主题，我好了，你呢？

软件篇

软件清单：7-Zip、Snipaste、Listary、Rainmeter、Chocolatey、ConEmu、Atom 或 SublimeText、Chrome、WPS 专业版、Adobe 系列、JetBrains 系列、TIM、WeChat、Tg、网易云音乐等。

其实软件这东西，除了常用的外，也是想到啥装啥呗 😑 。下面挑几个需要稍微做点工作的软件工具。

Rainmeter

Rainmeter 是一个 Windows 下的桌面插件工具，给予用户如 Android 桌面插件的体验，为了满足自己的需求，在自带插件例子下，修改编写了一个极简时钟插件。

直接新建一个主题，然后将文件复制粘贴过去即可，主题文件夹位于：

C:\Users\[username]\Documents\Rainmeter\Skins\

主题代码贴到 Gist 上了，位置及其它设置可自行调整。

Chocolatey

使用 Chocolatey 进行软件包管理，纵享丝滑，有着如 Linux/macOS 下软件包管理的体验，尤其是安装一些工具时，安装完成后自动配置环境变量。一些基本的你想得到的软件包，都已经支持了，详情可参见包列表。

例如安装 Git、Vim、JDK 等，只需一行命令，且无需手动设置环境变量，也算是解决了一些 Windows 被诟病的问题。

$ choco install git
$ choco install vim
$ choco install jdk8

补一张安装 ffmpeg 的截图：

ConEmu

使用 ConEmu，还原最优的终端体验，说到终端，在 Windows 下使用 PowerShell 而不是 Cmd (因为 Cmd 是旧时代的遗留物)。提到 ConEmu 和 PowerShell，我又想起了 oh-my-posh，这个在 ConEmu 里为 PowerShell 提供的主题引擎。

README 文档里展示的主题还是挺漂亮的，就是我下载了那个字体后，出来的并不是它展示的那个效果，也不知道是我搞错字体了还是作者搞错了。那就换我最心爱的 Monaco 字体吧 (ConEmu 设置里一把梭)，当然，还不能不考虑到中文字体，所以就选择 HeyMona 吧。但是，这时候发现，主题里炫酷的效果没了，很多字符这个字体根本不支持。正所谓「两权相害取其轻」，干脆自己写个主题算了，稍微研究了一下官方给的主题，摸清了这个语法套路，写了个极简主题 Minimalism。

这个主题大概长这样：

管理员权限时：

如果你也想配置成这个样子 😐 ，可以按下面步骤配置。

调整了配色，修改后的 ConEmu 配置文件在 Gist 上贴出，其文件默认位于：

C:\Users\[username]\AppData\Roaming\ConEmu.xml

将其内容复制粘贴覆盖即可，你也可以根据自己需求改动，而 oh-my-posh 的主题目录默认在：

C:\Users\[username]\Documents\WindowsPowerShell\PoshThemes\

下载主题文件，放置在这个目录下，一行命令即可设置成功 (但是只是当前窗口生效，想要启动时自动切换到这个主题，需要写在 PowerShell 的配置文件中，详细见下文)：

$ Set-Theme Minimalism

主题可以根据自己的需求修改，其中发现了一个网站，一并注释在主题文件中，Enjoy yourself！

那么现在插播一下 PowerShell 的配置文件，相当于 Bash 下的 .bashrc，默认位置位于：

C:\Users\[username]\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1

自己添加了两个命令，方便修改 PowerShell 和 Vim 的配置：

Import-Module posh-git
Import-Module oh-my-posh
Set-Theme Minimalism

Set-Alias vi vim

# for editing PowerShell profile
Function Edit-Profile
{
    vim $profile
}

# for editing Vim settings
Function Edit-Vimrc
{
    vim $home\_vimrc
}

新增了一个类似 zsh 默认样式效果的主题 zshStyle，效果如下图所示，我已经用上了，你呢？

WPS 专业版

WPS 专业版相比普通的 WPS 版本，好在哪里呢？谁用谁知道 🙄 ，至于那啥 🤐 ，百度一下就有了。

以上提及的一些资源一并上传到 GitHub 仓库中方便下载使用。

Java 基础语法关键点总结

Thu, 27 Sep 2018 03:03:07 +0000

Java 文档

命令：javadoc -help

分隔符、标识符和关键字

分隔符：分号 (;)、花括号 ({})、方括号 ([])、圆括号 (())、空格 ( )、圆点 (.)。

Java 采用分号 (;) 作为语句的分隔，语句可跨行书写，但一个字符串、变量名不能跨多行书写。

// good
String words = "Hello " +
    "Java";

// error
String words = "Hello
    Java";
String word
    s = "Hello Java";

标识符：用于命名的符号，必须以字母、下划线 (_)、美元符 ($) 开头，后可跟任意字母、数字、下划线和美元符。

标识符不能是 Java 关键字和保留字。

关键字：特殊用途的单词，所有的关键字都是小写的。

数据类型

Java 数据类型分为：基本类型和引用类型。

char 代表字符型，用单引号 (‘) 表示，存的是字符的编码，所以实际上也是一种整数类型，相当于无符号整数类型。

引用数据类型就是对一个对象的引用，对象包括实例和数组两种。空类型就是 null 值的类型，这种类型没有名称，所以不可能声明一个 null 类型的变量或者转换到 null 类型。

空引用只能被转换成引用类型，不能转换成基本类型，因此不要把一个 null 值赋给基本数据类型的变量。

Java 中整数值的 4 种表达方式：十进制、二进制 (以 0b 或 0B 开头)、八进制 (以 0 开头) 和十六进制 (以 0x 或 0X 开头)。

数值可用下划线分隔，可以更加直观地分辨数值包含的位数，如下：

int bina = 0B1000_0000_0000_0000_0000_0000_0000_0011;
double pi = 3.14_15_92_65_36;

Java 中浮点类型默认是 double 类型，因此，如果希望把一个浮点类型值当成 float 类型处理，其后应紧跟 f 或 F。

// normal
double pi = 3.14;

// error
float pi = 3.14;

// good
float pi = 3.14f;

基本类型的类型转换

由小到大的类型转换为自动类型转换，由大到小的类型转换为强制类型转换，需在转换数值前加转换类型，其语法为：(TargetType) value。

强制类型转换容易引起精度、信息的丢失及溢出错误。

表达式类型的自动提升：当一个算术表达式中含多个基本类型的值时，整个算术表达式的数据类型将发生自动提升，提升规则如下

所有的 byte 类型、short 类型和 char 类型将被提升到 int 类型。
整个算术表达式的数据类型自动提升到表达式中最高等级操作数的类型。

// 输出 Hello!a7
System.out.println("Hello!" + 'a' + 7);

// 输出 104Hello!
System.out.println('a' + 7 + "Hello!");

直接量

直接量是指在程序中通过源代码直接给出的值，例如 int a = 18; 中为 a 所分配的初始值 18 就是一个直接量。

char 类型的直接量有三种：字符 (‘a’)、转义字符 (‘\n’)、Unicode 值表示的字符 (‘\u0061’)。

String 类型的直接量为双引号括起来的字符序列，不能赋给其他类型的变量。String 类是典型的不可变类，String 对象创建出来就不可能被改变。

关于字符串直接量，当程序第一次使用某个字符串直接量时，Java 会直接使用常量池 (constant pool) 中的字符串直接量。常量池指的是在编译期被确定，并被保存在已编译的 .class 文件中的一些数据。它包括关于类、方法、接口中的常量，也包括字符串直接量。

String s0 = "hello";
String s1 = "hello";
String s2 = "he" + "llo";

// true
System.out.println(s0 == s1);
// true
System.out.println(s0 == s2);

Java 会确保每个字符串常量只有一个，不会产生多个副本。s0 和 s1 中的 “hello” 都是字符串常量，在编译期就被确定量，所以第一个返回 true，而 “he” 和 “llo” 也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它本身也是字符串常量，s2 也在编译期就被解析为一个字符串常量，所以 s2 也是常量池中 “hello” 的引用，所以第二个也返回 true。

运算符

单目运算符自加和自减中运算符在操作数左边和右边的区别：当运算符在操作数左边时，操作数先进行单目运算，再将操作数代入表达式中运算；当运算符在操作数右边时，先将操作数代入表达式中运算，再对操作数进行单目运算。

// case 1
int a = 5;
int b = a++ + 6;
// 输出 a 为 6，b 为 11
System.out.println(a + "\n" + b);

// case 2
int a = 5;
int b = ++a + 6;
// 输出 a 为 6，b 为 12
System.out.println(a + "\n" + b);

赋值表达式是有值的，其值就是右边被赋的值，因此，赋值运算符支持连续赋值，但这种写法使程序可读性降低，不推荐。

int a;
int b;
int c;

// 同时为 a, b, c 赋值 18
a = b = c = 18;

推荐使用扩展后的赋值运算符如：+=、-=、*=、&=、|=、^= 等，这种运算符不仅具有更好的性能，而且程序会更加健壮。

byte a = 5;
// a 为 byte 类型，a + 5 由表达式类型的自动提升
// 其结果为 int 类型，因此下面语法会出错
a = a + 5;

byte b = 5;
// 下面使用扩展后的赋值运算符不会出错
b += 5;

逻辑运算符中的短路与不短路：逻辑与 && (短路与) 或 & (不短路与) 和逻辑或 || (短路或) 或 | (不短路或) 的区别在于，短路逻辑运算符如果在第一个表达式的结果就能得出最终表达式的结果，将不再进行后续表达式的运算，相反，不短路的逻辑运算符不管怎样，都会计算各个表达式。

int a = 5;
int b = 10;
if (a > 4 || b++ > 10) {
    // 输出：a = 5, b = 10
    System.out.println("a = " + a + ", b = " + b);
}

int c = 5;
int d = 10;
if (c > 4 | d++ > 10) {
    // 输出：c = 5, d = 11
    System.out.println("c = " + c + ", d = " + d);
}

数组类型

Java 中的数组要求所有的元素具有相同的数据类型，一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。即使把某个数组元素的数据清空，但它所占据的空间依然被保留，依然属于该数组，数组的长度依然不变。

Java 的数组可以存储基本类型的数据，也可存储引用类型的数据，只要所有的数组元素具有相同的类型即可 (父类定义的类型，可存放其继承而来的不同类型子类)。

数组也是一种数据类型，它本身是一种引用类型。例如 int 是一个基本类型，但 int[] 就是一种引用类型。

数组的定义支持两种语法：

type[] arrayName;
type arrayName[];

但推荐第一种语法，不仅具有更好的语意，而且更具可读性，type[] 确实是一种新类型 (引用类型)，符合定义变量的语法。第二种定义数组的语法方式，是一种糟糕的方式，越来越多的语言都不再支持这种定义语法了。

定义数组时不能指定数组的长度，也不能使用，只有对数组进行初始化后才可以使用。

数组初始化

数组初始化分两种：

静态初始化：由程序员显式指定每个数组元素的初始值，由系统决定数组长度。
动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值。

// 定义数组类型变量
int[] intArr;
// 静态初始化
intArr = new int[]{5, 6, 7, 8};

// 静态初始化简洁语法
// 只有在定义和初始化同时执行时才支持使用这种语法
int[] a = {5, 6, 7, 8};

int[] prices;
// 动态初始化
// 由系统分配初始值
prices = new int[5];
// 定义和初始化同时执行
Object[] books = new String[4];

动态初始化，系统分配初始值规则如下：

基本类型中整数类型 (byte、short、int、long) 为 0。
基本类型中浮点类型 (float、double) 为 0.0。
基本类型中字符类型 (char) 为 ‘\u0000’。
基本类型中布尔类型 (boolean) 为 false。
引用类型 (类、接口、数组) 为 null。

不要同时使用静态初始化和动态初始化，也就是说，不要在进行数组初始化时，既指定数组长度，又为每个数组元素分配初始值。

foreach 循环

使用 foreach 循环遍历数组和集合元素时，无须获得数组和集合长度，无须根据索引来访问数组元素和集合元素，foreach 循环自动遍历数组和集合的每个元素。使用 foreach 循环时，通常不要对循环变量进行赋值，没有太大的实际意义，因为 foreach 循环中的循环变量相当于一个临时变量，系统会把数组元素依次赋给这个临时变量，而这个临时变量并不是数组元素，它只是保存了数组元素的值。因此，如果希望改变数组元素的值，不能使用这种 foreach 循环。

String[] books = {"Git", "Java", "Python"};

for (String book: books) {
    book = "itsCoder";
    System.out.println(book);
}

System.out.println(books[0]);

输出结果如下：

itsCoder
itsCoder
itsCoder
Git

内存中的数组

初始化一个数组后，实际数组对象数据被存储在堆 (heap) 内存中，引用该数组对象的数组引用变量，如果是一个局部变量，被存储在栈 (stack) 内存中，可以理解为 C 语言中的指针，数组引用变量存放的是数组在堆内存中的地址，通过 arrayName[index] 的方式实现数据的访问。

通过设置 arrayName = null 的方式切断与实际数组间的引用关系，当实际数组无引用指向时，在堆中就成了垃圾，等待回收。

类的对象的存储和引用也是一样的。

面向对象

对象的 this 引用

Java 提供的 this 关键字总是指向调用该方法的对象，根据 this 出现的位置不同，this 作为对象的默认引用有两种情形。

构造器中引用该构造器正在初始化的对象。
在方法中引用调用该方法的对象。

this 可以代表任何对象，当 this 出现在某个方法中时，它所代表的对象是不确定的，但它的类型是确定的，它所代表的对象只能是当前类，只有这个方法被调用时，它所代表的对象才能被确定下来：谁在调用这个方法，this 就代表谁。

public class Dog {
    public void jump() {
        System.out.println("jump");
    }

    public void run() {
        this.jump();
        System.out.println("run");
    }
}

public class DogTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.run();
    }
}

因为当程序调用 run() 方法时，一定会提供一个 Dog 对象，这样就可以直接使用这个对象了而无须重新创建一个对象了，使用 this 来指代这个对象，从而调用 Dog 类的实例方法。Java 中对象里的这种方法依赖关系很常见，因此，Java 允许对象的一个成员直接调用另一个成员，可以省略 this 前缀。

而对于 static 修饰的方法 (称为类方法或静态方法)，可以直接使用类来调用，所以，若在类方法中使用 this 关键字，此时这个关键字无法指向合适的对象。因此，static 修饰的方法不能访问不使用 static 修饰的普通成员，即：静态成员不能直接访问非静态成员。

对象访问类成员的陷阱

当需要修改类变量时，应使用类作为调用者来操作，虽然 Java 中允许使用这个类的实例对象访问类成员，但这是一个「错误」的设计，应避免这种调用方法，才不会产生歧义，提高程序的可读性。

当第一次使用一个类时，会进行初始化操作，此时对类成员变量系统进行自动赋值，其类成员变量在堆中是存放于一块独立的内存中。当对象赋给实例变量时，其实例变量在堆中开辟另一块独立的内存，所以多个实例间，类成员变量是共有的，实例变量是各自私有的，通过任何一个实例对象访问修改类成员变量，都会对其他实例访问造成影响。

例如一个 Person 类：

class Person {
    public static int eyeNum;
    public String name;
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "张三";
        p1.eyeNum = 2;

        Person p2 = new Person();
        p2.name = "李四";
        // 输出 2
        System.out.println(p2.eyeNum);
    }
}

其类初始化内存分配及各实例初始化后内存分配情况如下：

方法的参数传递机制

Java 里方法的参数传递方式只有一种：「值传递」。所谓值传递，就是将实际参数值的副本 (复制品) 传入方法内，而参数本身不会受到影响。

public class Test {
    public static void swap(int a, int b) {
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("swap 方法里，a 的值是 "
            + a + "; b 的值是 " + b);
    }

    public static void main(String[] args) {
        int a = 6;
        int b = 9;
        swap(a, b);
        System.out.println("交换后，变量 a 的值是 "
            + a + "; 变量 b 的值是 " + b);
    }
}

输出结果是：

swap 方法里，a 的值是 9; b 的值是 6
交换后，变量 a 的值是 6; 变量 b 的值是 9

在 main 方法的栈区里，存在 a，b 两个值，而在 swap 方法的栈区中，存储的是 main 方法里 a，b 变量值的副本，所以在 swap 方法中对 a，b 进行操作，修改的是 swap 方法栈区的值，不会影响到 mian 方法栈区中的 a，b 变量。

同理，对于引用类型也是一样的，但是，因为引用类型变量存储的是「地址」，所以即使是值传递，当对其数据操作时，地址指向的还是同一个堆里的对象数据，因此，引用类型的操作是「有效的」。

形参个数可变的方法

形参个数可变的参数，本质上就是一个数组参数。

其语法为：[修饰符] 方法返回值类型 functionName(Type... parameterName)。

方法内部可用 foreach 循环取得可变参数的各个值，一个方法中最多包含一个长度可变的形参，且长度可变的形参只能置于形参列表的最后。

public static void test(int a, int b, String... books) {

    System.out.println(a);
    System.out.println(b);

    for (String book: books) {
        System.out.println(book);
    }
}

方法重载

方法重载的要求：同一个类中方法名相同，参数列表不同，至于方法的其他部分，如方法返回值类型、修饰符等，与方法重载没有任何关系。

静态导入语法

除了导入类之外，Java 还支持导入指定类的某个静态成员变量、方法或全部的静态成员变量、方法。

其语法是：

import static package.subpackage....ClassName.fieldName|methodName/ClassName.*;

import static java.lang.System.*;
import static java.lang.Math.*;

public class StaticImportTest {
    public static void main(String[] args) {
        out.println(PI);
        out.println(sqrt(256));
    }
}

方法重写

在使用继承时，子类重写父类方法，遵循『两同两小一大』原则：方法名、形参列表相同；子类方法返回值类型、子类方法声明抛出的异常类都应比父类的更小或相等；子类方法的访问权限应比父类方法的访问权限更大或相等。而且覆盖方法和被覆盖方法都只能同时是类方法或实例方法，不能一个为类方法，一个为实例方法。

类的初始化顺序

当类第一次被加载使用时，系统会在类准备阶段为该类所有静态成员变量分配内存，在初始化阶段，先会对静态成员变量初始化，即：由子类回溯到最高父类，执行静态初始化块或声明类变量时指定的初始值，然后向下依次执行直至当前类。其次是普通初始化块、声明实例变量和构造器，也是由最高父类向下依次执行直至当前类。

用一个例子说明：

class Root {
    static {
        System.out.println("Root 的静态初始化块");
    }

    {
        System.out.println("Root 的普通初始化块");
    }

    public Root() {
        System.out.println("Root 的无参构造器");
    }
}

class Mid extends Root {
    static {
        System.out.println("Mid 的静态初始化块");
    }

    {
        System.out.println("Mid 的普通初始化块");
    }

    public Mid() {
        System.out.println("Mid 的无参构造器");
    }

    public Mid(String msg) {
        this();
        System.out.println("Mid 的带参构造器，其参数值：" + msg);
    }
}

class Leaf extends Mid {
    static {
        System.out.println("Leaf 的静态初始化块");
    }

    {
        System.out.println("Leaf 的普通初始化块");
    }

    public Leaf() {
        super("itsCoder");
        System.out.println("Leaf 的无参构造器");
    }
}

public class Test {
    public static void main(String[] args) {
        new Leaf();
        new Leaf();
    }
}

其输出结果是 (虚线为手动添加，为了更直观分析)：

Root 的静态初始化块
Mid 的静态初始化块
Leaf 的静态初始化块
-------------------------
Root 的普通初始化块
Root 的无参构造器
Mid 的普通初始化块
Mid 的无参构造器
Mid 的带参构造器，其参数值：itsCoder
Leaf 的普通初始化块
Leaf 的无参构造器
-------------------------
Root 的普通初始化块
Root 的无参构造器
Mid 的普通初始化块
Mid 的无参构造器
Mid 的带参构造器，其参数值：itsCoder
Leaf 的普通初始化块
Leaf 的无参构造器

静态初始化块和声明静态成员变量时所指定的初始值都是该类的初始化代码，它们的执行顺序和源程序中的排列顺序相同。

public class StaticInitTest {
    static {
        a = 6;
    }

    static int a = 9;

    public static void main(String[] args) {
        // 输出 9
        System.out.println(StaticInitTest.a);
    }
}

实际上初始化块是一个『假象』，使用 javac 命令编译 Java 类后，该 Java 类中的初始化块会消失 —— 初始化块中的代码会被『还原』到每个构造器中，且位于构造器所有代码的前面。

自动装箱的特别情形

自动装箱，即可以直接把一个基本类型值赋给一个包装类实例，这种情况下可能会出现一些特别的情形。

Integer ina = 2;
Integer inb = 2;
// 输出 true
System.out.println("两个 2 自动装箱后是否相等：" + (ina == inb));

Integer biga = 128;
Integer bigb = 128;
// 输出 false
System.out.println("两个 128 自动装箱后是否相等：" + (biga == bigb));

这是因为 Integer 类的设计中，对 -128 到 127 间的数据做了缓存：

// java.lang.Integer

// 定义一个长度为 256 的 Integer 数组
static final Integer[] cache = new Integer[-(-128) + 127 + 1];
static {
    // 执行初始化，创建 -128 到 127 的 Integer 实例，并放入 cache 数组中
    for(int i = 0; i < cache.length; i++)
        cache[i] = new Integer(i - 128);
}

所以如果把一个 -128 ~ 127 之间的整数自动装箱成一个 Integer 实例时，实际上是直接指向对应的数组元素。即引用的是 cache 数组中的同一个数组元素，所以 ina 和 inb 相等。

`==` 和 `equals` 方法

当使用 == 来判断两个变量是否相等时：如果两个变量是基本类型变量，且都是数值类型 (不一定要求数据类型严格相同)，则只要两个变量的值相等，就将返回 true；如果两个变量是引用类型变量，只有它们指向同一个对象时，判断才返回 true。== 不可用于比较类型上没有父子关系的两个对象，否则引发编译错误。

int it = 18;
float fl = 18.0f;
// 输出 true
System.out.println("18 和 18.0f 是否相等？" + (it == fl));

char ch = 'A';
// 输出 true
System.out.println("65 和 'A' 是否相等？" + (65 == ch));

String str1 = new String("hello");
String str2 = new String("hello");
// 输出 false
System.out.println("str1 和 str2 是否相等？" + (str1 == str2));
// 输出 true
System.out.println("str1 是否 equals str2？" + (str1.equals(str2)));

// java.lang.String 与 EqualTest 类没有继承关系
// 引发编译错误
System.out.println("hello" == new EqualTest());

equals() 方法是 Object 类提供的一个实例方法，因此所有引用变量都可调用该方法来判断是否与其他引用变量相等，但是这个方法判断两个对象相等的标准与使用 == 运算符没有区别，同样要求两个引用变量指向同一个对象才会返回 true。因此，这个 Object 类提供的 equals() 方法没有太大的实际意义，如果希望采用自定义的相等标准，则可采用重写 equals 方法来实现。

String 已经重写了 Object 的 equals() 方法，String 的 equals() 方法判断两个字符串相等的标准是：只要两个字符串所包含的字符序列相同，通过 equals() 比较将返回 true，所以 str1.equals(str2) 才返回 true。

final 修饰符

final 成员变量 (包括实例变量和类变量) 必须由程序员显式初始化，系统不会对 final 成员进行隐式初始化。

final 修饰基本类型变量和引用类型变量的区别：当使用 final 修饰基本类型变量时，不能对基本类型变量重新赋值，因此基本类型变量不能被改变。对于引用类型变量而言，它保存的仅仅是一个引用，final 只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以发生改变。

抽象方法和抽象类

抽象类不能用于创建实例，只能被其他子类继承，抽象类的构造器主要是用于被其子类调用。抽象方法是只有方法签名，没有方法实现 (没有方法体，而非空方法体) 的方法。

有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法。

自我克隆

Java 的 Object 类还提供了一个 protected 修饰的 clone() 方法，用于帮助其他对象来实现「自我克隆」，得到当前对象的一个副本，二者之间完全隔离，但这种克隆是一种「简单克隆/浅克隆」—— 它只克隆该对象的所有成员变量值，不会对引用类型的成员变量值所引用的对象进行克隆，即引用类型对象克隆的是地址值，指向同一个内存地址。如果要进行「深克隆」，则需要自己进行「递归克隆」。

自定义类要实现「克隆」需要实现 Cloneable 接口，这是一个标记性的接口，里面没有定义任何方法。其次需要实现自己的 clone() 方法，在实现这个方法时，通过调用 super.clone() 方法来得到该对象的副本，并将其返回。

class Address {
    String detail;
    public Address(String detail) {
        this.detail = detail;
    }
}

class User implements Cloneable {
    int age;
    Address address;

    public User(int age) {
        this.age = age;
        address = new Address("itsCoder");
    }

    public User clone() throws CloneNotSupportedException {
        return (User)super.clone();
    }
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        User u1 = new User(29);
        User u2 = u1.clone();
        // 返回 false
        System.out.println(u1 == u2);
        // 返回 true
        System.out.println(u1.address == u2.address);
    }
}

Objects 类

使用 Java 7 新增的 Objects 工具类来操作对象，这些工具方法大多是「空指针」安全的。

public class ObjectTest {
    static ObjectTest obj;

    public static void main(String[] args) {
        // 输出一个 null 对象的 hashCode 值，输出 0
        System.out.println(Objects.hashCode(obj));
        // 输出一个 null 对象的 toString，输出 null
        System.out.println(Objects.toString(obj));
        // 要求 obj 不能为 null，如果 obj 为 null 引发空指针异常
        System.out.println(Objects.requireNonNull(obj, "obj 参数不能是 null!"));
    }

    public test(Object obj) {
        // 赋值时用于校验参数，为 null 引发异常
        this.obj = Objects.requireNonNull(obj);
    }
}

String、StringBuffer 和 StringBuilder

String 类是不可变类，一旦一个 String 对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。因为是不可变的，所以会额外产生很多临时变量，如下：

String str = "java";
str = str + "struts";
str = str + "spring";

上面程序除了使用了 3 个字符串直接量之外，还会额外产生 2 个字符串直接量 —— “javastruts” 和 “javastrutsspring”，程序中的 str 依次指向 3 个不同的字符串对象。使用 StringBuffer 或 StringBuilder (追加方法) 就可以避免这个问题。

StringBuffer 代表一个字符序列可变的字符串，提供有 append()、insert()、reverse()、setCharAt()、setLength() 等方法用来改变字符串对象的字符序列。

StringBuilder 是 JDK 1.5 新增的类，和 StringBuffer 基本类似，只是 StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。通常情况下，如需创建一个内容可变的字符串对象，则应优先考虑使用 StringBuilder 类。

集合

『善用集合工具类 Collections』

Java 集合大致可分为 Set、List、Queue 和 Map 四种体系，其中 Set 代表无序、不可重复的集合；List 代表有序、重复的集合；而 Map 代表具有映射关系的集合，Java 5 又增加了 Queue 体系集合，代表一种队列集合实现。

集合类主要由两个接口派生而来 —— 「Collection 和 Map」，二者是集合框架的根接口，包含一些子接口和实现类。继承树体系如下所示：

图中灰色背景为最常用实现类：HashSet、TreeSet、ArrayList、ArrayDeque、LinkedList、HashMap 和 TreeMap。

HashSet

HashSet 判断两个元素相等的标准：equals()、hashCode() 均相等。「相等元素」使用 add() 方法添加时返回 false 并不加入集合中。

HashSet 中每个能存储元素的「槽位」(slot) 通常称为「桶」(bucket)，如果有多个元素的 hashCode 值相同，但它们通过 equals() 方法比较返回 false，就需要在一个「桶」里放多个元素，这样会导致性能下降。所以重写 hashCode() 方法的一些基本规则如下：

在程序运行过程中，同一个对象多次调用 hashCode() 方法应该返回相同的值。
当两个对象通过 equals() 方法比较返回 true 时，这两个对象的 hashCode() 方法应返回相等的值。
对象中用作 equals() 方法比较标准的实例变量，都应该用于计算 hashCode 值。

TreeSet

TreeSet 是 SortedSet 接口的实现类，可以确保集合元素处于排序状态 (按元素的实际值大小进行排序)。与 HashSet 集合采用 hash 算法来决定元素的存储位置不同，TreeSet 采用红黑树的数据结构来存储集合元素。

TreeSet 支持两种排序方法：自然排序 (默认) 和定制排序。

自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序排序。所以将一个对象添加到 TreeSet 时，则该对象必须实现 Comparable 接口，否则程序将会抛出异常。一些常用类都实现了 Comparable 接口，其比较规则如下：

BigDecimal、BigInteger 以及所有数值型对象的包装类，按它们对应的数值大小比较。
Character、String 类，按字符 (/字符串中的字符) 的 UNICODE 值进行比较。
Boolean 类,其 true 对应的包装类实例大于 false 对应的包装类实例。
Date、Time 类，后面的时间、日期大于前面的时间、日期。

当向 TreeSet 集合中添加第一个元素时，这个元素可以没有实现 Comparable 接口，因为只有一个元素时，无须进行比较，也就不用调用当前元素的 compareTo() 方法，但这不是一种好做法，当试图从 TreeSet 中取出元素时，会引发 ClassCastException 异常。而又因为只有相同类的两个实例才会比较大小，所以 TreeSet 只能添加同一种类型的对象，否则依然会引发 ClassCastException 异常。

总结一下就是，当把一个对象加入 TreeSet 集合时，TreeSet 调用该对象的 compareTo(Object obj) 方法与容器中的其他对象比较大小，然后根据红黑树结构找到它的存储位置。如果两个对象通过 compareTo(Object obj) 方法比较相等，则新对象将无法添加到 TreeSet 集合中。

定制排序：如需实现定制排序，例如降序排序，则可通过 Comparator 接口 (函数式接口) 的帮助，该接口包含一个 int compare(T O1, T O2) 方法，使用示例如下：

class M {
    int age;

    public M(int age) {
        this.age = age;
    }

    public String toString() {
        return "M[age: " + age + "]";
    }
}

public class TreeSetTest {
    public static void main(String[] args) {
        //函数式接口，可使用 Lambda 表达式
        TreeSet ts = new TreeSet((o1, o2) -> {
            M m1 = (M) o1;
            M m2 = (M) o2;
            // 年龄大的对象反而小
            return m1.age > m2.age ? -1 : m1.age < m2.age ? 1 : 0;
        });

        // 使用定制排序的添加对象类无须实现 Comparator 接口
        ts.add(new M(5));
        ts.add(new M(-3));
        ts.add(new M(9));
        System.out.println(ts);
    }
}

// 输出:
// [M[age: 9], M[age: 5], M[age: -3]]

HashSet、TreeSet 性能分析

HashSet 的性能总是比 TreeSet 好 (特别是最常用的添加、查询元素等操作)，因为 TreeSet 需要额外的红黑树算法来维护集合元素的次序。只有当需要一个保持排序的 Set 时，才应该使用 TreeSet，否则都应该使用 HashSet。

HashSet 还有一个子类：LinkedHashSet，对于普通的插入、删除操作，LinkedHashSet 比 HashSet 要略微慢一点，这是由于维护链表所带来的额外开销造成的，但由于有了链表，遍历 LinkedHashSet 会更快。

由于 Set 的 HashSet、TreeSet 这两个实现类都是线程不安全的，因此可以通过 Collections 工具类的 synchronizedSortedSet 方法来「包装」该 Set 集合，使用语法如下：

SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));

List 集合

List 集合判断两个对象相等的标准是通过 equals() 方法返回 true 即可。

class A {
    public boolean equals(Object obj) {
        return true;
    }
}

public class ListTest {
    public static void main(String[] args) {
        List books = new ArrayList();
        book.add(new String("itsCoder"));
        book.add(new String("Java"));
        book.add(new String("Kotlin"));
        System.out.println(books);
        // String 类的 equals 方法比较字符串序列值，删除成功
        books.remove(new String("Kotlin"));
        System.out.println(books);
        // 删除 A 对象，将导致第一个元素被删除
        books.remove(new A());
        System.out.println(books);
    }
}

// 输出：
// [itsCoder, Java, Kotlin]
// [itsCoder, Java]
// [Java]

Java 8 为 List 集合增加了 sort() 和 replaceAll() 两个常用的默认方法，其中 sort() 方法需要一个 Comparator (函数式接口) 对象来控制元素排序，而 replaceAll() 方法则需要一个 UnaryOperator (函数式接口) 来替换所有集合元素。

public class ListTest {
    public static void main(String[] args) {
        List books = new ArrayList();
        book.add(new String("itsCoder"));
        book.add(new String("Java"));
        book.add(new String("Kotlin"));
        book.add(new String("JavaScript"));
        System.out.println(books);

        books.sort((o1, o2) -> ((String) o1).length() - ((String) o2).length());
        System.out.println(books);

        books.replaceAll(ele -> ((String) ele).length());
        System.out.println(books);
    }
}

// 输出：
// [itsCoder, Java, Kotlin, JavaScript]
// [java, Kotlin, itsCoder, JavaScript]
// [4, 6, 8, 10]

List 与 Set 只提供了一个 iterator() 方法不同，此外还提供了一个 listIterator() 方法，该方法返回一个 ListIterator 对象，ListIterator 接口继承了 Iterator 接口，在其基础上增加了几个专门操作 List 的方法：

boolean hasPrevious(): 返回该迭代器关联的集合是否还有上一个元素。
Object previous(): 返回该迭代器的上一个元素。
void add(Object o)：在指定位置插入一个元素。

即 List 集合可实现向前迭代功能，并且在迭代期间可执行 add 操作并生效。

ArrayList 和 Vector 实现类

二者都是基于数组实现的 List 类，即封装了一个动态的、允许再分配的 Object[] 数组。其对象使用 initalCapacity 参数来设置该数组长度，当添加元素超出时，该参数自动增加。在创建空的这两个集合时不指定 initalCapacity 参数，则其数组默认长度为 10。

如果要向集合中添加大量元素的话，可使用 void ensureCapacity(int minCapacity) 方法一次性地增加 initalCapacity 大小，以减少重分配次数，提高性能。

同时，还提供了 void trimToSize() 方法用来调整数组长度为当前元素个数，减少集合对象占用的存储空间。

ArrayList 和 Vector 在用法上几乎完全相同，但由于 Vector 是一个古老的集合 (从 JDK 1.0 就有了)，那时候 Java 还没有提供系统的集合框架，这就使得 Vector 里提供了一些方法名很长的方法，例如 addElement(Object obj)，实际上这个方法与 add(Object obj) 没有任何区别。从 JDK 1.2 后，Java 提供了系统的集合框架，就将 Vector 改为实现 List 接口，作为 List 的实现之一，从而导致 Vector 里有一些方法功能重复。(实际上，Vector 具有很多缺点，通常尽量少用 Vector 实现类)

此外，还有一个显著的区别就是，ArrayList 是线程不安全的，而 Vector 集合是线程安全的 (也因此 Vector 的性能比 ArrayList 的性能要低)，同样地，使用 Collections 工具类也可以将 ArrayList 变成线程安全的。

Vector 还提供了一个 Stack 子类，用于模拟「栈」这种数据结构，由于 Stack 继承了 Vector，因此它也是一个非常古老的 Java 集合类，它同样是线程安全的、性能较差的，应尽量少用 Stack 类，如需使用「栈」这种数据结构，可以考虑 ArrayDeque (既实现了 List 接口 —— 「底层基于数组实现，性能也很好」，也实现了 Deque 接口 —— 「可以作为栈来使用」)。

Queue 集合

Queue 是用于模拟队列这种数据结构，队列即通常指「先进先出」的容器。Queue 接口有一个 PriorityQueue 实现类。此外，Queue 还有一个 Deque 接口，Deque 代表一个「双端队列」，可当成队列使用，也可当成栈使用，Java 为 Deque 提供了 ArrayDeque 和 LinkedList 两个实现类。

PriorityQueue 实现类

PriorityQueue 是一个『比较标准』(而非绝对标准) 的队列实现类，因为该队列保存元素的顺序并不是按加入队列的顺序，而是按队列元素的大小进行重新排序，所以当调用 peek() 方法或 poll() 方法取出元素时，并不是最先进入的那个元素，而是最小的那一个。从这来看，它已经违反了队列最基本的规则：先进先出。

class PriorityQueueTest {
    public static void main(String[] args) {
        PriorityQueue pq = new PriorityQueue();
        pq.offer(6);
        pq.offer(-3);
        pq.offer(20);
        pq.offer(18);
        System.out.println(pq.poll());
        System.out.println(pq.poll());
        System.out.println(pq.poll());
        System.out.println(pq.poll());
    }
}

// 输出：
// -3
// 6
// 18
// 20

当然，PriorityQueue 有两种排序方式：自然排序和定制排序，其要求及方法与前面介绍的 TreeSet 一致。

ArrayDeque 实现类

ArrayDeque 从名称就可看出，它是一个基于数组实现的双端队列，创建 Deque 时同样可指定一个 numElements 参数，该参数用于指定 Object[] 数组的长度，如果不指定，默认 Deque 底层数组的长度为 16。当程序中需要使用「栈」这种数据结构时，尽量避免使用 Stack，推荐使用 ArrayDeque，但同时，它不仅可以作为栈使用，不要忘了，最基本的，它还可以当成队列使用。

LinkedList 实现类

LinkedList 类是 List 接口的实现类，这意味着它是一个 List 集合，可以根据索引来随机访问集合元素，同时，它还实现了 Deque 接口，这意味着它也能当成双端队列来使用，因此，它既能当作「栈」来使用，也能当作「队列」来使用。这是一个功能十分强大的集合类。

LinkedList 内部以链表的形式来保存元素，其随机访问集合元素性能相比 ArrayList、ArrayDuque 这类以数组形式存储元素的集合类要差，但在插入、删除元素时性能比较出色。而 Vector 虽然也是以数组形式存储元素，但因其实现了线程同步功能 (而且实现机制也不好)，所以各方面性能都比较差。

Map 集合

Map 用于保存具有映射关系的数据，因此 Map 集合里保存着两组值，一组值用于保存 Map 里的 key，另一组用于保存 value，key 和 value 都可以是任何引用类型的数据。

Map 的 key 不允许重复，任何两个 key 通过 equals 方法比较总是返回 false，如果把 Map 里的所有 key 放在一起来看，它们就组成了一个 Set 集合 (所有的 key 没有顺序，不能重复)。其实 Map 的实现类和子接口中的 key 集的存储形式和对应 Set 集合中元素的存储形式完全相同。

Set 与 Map 间的关系非常密切，如果把 key-value 对中的 value 当成 key 的附庸，就可以像对待 Set 一样来对待 Map 了。而事实上 Map 提供了一个 Entry 内部类来封装 key-value 对，而计算 Entry 存储时则只考虑 Entry 封装的 key。从 Java 源码来看，Java 是先实现了 Map，然后通过包装一个所有 value 都为 null 的 Map 就实现了 Set 集合。

从另一个角度来看，如果把 Map 里的所有 value 放一起来看，它们又像一个 List：元素可重复，可通过索引来查找，只不过 Map 中的索引不再使用整数值，而是以另一个对象作为索引，即 key 索引。所以，Map 有时也被称为「字典」或者「关联数组」。

Map 集合最经典的用法就是成对地添加、删除 key-value 对，当添加 key-value 对时，如果 Map 中已有重复的 key，那么新添加的 value 会覆盖该 key 原来的 value 值，该方法将返回被覆盖的 value 值。

HashMap 和 Hashtable 类

二者都是 Map 接口的典型实现类，它们之间的关系完全类似于 ArrayList 和 Vector 的关系 (同 Vector 一样，Hashtable 也是一个从 JDK 1.0 就已经出现的古老的 Map 实现类，『甚至于它的命名都没遵守 Java 的命名规范…』)。

Hashtable 是一个线程安全的 Map 实现，HashMap 是线程不安全的实现，但也因此性能高于 Hashtable。

Hashtable 不允许使用 null 作为 key 和 value，否则引发空指针异常，但 HashMap 可以使用 null 作为 key 或 value。

Properties 读写属性文件

Properties 类是 Hashtable 类的子类，可以把 Map 对象和属性文件关联起来。由于属性文件里的属性名、属性值只能是字符串类型，所以 Properties 相当于一个 key、value 都是 String 类型的 Map。

SortedMap 接口和 TreeMap 实现类

二者关系同 SortedSet 接口和 TreeSet 实现类一样。

WeakHashMap 实现类

与 HashMap 类似，区别在于 HashMap 的 key 保留了对实际对象的强引用，只要该 HashMap 对象不被销毁，该 HashMap 的所有 key 引用的对象就不会被垃圾回收，HashMap 也不会自动删除这些 key 所对应的 key-value 对。

而 WeakHashMap 的 key 只保留了对实际对象的弱引用，这些 key 所引用的对象可能被垃圾回收，WeakHashMap 会自动删除该 key 对应的 key-value 对。

WeakHashMap whm = new WeakHashMap();
whm.put(new String("Sun"), new String("sun"));
whm.put(new String("Mon"), new String("rain"));
whm.put(new String("Tue"), new String("wind"));
whm.put("Fri", new String("sun"));
System.out.println(whm);
// 通知系统垃圾回收
System.gc();
System.runFinalization();
System.out.println(whm);

// 输出 (一般情况下第二次输出就只有一个键值对):
// {Sun=sun, Mon=rain, Tue=wind, Fri=sun}
// {Fri=sun}

IdentityHashMap 实现类

实现机制与 HashMap 类似，但它在处理两个 key 相等时判断机制不同，只有当两个 key 严格相等时 (key1 == key2)，才认为二个 key 相等，而对于普通 HashMap 而言，只要 equals() 方法返回 true 以及二者 hashCode 值相等即可。

泛型

Java 增加泛型支持很大程度上是为了让集合能记住元素的数据类型。在没有泛型之前，把一个对象「丢进」集合中，集合就会忘记对象类型，把所有对象当成 Object 类型处理，当需要取出时需要进行强制类型转换，不仅使代码臃肿，而且容易引发 ClassCastExeception 异常。

泛型设计的原则：只要代码在编译时没有出现警告，就不会遇到运行时 ClassCastException 异常。

泛型语法

在 Java 5 后引入了「参数化类型」即「泛型」，其语法为：

List<String> strList = new ArrayList<String>();

但 Java 7 后，简化了语法，无须在构造器后带泛型信息，可自动推断，被称之为「菱形语法」：

List<String> strList = new ArrayList<>();

类型通配符

如果 Foo 是 Bar 的一个子类或子接口，而 G 是具有泛型声明的类或接口，G<Foo> 并不是 G<Bar> 的子类型

为了表示各类泛型 List 的父类，可以使用类型通配符，将一个 ? 作为类型实参传给 List 集合，语法为：List<?> (意为元素类型未知的 List)。这个 ? 被称为通配符。

看下面一个例子 (Foo 是 Bar 的一个子类或子接口)：

public void test(List<Bar> barList) {
    for (Bar bar : barList) {
        ...
    }
}

List<Foo> fooList = new ArrayList<>();
test(fooList);

由于 List<Foo> 并不是 List<Bar> 的子类型，上述代码将引发编译错误。为了表示 List<Foo> 的父类，可以考虑使用 List<?> 通配符来表示所有类型。

public void test(List<?> barList) {
    for (Object obj : barList) {
        Bar bar = (Bar) obj;
        ...
    }
}

List<Foo> fooList = new ArrayList<>();
test(fooList);

但是这种实现方法显得臃肿繁琐，使用了泛型还要进行强制类型转换，通过设定通配符上限用以解决此类问题。

public void test(List<? extends Bar> barList) {
    for (Bar bar : barList) {
        ...
    }
}

List<Foo> fooList = new ArrayList<>();
test(fooList);

对应的，有通配符上限就有通配符下限，语法为 <? super SubClass>。

泛型方法

先引出一个问题，下面方法将一个 Object 数组所有元素添加至 Collection 集合：

static void fromArrayToCollection(Object[] a, Collection<Object> c) {
    for (Object o : a) {
        c.add(o);
    }
}

但是这个方法功能有限，它只能将 Object[] 数组的元素复制到元素为 Object (其子类也不行) 的 Collection 集合中：

String[] str = {"a", "b"};
List<String> strList = new ArrayList<>();
// 引发编译错误
fromArrayToCollection(str, strList);

上述方法的参数类型不能使用 Collection，即使使用通配符 Collection<?> 也不行，因为 Java 不允许把对象放进一个未知类型的集合中，Java 5 提供的泛型方法即可解决这个问题。

static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
    for (T o : a) {
        c.add(o);
    }
}

泛型方法的语法为：类型形参声明放置于方法修饰符和方法返回值类型之间。

异常处理

Java 将异常分为两种，Checked 异常和 Runtime 异常，并认为 Checked 异常都是可以在编译阶段被处理的异常，所以它强制要求程序处理所有的 Checked 异常，而 Runtime 异常则无须处理。

异常捕获处理应先处理小异常，再处理大异常。

声明抛出异常

使用 throws 声明抛出异常，表示当前方法不知如何处理这种类型的异常，并交由上一级调用者处理，若 main 方法也不知如何处理，通过 throws 声明抛出异常后，将交由 JVM 处理，即打印异常的跟踪栈信息，并终止程序运行。

调用声明抛出异常的方法时，要么将该方法放在 try 块中显式捕获该异常，要么放在另一个带 throws 声明抛出的方法中。

public class ThrowsTest {
    public static void main(String[] args) throws Exception {
        test();
    }

    public static void test() throws IOException {
        FileInputStream fis = new FileInputStream("a.txt");
    }
}

throws 声明抛出只能在方法签名中使用

多异常捕获

Java 7 提供了多异常捕获，一个 catch 块可以捕获多种类型的异常，各类异常用 | 分隔，但要注意捕获多种异常时，异常变量有隐式的 final 修饰，因此程序不能对异常变量重新赋值。

try {
    ...
} catch(IndexOutOfBoundsException|NumberFormatException|ArithmeticException ie) {
    // 以下代码错误，多异常捕获其异常变量默认有 final 修饰
    ie = new ArithmeticException("test");
} catch(Exception e) {
    // 单异常捕获，异常变量没有 final 修饰，代码正确
    e = new RuntimeException("test");
}

自动关闭资源的 try 语句

Java 7 增强了 try 语句功能，使得无须手动在 finally 块中显式关闭一些资源，这种增强型的 try 语句相当于包含了隐式的 finally 块。其语法是在 try 后紧跟圆括号，里面可以声明、初始化一个或多个资源 (即需要在程序结束时显式关闭的资源，如数据库、网络连接等)，try 语句在该语句结束时自动关闭这些资源。

public class AutoCloseTest {
    public static void main(String[] args) throws IOException {
        try (
            BufferedReader br = new BufferedReader(new FileReader("AutoCloseTest.java"));
            PrintStream ps = new PrintStream(new FileOutputStream("a.txt"));
            ) {
                System.out.println(br.readLine());
                ps.println("itsCoder");
            }
    }
}

需要指出的是，为保证 try 语句可以正常关闭资源，这些资源实现类必须实现了 AutoCloseable 接口或其子接口 Closeable，即实现其接口的 close() 方法，而 Closeable 接口里的 close() 方法声明抛出了 IOException 异常，因此它的实现类在实现 close() 时只能声明抛出 IOException 或其子类，而 AutoCloseable 接口里的 close() 方法声明抛出 Exception 异常，因此它的实现类在实现 close() 时可声明抛出任何异常。

Java 7 几乎把所有的「资源类」进行了改写，都实现了 AutoCloseable 或 closeable 接口。

注解

Annotation (即注解) 为代码里的一种特殊标记，这种标记可以在编译、类加载、运行时被读取，并执行相应的处理。通过使用注解，可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者部署。

Annotation 不影响程序代码的执行，无论增加、删除 Annotation，代码都始终如一地执行。如果希望让程序中的 Annotation 在运行时起一定的作用，只有通过某种配套的工具对 Annotation 中的信息进行访问和处理，访问和处理 Annotation 的工具统称 APT (Annotation Processing Tool)。

自定义注解

定义一个注解使用 @interface 关键字，与定义一个接口类似：

// 定义一个 @Test 注解
public @interface Test {

}

public class MyClass {
    // info() 方法使用 @Test 注解
    @Test
    public void info() {
        ...
    }
}

如果注解带有成员变量，其声明方式同接口声明方法类似，方法名代表变量名，返回值类型代表变量类型。而一旦指定成员变量，使用该注解时就应该指定相应的值，除非使用 default 指定了默认初始值：

public @interface MyTag {
    String name();
    int age() default 18;
}

public class MyClass {
    @MyTag(name="showzeng")
    public void info() {
        ...
    }
}

Java 根据有无定义成员变量将注解分为两类：

类别	有无定义成员变量	作用
标记 Annotation	无	利用自身的存在与否来提供信息
元数据 Annotation	有	可以接收更多的元数据进行一些操作

基本注解

Java 提供了 5 个基本的注解，其中 @SafeVarargs 是 Java 7 新增的，@FunctionalInterface 是 Java 8 新增的，这 5 个基本的注解都定义在 java.lang 包下。

注解名	作用
@Override	强制子类必须覆盖父类方法，注解会告诉编译器检查这个被注解的方法，保证父类一定包含了该方法重写的方法，以避免一些如方法签名及方法名拼写错误等低级错误
@Deprecated	标识此方法已经过时，会引发编译器的警告
@SuppressWarnings	抑制一些编译器警告，其中有一个 value 成员变量
@SafeVarargs	抑制堆污染警告
@FunctionalInterface	为 Java 8 的 Lambda 表达式所准备的，检查是否为规范的函数式接口

当 Annotation 的成员变量名为 value 时，可以直接在 Annotation 后的括号里指定该成员变量的值，无须使用「name=value」的形式

// 关闭整个类里的编译器警告，两种用法均可
// @SuppressWarnings("unchecked")
@SuppressWarnings(value="unchecked")
public class Test {
    ...
}

JDK 的元 Annotation

JDK 除了提供有 5 个基本注解外，还在 java.lang.annotation 包下提供了 6 个 Meta Annotation (元 Annotation)，所谓元注解，就是用来修饰其他自定义注解的注解。

注解名	value 成员变量值	作用
@Retention	RetentionPolicy.CLASS	默认值，该注解被记录在 class 文件中，运行 Java 程序时，JVM 不可获取注解信息
-	RetentionPolicy.RUNTIME	注解记录在 class 文件中，运行时 JVM 可获取注解信息，程序可通过反射来获取注解信息
-	RetentionPolicy.SOURCE	只保留在源代码中，编译器直接丢弃这种注解
@Target	ElementType.ANNOTATION_TYPE	指定该注解只能用来修饰注解
-	ElementType.CONSTRUCTOR	指定该注解只能用来修饰构造器
-	ElementType.FIELD	指定该注解只能用来修饰成员变量
-	ElementType.LOCAL_VARIABLE	指定该注解只能用来修饰局部变量
-	ElementType.METHOD	指定该注解只能用来修饰方法定义
-	ElementType.PACKAGE	指定该注解只能用来修饰包定义
-	ElementType.PARAMETER	指定该注解只能用来修饰参数
-	ElementType.TYPE	指定该注解可以修饰类、接口 (包括注解)或枚举定义
@Documented	-	指定该注解将被 javadoc 工具提取成文档
@Inherited	-	指定该注解修饰的类，其子类将默认继承该注解
@Repeatable	-	指定该注解可重复修饰程序元素

例如，定义一个自定义注解，该注解用来修饰成员变量，并能够保留到运行时，通过反射获取信息：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BindView {
    int value();
}

public class Activity {
    @BindView(R.id.btn_login)
    Button buttonLogin;

    ...
}

重复注解

重复注解是 Java 8 新增的一个特性，在此前同一个程序元素最多只能使用一个相同类型的注解，如果需要使用多个，必须使用「Annotation 容器」，例如在 Struts 2 开发中，需在 Action 类上使用多个 @Result 注解：

@Results({@Result(name="failure", location="failed.jsp"),
        @Result(name="success", location="succ.jsp")})
public Action FooAction { ... }

其实重复注解也是使用注解容器，只是简化了使用时的写法。在使用 @Repeatable 修饰注解成为可重复注解时，必须为 value 成员变量指定值，该成员变量值即为「容器注解」—— 该容器注解可包含多个当前注解，如下示例所示：

// 可重复注解 @MyTag
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Repeatable(MyTags.class)
public @interface MyTag {
    String name() default "itsCoder";
    int age();
}

// @MyTag 的注解容器
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyTags {
    MyTag[] value();
}

// 使用可重复注解 @MyTag 修饰程序元素，写法简化
@MyTag(age=3)
@MyTag(name="showzeng", age=18)
public class Test { ... }

提取注解信息

使用注解修饰了类、方法、成员变量等成员后，注解不会自己生效，必须由开发者提供相应的工具来提取并处理注解信息。

Java 使用 Annotation 接口来代表程序元素面前的注解，该接口是所有注解的父接口。在 java.lang.reflect 包下主要包含一些实现反射功能的工具类。

而从 Java 5 开始，java.lang.reflect 包提供的反射 API 增加了读取运行时 Annotation (定义时使用了 @Retention(RetentionPolicy.RUNTIME) 修饰) 的能力，此外还新增了 AnnotatedElement 接口，该接口代表程序中可以接受注解的程序元素，主要有以下几个实现类：

Class：类定义
Constructor：构造器定义
Field：类的成员变量定义
Method：类的方法定义
Package：类的包定义

也由于 AnnotatedElement 接口是所有程序元素 (如 Class、Method、Constructor 等) 的父接口，所以程序可通过反射来获取某个类的 AnnotatedElement 对象 (如 Class、Method、Constructor 等) 之后，调用该对象的一些方法来访问注解信息。

方法	作用
<A extends Annotation> A getAnnotation(Class<A> annotationClass)	返回该程序元素上存在的指定类型的注解，不存在返回 null
<A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass)	Java 8 新增方法，获取直接修饰该程序元素、指定类型的注解，不存在返回 null
Annotation[] getAnnotations()	返回该程序元素上存在的所有注解
Annotation[] getDeclaredAnnotations()	返回直接修饰该程序元素的所有注解
boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)	判断该程序元素上是否存在指定类型的注解
<A extends Annotation> A[] getAnnotationsByType(Class<A> annotationClass)	与 getAnnotation() 方法相似，但因 Java 8 新增了重复注解功能，需使用此方法获取修饰该程序元素、指定类型的多个注解
<A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotionClass)	与 getDeclaredAnnotations() 方法相似，同理同上

下面是一个提取『Button id』的例子：

// ~/annotationtest/BindView.java
import java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BindView {
    int value();
}

// ~/annotationtest/Activity.java
import java.lang.annotation.*;

public class Activity {

    @BindView(18)
    Button button;

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Annotation[] annotationArray = Class.forName("Activity").getDeclaredField("button").getAnnotations();
        for (Annotation annotation : annotationArray ) {
            if (annotation instanceof BindView) {
                System.out.println("Button's id is: " + ((BindView) annotation).value());
            }
        }
    }
}

class Button { }

编译运行可得以下结果：

➜ annotationtest $ javac Activity.java BindView.java
➜ annotationtest $ java Activity                    
Button's id is: 18

编译时处理注解

很多时候运行时通过反射来获取注解，并进行一些处理，性能可能不是很好，如果在编译时就对注解进行一些操作是不是就要好一些呢。Java 的编译工具 javac 有一个 -processor 选项，用于指定一个「注解处理器」，那么我们就可以通过自定义一个注解处理器来实现在编译时对注解进行处理操作，用来生成源文件或其他的附属文件等。要实现一个注解处理器需要实现 javax.annotation.processing 包下的 Processor 接口，不过实现该接口需实现的方法过多，所以通常会采用继承 AbstractProcessor 的方式来实现注解处理器。

在编译时处理的注解，就不需要同反射一样存留时间保持到运行时，只需要在源文件中存留即可：

@Retention(RetentionPolicy.SOURCE)

同时，注解处理器是通过 RoundEnvironment 来获取注解信息的，具体使用方法可查阅官方文档。

外链测试

Sat, 25 Aug 2018 07:12:52 +0000

在博客中有时候我们会想要插入一些外链来丰富博客的内容，比如音乐、视频等，这篇博客尽可能多地加入和测试这些外链，并优化其在博客中的样式及排版。

音乐

网易云音乐

但需要注意的是，生成的外链代码粘贴到文章里时，需要为宽高的数值加上引号，不然解析时会被当成文本处理，如下：

<!-- before -->
<iframe frameborder="no" border="0" marginwidth="0"
 marginheight="0" width=330 height=86
  src="//music.163.com/outchain/player?type=2&id=4340800&auto=1&height=66">
</iframe>

<!-- after -->
<iframe frameborder="no" border="0" marginwidth="0"
 marginheight="0" width="330" height="86"
 src="//music.163.com/outchain/player?type=2&id=4340800&auto=1&height=66">
</iframe>

当然，你会发现很多歌曲因为版权保护无法生成外链，其实想要引用，办法还是有的，但是因为涉及版权问题，这里就不讨论了，自己研究去吧 :p

视频

Youtube

Youtube 的嵌入代码直接使用就可以了 (当然，前提是需要科学上网 :unamused:)。

优酷视频

通过 iframe 引入时，同样需要修改一下格式，例如加上引号等 (如果觉得太小，可以给视频类的宽度设为 100%)，如下：

<!-- before -->
<iframe height=498 width=510
 src='https://player.youku.com/embed/XMzA0MTU5MzQ1Ng=='
 frameborder=0 'allowfullscreen'></iframe>

<!-- after -->
<iframe height="498" width="100%"
 src='https://player.youku.com/embed/XMzA0MTU5MzQ1Ng=='
 frameborder="0" allowfullscreen></iframe>

如果是通过 embed 引入的，需要浏览器启用 flash，同时去掉闭合标签及设置宽度等，如下：

<!-- before -->
<embed src='https://player.youku.com/player.php/sid/XMzA0MTU5MzQ1Ng==/v.swf'
 allowFullScreen='true' quality='high'
 width='480' height='400' align='middle'
 allowScriptAccess='always' type='application/x-shockwave-flash'></embed>

<!-- after -->
<embed src='https://player.youku.com/player.php/sid/XMzA0MTU5MzQ1Ng==/v.swf'
 allowFullScreen='true' quality='high'
 width='100%' height='400' align='middle'
 allowScriptAccess='always' type='application/x-shockwave-flash'>

腾讯视频

使用方法和上面是一样的，如下：

<!-- before -->
<iframe frameborder="0" width="640" height="498"
 src="https://v.qq.com/iframe/player.html?vid=p03251eyz0k&tiny=0&auto=0"
 allowfullscreen></iframe>

<!-- after -->
<iframe frameborder="0" width="100%" height="498"
 src="https://v.qq.com/iframe/player.html?vid=p03251eyz0k&tiny=0&auto=0"
 allowfullscreen></iframe>

bilibili

B 站的嵌入代码可以给它加个宽高，不至于那么小，如下：

<!-- before -->
<iframe src="//player.bilibili.com/player.html?aid=19388000&cid=31616791&page=1"
 scrolling="no" border="0" frameborder="no"
 framespacing="0" allowfullscreen="true">
</iframe>

<!-- after -->
<iframe width="100%" height="498"
 src="//player.bilibili.com/player.html?aid=19388000&cid=31616791&page=1"
 scrolling="no" border="0" frameborder="no"
 framespacing="0" allowfullscreen="true">
</iframe>

爱奇艺

使用如下：

<!-- before -->
<embed src="//player.video.qiyi.com/dfa6fe2093c348e79481c44ac0f3e6b6/0/0/v_19rrg5wb8o.swf-albumId=137671300-tvId=137671300-isPurchase=false-cnId=5"
 allowFullScreen="true" quality="high"
 width="480" height="350" align="middle"
 allowScriptAccess="always" type="application/x-shockwave-flash"></embed>

<!-- after -->
<embed src="//player.video.qiyi.com/dfa6fe2093c348e79481c44ac0f3e6b6/0/0/v_19rrg5wb8o.swf-albumId=137671300-tvId=137671300-isPurchase=false-cnId=5"
 allowFullScreen="true" quality="high"
 width="100%" height="350" align="middle"
 allowScriptAccess="always" type="application/x-shockwave-flash">

总体看起来，(不用看了) Youtube 使用体验最佳，而且在使用嵌入代码之前还可以进行一些设置，可惜的是它不在『我方包围圈』，次之，国内的来看，还是要优酷的要清爽一些。当然，此外肯定还有很多其他视频平台提供分享的，使用方法都是一样的，就不一一列举了。

推文

Twitter

Hawaiia’n sea turtles | Photography by Chad Koga pic.twitter.com/dt7zmKWK0b
— Earth Pics 🌎 (@earthescope) 2018年8月24日

在博客中也是可以嵌入推特推文的，只需从推文处获取嵌入代码即可，当然，需要科学上网，国内环境是会被解析成引用块。

暂时就想到这么多啦，如果你还有什么外链嵌入代码以上没有提及的，欢迎与我联系。

新的主题 Minimalism

Fri, 17 Aug 2018 11:03:28 +0000

回忆

想起来第一次搭建博客的时候还是大一 (2016/5/5)，那时候觉得有一个自己的博客还是一件挺酷的事，就决定自己也要搭一个博客。那时候网上一搜，就是挺多 Hexo 框架搭建博客的教程，也就跟着弄了，选了一个觉得还不错的主题，跟着配置的教程捣鼓着，想着怎么样让自己的博客更漂亮。那时候也不知道写点啥，一个是自己接触编程时间也不久，很多也只是入门阶段，所以当时萌生了一个写写学校教的一些和软件相关的课程总结的想法，或许还能给学弟学妹看看呢。所以现在能看到初期写了几篇数据结构的文章，不过后来就没有执行下去了。主要是觉得自己写的东西很浅显，都是一些课本上的概念性的东西，所以就感觉没有写下去的必要了。后来的很长一段时间，都会想把以前写的一些文章删掉，就好像是把一些不好的东西扔掉一样，但是又想通了一点东西。不管怎么样，都是自己产出的东西，如果当你回首时，会觉得有些不堪，那说明是自己进步了，全当是一个记录吧。

在之后的一个闷热的夏天 (2016/8/21)，那个时候发现了组织，正式申请加入。之后的一段时间博客才得以有持续的内容输出。其实那时候就对博客的样式不是很满意，Hexo 换了也有四五个主题了，后来看到猴哥的博客，觉得挺好看的，用的 Jekyll 框架，就开始去接触了解了一下。当时就感觉 Jekyll 清晰、简洁、可定制度高，于是就试着自己写个主题试试水了，看了官方文档，也仔细研究了一下猴哥的博客模板，差不多掌握了基本的用法后就开始写了。当时脑海里可能就是各种炫酷的画面吧 :joy: ，不过真轮到自己写页面的时候，发现还挺难的，也不是说代码难以实现，而是设计上脑袋的一片空白，不过后来还是勉强写出来了。下面截两张首页的图纪念一下上一版的博客吧 (本来是录制了屏幕视频的，介于太大了就没上传)。

头像的动画和效果当时是看到 Twitter 的页面，觉得挺不错的，就自己实现了。之后只要是在网上看到什么稀奇好玩的小东西，都会往自己博客上加。这版博客也不能说不好看吧，毕竟自己还是花了点心思，很多细节也都是比较满意，以至于后面还纠结了很长一段时间，是在这个基础上修改，还是直接推翻。

直到后来，想明白了些事，或许长期以来自己所追求的都是些花里胡哨的东西。

博客，还是以文章、内容为主，渐渐地或许就会忘记了博客的本质。也有很多人，搭完博客之后，就再也没有动过笔了。或许就是因为没有优质的内容产出，才会转移到博客页面样式上去，想要以此来弥补？但是就算网站再好看，「没有内容」，顶多也就初见时一句 nb 就完事了。只有优质的内容，在此基础上加以舒服的阅读体验，简洁的设计，这才是博客的加分项。而其实自己一直以来也很喜欢极简主义风格的设计，且这正与博客真正的意义不谋而合，所以就有了 Minimalism 这款极简主义风格的主题。心里有了这个打算后 (当然，诞生这个想法的时候已经是在 2018 年了)，但也没有立马动手，因为脑袋里一直还在构思，而且其实这还持续了挺长一段时间。

排版

排版，可以说是这个主题最为重要的一部分，因为之前说过，博客是基于文章，一个好的排版，对于阅读体验的提升是至关重要的。下面就来说说自己对排版的一些见解和心得。

关于英文排版和中文排版的讨论，曾看过一篇文章 —— 涨姿势！英文排版真得比中文排版好看吗？但是对于其中几个观点并不认同。文章文本段落，中文字体的方正倒显得比英文的「错落感」好看很多，或许他讨论的范围不一样吧，如果是海报设计，一些文本主体，我倒是觉得英文的这种错落感要比中文好。文章段落中的那种「错落」跳跃会让我感觉很不舒服，尤其是涉及到一些较长的字词时，这种跳跃会让人感觉很突兀，所以，我会选择两端对齐。但是，这种做法也是存在弊端的，尤其是做开发的，写文章时难免会有中英文混排 (中英文混排的特殊性，会导致排版上出现很多问题)。因为当设置为两端对齐时，当出现「最后一个字符」长度超越文本行的长度时，会将这个字符排在下一行，而此行多出来的空间将均分给剩余字符。如果是纯中文文本，肯定是不会有太大的问题的，因为每个字所占得字符长度是相同的，不会出现较大的字符长度剩余。而涉及到中英文混排或者纯英文混排时，就必须进行取舍，对于英文，可以选择以每个词为单位进行分割，这样，当「最后一个字符」为长单词时，就会使本行字词间间隔的太远，另一种分割方法是不管字词的整体含义性，而是以字母为单位，到了行尾就强行截断，这一般不是很好的做法，对单词的分割会照成阅读时的断层，需要一定的时间对单词进行拼接。所以，综上所述，最后我推荐的做法是两端对齐，并以字词为分割单位。而至于它的弊端，其实一般来说，碰到那种特别长的单词是很少见的，倒是有时候在写一些文件路径名时，它好像并不会以 / 为分割单位，而是当成了字词的一部分，这就很容易造成较大的空间空余，所以在行文过程中因尽量避免出现这种较长的英文字符，必要时可用代码块来代替说明。

其次是段落或者说文章的宽度，我看到过很多博客类型的网站，往往段落宽度占比非常大，而一旦段落文字又少 (就是经常换行的行文风格，每一换行为一个段落)，整体感觉就非常的松散，而且宽度过长，因为换行时人眼的视距也会变长，这样容易加重视觉的疲劳。所以，一个合理的段落宽度，当然，还有合理的行高，这二者也是很重要的。

最后一个是从 HenCoder 网站所启发的 ——「颜色」。首先，纯黑的字体颜色是不推荐的，这样与白色背景的对比度太高了，可能一般都是使用 #111 或者 #333 的颜色。受 HenCoder 网站启发所吸纳的有两点：一个是文本主体使用 #666 颜色，标题使用 #111，我发现这种 #666 颜色的文本，在白色背景的对比之下，显得非常的舒服，减轻了用户视觉的负担，同时，这与标题形成了对比，这是除去字体大小差异所带来的另一种分明，可以比较好的形成文章结构的划分；另一个就是鼠标选中文本时的颜色，一般默认的都是蓝色，而这种淡黄色有一种荧光笔标记的视觉效果，而且对比度也控制的很好。

这是主题中最主要的排版部分，而 Markdown 的渲染则主要是参考 GitHub 的渲染风格。

页面布局

主题的整体色调就是黑、灰、白，其中还搭配着一些文本渲染样式的蓝、黄。我想怎么简洁怎么来吧，在设计完主页后，就是文章页了，整体布局中只存在着必要的元素，一个导航栏，一个文章列表，一个页脚的版权声明。文章详情页，一般会预留一个返回键，其实我很奇怪，我觉得这个按钮完全没有存在的必要，因为浏览器本身就自带返回等导航键，难道是为了使网站的结构更加清晰？如果少了这个返回键用户就不知道何去何从？为了保留这个引导，我将这个功能加在了文章的标题上，同时用闪烁的下划线来提示其可交互性。其余的就是归档、分类以及关于页面，几乎整个博客的风格都显得克制和简洁，只留下了必要的元素，或许对于一些追求各种「模块」的人来说，会觉得这个主题缺少了一些东西，但是从博客的整体来看，我认为已经具备了一个博客该有的所有东西。

写在最后

这应该是最后一次折腾自己博客的主题了，还是多看看书，写点优质的文章吧。

Markdown 语法及渲染

Sun, 05 Aug 2018 02:11:49 +0000

说明

Jekyll 默认使用 kramdown 来渲染 markdown 类型文件，在 Minimalism 主题中也是使用其默认配置，但在其渲染的基础上自定义了自己的样式，主要参考了 GitHub 的渲染风格。

Markdown 基本语法

:stuck_out_tongue: 可能 Markdown 的基本语法大家都很熟悉了，这里主要还是想展示一下主题对各种格式的渲染效果，况且日常写作中，通常也不会全用得上。

1. 斜体和粗体

使用 * 和 ** 表示斜体和粗体。

示例：

这是 *斜体*，这是 **粗体**。

效果：

这是斜体，这是粗体。

2. 分级标题

标题分 6 级，在行首加 # 以表示不同级别的标题 (H1-H6)，例如：# H1, ## H2, ### H3，#### H4，常用的标题主要就是 1 ~ 3 级，往后标题基本同加粗的效果差不多了。

示例：

# 一级标题

## 二级标题

### 三级标题

#### 四级标题

##### 五级标题

###### 六级标题

效果：

一级标题

二级标题

三级标题

四级标题

五级标题

六级标题

3. 外链接

使用 [描述](链接地址) 为文章增加外链接。

示例：

这是去往 [主题 Minimalism](https://github.com/zoeywoohoo/minimalism) 的链接。

效果：

这是去往主题 Minimalism 的链接。

也可在链接地址后加一个标题，直观效果时鼠标悬停时的文本提示，其语法是链接后加空格和标题文本。

示例：

这是去往 [主题 Minimalism](https://github.com/zoeywoohoo/minimalism "Minimalism") 的链接。

效果 (鼠标悬停在链接上时触发)：

这是去往主题 Minimalism 的链接。

同时外链接还有另一种使用方式，一般是在文末放置链接标注，在文中就直接使用标注。

示例：

文末放置 Minimalism 的链接标注：
[Minimalism]: https://github.com/zoeywoohoo/minimalism

文章中直接使用标注替代链接：
这是我开发的一个新主题 [Minimalism]。

效果：

这是我开发的一个新主题 Minimalism。

此外，在使用链接标注时，可以替换需要显示的链接文本。

示例：

文末放置 Minimalism 的链接标注：
[Minimalism]: https://github.com/zoeywoohoo/minimalism

文章中直接使用标注替代链接：
这是我开发的一个新主题 [Minimalism Theme][Minimalism]。

效果：

这是我开发的一个新主题 Minimalism Theme。

4. 无序列表

使用 * / - / + 表示无序列表。

示例：

* 无序列表项 一
* 无序列表项 二
* 无序列表项 三

效果：

无序列表项一
无序列表项二
无序列表项三

5. 有序列表

使用数字和点表示有序列表。

示例：

有序列表项 一
有序列表项 二
有序列表项 三

效果：

有序列表项一
有序列表项二
有序列表项三

6. 引用

使用 > 表示引用。

示例：

> Less is more. —— 「Andrea del Sarto」

效果：

Less is more. —— 「Andrea del Sarto」

当然，引用也可以嵌套使用。

示例：

> Less is more. —— 「Andrea del Sarto」
>> 万物之始，大道至简，衍化至繁。 —— 『道德经』

效果：

Less is more. —— 「Andrea del Sarto」

万物之始，大道至简，衍化至繁。 —— 『道德经』

7. 行内代码块

使用 `代码` 表示行内代码块。

示例：

让主题 `Minimalism` 成为行内代码块。

效果：

让主题 Minimalism 成为行内代码块。

8. 代码块

使用四个缩进空格表示代码块。

示例：

    这是一个代码块，此行左侧有四个不可见的空格。

效果：

这是一个代码块，此行左侧有四个不可见的空格。

需要指出的是，我并不喜欢和推荐用这种格式来书写，其实这个代码块在主题中就是没有指定代码类型默认的代码块样式 (而指定代码类型使用的是 Prism 官网定制的代码渲染主题，你也可以制作你自己的代码渲染主题并替换博客主题的代码渲染主题，具体请参考博客主题定制文章。)，所以，当你想实现一个代码块效果时，推荐如下用法。

示例：

  
  ```
  这是一个代码块。
  ```

  ```text
  指定代码类型的代码块。
  ```

  ```java
  public class HelloWorld {

      public static void main(String[] args) {
          // Prints "Hello, World" to the terminal window.
          System.out.println("Hello, World");
      }

  }
  ```

效果：

这是一个代码块。

指定代码类型的代码块。

public class HelloWorld {

    public static void main(String[] args) {
        // Prints "Hello, World" to the terminal window.
        System.out.println("Hello, World");
    }

}

9. 插入图像

使用 ![描述](图片链接地址) 插入图像。

示例：

![头像](https://www.z4a.net/images/2017/08/31/shortcut_icon.png)

效果：

同外链接，图片也可在链接地址后加一个标题，直观效果时鼠标悬停时的文本提示，其语法是链接后加空格和标题文本。

示例：

![头像](https://www.z4a.net/images/2017/08/31/shortcut_icon.png "头像")

效果 (鼠标悬停在头像上时触发)：

10. 分隔符

使用 --- 可显示分隔符。

示例：

---

效果：

11. 反转义

使用 \ 可使 Markdown 解析时不会去解析本该属于语法部分的一些符号。

示例：

\`代码块\`

效果：

`代码块`

12. Emoji

主题同样也支持 Emoji 表情，使用方法很简单。

示例：

(Smile) :smile: (Sob) :sob:

效果：

(Smile) :smile: (Sob) :sob:

Emoji 的代码参考 Emoji sheet。

13. 段内换行

在同一段落里让文本换行，只需在上一行末尾加 2 个空格即可。

示例：

这是这个段落的第一行。  
这是同一个段落的第二行。

效果：

这是这个段落的第一行。
这是同一个段落的第二行。

Markdown 高阶语法

1. 删除线

使用 ~~ 表示删除线。

示例：

~~这是一段错误的文本。~~

效果：

~~这是一段错误的文本。~~

2. 注脚

使用 [^keyword] 表示注脚。

示例：

这是第一个注脚 [^footnote1] 的样例。

这是第二个注脚 [^footnote2] 的样例。

对应在文章末尾放置如下，点击效果中的注脚即可跳转至文章末尾的注脚注解。

[^footnote1]: 这是第一个注脚的注解。
[^footnote2]: 这是第二个注脚的注解。

效果：

这是第一个注脚 ¹ 的样例。

这是第二个注脚 ² 的样例。

3. 加强的代码块

使用 Prism 官网定制的代码高亮主题，选择了所有支持的编程语言，你可以定制你自己的语法主题。

非代码示例：


```
$ sudo pacman -S oh-my-zsh-git
```

效果：

$ sudo pacman -S oh-my-zsh-git

Python 示例：


```python
@requires_authorization
def somefunc(param1='', param2=0):
    '''A docstring'''
    if param1 > param2: # interesting
        print 'Greater'
    return (param2 - param1 + 1) or None

class SomeClass:
    pass

>>> message = '''interpreter
... prompt'''
```

效果：

@requires_authorization
def somefunc(param1='', param2=0):
    '''A docstring'''
    if param1 > param2: # interesting
        print 'Greater'
    return (param2 - param1 + 1) or None

class SomeClass:
    pass

>>> message = '''interpreter
... prompt'''

JavaScript 示例：


``` javascript
/**
* nth element in the fibonacci series.
* @param n >= 0
* @return the nth element, >= 0.
*/
function fib(n) {
  var a = 1, b = 1;
  var tmp;
  while (--n >= 0) {
    tmp = a;
    a += b;
    b = tmp;
  }
  return a;
}

document.write(fib(10));
```

效果：

/**
* nth element in the fibonacci series.
* @param n >= 0
* @return the nth element, >= 0.
*/
function fib(n) {
  var a = 1, b = 1;
  var tmp;
  while (--n >= 0) {
    tmp = a;
    a += b;
    b = tmp;
  }
  return a;
}

document.write(fib(10));

4. 表格支持

示例：

| 项目 | 价格 | 数量 |
| -- | -- | -- |
| 计算机 | \$1600 | 5 |
| 手机 | \$12 | 12 |
| 管线 | \$1 | 234 |

效果：

项目	价格	数量
计算机	$1600	5
手机	$12	12
管线	$1	234

表格中的项默认都是左对齐，使用 :--: 和 --: 可设置居中和右对齐。

示例：

| 项目 | 价格 | 数量 |
| -- | :--: | --: |
| 计算机 | \$1600 | 5 |
| 手机 | \$12 | 12 |
| 管线 | \$1 | 234 |

效果：

项目	价格	数量
计算机	$1600	5
手机	$12	12
管线	$1	234

5. 定义型列表

示例：

名词 1
: 定义 1（左侧有一个可见的冒号和空格）

名词 2
: 定义 2（左侧有一个可见的冒号和空格）

效果：

名词 1: 定义 1（左侧有一个可见的冒号和空格）
名词 2: 定义 2（左侧有一个可见的冒号和空格）

6. Html 标签

可在 Markdown 语法中直接嵌套 Html 标签，譬如，你可以用 Html 写一个纵跨两行的表格：

示例：

<table>
    <tr>
        <th rowspan="2">值班人员</th>
        <th>星期一</th>
        <th>星期二</th>
        <th>星期三</th>
    </tr>
    <tr>
        <td>李强</td>
        <td>张明</td>
        <td>王平</td>
    </tr>
</table>

效果：

值班人员	星期一	星期二	星期三
值班人员	李强	张明	王平

7. 待办事项 Todo 列表

使用带有 [ ] 或 [x] (未完成或已完成) 项的列表语法撰写一个待办事项列表，并且支持子列表嵌套以及混用Markdown语法。

示例：

- [ ] **博客改版**
    - [ ] 响应式布局，移动端适配
    - [ ] 多语言支持
    - [x] 主页
    - [x] 文章列表页
    - [ ] 归档页
    - [ ] 关于页
    - [x] 文章详情页
        - [x] 排版
        - [x] Markdown 渲染
        - [x] 代码高亮，使用 [Prism](https://prismjs.com/)
        - [ ] Toc 功能
        - [ ] 评论功能
        - [ ] 打赏功能

- [ ] **Minimalism 主题发布**
    - [ ] 主题编写
    - [ ] 打包发布

效果：

写在最后

本篇博客列举的语法模板部分参考了 Cmd Markdown 编辑阅读器的语法说明 :+1:，感谢。

这是第一个注脚的注解。 ↩
这是第二个注脚的注解。 ↩

Android & 单片机红外开发

Tue, 03 Jul 2018 06:30:29 +0000

效果展示

单片机接收显示发送的用户码和数据码

手机控制单片机 LED

红外简介

红外遥控技术是红外技术、红外通信技术和遥控技术的结合。红外遥控技术一般采用红外光波段内的近红外线，波长在 0.75 ~ 1.5μm 之间。由于红外线的波长较短，对障碍物的衍射能力较差，无法穿透墙壁，所以红外遥控术更适合应用在短距离直线控制的场合，也正是这样，放置在不同房间的家用电器可使用通用的遥控器而不会产生相互干扰。红外遥控所需传输的数据量较小，一般仅为几个至几十个字节的控制码，传输距离一般小于 10 米，广泛应用于电视机、机顶盒、DVD 播放器、功放等家用电器的遥控。通用红外遥控系统主要由发射和接收两大部分组成。发射部分包括单片机芯片或红外遥控发射专用芯片实现编码和调制，红外发射电路实现发射;接收部分包括一体化红外接收头电路实现接收和解调，单片机芯片实现解码。红外遥控发射专用芯片非常多，编码及调制频率也不完全一样。

红外发射原理简介

红外遥控二进制信号的编码。 红外遥控器发射的信号由一串「0」和「1」的二进制代码组成，不同的芯片对「0」和「1」的编码有所不同，通常有曼彻斯特 (Manchester) 编码和脉冲宽度编码 (PWM)。家用电器使用的红外遥控器绝大部分都是脉冲宽度编码，如下图所示。

红外遥控二进制信号的调制。 二进制信号的调制由发送单片机芯片或红外遥控发射专用芯片来完成，把编码后的二进制信号调制成频率为 38kHz 的间断脉冲串，相当于用二进制信号的编码乘以频率为38kHz 的脉冲信号得到的间断脉冲串，即是调制后用于红外发射二极管发送的信号。通用红外遥控器里面常用的红外遥控发射专用芯片载波频率为 38kHz，这是由发射端所使用的 455kHz 陶瓷晶振来决定的。在发射端对晶振进行整数分频，分频系数一般取 12 所以 455kHz ÷ 12 ≈ 37.9kHz ≈ 38kHz。

红外接收原理简介

红外遥控的接收与解调。 红外遥控接收采用一体化红外接收头，它将红外接收二极管、放大、解调、整形等电路集成在一起，具有体积小，抗干扰能力强等优点。红外接收头的封装主要有两种：一种采用铁皮屏蔽、一种是塑料封装。均有三只引脚，即电源正 (VDD) 电源负 (GND) 和数据输出 (VO 或 OUT)。红外接收头的引脚排列因型号不同而不尽相同，可参考厂家的使用说明。红外接收典型应用电路如下图所示。

一体化红外接收头内部电路包括红外监测二极管、放大器、限幅器、带通滤波器、积分电路、比较器等。红外监测二极管监测到红信号，然后把信号送到放大器和限幅器，限幅器把脉冲幅度控制在一定的水平，而不论外发射器和接收器的距离远近。交流信号进入带通滤波器，带通滤波器可以通过 30kHz 到 60kHz 的副载波，通过解调电路和积分电路进入比较器，比较器输出高低电平，还原出发射的信号波形。红外接收头的信号输出端接单片机的外部中断 INT 引脚，单片机外部中断 INT 在红外脉冲下降沿时产生中断。

红外遥控的解码。 二进制信号的解码由接收单片机来完成，它把红外接收头送来的二进制编码波形通过解码，还原出发送端发送的数据。具体流程是单片机在中断期间启动定时器进行计数，直到下一个负脉冲到来将计数结果取出处理。根据其时长来判断信号「0」或「1」，从而还原发送的二进制信号。

NEC 编码协议

在红外开发中，可能最重要的就是发送二进制信号的编码协议了，各个厂家所使用的编码协议不同，所以遥控器也不能相互控制，而即使编码协议相同，使用的用户码不同，也不能被接收端接受。所以类似万能遥控器这种应用，第一个要解决的问题就是各类家用电器，各类厂家所使用的编码协议以及所使用的用户码等。但各类电器众多，这种应用是很难兼容全的，有的大厂家会将自家产品的编码及对应功能键的数据序列公布在网上，方便其他开发者开发，至于其他没有公布的，可能就要使用红外解码仪来破解它所使用的协议以及各功能键对应的数据码等。但这些都是题外话，回到主题，在日常家用电器中，NEC 编码是比较常见的一种编码协议，此次应用就是使用 NEC 编码协议来进行开发的。

通用红外遥控器发出的一串二进制代码按功能可以分为分「引导码、用户码 16 位、数据码 8 位、数据反码 8 位和结束位」，编码共占 32 位，如下图所示。

其中引导码由一个 9ms 的 38kHz 载波起始码和一个 4.5ms 的无载波低电平结果码组成。用户码由低 8 位和高 8 位组成 (用户码高八位和低八位可采用原码与反码的方式，可用于纠错，但也可直接是 16 位的原码方式)，不同的遥控器有不同的用户码，避免不同设备产生干扰，用户码又称为地址码或系统码。数据码采用原码和反码方式重复发送，编码时用于对数据的纠错，遥控器发射编码时，低位在前，高位在后。结束位是 0.56ms 的 38kHz 载波。

而其中的「0」码由 0.56ms 的 38kHz 载波和 0.56ms 的无载波低电平组合而成，脉冲宽度为 1.125ms，「1」码由 0.56ms 的 38kHz 载波和 1.69ms 的无载波低电平组合而成，脉冲宽度为 2.25ms，如下图所示。

Android 端红外发射

对于 Android 上的红外开发，其实「挺简单的」，因为接口就那么几个方法，重点还是编码协议，还是侧重于单片机接收端的开发。Android 上红外是在 4.4 后才开始支持的，其对应的管理类为 ConsumerIrManager，它对应有三个方法：

getCarrierFrequencies()：用于查询获取红外发射器支持可用的载波频率范围

hasIrEmitter()：用于检查该设备是否具有红外发射器

transmit(int carrierFrequency, int[] pattern)：用于发射红外信号，第一个参数为发射的载波频率，第二个参数为红外信号的模式序列

本次应用设定用户码为 2333，采用 NEC 编码协议，其主要代码如下：

@RequiresApi(api = Build.VERSION_CODES.KITKAT)

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    @BindViews({R.id.btn_led1, R.id.btn_led2, R.id.btn_led3, R.id.btn_led4, R.id.btn_led5, R.id.btn_led6})
    List<Button> leds;

    private ConsumerIrManager consumerIrManager;

    // NEC 协议固定引导码 9000,4500 以及结束码 560,20000
    // 用户码 2333 ==> 0010 0011 0011 0011 =(逆序)=> 1100 0100 1100 1100

    // 数据码 01 ==> 0000 0001 =(逆序)=> 1000 0000
    private int[] pattern1 = {
            9000,4500,
            560,1690, 560,1690, 560,560, 560,560, 560,560, 560,1690, 560,560, 560,560,
            560,1690, 560,1690, 560,560, 560,560, 560,1690, 560,1690, 560,560, 560,560,
            560,1690, 560,560, 560,560, 560,560, 560,560, 560,560, 560,560, 560,560,
            560,560, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690,
            560,20000
    };

    // 数据码 02 ==> 0000 0010 =(逆序)=> 0100 0000
    private int[] pattern2 = {
            9000,4500,
            560,1690, 560,1690, 560,560, 560,560, 560,560, 560,1690, 560,560, 560,560,
            560,1690, 560,1690, 560,560, 560,560, 560,1690, 560,1690, 560,560, 560,560,
            560,560, 560,1690, 560,560, 560,560, 560,560, 560,560, 560,560, 560,560,
            560,1690, 560,560, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690,
            560,20000
    };

    // 数据码 03 ==> 0000 0011 =(逆序)=> 1100 0000
    private int[] pattern3 = {
            9000,4500,
            560,1690, 560,1690, 560,560, 560,560, 560,560, 560,1690, 560,560, 560,560,
            560,1690, 560,1690, 560,560, 560,560, 560,1690, 560,1690, 560,560, 560,560,
            560,1690, 560,1690, 560,560, 560,560, 560,560, 560,560, 560,560, 560,560,
            560,560, 560,560, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690,
            560,20000
    };

    // 数据码 04 ==> 0000 0100 =(逆序)=> 0010 0000
    private int[] pattern4 = {
            9000,4500,
            560,1690, 560,1690, 560,560, 560,560, 560,560, 560,1690, 560,560, 560,560,
            560,1690, 560,1690, 560,560, 560,560, 560,1690, 560,1690, 560,560, 560,560,
            560,560, 560,560, 560,1690, 560,560, 560,560, 560,560, 560,560, 560,560,
            560,1690, 560,1690, 560,560, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690,
            560,20000
    };

    // 数据码 05 ==> 0000 0101 =(逆序)=> 1010 0000
    private int[] pattern5 = {
            9000,4500,
            560,1690, 560,1690, 560,560, 560,560, 560,560, 560,1690, 560,560, 560,560,
            560,1690, 560,1690, 560,560, 560,560, 560,1690, 560,1690, 560,560, 560,560,
            560,1690, 560,560, 560,1690, 560,560, 560,560, 560,560, 560,560, 560,560,
            560,560, 560,1690, 560,560, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690,
            560,20000
    };

    // 数据码 06 ==> 0000 0110 =(逆序)=> 0110 0000
    private int[] pattern6 = {
            9000,4500,
            560,1690, 560,1690, 560,560, 560,560, 560,560, 560,1690, 560,560, 560,560,
            560,1690, 560,1690, 560,560, 560,560, 560,1690, 560,1690, 560,560, 560,560,
            560,560, 560,1690, 560,1690, 560,560, 560,560, 560,560, 560,560, 560,560,
            560,1690, 560,560, 560,560, 560,1690, 560,1690, 560,1690, 560,1690, 560,1690,
            560,20000
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);

        initInfrared();
        for (Button led: leds) {
            led.setOnClickListener(this);
        }
    }

    @SuppressLint("DefaultLocale")
    private void initInfrared() {
        consumerIrManager = (ConsumerIrManager) getSystemService(Context.CONSUMER_IR_SERVICE);
        assert consumerIrManager != null;
        if (!consumerIrManager.hasIrEmitter()) {
            Toast.makeText(this, "当前手机不支持红外遥控", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(this, "红外设备就绪", Toast.LENGTH_SHORT).show();
        }
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.btn_led1:
                sendMessage(pattern1);
                break;
            case R.id.btn_led2:
                sendMessage(pattern2);
                break;
            case R.id.btn_led3:
                sendMessage(pattern3);
                break;
            case R.id.btn_led4:
                sendMessage(pattern4);
                break;
            case R.id.btn_led5:
                sendMessage(pattern5);
                break;
            case R.id.btn_led6:
                sendMessage(pattern6);
                break;
        }
    }

    private void sendMessage(int[] pattern) {
        consumerIrManager.transmit(38000, pattern);
        Toast.makeText(this, "发射完成", Toast.LENGTH_SHORT).show();
    }
}

对代码进行简单的分析，其中的 pattern 为红外信号序列的模式，其数值格式对应编码协议，根据协议来设定序列值。比如 NEC 编码协议，首先需要一个引导码表示信号的开始，先是一个 9ms 的 38kHz 载波起始码，再是一个 4.5ms 的无载波低电平结果码，对应 pattern 中，数值单位是 μs，所以是一个 9000 的高电平，再是一个 4500 的低电平。同理「0」码为一个 560 的高电平和一个 560 的低电平，「1」码为一个 560 的高电平和一个 1690 的低电平。而因为信号序列的发送，到接收端，其顺序刚好是相反的 (高电平变低电平，低电平变高电平)，这里发送的信号也需要做逆序处理，以一个字节 (对应 8 位) 为一组。最后以 560 的高电平结束。

单片机端红外接收

至于单片机接收端，不同型号的单片机肯定有所不同，但其核心原理和逻辑还是相同的，只需要参考自己单片机的数据手册做相应变化即可，此次使用的是普中的单片机开发试验仪。根据手册可知，其红外接收器的输出端和中断是相连的，以下降沿方式触发。程序的流程图如下：

主程序首先为初始化逻辑，然后就是不断循环从数据缓冲区中取出数据，并作相应的响应。而中断程序，则是接收信号，如果成功，就将其存入缓冲区中，以供主程序做出响应。为了直观展示效果 (因为这个单片机中的数码管和 LED 的端口是串联在一起的，所以不能同时展示数据值和 LED 的功能)，实验中写了两份代码，一个用于展示接收到来自手机发射的用户码和数据码的值，另一个用于展示控制单片机 LED 的功能。下面以显示用户码和数据码的代码为例，其完整代码如下：

#include "reg52.h"

typedef unsigned char u8;
typedef unsigned int u16;

sbit IRIN = P3^2; // 红外输出口
u8 IrValue[6];  // 数据数组
u8 Time;        // 计时暂存
u8 DisplayData[8];  // 显示数据缓存

u8 code smgduan[17]={
0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0X76};
// 0、1、2、3、4、5、6、7、8、9、A、b、C、d、E、F、H的显示码

// 延时函数，i=1时，大约延时10us
void delay(u16 i) {
    while(i--);
}

// 数码管显示函数
void DigDisplay() {

    u8 i;
    for(i=0; i<8; i++) {
        // 位选，选择点亮的数码管
        switch(i) {
            case(0):
                P2 = 0; break; // 显示第 1 位
            case(1):
                P2 = 1; break; // 显示第 2 位
            case(2):
                P2 = 2; break; // 显示第 3 位
            case(3):
                P2 = 3; break; // 显示第 4 位
            case(4):
                P2 = 4; break; // 显示第 5 位
            case(5):
                P2 = 5; break; // 显示第 6 位
            case(6):
                P2 = 6; break; // 显示第 7 位
            case(7):
                P2 = 7; break; // 显示第 8 位
        }
        P0 = DisplayData[i]; // 发送数据
        delay(100); // 间隔一段时间扫描
        P0 = 0x00;  // 消隐
    }
}


// 初始化红外线接收
void IrInit() {

    IT0=1;  // 下降沿触发
    EX0=1;  // 打开中断0允许
    EA=1;   // 打开总中断

    IRIN=1; // 初始化端口
}


// 主函数
void main() {

    IrInit();
    while(1) {
        DisplayData[0] = smgduan[IrValue[0]/16];    // 用户码高位高半字节
        DisplayData[1] = smgduan[IrValue[0]%16];    // 用户码高位低半字节
        DisplayData[2] = smgduan[IrValue[1]/16];    // 用户码低位高半字节
        DisplayData[3] = smgduan[IrValue[1]%16];    // 用户码低位低半字节
        DisplayData[5] = smgduan[IrValue[2]/16];    // 数据码高半字节
        DisplayData[6] = smgduan[IrValue[2]%16];    // 数据码低半字节
        DisplayData[7] = smgduan[16];
        DigDisplay();
    }
}

// 读取红外数值的中断函数
void ReadIr() interrupt 0 {

    u8 j,k;
    u16 err;
    Time = 0;
    delay(700); // 7ms
    // 确认是否真的接收到正确的信号
    if(IRIN==0) {

        err = 1000; // 1000 * 10μs = 10ms，超过说明接收到错误的信号

        // 当两个条件都为真是循环，如果有一个条件为假的时候跳出循环，免得程序出错的时侯，程序死在这里
        // 等待前面 9ms 的低电平过去
        while((IRIN==0) && (err>0)) {
            delay(1);
            err--;
        }

        // 如果正确等到9ms低电平
        if(IRIN==1)	{
            err=500;
            // 等待 4.5ms 的起始高电平过去
            while((IRIN==1) && (err>0)) {
                delay(1);
                err--;
            }
            // 共有 4 组数据
            for(k=0; k<4; k++) {
                // 接收一组数据
                for(j=0; j<8; j++) {

                    err = 60;
                    // 等待信号前面的 560μs 低电平过去
                    while((IRIN==0) && (err>0)) {
                        delay(1);
                        err--;
                    }
                    err = 500;
                    // 计算高电平的时间长度
                    while((IRIN==1) && (err>0)) {
                        delay(10); // 0.1ms
                        Time++;
                        err--;
                        if(Time>30) {
                            return;
                        }
                    }
                    IrValue[k]>>=1; // k 表示第几组数据
                    // 如果高电平出现大于 565μs，那么是 1
                    if(Time>=8) {
                        IrValue[k]|=0x80;
                    }
                    Time=0; // 用完时间要重新赋值
                }
            }
        }
        // 利用反码判断数据码是否发生错误，如果错误则舍弃
        if(IrValue[2]!=~IrValue[3]) {
            return;
        }
    }
}

简单地解释一下，P2 口控制数码管的位选，P0 口控制数码管的段选，主程序从 IrValue 数据数组中获得相应位的数值并转换为段选码存入显示缓存数值的对应位。然后将各个数码管的数值显示出来，其循环不断的从第一个数码管刷新显示到第八个数码管，如此反复，因为刷新显示的时间很短，而人眼有视觉的滞留效应，所以看起来八个数码管是「静态显示的」。其次中断中，因为低电平的时长都是相同的，「0」码和「1」码不同的是高电平的时长 (发送端的载波信号，原本是高电平相同，低电平时长不同，但接收端刚好是反相的)，所以就粗略地认为，高电平大于 565μs 的为「1」码，低于其值的为「0」码，当 32 位数据接收完后，利用数据码的反码来简单的判断数据码是否发生错误。

而对于 LED 的程序，只需修改主函数的逻辑即可，首先可以判断用户码是否符合预订设置的用户码 (项目中我没有判断用户码)，其次再根据取得的数据码，控制 LED 的亮灭等。对于三个项目的代码，已经上传到 GitHub，有需要的可以在文末链接中自取。

写在最后

其实弄懂了红外的原理后，会发现 (除去底层硬件自己实现) 还是挺简单的，应用层的编写无非就是需要掌握通信的编码协议。拓展思考后，发现给单片机加个 WIFI 模块，或者买个树莓派啥的，完全可以实现在外面用手机控制家里的电器 (使用红外控制的)，比如空调，这就简单的实现了所谓的「智能家居」？

扩展阅读，参考文档

GitHub 项目地址

脉冲宽度编码

NEC Infrared Transmission Protocol

ConsumerIrManager

ZoeyWoohoo

Android 渐变色昵称实现探索

需求场景

设计中的渐变色

Android 中的渐变色

文本画笔着色器

自定义 Span

实现难点

实现探索

实现方案

实现方式

利用 GitHub 搭建个人私有 Maven 仓库

起因

原理

流程

新建一个私人仓库

本地发布 release 包

将发布的包推送到仓库中

项目中引用自己的三方库

(入门指南) 在 Google Cloud 上部署 Maven 私服

创建服务器

连接服务器

安装 Docker

运行 Nexus 容器服务

Android 图标设计 & 使用指南

前言

设计规范

传统图标

自适应图标

图标使用

传统图标

自适应图标

Asset Studio 一键生成

参考文档

Windows 10 快速配置指南

告别

系统篇

软件篇

Rainmeter

Chocolatey

ConEmu

WPS 专业版

Java 基础语法关键点总结

Java 文档

分隔符、标识符和关键字

数据类型

基本类型的类型转换

直接量

运算符

数组类型

数组初始化

foreach 循环

内存中的数组

面向对象

对象的 this 引用

对象访问类成员的陷阱

方法的参数传递机制

形参个数可变的方法

方法重载

静态导入语法

方法重写

类的初始化顺序

自动装箱的特别情形

== 和 equals 方法

final 修饰符

抽象方法和抽象类

自我克隆

Objects 类

String、StringBuffer 和 StringBuilder

集合

HashSet

TreeSet

HashSet、TreeSet 性能分析

List 集合

ArrayList 和 Vector 实现类

Queue 集合

PriorityQueue 实现类

ArrayDeque 实现类

LinkedList 实现类

Map 集合

`==` 和 `equals` 方法