看毕向东老师的视频，讲readline()实现的原理本质还是read()方法，只是在里面封装了一个数组，请问这个数组到底有多长，假设我有一个很大的文本，该文本的每行字符很长，这个方法会不会抛出异常或者是程序错误？

不会，这个数组会自动增加存储空间。。。

这种问题看看源码就懂了，看不全懂，也能懂个大概吧！

1. String readLine(boolean ignoreLF) throws IOException {
   
2.         StringBuffer s = null;
   
3.         int startChar;
   
4. 
   
5.         synchronized (lock) {
   
6.             ensureOpen();
   
7.             boolean omitLF = ignoreLF || skipLF;
   
8. 
   
9.         bufferLoop:
   
10.             for (;;) {
    
11. 
    
12.                 if (nextChar >= nChars)
    
13.                     fill();
    
14.                 if (nextChar >= nChars) { /* EOF */
    
15.                     if (s != null && s.length() > 0)
    
16.                         return s.toString();
    
17.                     else
    
18.                         return null;
    
19.                 }
    
20.                 boolean eol = false;
    
21.                 char c = 0;
    
22.                 int i;
    
23. 
    
24.                 /* Skip a leftover '\n', if necessary */
    
25.                 if (omitLF && (cb[nextChar] == '\n'))
    
26.                     nextChar++;
    
27.                 skipLF = false;
    
28.                 omitLF = false;
    
29. 
    
30.             charLoop:
    
31.                 for (i = nextChar; i < nChars; i++) {
    
32.                     c = cb[i];
    
33.                     if ((c == '\n') || (c == '\r')) {
    
34.                         eol = true;
    
35.                         break charLoop;
    
36.                     }
    
37.                 }
    
38. 
    
39.                 startChar = nextChar;
    
40.                 nextChar = i;
    
41. 
    
42.                 if (eol) {
    
43.                     String str;
    
44.                     if (s == null) {
    
45.                         str = new String(cb, startChar, i - startChar);
    
46.                     } else {
    
47.                         s.append(cb, startChar, i - startChar);
    
48.                         str = s.toString();
    
49.                     }
    
50.                     nextChar++;
    
51.                     if (c == '\r') {
    
52.                         skipLF = true;
    
53.                     }
    
54.                     return str;
    
55.                 }
    
56.                
    
57.                 if (s == null)
    
58.                     s = new StringBuffer(defaultExpectedLineLength);
    
59.                 s.append(cb, startChar, i - startChar);
    
60.             }
    
61.         }
    
62.     }

复制代码

粗略看了看源码，貌似数组定长是8192.

1. private static int defaultCharBufferSize = 8192

复制代码

楼上贴上了readLine()方法，那我就贴调用的fill()方法吧

1. /**
   
2. * Fills the input buffer, taking the mark into account if it is valid.
   
3. */
   
4. private void fill() throws IOException {
   
5. int dst;
   
6. if (markedChar <= UNMARKED) {
   
7. /* No mark */
   
8. dst = 0;
   
9. } else {
   
10. /* Marked */
    
11. int delta = nextChar - markedChar;
    
12. if (delta >= readAheadLimit) {
    
13. /* Gone past read-ahead limit: Invalidate mark */
    
14. markedChar = INVALIDATED;
    
15. readAheadLimit = 0;
    
16. dst = 0;
    
17. } else {
    
18. if (readAheadLimit <= cb.length) {
    
19. /* Shuffle in the current buffer */
    
20. System.arraycopy(cb, markedChar, cb, 0, delta);
    
21. markedChar = 0;
    
22. dst = delta;
    
23. } else {
    
24. /* Reallocate buffer to accommodate read-ahead limit */
    
25. char ncb[] = new char[readAheadLimit];
    
26. System.arraycopy(cb, markedChar, ncb, 0, delta);
    
27. cb = ncb;
    
28. markedChar = 0;
    
29. dst = delta;
    
30. }
    
31. nextChar = nChars = delta;
    
32. }
    
33. }
    
34. 
    
35. int n;
    
36. do {
    
37. n = in.read(cb, dst, cb.length - dst);
    
38. } while (n == 0);
    
39. if (n > 0) {
    
40. nChars = dst + n;
    
41. nextChar = dst;
    
42. }
    
43. }

复制代码