1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
assert source != null : "source should not be null";
assert pattern != null : "pattern should not be null";
//传入输入流
this.source = source;
//传入分隔令牌模式
delimPattern = pattern;
//传入一个容量为BUFFER_SIZE（默认1024字节）的CharBuffer对象
buf = CharBuffer.allocate(BUFFER_SIZE);
//传入limit=0；Invariants: mark <= position <= limit <= capacity
buf.limit(0);
//传入用分隔模式匹配字符缓存的匹配器
matcher = delimPattern.matcher(buf);
//设置匹配器可跨边界检验匹配是否正确
matcher.useTransparentBounds(true);
//匹配器不对区域边界进行铆钉
matcher.useAnchoringBounds(false);
//传入默认的语言环境下的格式化日期、数字和货币
useLocale(Locale.getDefault(Locale.Category.FORMAT));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

while (true) {
@1	若准备工作完成，获取完整令牌
String token = getCompleteTokenInBuffer(null);
if (token != null) {
matchValid = true;
skipped = false;
return token;
}
if (needInput)
//从source中读取buf大小的数据
readInput();
else
throwFor();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//-首先跳过delim
//Skip delims first
//设置matcher的parentPattern为delimPattern
matcher.usePattern(delimPattern);
//判断此次操作是否还未被跳过delims
if (!skipped) { // Enforcing only one skip of leading delims
//仅强制执行前导delim的一次跳过
//设定matcher匹配区域，默认from=0，end=0
matcher.region(position, buf.limit());
//尝试将从区域开头开始的输入序列与模式匹配。
if (matcher.lookingAt()) {
// If more input could extend the delimiters then we must wait
// for more input
//-如果更多的输入可以扩展分隔符，那么我们必须等待
//获得更多输入
if (matcher.hitEnd() && !sourceClosed) {
needInput = true;
return null;
}
// The delims were whole and the matcher should skip them
skipped = true;
position = matcher.end();
}
}
// Must look for next delims. Simply attempting to match the
// pattern at this point may find a match but it might not be
// the first longest match because of missing input, or it might
// match a partial token instead of the whole thing.
//-必须寻找下一个delims。 只是试图匹配
//此时的模式可能会找到匹配但可能不匹配
//由于缺少输入而导致的第一个最长匹配，或者可能
//匹配部分令牌而不是整个事物。
// Then look for next delims
matcher.region(position, buf.limit());
boolean foundNextDelim = matcher.find();
if (foundNextDelim && (matcher.end() == position)) {
// Zero length delimiter match; we should find the next one
// using the automatic advance past a zero length match;
// Otherwise we have just found the same one we just skipped
foundNextDelim = matcher.find();
}
if (foundNextDelim) {
// In the rare case that more input could cause the match
// to be lost and there is more input coming we must wait
// for more input. Note that hitting the end is okay as long
// as the match cannot go away. It is the beginning of the
// next delims we want to be sure about, we don't care if
// they potentially extend further.
if (matcher.requireEnd() && !sourceClosed) {
needInput = true;
return null;
}
int tokenEnd = matcher.start();
// There is a complete token.
if (pattern == null) {
// Must continue with match to provide valid MatchResult
pattern = FIND_ANY_PATTERN;
}
//
Attempt to match against the desired pattern
matcher.usePattern(pattern);
matcher.region(position, tokenEnd);
@2
if (matcher.matches()) {
@3
String s = matcher.group();
position = matcher.end();
return s;
} else { // Complete token but it does not match
return null;
}
}
// If we can't find the next delims but no more input is coming,
// then we can treat the remainder as a whole token
if (sourceClosed) {
if (pattern == null) {
// Must continue with match to provide valid MatchResult
pattern = FIND_ANY_PATTERN;
}
// Last token; Match the pattern here or throw
matcher.usePattern(pattern);
matcher.region(position, buf.limit());
if (matcher.matches()) {
String s = matcher.group();
position = matcher.end();
return s;
}
// Last piece does not match
return null;
}
// There is a partial token in the buffer; must read more
// to complete it
needInput = true;
return null;
}