== 十六进制和二进制

log2(16) = 4

我们这里算的是『序列』case 数目，不过我们知道，

2^4 = 16，也就是说，一位 2 case，重复 4 次就可以表示一位 16 case 的情况（或者说，4 位二进制有 16 个 case）

log2(10) 不是整数，所以无法直接将 10 进制和二进制对应，不过 log2(8) 也是整数 3，所以 3 位二进制可以对应一位 8 进制

下面 0x 后面跟随十六进制、0b 后面跟随二进制

所谓 16 个 case 是，四位二进制，按照 <> 里的位为 1 的情况，可以这么与 16 进制对应：

0b <+8> <+4> <+2> <+1>

{} 里的东西可以重复无数遍或者不出现，[] 里的东西是一些字符的区间，用于表示 {} 里重复的字符都在此区间里

0x {[0-9A-Z]}

0-9 A-F 一共是 16 个数字，10 通过 A 表示，11 通过 B 表示，...

因为一般都是这么表示的（简单的二进制加减法）

0xFF : 0b1111_1111
0xFE: 0b1111_1110

0xFE 换算为二进制，直接对每一位写对应的二进制

hexDigitToBinary(0xA) = 0b1010 — +8 +2 = 10
hexDigitToBinary(0xD) = 0b1101 — +8 +4 +1 = 13
hexDigitToBinary(0xE) = 0b1110
hexDigitToBinary(0xF) = 0b1111 — 15

换算回来等同（这本身就是一个双向映射关系）。

== 字节序（ByteOrder）

字节序是一个底层硬件实现的细节，一般分为大端字节序和小端字节序，二者可以互相转化，它是一种二进制数值表示的规格
一旦一个数值类型长过一字节（比如 Java int，4 字节）就会出现字节序的问题

enum ByteOrd { LittleEndian = 0xfffe; BigEndian = 0xfeff }

我们所认为的『大位』（比如 13 里的十位）会被小端放在前面的字节里（所以它是从结束的字节起始一个数值），被大端放在后面的字节里

一般 x86 等 CISC 机器都会使用小端字序、ARM 等 RISC 机器会使用大端字序，大端字序也被称为网络序（因为在计算机网络上传递整型一般使用大端），小端也被称为本地序

最后在铺垫了这么多之后我们可以看看 Java 基本型的位长度了：

所谓基本型就是：

byte short
int long float double
char boolean

== Java 可以对这些『基元类型』进行打包（到 Java Heap，堆上，用于 pass-by-reference 等，一般 int 等类型都是按值复制“传递” pass-by-value 的）

=== 传递和堆上存储

private class Product2 {
  String name, int value;
  public Product2(String name, int value) {...}
}
// invariant over T
private class Product2ParamizedType<T> {
  String name, T value;
  public Product2(String name, T value) {...}
}

public void main(String... args) {
int a = 1;
dowith(a);
out.println(a);
Product2 prod = new Product2("int", a);


// 不得不转换为引用型 Object，因为 Java 的泛型支持是（基于泛型擦除的）假泛型，实际上 Java 编译器不需要让 ParamizedType 类变成字节码模板
// 使用了 Java 1.3 开始的自动值类型装箱和泛型检查语法糖
  Product2ParamizedType<Integer> prod_generic = new Product2ParamizedType<>("int", 2);

}

void dowith(int x) { x = 2; out.println(x); }

Java 运行时，在一个小的视角下非常简单：

一个方法本地表，存储 int a; 这种局部变量，一个方法实例（存在调用栈上的方法）的本地表会在方法结束运行后删除
一个求值栈，用来向被组合的操作传递参数（比如调用 dowith(a);）

有时候不同方法的本地表有重叠（比如参数传递时）不过这里不需要考虑，这是由于运行时优化相关的原因

==== Java 的 Lambda 和本地表这些无关，Java 本身“好像”是支持 Lexical Scoping 的（Lexicalscope 和 Lambda calculus 本身有很大的关系）（因为 Java 支持 Higher-Order function？并不）
Java 的 Lambda 只是匿名内部类的语法糖，而 invokedynamic 和 Lambda 本身没有本质性的联系，只不过是 invokedynamic 必须被用来（在内部实现 Lambda 对象生成时）调用 java.lang.invoke.LambdaMetaFactory 实现 Lambda 的 bootstrap 而已，Google 也有 Runtime desugar 实现，invokedynamic 本身能实现的功能 Reflect 同样也可以实现（通过 java.lang.reflect.Method）
Lambda 里的变量都必须是“effective final”的原因，也正是因为 Lambda out.println(x -> x + 1) 只是匿名内部类 new Object() { @Override boolean equals(Object y) { return true; } } 的语法糖而已，被“capture”的本地变量只是会被复制到被动态生成子类的字段里而已，本身不能被 Lambda 对象操作而改变。

import java.util.Arrays;
import java.util.stream.Collectors;

public static void main(String[] args) {out.println(Arrays.asList(new Integer[] {1,2,3}).stream().map(x -> x + 1).collect(Collectors.toList()));}

==== 相关的还有子程序（包括所谓的各种运算符比如 +-*/）参数求值方式：立即求值（call-by-value）、惰性求值（call-by-name）、每次重新求值（call-by-need）

== 打包后的类型

int.class => java.lang.Integer
short long boolean 什么的依此类推

Arrays.asList(char.class.getClass().getMethods()).stream().filter { it.getName().endsWith("Name") }.collect(java.util.stream.Collectors.toList())

char.class 是个例外： => java.lang.Character

== 长度

byte short int long 的字节长度分别是
1 2 4 8
按位算就是 (*8)
8 16 32 64
float double 分别是 32/64 位 IEEE754 浮点

char 是 16 位 UTF-16 字符 code point 值
boolean 理论上是一位，实现时有人作为 int 实现（虽然也可以作为实际的一位实现，不过有个对齐(alignment)的问题，可以使用类似 bitmask/bitshift 的方法解决，只是硬件的原因），不过值只能是 0 或者 1

== 所以，有长度就有最大最小值

Integer.MAX_VALUE == 0x7F_FF_FF_FF
Integer.MIN_VALUE == -0x80_00_00_00

根据上面的十六进制速记法应该知道
MAX 第一个字节是：0b0111_1111
MIN 的则是：0b1000_0000
可以看到第一位是符号位，不过因为 Java 语言的原因，Hex 表示溢出了没有正确设置符号位，所以得手动加上负号

== 余下的表示

assert Byte.MAX_VALUE == (2**7)-1
assert Byte.MIN_VALUE == -(2**(8-1))

然后我们干脆定义个函数帮我们做算了...

void assertSignedMinMax(lenSigned, klass) {
final MIN_VALUE_VAR = "MIN_VALUE"
final MAX_VALUE_VAR = "MAX_VALUE"
validSpace = 2 ** (lenSigned - 1)
max = validSpace - 1
min = -validSpace
final expectMin = klass.getDeclaredField(MIN_VALUE_VAR).get(null), expectMax = klass.getDeclaredField(MAX_VALUE_VAR).get(null)
assert min == expectMin && max == expectMax
}

assertSignedMinMax(16, Short.class)

... 跑路... 又熬夜了

啊嗨！
java.lang.Deprecated 是什么鬼类型…

[DuangSUSE@duangsuse]~% javap java.lang.Deprecated
Compiled from "Deprecated.java"

public interface java.lang.Deprecated extends java.lang.annotation.Annotation {}

它是一个 @interface 啊，用来标记某些东西已经『被废弃了』

[src/share/classes/java/lang/Deprecated.java] [oracle docs]

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {}

接上面没有写完的：
最终结果：

assertSignedMinMax(8, Byte.class)

assertSignedMinMax(16, Short.class)


assertSignedMinMax(32, Integer.class)

assertSignedMinMax(64, Long.class)

这是整形

Float.MIN_VALUE //=> 1.4E-45
Float.MAX_VALUE //=> 3.4028235E38

Double.MIN_VALUE //=> 4.9E-324
Double.MAX_VALUE //=> 1.7976931348623157E308

这是实型（准确的说只是有理数不是实数）

https://en.wikipedia.org/wiki/IEEE_754#Basic_and_interchange_formats

Float 有 24 个二进制位的有效数值，Double 则有 53 个
JavaScript 的 Number 默认为 Double，不过 ES6 也加入了 Integer 和 Integer literal 1000n


Character 的最小值为 0，想也知道（往下肯定不是 Unicode 有效的，再说还有下面的 unsigned）

(int) Character.MIN_VALUE //=> 0

(int) Character.MAX_VALUE //=> 65535

最大值是 2 ^ sizeof(unsigned short)

Boolean 是完全可枚举的（理论上或者实践上或者语义上），就不需要认为它是 Number 了

实际上一些语言里 True False 完全可以只是一个类型的数据构造器而已...

比如 Haskell：

data Boolean = True | False deriving (Eq, Show, Read, Enum)

比如 Agda：

data Bool: Type0 where
true false : Bool

https://agda.github.io/agda-stdlib/Agda.Builtin.Bool.html


====

完结撒花！ 🌸

尾记：

上面的东西意义不明确，而且有点冗长
有人可能会说我写东西经常这样（废话一大堆）
其实这正是我的风格，我有这样先写 background 的习惯，
不同于其他很多人（尤其是学院派），我会把一些比较难理解的东西一遍一遍的重复，这是为了能更好的记住他们，顺带多传播点信息
就是这样，喵。

#Math #music

最近知道了两个之前不知道的芝士： 🤔

+ 音高是什么！
+ x 的 （n 的倒数次方）等于开 x 的 n 次方根
where
n 的倒数: 1 / n
x 的 k 次方: x {* x} repeats for (k-1) times
n 的 k 次方根: (x 的 k 次方 = n) => x
+ 数学函数和数学操作符是不一样的

#tech #daily #Java #JavaScript #dev

🐱 duangsuse 的学习日常 ⭐️

+ 程序设计语言::Closure、Pattern Matching、Stream、Generators #pl #cs

+ 程序设计语言类型::这些名词，你知道吗？（涉及 Parameteric Polymorphism 和 Empty Types(aka. Bottom types)、Product types、Subtyping 等内容）

+ 高性能计算::C 语言和高性能计算、x86 汇编和 SIMD（单指令多数据）运算、JNI 外置原生算法

+ 软件架构::FFMpeg av* 库水印程序

+ 数据库::关系代数 #db

+ {Android, 数据结构和算法}::Android 的离散数组 SparseArray 和 ArrayMap #algorithm

+ 数据结构和算法::这些算法和数据结构，忘记了吗？

+ Rust/数据结构和算法::Rust 的 Vector 实现
+ Rust::Hole 类型、snappy 绑定、Tree 类型、LinkedList、Box、Rc、std::thread 等

+ Java 的二进制流读写器 #bin
+ Java 的 Android android.content.SharedPreferences 代理库 Prefer
+ {软件架构, Android}::编写一个 Android 上的 Service！（感谢 @YuutaW 提供学习资源，ShutdownService 默写）
+ 软件项目管理::Gradle 的抽象总结

+ JavaScript ES6: sm.ms.js
+ JavaScript ES6: 基于 CheerIO 和 Requests.js-promise-native 的爬虫，默写（感谢 @ice1000 的原实现，这可能是冰封哥有史以来最奇怪的代码，因为他写了两个完全可以被替换为更有意义结构的没有用的控制结构...）
+ JavaScript ES6: ArrayBuffer, DataView 读 BMP、再看 ASCII 艺术画生成

+ Kotlin::简单的 Realm ORM + RecyclerView Android 应用
+ Kotlin::Shell execute
+ Kotlin::Coroutine
+ Kotlin::Kotlin Native 和 Kotlin JavaScript 与 Gradle/Groovy
+ Kotlin HTML DSL
+ Kotlin 内部代理类 (Delegates)
+ Kotlin OkHttp 同步/异步封装

+ C 程序设计语言::libBMP 和 libWAV
+ C 程序设计语言::OpenGL 体验

+ 无脑模式::线性代数::高斯·约当消元法（Gauss Jordan）解齐次线性方程组（Homogenuous Linear Equation Group）
+ 无脑模式::C++/Qt::拼音分词、英文音标转换和 TTS 合成
+ 无脑模式::Haskell 抄写 Haskell 的 AlgorithmW Hindley-Milner Type system type infer algorithm 实现

+ Javax Servlet 架构体验 🤔

https://raw.githubusercontent.com/yairchu/Algorithm-W-Step-By-Step/master/AlgorithmW.lhs

现在就可以试用 Haskell 编写的 Type inferer，可惜我还要再抄一遍（🙈

AlgorithmW.tex: Algorithm.lhs
lhs2Tex $< > $@

AlgorithmW.pdf: AlgorithmW.tex
latex $<
pdflatex $<

AlgorithmW: Algotithm.lhs
ghc --make $<

https://www.gnu.org/software/make/manual/html_node/Automatic-Variables.html

#Haskell 开心。 ghc -e main AlgorithmW.lhs

卒。
选错了 VHD，把 Root VHD 当 Child 选了，然后手残 Bootice 点了压缩。

卒，开机就重启。看来只能用 Root 了

#Java https://javaranch.com/journal/2002/01/jlsjan2002.html
你可能不知道的 Java 语法 "Qualified class instance creation"：最好的解释...

上 DuckDuckGo 居然没几个人、没几个教程知道还有这种语法... 可谓冷门了...

我也无法快速理解了，只能到时候看编译器源码吧（

最近 CSS 和 JavaScript 都宣布了一个管道操作符，还不能使用。尽管反复看，前一个只记得住使用范围（<table>）… 后一个只记得住作用（简化连锁函数调用）… 真是要多用才能理解，才能记住。

不过，这个 Qualified class instance creation 可不是新的 Java Feature 了（至少是 Java 1.2 就有），新的是 var local variable type inference (Java 10+)，Java 以前一直是显式类型的语言呢，现在终于有了 Type inference。

如你们所见，很多，所以一天是无法完成的，所以这个列表慢慢累积...

先默写一下 Java 和 Kotlin 的 Modifiers

== Java

Class members

abstract final static strictfp volatile stransient

Procedural

native synchronized

== Kotlin

Classes

abstract open final
enum annotation data sealed

Class members

abstract open final override lateinit
const

Procedural

suspend infix operator inline external tailrec

Access control

public private protected interal

Parameters

vararg crossinline noinline

Parameterized Type Variance

in out

Type Parameters

reified

#Java #Kotlin https://gist.github.com/duangsuse/dfc532a16f547459bcf3f4f8d922d849 更新了一个字

https://gist.github.com/duangsuse/dfc532a16f547459bcf3f4f8d922d849/revisions

Void 改成了 Nothing
其实 Unit 也可以，反正 Void 类型只有一种可能的值：null
Nothing? 和 Unit 也都是一样（被 Rust 称为 Zero Size Types，因为他们在值的层面讨论只有一种可能性：Unit 就是 object Unit、Nothing? 就是 null、Void 也是 null），而 Nothing 类型没有可能的值（Empty Type/Bottom Type，这个名字是来源与它在子类型层次结构里处于最底端的缘故）

val empty: Nothing? = null

虽然 Nothing? 的语义很正常，但是 unsupported [Array<Nothing> in return type is illegal]
...