首页 建站教程 正文
我要投稿

Java 中的 BufferedReader 介绍_动力节点Java学院整理

建站教程
2025-05-29 0 67
也想出现在这里？点击联系我~

BufferedReader 介绍

BufferedReader 是缓冲字符输入流。它继承于Reader。

BufferedReader 的作用是为其他字符输入流添加一些缓冲功能。

BufferedReader 函数列表

?

1

2

3

4

5

6

7

8

9

10

11
BufferedReader(Reader in)

BufferedReader(Reader in, int size)

void close()

void mark(int markLimit)

boolean markSupported()

int read()

int read(char[] buffer, int offset, int length)

String readLine()

boolean ready()

void reset()

long skip(long charCount)

BufferedReader 源码分析(基于jdk1.7.40)

?

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

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325
package java.io;

public class BufferedReader extends Reader {

private Reader in;

// 字符缓冲区

private char cb[];

// nChars 是cb缓冲区中字符的总的个数

// nextChar 是下一个要读取的字符在cb缓冲区中的位置

private int nChars, nextChar;

// 表示“标记无效”。它与UNMARKED的区别是：

// (01) UNMARKED 是压根就没有设置过标记。

// (02) 而INVALIDATED是设置了标记，但是被标记位置太长，导致标记无效！

private static final int INVALIDATED = -2;

// 表示没有设置“标记”

private static final int UNMARKED = -1;

// “标记”

private int markedChar = UNMARKED;

// “标记”能标记位置的最大长度

private int readAheadLimit = 0; /* Valid only when markedChar > 0 */

// skipLF(即skip Line Feed)是“是否忽略换行符”标记

private boolean skipLF = false;

// 设置“标记”时，保存的skipLF的值

private boolean markedSkipLF = false;

// 默认字符缓冲区大小

private static int defaultCharBufferSize = 8192;

// 默认每一行的字符个数

private static int defaultExpectedLineLength = 80;

// 创建“Reader”对应的BufferedReader对象，sz是BufferedReader的缓冲区大小

public BufferedReader(Reader in, int sz) {

super(in);

if (sz <= 0)

throw new IllegalArgumentException("Buffer size <= 0");

this.in = in;

cb = new char[sz];

nextChar = nChars = 0;

}

// 创建“Reader”对应的BufferedReader对象，默认的BufferedReader缓冲区大小是8k

public BufferedReader(Reader in) {

this(in, defaultCharBufferSize);

}

// 确保“BufferedReader”是打开状态

private void ensureOpen() throws IOException {

if (in == null)

throw new IOException("Stream closed");

}

// 填充缓冲区函数。有以下两种情况被调用：

// (01) 缓冲区没有数据时，通过fill()可以向缓冲区填充数据。

// (02) 缓冲区数据被读完，需更新时，通过fill()可以更新缓冲区的数据。

private void fill() throws IOException {

// dst表示“cb中填充数据的起始位置”。

int dst;

if (markedChar <= UNMARKED) {

// 没有标记的情况，则设dst=0。

dst = 0;

} else {

// delta表示“当前标记的长度”，它等于“下一个被读取字符的位置”减去“标记的位置”的差值；

int delta = nextChar - markedChar;

if (delta >= readAheadLimit) {

// 若“当前标记的长度”超过了“标记上限(readAheadLimit)”，

// 则丢弃标记！

markedChar = INVALIDATED;

readAheadLimit = 0;

dst = 0;

} else {

if (readAheadLimit <= cb.length) {

// 若“当前标记的长度”没有超过了“标记上限(readAheadLimit)”，

// 并且“标记上限(readAheadLimit)”小于/等于“缓冲的长度”；

// 则先将“下一个要被读取的位置，距离我们标记的置符的距离”间的字符保存到cb中。

System.arraycopy(cb, markedChar, cb, 0, delta);

markedChar = 0;

dst = delta;

} else {

// 若“当前标记的长度”没有超过了“标记上限(readAheadLimit)”，

// 并且“标记上限(readAheadLimit)”大于“缓冲的长度”；

// 则重新设置缓冲区大小，并将“下一个要被读取的位置，距离我们标记的置符的距离”间的字符保存到cb中。

char ncb[] = new char[readAheadLimit];

System.arraycopy(cb, markedChar, ncb, 0, delta);

cb = ncb;

markedChar = 0;

dst = delta;

}

// 更新nextChar和nChars

nextChar = nChars = delta;

}

}

int n;

do {

// 从“in”中读取数据，并存储到字符数组cb中；

// 从cb的dst位置开始存储，读取的字符个数是cb.length - dst

// n是实际读取的字符个数；若n==0(即一个也没读到)，则继续读取！

n = in.read(cb, dst, cb.length - dst);

} while (n == 0);

// 如果从“in”中读到了数据，则设置nChars(cb中字符的数目)=dst+n，

// 并且nextChar(下一个被读取的字符的位置)=dst。

if (n > 0) {

nChars = dst + n;

nextChar = dst;

}

}

// 从BufferedReader中读取一个字符，该字符以int的方式返回

public int read() throws IOException {

synchronized (lock) {

ensureOpen();

for (;;) {

// 若“缓冲区的数据已经被读完”，

// 则先通过fill()更新缓冲区数据

if (nextChar >= nChars) {

fill();

if (nextChar >= nChars)

return -1;

}

// 若要“忽略换行符”，

// 则对下一个字符是否是换行符进行处理。

if (skipLF) {

skipLF = false;

if (cb[nextChar] == '\\n') {

nextChar++;

continue;

}

}

// 返回下一个字符

return cb[nextChar++];

}

}

}

// 将缓冲区中的数据写入到数组cbuf中。off是数组cbuf中的写入起始位置，len是写入长度

private int read(char[] cbuf, int off, int len) throws IOException {

// 若“缓冲区的数据已经被读完”，则更新缓冲区数据。

if (nextChar >= nChars) {

if (len >= cb.length && markedChar <= UNMARKED && !skipLF) {

return in.read(cbuf, off, len);

}

fill();

}

// 若更新数据之后，没有任何变化；则退出。

if (nextChar >= nChars) return -;

// 若要“忽略换行符”，则进行相应处理

if (skipLF) {

skipLF = false;

if (cb[nextChar] == '\\n') {

nextChar++;

if (nextChar >= nChars)

fill();

if (nextChar >= nChars)

return -1;

}

}

// 拷贝字符操作

int n = Math.min(len, nChars - nextChar);

System.arraycopy(cb, nextChar, cbuf, off, n);

nextChar += n;

return n;

}

// 对read()的封装，添加了“同步处理”和“阻塞式读取”等功能

public int read(char cbuf[], int off, int len) throws IOException {

synchronized (lock) {

ensureOpen();

if ((off < 0) || (off > cbuf.length) || (len < 0) ||

((off + len) > cbuf.length) || ((off + len) < 0)) {

throw new IndexOutOfBoundsException();

} else if (len == 0) {

return 0;

}

int n = read1(cbuf, off, len);

if (n <= 0) return n;

while ((n < len) && in.ready()) {

int n1 = read1(cbuf, off + n, len - n);

if (n1 <= 0) break;

n += n1;

}

return n;

}

}

// 读取一行数据。ignoreLF是“是否忽略换行符”

String readLine(boolean ignoreLF) throws IOException {

StringBuffer s = null;

int startChar;

synchronized (lock) {

ensureOpen();

boolean omitLF = ignoreLF || skipLF;

bufferLoop:

for (;;) {

if (nextChar >= nChars)

fill();

if (nextChar >= nChars) { /* EOF */

if (s != null && s.length() > 0)

return s.toString();

else

return null;

}

boolean eol = false;

char c = 0;

int i;

/* Skip a leftover '\\n', if necessary */

if (omitLF && (cb[nextChar] == '\\n'))

nextChar++;

skipLF = false;

omitLF = false;

charLoop:

for (i = nextChar; i < nChars; i++) {

c = cb[i];

if ((c == '\\n') || (c == '\\r')) {

eol = true;

break charLoop;

}

}

startChar = nextChar;

nextChar = i;

if (eol) {

String str;

if (s == null) {

str = new String(cb, startChar, i - startChar);

} else {

s.append(cb, startChar, i - startChar);

str = s.toString();

}

nextChar++;

if (c == '\\r') {

skipLF = true;

}

return str;

}

if (s == null)

s = new StringBuffer(defaultExpectedLineLength);

s.append(cb, startChar, i - startChar);

}

}

}

// 读取一行数据。不忽略换行符

public String readLine() throws IOException {

return readLine(false);

}

// 跳过n个字符

public long skip(long n) throws IOException {

if (n < 0L) {

throw new IllegalArgumentException("skip value is negative");

}

synchronized (lock) {

ensureOpen();

long r = n;

while (r > 0) {

if (nextChar >= nChars)

fill();

if (nextChar >= nChars) /* EOF */

break;

if (skipLF) {

skipLF = false;

if (cb[nextChar] == '\\n') {

nextChar++;

}

}

long d = nChars - nextChar;

if (r <= d) {

nextChar += r;

r = 0;

break;

}

else {

r -= d;

nextChar = nChars;

}

}

return n - r;

}

}

// “下一个字符”是否可读

public boolean ready() throws IOException {

synchronized (lock) {

ensureOpen();

// 若忽略换行符为true；

// 则判断下一个符号是否是换行符，若是的话，则忽略

if (skipLF) {

if (nextChar >= nChars && in.ready()) {

fill();

}

if (nextChar < nChars) {

if (cb[nextChar] == '\\n')

nextChar++;

skipLF = false;

}

}

return (nextChar < nChars) || in.ready();

}

}

// 始终返回true。因为BufferedReader支持mark(), reset()

public boolean markSupported() {

return true;

}

// 标记当前BufferedReader的下一个要读取位置。关于readAheadLimit的作用，参考后面的说明。

public void mark(int readAheadLimit) throws IOException {

if (readAheadLimit < 0) {

throw new IllegalArgumentException("Read-ahead limit < 0");

}

synchronized (lock) {

ensureOpen();

// 设置readAheadLimit

this.readAheadLimit = readAheadLimit;

// 保存下一个要读取的位置

markedChar = nextChar;

// 保存“是否忽略换行符”标记

markedSkipLF = skipLF;

}

}

// 重置BufferedReader的下一个要读取位置，

// 将其还原到mark()中所保存的位置。

public void reset() throws IOException {

synchronized (lock) {

ensureOpen();

if (markedChar < 0)

throw new IOException((markedChar == INVALIDATED)

? "Mark invalid"

: "Stream not marked");

nextChar = markedChar;

skipLF = markedSkipLF;

}

}

public void close() throws IOException {

synchronized (lock) {

if (in == null)

return;

in.close();

in = null;

cb = null;

}

}

}

说明：

要想读懂BufferReader的源码，就要先理解它的思想。BufferReader的作用是为其它Reader提供缓冲功能。创建BufferReader时，我们会通过它的构造函数指定某个Reader为参数。BufferReader会将该Reader中的数据分批读取，每次读取一部分到缓冲中；操作完缓冲中的这部分数据之后，再从Reader中读取下一部分的数据。

为什么需要缓冲呢？原因很简单，效率问题！缓冲中的数据实际上是保存在内存中，而原始数据可能是保存在硬盘或NandFlash中；而我们知道，从内存中读取数据的速度比从硬盘读取数据的速度至少快10倍以上。

那干嘛不干脆一次性将全部数据都读取到缓冲中呢？第一，读取全部的数据所需要的时间可能会很长。第二，内存价格很贵，容量不想硬盘那么大。

下面，我就BufferReader中最重要的函数fill()进行说明。其它的函数很容易理解，我就不详细介绍了，大家可以参考源码中的注释进行理解。我们先看看fill()的源码：

?

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
private void fill() throws IOException {

int dst;

if (markedChar <= UNMARKED) {

/* No mark */

dst = 0;

} else {

/* Marked */

int delta = nextChar - markedChar;

if (delta >= readAheadLimit) {

/* Gone past read-ahead limit: Invalidate mark */

markedChar = INVALIDATED;

readAheadLimit = 0;

dst = 0;

} else {

if (readAheadLimit <= cb.length) {

/* Shuffle in the current buffer */

System.arraycopy(cb, markedChar, cb, 0, delta);

markedChar = 0;

dst = delta;

} else {

/* Reallocate buffer to accommodate read-ahead limit */

char ncb[] = new char[readAheadLimit];

System.arraycopy(cb, markedChar, ncb, 0, delta);

cb = ncb;

markedChar = 0;

dst = delta;

}

nextChar = nChars = delta;

}

}

int n;

do {

n = in.read(cb, dst, cb.length - dst);

} while (n == 0);

if (n > 0) {

nChars = dst + n;

nextChar = dst;

}

}

根据fill()中的if…else…，我将fill()分为4种情况进行说明。

情况1：读取完缓冲区的数据，并且缓冲区没有被标记

执行流程如下，

(01) 其它函数调用 fill()，来更新缓冲区的数据

(02) fill() 执行代码 if (markedChar <= UNMARKED) { … }

为了方便分析，我们将这种情况下fill()执行的操作等价于以下代码：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15
private void fill() throws IOException {

int dst;

if (markedChar <= UNMARKED) {

/* No mark */

dst = 0;

}

int n;

do {

n = in.read(cb, dst, cb.length - dst);

} while (n == 0);

if (n > 0) {

nChars = dst + n;

nextChar = dst;

}

}

说明：

这种情况发生的情况是 — — Reader中有很长的数据，我们每次从中读取一部分数据到缓冲中进行操作。每次当我们读取完缓冲中的数据之后，并且此时BufferedReader没有被标记；那么，就接着从Reader(BufferReader提供缓冲功能的Reader)中读取下一部分的数据到缓冲中。

其中，判断是否读完缓冲区中的数据，是通过“比较nextChar和nChars之间大小”来判断的。其中，nChars 是缓冲区中字符的总的个数，而 nextChar 是缓冲区中下一个要读取的字符的位置。

判断BufferedReader有没有被标记，是通过“markedChar”来判断的。

理解这个思想之后，我们再对这种情况下的fill()的代码进行分析，就特别容易理解了。

(01) if (markedChar <= UNMARKED) 它的作用是判断“BufferedReader是否被标记”。若被标记，则dst=0。

(02) in.read(cb, dst, cb.length – dst) 等价于 in.read(cb, 0, cb.length)，意思是从Reader对象in中读取cb.length个数据，并存储到缓冲区cb中，而且从缓冲区cb的位置0开始存储。该函数返回值等于n，也就是n表示实际读取的字符个数。若n=0(即没有读取到数据)，则继续读取，直到读到数据为止。

(03) nChars=dst+n 等价于 nChars=n；意味着，更新缓冲区数据cb之后，设置nChars(缓冲区的数据个数)为n。

(04) nextChar=dst 等价于 nextChar=0；意味着，更新缓冲区数据cb之后，设置nextChar(缓冲区中下一个会被读取的字符的索引值)为0。

情况2：读取完缓冲区的数据，缓冲区的标记位置>0，并且“当前标记的长度”超过“标记上限(readAheadLimit)”

执行流程如下，

(01) 其它函数调用 fill()，来更新缓冲区的数据

(02) fill() 执行代码 if (delta >= readAheadLimit) { … }

为了方便分析，我们将这种情况下fill()执行的操作等价于以下代码：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19
private void fill() throws IOException {

int dst;

if (markedChar > UNMARKED) {

int delta = nextChar - markedChar;

if (delta >= readAheadLimit) {

markedChar = INVALIDATED;

readAheadLimit = 0;

dst = 0;

}

}

int n;

do {

n = in.read(cb, dst, cb.length - dst);

} while (n == 0);

if (n > 0) {

nChars = dst + n;

nextChar = dst;

}

}

说明：

这种情况发生的情况是 — — BufferedReader中有很长的数据，我们每次从中读取一部分数据到缓冲区中进行操作。当我们读取完缓冲区中的数据之后，并且此时，BufferedReader存在标记时，同时，“当前标记的长度”大于“标记上限”；那么，就发生情况2。此时，我们会丢弃“标记”并更新缓冲区。

(01) delta = nextChar – markedChar；其中，delta就是“当前标记的长度”，它是“下一个被读取字符的位置”减去“被标记的位置”的差值。

(02) if (delta >= readAheadLimit)；其中，当delta >= readAheadLimit，就意味着，“当前标记的长度”>=“标记上限”。为什么要有标记上限，即readAheadLimit的值到底有何意义呢？

我们标记一个位置之后，更新缓冲区的时候，被标记的位置会被保存；当我们不停的更新缓冲区的时候，被标记的位置会被不停的放大。然后内存的容量是有效的，我们不可能不限制长度的存储标记。所以，需要readAheadLimit来限制标记长度！

(03) in.read(cb, dst, cb.length – dst) 等价于 in.read(cb, 0, cb.length)，意思是从Reader对象in中读取cb.length个数据，并存储到缓冲区cb中，而且从缓冲区cb的位置0开始存储。该函数返回值等于n，也就是n表示实际读取的字符个数。若n=0(即没有读取到数据)，则继续读取，直到读到数据为止。

(04) nChars=dst+n 等价于 nChars=n；意味着，更新缓冲区数据cb之后，设置nChars(缓冲区的数据个数)为n。

(05) nextChar=dst 等价于 nextChar=0；意味着，更新缓冲区数据cb之后，设置nextChar(缓冲区中下一个会被读取的字符的索引值)为0。

情况3：读取完缓冲区的数据，缓冲区的标记位置>0，“当前标记的长度”没超过“标记上限(readAheadLimit)”，并且“标记上限(readAheadLimit)”小于/等于“缓冲的长度”；
执行流程如下，

(01) 其它函数调用 fill()，来更新缓冲区的数据

(02) fill() 执行代码 if (readAheadLimit <= cb.length) { … }

为了方便分析，我们将这种情况下fill()执行的操作等价于以下代码：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20
private void fill() throws IOException {

int dst;

if (markedChar > UNMARKED) {

int delta = nextChar - markedChar;

if ((delta < readAheadLimit) && (readAheadLimit <= cb.length) ) {

System.arraycopy(cb, markedChar, cb, 0, delta);

markedChar = 0;

dst = delta;

nextChar = nChars = delta;

}

}

int n;

do {

n = in.read(cb, dst, cb.length - dst);

} while (n == 0);

if (n > 0) {

nChars = dst + n;

nextChar = dst;

}

}

说明：

这种情况发生的情况是 — — BufferedReader中有很长的数据，我们每次从中读取一部分数据到缓冲区中进行操作。当我们读取完缓冲区中的数据之后，并且此时，BufferedReader存在标记时，同时，“当前标记的长度”小于“标记上限”，并且“标记上限”小于/等于“缓冲区长度”；那么，就发生情况3。此时，我们保留“被标记的位置”(即，保留被标记位置开始的数据)，并更新缓冲区(将新增的数据，追加到保留的数据之后)。

情况4：读取完缓冲区的数据，缓冲区的标记位置>0，“当前标记的长度”没超过“标记上限(readAheadLimit)”，并且“标记上限(readAheadLimit)”大于“缓冲的长度”；

执行流程如下，

(01) 其它函数调用 fill()，来更新缓冲区的数据

(02) fill() 执行代码 else { char ncb[] = new char[readAheadLimit]; … }

为了方便分析，我们将这种情况下fill()执行的操作等价于以下代码：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22
private void fill() throws IOException {

int dst;

if (markedChar > UNMARKED) {

int delta = nextChar - markedChar;

if ((delta < readAheadLimit) && (readAheadLimit > cb.length) ) {

char ncb[] = new char[readAheadLimit];

System.arraycopy(cb, markedChar, ncb, 0, delta);

cb = ncb;

markedChar = 0;

dst = delta;

nextChar = nChars = delta;

}

}

int n;

do {

n = in.read(cb, dst, cb.length - dst);

} while (n == );

if (n > ) {

nChars = dst + n;

nextChar = dst;

}

}

说明：

这种情况发生的情况是 — — BufferedReader中有很长的数据，我们每次从中读取一部分数据到缓冲区中进行操作。当我们读取完缓冲区中的数据之后，并且此时，BufferedReader存在标记时，同时，“当前标记的长度”小于“标记上限”，并且“标记上限”大于“缓冲区长度”；那么，就发生情况4。此时，我们要先更新缓冲区的大小，然后再保留“被标记的位置”(即，保留被标记位置开始的数据)，并更新缓冲区数据(将新增的数据，追加到保留的数据之后)。

示例代码

关于BufferedReader中API的详细用法，参考示例代码(BufferedReaderTest.java)：

?

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
import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.InputStream;

import java.io.FileReader;

import java.io.IOException;

import java.io.FileNotFoundException;

import java.lang.SecurityException;

/**

* BufferedReader 测试程序

*

*

*/

public class BufferedReaderTest {

private static final int LEN = 5;

public static void main(String[] args) {

testBufferedReader() ;

}

/**

* BufferedReader的API测试函数

*/

private static void testBufferedReader() {

// 创建BufferedReader字符流，内容是ArrayLetters数组

try {

File file = new File("bufferedreader.txt");

BufferedReader in =

new BufferedReader(

new FileReader(file));

// 从字符流中读取5个字符。“abcde”

for (int i=0; i<LEN; i++) {

// 若能继续读取下一个字符，则读取下一个字符

if (in.ready()) {

// 读取“字符流的下一个字符”

int tmp = in.read();

System.out.printf("%d : %c\\n", i, tmp);

}

}

// 若“该字符流”不支持标记功能，则直接退出

if (!in.markSupported()) {

System.out.println("make not supported!");

return ;

}

// 标记“当前索引位置”，即标记第6个位置的元素--“f”

// 1024对应marklimit

in.mark(1024);

// 跳过22个字符。

in.skip(22);

// 读取5个字符

char[] buf = new char[LEN];

in.read(buf, 0, LEN);

System.out.printf("buf=%s\\n", String.valueOf(buf));

// 读取该行剩余的数据

System.out.printf("readLine=%s\\n", in.readLine());

// 重置“输入流的索引”为mark()所标记的位置，即重置到“f”处。

in.reset();

// 从“重置后的字符流”中读取5个字符到buf中。即读取“fghij”

in.read(buf, , LEN);

System.out.printf("buf=%s\\n", String.valueOf(buf));

in.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (SecurityException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

程序中读取的bufferedreader.txt的内容如下：

?

1

2

3
abcdefghijklmnopqrstuvwxyz

0123456789

ABCDEFGHIJKLMNOPQRSTUVWXYZ

运行结果：

?

1

2

3

4

5

6

7

8
0 : a

1 : b

2 : c

3 : d

4 : e

buf=01234

readLine=56789

buf=fghij

以上所述是小编给大家介绍的Java 中的 BufferedReader 介绍_动力节点Java学院整理，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对快网idc网站的支持！

收藏 (0) 打赏

感谢您的支持，我会继续努力的!

打开微信/支付宝扫一扫，即可进行扫码打赏哦，分享从这里开始，精彩与您同在
点赞 (0)

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

快网idc优惠网 建站教程 Java 中的 BufferedReader 介绍_动力节点Java学院整理 https://www.kuaiidc.com/116459.html

也想出现在这里？点击联系我~

相关文章

个人服务器网站搭建：如何选择适合自己的建站程序或框架？
个人服务器网站搭建：如何选择适合自己的建站程序或框架？
建站教程
5个月前 98
64M VPS建站：能否支持高流量网站运行？
64M VPS建站：能否支持高流量网站运行？
建站教程
5个月前 80
64M VPS建站：怎样选择合适的域名和SSL证书？
64M VPS建站：怎样选择合适的域名和SSL证书？
建站教程
5个月前 99
64M VPS建站：怎样优化以提高网站加载速度？
64M VPS建站：怎样优化以提高网站加载速度？
建站教程
5个月前 136
猜你喜欢
发表评论
暂无评论
TA的动态
快网idc优惠网

idc信息共同学习，共同进步，共同成长！

QQ交流群
快网idc优惠网

QQ交流群

您的支持，是我们最大的动力！
热门文章
热门评论
终身VIP会员限时钜惠
首页 SSL证书 菜单 论坛 问答