Skip to content

C
CSDN-技能森林

Zebra-h / CSDN-技能森林
与 Fork 源项目一致

Fork自 CSDN 技术社区 / CSDN-技能森林

通知 1
Star 0
Fork 0
C
CSDN-技能森林

体验新版 GitCode，发现更多精彩内容 >>

切换分支/标签
查找文件 普通视图历史永久链接Permalink
java_tree.txt 440.8 KB
Newer Older
L
update node level  
luxin 已提交
1 
java --> ( 难度等级: [0, 1) || 挂载数据: 无 )
L
update node level  
luxin 已提交
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 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 
├── java初阶 --> ( 难度等级: [0.0, 0.3333) || 挂载数据: 无 ) 
│   ├── Java的历史和演变 --> ( 难度等级: [0.0, 0.0208) || 挂载数据: 无 ) 
│   │   ├── Java的家世 --> ( 难度等级: [0.0, 0.0023) || 挂载数据: 无 ) 
│   │   │   ├── 现代编程语言的诞生：C语言 --> ( 难度等级: [0.0, 0.0008) || 挂载数据: qa: 1 ) 
│   │   │   ├── C++：下一个阶段 --> ( 难度等级: [0.0008, 0.0015) || 挂载数据: qa: 5 ) 
│   │   │   └── Java出现的时机已经成熟 --> ( 难度等级: [0.0015, 0.0023) || 挂载数据: 无 ) 
│   │   ├── Java的诞生 --> ( 难度等级: [0.0023, 0.0046) || 挂载数据: 无 ) 
│   │   ├── Java改变Internet的方式 --> ( 难度等级: [0.0046, 0.0069) || 挂载数据: qa: 1 ) 
│   │   │   ├── Java applet --> ( 难度等级: [0.0046, 0.0054) || 挂载数据: 无 ) 
│   │   │   ├── 安全性 --> ( 难度等级: [0.0054, 0.0062) || 挂载数据: 无 ) 
│   │   │   └── 可移植性 --> ( 难度等级: [0.0062, 0.0069) || 挂载数据: 无 ) 
│   │   ├── Java的魔力：字节码 --> ( 难度等级: [0.0069, 0.0093) || 挂载数据: 无 ) 
│   │   ├── servlet：服务器端的Java --> ( 难度等级: [0.0093, 0.0116) || 挂载数据: 无 ) 
│   │   ├── Java的关键特性 --> ( 难度等级: [0.0116, 0.0139) || 挂载数据: 无 ) 
│   │   │   ├── 简单性 --> ( 难度等级: [0.0116, 0.0119) || 挂载数据: qa: 1 ) 
│   │   │   ├── 面向对象 --> ( 难度等级: [0.0119, 0.0122) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向对象概述 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   └── 面向对象程序设计的特点 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 8 ) 
│   │   │   │   ├── Java中的类与对象 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 类的定义 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 9 ) 
│   │   │   │   │   ├── 对象的创建与使用 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   ├── 存储到什么地方 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 3 ) 
│   │   │   │   │   │   └── Java中的数组 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 6 ) 
│   │   │   │   │   ├── 访问控制符 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── String类与StringBuffer类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── String类的初始化 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   ├── String类的常见操作 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── StringBuffer类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 4 ) 
│   │   │   │   │   │   ├── 声明字符串 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   └── 创建字符串 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── System类与Runtime类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── System类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   └── Runtime类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── Math类与Random类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Math类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   ├── Random类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 5 ) 
│   │   │   │   │   │   ├── Math类概述 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 常用数学运算方法 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 包装类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Integer类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   ├── Number类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── Integer --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 4 ) 
│   │   │   │   │   │   ├── Boolean --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 7 ) 
│   │   │   │   │   │   ├── Character --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 2 ) 
│   │   │   │   │   │   └── Number --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 日期与时间类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Date类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   ├── Calendar类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   └── JDK 8的日期与时间类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 格式化类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── DateFormat类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── SimpleDateFormat类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── DateTimeFormatter类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 用引用操纵对象 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 永远不需要销毁对象 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 作用域 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 对象的作用域 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 构建一个Java程序 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 名字可见性 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 运用其他构件 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 编码风格 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 访问对象的属性和行为 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 对象的引用 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 8 ) 
│   │   │   │   │   ├── 对象的销毁 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 打印对象和toString方法 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   └── ==和equals方法 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 8 ) 
│   │   │   │   ├── 类的封装 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   └── 如何实现封装 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 构造方法 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 构造方法的定义 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 5 ) 
│   │   │   │   │   └── 构造方法的重载 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   ├── static关键字 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 静态变量 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 静态方法 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 静态代码块 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 5 ) 
│   │   │   │   ├── 类的继承 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 继承的概念 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 重写父类方法 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── extends关键字 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 5 ) 
│   │   │   │   │   ├── 所有类的父类——Object类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 5 ) 
│   │   │   │   │   ├── 重写父类的方法 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 3 ) 
│   │   │   │   │   ├── super限定 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   └── 调用父类构造器 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── final关键字 --> ( 难度等级: [0.0119, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   ├── final关键字修饰类 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   │   ├── final关键字修饰方法 --> ( 难度等级: [0.0119, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   ├── final关键字修饰变量 --> ( 难度等级: [0.012, 0.012) || 挂载数据: qa: 6 ) 
│   │   │   │   │   ├── final数据 --> ( 难度等级: [0.012, 0.012) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── final方法 --> ( 难度等级: [0.012, 0.012) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── final类 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   └── 有关final的忠告 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   ├── 多态 --> ( 难度等级: [0.012, 0.012) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 多态概述 --> ( 难度等级: [0.012, 0.012) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 对象的类型转换 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 转机 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 方法调用绑定 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 产生正确的行为 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 可扩展性 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 缺陷：“覆盖”私有方法 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 多态性 --> ( 难度等级: [0.012, 0.012) || 挂载数据: qa: 2 ) 
│   │   │   │   │   └── 引用变量的强制类型转换 --> ( 难度等级: [0.012, 0.012) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── JDK 8的Lambda表达式 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   │   └── Lambda表达式入门 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   ├── 结构化程序设计简介 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   ├── 程序的三种基本结构 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向对象程序设计简介 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向对象的基本特征 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   ├── 方法详解 --> ( 难度等级: [0.012, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 方法的所属性 --> ( 难度等级: [0.012, 0.012) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 方法的参数传递机制 --> ( 难度等级: [0.012, 0.012) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 形参个数可变的方法 --> ( 难度等级: [0.012, 0.0121) || 挂载数据: qa: 2 ) 
│   │   │   │   │   └── 递归方法 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 类成员 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 理解类成员 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 8 ) 
│   │   │   │   │   └── 单例（Singleton）类 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   ├── final修饰符 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── final成员变量 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 5 ) 
│   │   │   │   │   ├── final局部变量 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 7 ) 
│   │   │   │   │   ├── final修饰基本类型变量和引用类型变量的区别 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 3 ) 
│   │   │   │   │   ├── 可执行“宏替换”的final变量 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 不可变类 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   ├── Java 9改进的接口 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 接口的概念 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Java 9中接口的定义 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 接口的继承 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 4 ) 
│   │   │   │   │   └── 面向接口编程 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   ├── Java 11增强的Lambda表达式 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Lambda表达式中使用var --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   └── 使用Lambda表达式调用Arrays的类方法 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   ├── 枚举类 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 手动实现枚举类 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 枚举类入门 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 实现接口的枚举类 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 3 ) 
│   │   │   │   │   └── 包含抽象方法的枚举类 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   ├── 修饰符的适用范围 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   └── 多版本JAR包 --> ( 难度等级: [0.0121, 0.0122) || 挂载数据: 无 ) 
│   │   │   │       ├── jar命令详解 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 10 ) 
│   │   │   │       ├── 创建可执行的JAR包 --> ( 难度等级: [0.0121, 0.0121) || 挂载数据: qa: 4 ) 
│   │   │   │       └── 关于JAR包的技巧 --> ( 难度等级: [0.0121, 0.0122) || 挂载数据: qa: 10 ) 
│   │   │   ├── 健壮性 --> ( 难度等级: [0.0122, 0.0124) || 挂载数据: 无 ) 
│   │   │   ├── 多线程 --> ( 难度等级: [0.0124, 0.0127) || 挂载数据: qa: 10 ) 
│   │   │   ├── 体系结构中立 --> ( 难度等级: [0.0127, 0.013) || 挂载数据: 无 ) 
│   │   │   ├── 解释执行和高性能 --> ( 难度等级: [0.013, 0.0133) || 挂载数据: 无 ) 
│   │   │   ├── 分布式 --> ( 难度等级: [0.0133, 0.0136) || 挂载数据: qa: 1 ) 
│   │   │   └── 动态性 --> ( 难度等级: [0.0136, 0.0139) || 挂载数据: 无 ) 
│   │   ├── Java的演变历程 --> ( 难度等级: [0.0139, 0.0162) || 挂载数据: 无 ) 
│   │   ├── Java SE 8 --> ( 难度等级: [0.0162, 0.0185) || 挂载数据: qa: 4 ) 
│   │   └── 文化革新 --> ( 难度等级: [0.0185, 0.0208) || 挂载数据: 无 ) 
│   ├── Java综述 --> ( 难度等级: [0.0208, 0.0417) || 挂载数据: 无 ) 
│   │   ├── 面向对象编程 --> ( 难度等级: [0.0208, 0.0243) || 挂载数据: qa: 1 ) 
│   │   │   ├── 两种范式 --> ( 难度等级: [0.0208, 0.0215) || 挂载数据: 无 ) 
│   │   │   ├── 抽象 --> ( 难度等级: [0.0215, 0.0222) || 挂载数据: 无 ) 
│   │   │   ├── OOP三原则 --> ( 难度等级: [0.0222, 0.0229) || 挂载数据: 无 ) 
│   │   │   ├── 面向对象基础 --> ( 难度等级: [0.0229, 0.0236) || 挂载数据: 无 ) 
│   │   │   │   └── 模块 --> ( 难度等级: [0.0229, 0.0236) || 挂载数据: 无 ) 
│   │   │   └── Java核心类 --> ( 难度等级: [0.0236, 0.0243) || 挂载数据: 无 ) 
│   │   │       ├── StringJoiner --> ( 难度等级: [0.0236, 0.0238) || 挂载数据: 无 ) 
│   │   │       ├── 包装类型 --> ( 难度等级: [0.0238, 0.0241) || 挂载数据: qa: 1 ) 
│   │   │       └── 记录类 --> ( 难度等级: [0.0241, 0.0243) || 挂载数据: 无 ) 
│   │   ├── 第一个简单程序 --> ( 难度等级: [0.0243, 0.0278) || 挂载数据: qa: 2 ) 
│   │   │   ├── 输入程序 --> ( 难度等级: [0.0243, 0.0255) || 挂载数据: qa: 10 ) 
│   │   │   ├── 编译程序 --> ( 难度等级: [0.0255, 0.0266) || 挂载数据: 无 ) 
│   │   │   └── 深入分析第一个示例程序 --> ( 难度等级: [0.0266, 0.0278) || 挂载数据: qa: 1 ) 
│   │   ├── 第二个简短程序 --> ( 难度等级: [0.0278, 0.0312) || 挂载数据: 无 ) 
│   │   ├── 两种控制语句 --> ( 难度等级: [0.0312, 0.0347) || 挂载数据: 无 ) 
│   │   │   ├── if语句 --> ( 难度等级: [0.0312, 0.033) || 挂载数据: qa: 2 ) 
│   │   │   └── for循环 --> ( 难度等级: [0.033, 0.0347) || 挂载数据: qa: 10 ) 
│   │   ├── 使用代码块 --> ( 难度等级: [0.0347, 0.0382) || 挂载数据: 无 ) 
│   │   └── Java类库 --> ( 难度等级: [0.0382, 0.0417) || 挂载数据: 无 ) 
│   ├── 数据类型、变量和数组 --> ( 难度等级: [0.0417, 0.0625) || 挂载数据: 无 ) 
│   │   ├── Java是强类型化的语言 --> ( 难度等级: [0.0417, 0.0422) || 挂载数据: 无 ) 
│   │   ├── 基本类型 --> ( 难度等级: [0.0422, 0.0428) || 挂载数据: 无 ) 
│   │   ├── 整型 --> ( 难度等级: [0.0428, 0.0433) || 挂载数据: 无 ) 
│   │   │   ├── byte --> ( 难度等级: [0.0428, 0.0429) || 挂载数据: qa: 10 ) 
│   │   │   ├── short --> ( 难度等级: [0.0429, 0.043) || 挂载数据: qa: 1 ) 
│   │   │   ├── int --> ( 难度等级: [0.043, 0.0432) || 挂载数据: qa: 10 ) 
│   │   │   └── long --> ( 难度等级: [0.0432, 0.0433) || 挂载数据: qa: 7 ) 
│   │   ├── 浮点型 --> ( 难度等级: [0.0433, 0.0439) || 挂载数据: 无 ) 
│   │   │   ├── float --> ( 难度等级: [0.0433, 0.0436) || 挂载数据: 无 ) 
│   │   │   └── double --> ( 难度等级: [0.0436, 0.0439) || 挂载数据: qa: 6 ) 
│   │   ├── 字符型 --> ( 难度等级: [0.0439, 0.0444) || 挂载数据: qa: 1 ) 
│   │   ├── 布尔型 --> ( 难度等级: [0.0444, 0.045) || 挂载数据: 无 ) 
│   │   ├── 深入分析字面值 --> ( 难度等级: [0.045, 0.0455) || 挂载数据: 无 ) 
│   │   │   ├── 整型字面值 --> ( 难度等级: [0.045, 0.0451) || 挂载数据: qa: 2 ) 
│   │   │   ├── 浮点型字面值 --> ( 难度等级: [0.0451, 0.0452) || 挂载数据: 无 ) 
│   │   │   ├── 布尔型字面值 --> ( 难度等级: [0.0452, 0.0453) || 挂载数据: 无 ) 
│   │   │   ├── 字符型字面值 --> ( 难度等级: [0.0453, 0.0454) || 挂载数据: qa: 1 ) 
│   │   │   └── 字符串字面值 --> ( 难度等级: [0.0454, 0.0455) || 挂载数据: 无 ) 
│   │   ├── 变量 --> ( 难度等级: [0.0455, 0.0461) || 挂载数据: 无 ) 
│   │   │   ├── 变量的声明 --> ( 难度等级: [0.0455, 0.0457) || 挂载数据: qa: 1 ) 
│   │   │   ├── 动态初始化 --> ( 难度等级: [0.0457, 0.0459) || 挂载数据: 无 ) 
│   │   │   └── 变量的作用域和生存期 --> ( 难度等级: [0.0459, 0.0461) || 挂载数据: 无 ) 
│   │   ├── 类型转换和强制类型转换 --> ( 难度等级: [0.0461, 0.0466) || 挂载数据: qa: 1 ) 
│   │   │   ├── Java的自动类型转换 --> ( 难度等级: [0.0461, 0.0463) || 挂载数据: 无 ) 
│   │   │   └── 强制转换不兼容的类型 --> ( 难度等级: [0.0463, 0.0466) || 挂载数据: qa: 4 ) 
│   │   ├── 表达式中的自动类型提升 --> ( 难度等级: [0.0466, 0.0471) || 挂载数据: 无 ) 
│   │   ├── 数组 --> ( 难度等级: [0.0471, 0.0477) || 挂载数据: 无 ) 
│   │   │   ├── 一维数组 --> ( 难度等级: [0.0471, 0.0473) || 挂载数据: qa: 10 ) 
│   │   │   ├── 多维数组 --> ( 难度等级: [0.0473, 0.0475) || 挂载数据: 无 ) 
│   │   │   └── 另一种数组声明语法 --> ( 难度等级: [0.0475, 0.0477) || 挂载数据: qa: 1 ) 
│   │   ├── 关于字符串的一些说明 --> ( 难度等级: [0.0477, 0.0482) || 挂载数据: qa: 1 ) 
│   │   │   ├── 字符串的连接 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: 无 ) 
│   │   │   │   ├── 连接字符串 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 2 ) 
│   │   │   │   └── 连接其他数据类型 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 10 ) 
│   │   │   ├── 提取字符串信息 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取字符串长度 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 获取指定位置的字符 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 获取子字符串索引位置 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 判断字符串首尾内容 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 9 ) 
│   │   │   │   ├── 获取字符数组 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 判断子字符串是否存在 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: 无 ) 
│   │   │   ├── 字符串的操作 --> ( 难度等级: [0.0477, 0.0478) || 挂载数据: 无 ) 
│   │   │   │   ├── 截取字符串 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 字符串替换 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 字符串分割 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 大小写转换 --> ( 难度等级: [0.0477, 0.0478) || 挂载数据: 无 ) 
│   │   │   │   ├── 去除空白内容 --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: 无 ) 
│   │   │   │   ├── 比较字符串是否相等 --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取子字符串 --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 去除空格 --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 判断字符串的开始与结尾 --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 按字典顺序比较两个字符串 --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: 无 ) 
│   │   │   │   └── 字母大小写转换 --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: 无 ) 
│   │   │   ├── 可变字符串StringBuffer类 --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: 无 ) 
│   │   │   ├── 不可变String --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: 无 ) 
│   │   │   ├── 重载"+"与StringBuilder --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: qa: 1 ) 
│   │   │   ├── 无意识的递归 --> ( 难度等级: [0.0478, 0.0479) || 挂载数据: 无 ) 
│   │   │   ├── String上的操作 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   ├── 格式化输出 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   ├── printf（） --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   ├── System.out.format（） --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   ├── Formatter类 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   ├── 格式化说明符 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   ├── Formatter转换 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   └── String.format（） --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: qa: 2 ) 
│   │   │   ├── 正则表达式 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 基础 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: qa: 8 ) 
│   │   │   │   ├── 创建正则表达式 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 限定符 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   ├── Pattern和Matcher --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── split（） --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 替换操作 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   ├── reset（） --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 正则表达式与Java I/O --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   ├── 扫描输入 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   ├── Scanner定界符 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   │   └── 用正则表达式扫描 --> ( 难度等级: [0.0479, 0.0479) || 挂载数据: 无 ) 
│   │   │   ├── StringTokenizer --> ( 难度等级: [0.0479, 0.048) || 挂载数据: 无 ) 
│   │   │   ├── 获取字符串信息 --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串查找 --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   │   └── 获取指定索引位置的字符 --> ( 难度等级: [0.048, 0.048) || 挂载数据: qa: 10 ) 
│   │   │   ├── 格式化字符串 --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   │   └── 常规类型格式化 --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   ├── 字符串生成器 --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   ├── 子串 --> ( 难度等级: [0.048, 0.0481) || 挂载数据: 无 ) 
│   │   │   ├── 拼接 --> ( 难度等级: [0.0481, 0.0481) || 挂载数据: 无 ) 
│   │   │   ├── 不可变字符串 --> ( 难度等级: [0.0481, 0.0481) || 挂载数据: 无 ) 
│   │   │   ├── 检测字符串是否相等 --> ( 难度等级: [0.0481, 0.0481) || 挂载数据: qa: 2 ) 
│   │   │   ├── 空串与Null串 --> ( 难度等级: [0.0481, 0.0482) || 挂载数据: 无 ) 
│   │   │   ├── 码点与代码单元 --> ( 难度等级: [0.0482, 0.0482) || 挂载数据: 无 ) 
│   │   │   ├── String API --> ( 难度等级: [0.0482, 0.0482) || 挂载数据: 无 ) 
│   │   │   ├── 阅读联机API文档 --> ( 难度等级: [0.0482, 0.0482) || 挂载数据: qa: 2 ) 
│   │   │   └── 构建字符串 --> ( 难度等级: [0.0482, 0.0482) || 挂载数据: 无 ) 
│   │   ├── 向C/C++程序员提供指针方面的说明 --> ( 难度等级: [0.0482, 0.0488) || 挂载数据: qa: 6 ) 
│   │   ├── 数组的定义 --> ( 难度等级: [0.0488, 0.0493) || 挂载数据: qa: 3 ) 
│   │   ├── 数组的常见操作 --> ( 难度等级: [0.0493, 0.0499) || 挂载数据: 无 ) 
│   │   ├── 数组的概述 --> ( 难度等级: [0.0499, 0.0504) || 挂载数据: 无 ) 
│   │   ├── 创建一维数组 --> ( 难度等级: [0.0504, 0.051) || 挂载数据: 无 ) 
│   │   ├── 给一维数组赋值 --> ( 难度等级: [0.051, 0.0515) || 挂载数据: qa: 5 ) 
│   │   ├── 获取数组长度 --> ( 难度等级: [0.0515, 0.0521) || 挂载数据: qa: 1 ) 
│   │   ├── 一维数组的使用场景 --> ( 难度等级: [0.0521, 0.0526) || 挂载数据: qa: 1 ) 
│   │   ├── 不规则数组 --> ( 难度等级: [0.0526, 0.0532) || 挂载数据: 无 ) 
│   │   ├── 数组的基本操作 --> ( 难度等级: [0.0532, 0.0537) || 挂载数据: 无 ) 
│   │   │   ├── 遍历数组 --> ( 难度等级: [0.0532, 0.0533) || 挂载数据: qa: 4 ) 
│   │   │   ├── 填充和批量替换数组元素 --> ( 难度等级: [0.0533, 0.0534) || 挂载数据: 无 ) 
│   │   │   ├── 填充替换数组元素 --> ( 难度等级: [0.0534, 0.0535) || 挂载数据: qa: 4 ) 
│   │   │   ├── 对数组进行排序 --> ( 难度等级: [0.0535, 0.0536) || 挂载数据: 无 ) 
│   │   │   └── 数组查询 --> ( 难度等级: [0.0536, 0.0537) || 挂载数据: qa: 2 ) 
│   │   ├── 数组是第一级对象 --> ( 难度等级: [0.0537, 0.0543) || 挂载数据: 无 ) 
│   │   ├── 返回一个数组 --> ( 难度等级: [0.0543, 0.0548) || 挂载数据: qa: 2 ) 
│   │   ├── 创建测试数据 --> ( 难度等级: [0.0548, 0.0554) || 挂载数据: 无 ) 
│   │   │   ├── Arrays.fill（） --> ( 难度等级: [0.0548, 0.055) || 挂载数据: qa: 1 ) 
│   │   │   ├── 数据生成器（Generator） --> ( 难度等级: [0.055, 0.0552) || 挂载数据: 无 ) 
│   │   │   └── 从Generator中创建数组 --> ( 难度等级: [0.0552, 0.0554) || 挂载数据: qa: 5 ) 
│   │   ├── Arrays实用功能 --> ( 难度等级: [0.0554, 0.0559) || 挂载数据: 无 ) 
│   │   │   ├── 复制数组 --> ( 难度等级: [0.0554, 0.0555) || 挂载数据: 无 ) 
│   │   │   ├── 数组元素的比较 --> ( 难度等级: [0.0555, 0.0556) || 挂载数据: qa: 3 ) 
│   │   │   ├── 数组排序 --> ( 难度等级: [0.0556, 0.0558) || 挂载数据: qa: 4 ) 
│   │   │   └── 在已排序的数组中查找 --> ( 难度等级: [0.0558, 0.0559) || 挂载数据: qa: 1 ) 
│   │   ├── 数组排序算法 --> ( 难度等级: [0.0559, 0.0565) || 挂载数据: 无 ) 
│   │   │   ├── 冒泡排序 --> ( 难度等级: [0.0559, 0.0561) || 挂载数据: qa: 4 ) 
│   │   │   ├── 直接选择排序 --> ( 难度等级: [0.0561, 0.0563) || 挂载数据: qa: 4 ) 
│   │   │   └── 反转排序 --> ( 难度等级: [0.0563, 0.0565) || 挂载数据: qa: 3 ) 
│   │   ├── 内存中的数组 --> ( 难度等级: [0.0565, 0.057) || 挂载数据: qa: 2 ) 
│   │   ├── 基本类型数组的初始化 --> ( 难度等级: [0.057, 0.0576) || 挂载数据: 无 ) 
│   │   ├── 引用类型数组的初始化 --> ( 难度等级: [0.0576, 0.0581) || 挂载数据: 无 ) 
│   │   ├── 操作数组的工具类：Arrays --> ( 难度等级: [0.0581, 0.0587) || 挂载数据: 无 ) 
│   │   ├── 数组应用举例 --> ( 难度等级: [0.0587, 0.0592) || 挂载数据: 无 ) 
│   │   ├── char类型 --> ( 难度等级: [0.0592, 0.0598) || 挂载数据: qa: 10 ) 
│   │   ├── boolean类型 --> ( 难度等级: [0.0598, 0.0603) || 挂载数据: 无 ) 
│   │   ├── 声明数组 --> ( 难度等级: [0.0603, 0.0609) || 挂载数据: 无 ) 
│   │   ├── 访问数组元素 --> ( 难度等级: [0.0609, 0.0614) || 挂载数据: 无 ) 
│   │   ├── for each循环 --> ( 难度等级: [0.0614, 0.062) || 挂载数据: 无 ) 
│   │   └── 数组拷贝 --> ( 难度等级: [0.062, 0.0625) || 挂载数据: 无 ) 
│   ├── 运算符 --> ( 难度等级: [0.0625, 0.0833) || 挂载数据: 无 ) 
│   │   ├── 算术运算符 --> ( 难度等级: [0.0625, 0.0639) || 挂载数据: qa: 1 ) 
│   │   │   ├── 基本算术运算符 --> ( 难度等级: [0.0625, 0.0628) || 挂载数据: qa: 1 ) 
│   │   │   ├── 求模运算符 --> ( 难度等级: [0.0628, 0.0632) || 挂载数据: 无 ) 
│   │   │   ├── 算术与赋值复合运算符 --> ( 难度等级: [0.0632, 0.0635) || 挂载数据: 无 ) 
│   │   │   └── 自增与自减运算符 --> ( 难度等级: [0.0635, 0.0639) || 挂载数据: 无 ) 
│   │   ├── 位运算符 --> ( 难度等级: [0.0639, 0.0653) || 挂载数据: 无 ) 
│   │   │   ├── 位逻辑运算符 --> ( 难度等级: [0.0639, 0.0642) || 挂载数据: 无 ) 
│   │   │   ├── 左移 --> ( 难度等级: [0.0642, 0.0644) || 挂载数据: 无 ) 
│   │   │   ├── 右移 --> ( 难度等级: [0.0644, 0.0647) || 挂载数据: 无 ) 
│   │   │   ├── 无符号右移 --> ( 难度等级: [0.0647, 0.065) || 挂载数据: qa: 4 ) 
│   │   │   └── 位运算符与赋值的组合 --> ( 难度等级: [0.065, 0.0653) || 挂载数据: qa: 9 ) 
│   │   ├── 关系运算符 --> ( 难度等级: [0.0653, 0.0667) || 挂载数据: 无 ) 
│   │   ├── 布尔逻辑运算符 --> ( 难度等级: [0.0667, 0.0681) || 挂载数据: 无 ) 
│   │   ├── 赋值运算符 --> ( 难度等级: [0.0681, 0.0694) || 挂载数据: 无 ) 
│   │   ├── “?”运算符 --> ( 难度等级: [0.0694, 0.0708) || 挂载数据: qa: 3 ) 
│   │   ├── 运算符的优先级 --> ( 难度等级: [0.0708, 0.0722) || 挂载数据: qa: 1 ) 
│   │   ├── 使用圆括号 --> ( 难度等级: [0.0722, 0.0736) || 挂载数据: 无 ) 
│   │   ├── 自增和自减运算符 --> ( 难度等级: [0.0736, 0.075) || 挂载数据: 无 ) 
│   │   ├── 复合赋值运算符 --> ( 难度等级: [0.075, 0.0764) || 挂载数据: 无 ) 
│   │   ├── 扩展后的赋值运算符 --> ( 难度等级: [0.0764, 0.0778) || 挂载数据: 无 ) 
│   │   ├── 三目运算符 --> ( 难度等级: [0.0778, 0.0792) || 挂载数据: qa: 3 ) 
│   │   ├── 数值类型之间的转换 --> ( 难度等级: [0.0792, 0.0806) || 挂载数据: 无 ) 
│   │   ├── 关系和boolean运算符 --> ( 难度等级: [0.0806, 0.0819) || 挂载数据: 无 ) 
│   │   └── 括号与运算符级别 --> ( 难度等级: [0.0819, 0.0833) || 挂载数据: qa: 2 ) 
│   ├── 控制语句 --> ( 难度等级: [0.0833, 0.1042) || 挂载数据: 无 ) 
│   │   ├── Java的选择语句 --> ( 难度等级: [0.0833, 0.0903) || 挂载数据: 无 ) 
│   │   │   ├── if语句 --> ( 难度等级: [0.0833, 0.0868) || 挂载数据: 无 ) 
│   │   │   └── switch语句 --> ( 难度等级: [0.0868, 0.0903) || 挂载数据: qa: 5 ) 
│   │   ├── 迭代语句 --> ( 难度等级: [0.0903, 0.0972) || 挂载数据: 无 ) 
│   │   │   ├── while语句 --> ( 难度等级: [0.0903, 0.0917) || 挂载数据: qa: 1 ) 
│   │   │   ├── do-while语句 --> ( 难度等级: [0.0917, 0.0931) || 挂载数据: 无 ) 
│   │   │   ├── for语句 --> ( 难度等级: [0.0931, 0.0944) || 挂载数据: qa: 1 ) 
│   │   │   ├── for循环的for-each版本 --> ( 难度等级: [0.0944, 0.0958) || 挂载数据: 无 ) 
│   │   │   └── 嵌套的循环 --> ( 难度等级: [0.0958, 0.0972) || 挂载数据: 无 ) 
│   │   └── 跳转语句 --> ( 难度等级: [0.0972, 0.1042) || 挂载数据: qa: 5 ) 
│   │       ├── 使用break语句 --> ( 难度等级: [0.0972, 0.0995) || 挂载数据: qa: 2 ) 
│   │       ├── 使用continue语句 --> ( 难度等级: [0.0995, 0.1019) || 挂载数据: 无 ) 
│   │       └── return语句 --> ( 难度等级: [0.1019, 0.1042) || 挂载数据: qa: 10 ) 
│   ├── 类 --> ( 难度等级: [0.1042, 0.125) || 挂载数据: qa: 4 ) 
│   │   ├── 类的基础知识 --> ( 难度等级: [0.1042, 0.1055) || 挂载数据: 无 ) 
│   │   │   ├── 类的一般形式 --> ( 难度等级: [0.1042, 0.1048) || 挂载数据: qa: 1 ) 
│   │   │   └── 一个简单的类 --> ( 难度等级: [0.1048, 0.1055) || 挂载数据: 无 ) 
│   │   ├── 声明对象 --> ( 难度等级: [0.1055, 0.1068) || 挂载数据: 无 ) 
│   │   ├── 为对象引用变量赋值 --> ( 难度等级: [0.1068, 0.1081) || 挂载数据: 无 ) 
│   │   ├── 方法 --> ( 难度等级: [0.1081, 0.1094) || 挂载数据: 无 ) 
│   │   │   ├── 为Box类添加方法 --> ( 难度等级: [0.1081, 0.1085) || 挂载数据: 无 ) 
│   │   │   ├── 返回值 --> ( 难度等级: [0.1085, 0.1089) || 挂载数据: qa: 2 ) 
│   │   │   └── 添加带参数的方法 --> ( 难度等级: [0.1089, 0.1094) || 挂载数据: 无 ) 
│   │   ├── 构造函数 --> ( 难度等级: [0.1094, 0.1107) || 挂载数据: qa: 1 ) 
│   │   ├── this关键字 --> ( 难度等级: [0.1107, 0.112) || 挂载数据: qa: 3 ) 
│   │   │   ├── 在构造器中调用构造器 --> ( 难度等级: [0.1107, 0.1113) || 挂载数据: 无 ) 
│   │   │   └── static的含义 --> ( 难度等级: [0.1113, 0.112) || 挂载数据: qa: 2 ) 
│   │   ├── 垃圾回收 --> ( 难度等级: [0.112, 0.1133) || 挂载数据: qa: 1 ) 
│   │   ├── finalize方法 --> ( 难度等级: [0.1133, 0.1146) || 挂载数据: 无 ) 
│   │   ├── 堆栈类 --> ( 难度等级: [0.1146, 0.1159) || 挂载数据: qa: 2 ) 
│   │   ├── 基本成员默认值 --> ( 难度等级: [0.1159, 0.1172) || 挂载数据: 无 ) 
│   │   ├── 成员变量 --> ( 难度等级: [0.1172, 0.1185) || 挂载数据: qa: 2 ) 
│   │   ├── 成员方法 --> ( 难度等级: [0.1185, 0.1198) || 挂载数据: qa: 1 ) 
│   │   ├── 权限修饰符 --> ( 难度等级: [0.1198, 0.1211) || 挂载数据: qa: 1 ) 
│   │   ├── 操作对象的Objects工具类 --> ( 难度等级: [0.1211, 0.1224) || 挂载数据: qa: 1 ) 
│   │   ├── ThreadLocalRandom与Random --> ( 难度等级: [0.1224, 0.1237) || 挂载数据: 无 ) 
│   │   └── BigDecimal类 --> ( 难度等级: [0.1237, 0.125) || 挂载数据: 无 ) 
│   ├── 方法和类的深入分析 --> ( 难度等级: [0.125, 0.1458) || 挂载数据: 无 ) 
│   │   ├── 重载方法 --> ( 难度等级: [0.125, 0.1266) || 挂载数据: 无 ) 
│   │   │   ├── 区分重载方法 --> ( 难度等级: [0.125, 0.1255) || 挂载数据: qa: 7 ) 
│   │   │   ├── 涉及基本类型的重载 --> ( 难度等级: [0.1255, 0.1261) || 挂载数据: 无 ) 
│   │   │   └── 以返回值区分重载方法 --> ( 难度等级: [0.1261, 0.1266) || 挂载数据: qa: 1 ) 
│   │   ├── 将对象用作参数 --> ( 难度等级: [0.1266, 0.1282) || 挂载数据: 无 ) 
│   │   ├── 参数传递的深入分析 --> ( 难度等级: [0.1282, 0.1298) || 挂载数据: 无 ) 
│   │   ├── 返回对象 --> ( 难度等级: [0.1298, 0.1314) || 挂载数据: 无 ) 
│   │   ├── 递归 --> ( 难度等级: [0.1314, 0.133) || 挂载数据: qa: 4 ) 
│   │   ├── 访问控制 --> ( 难度等级: [0.133, 0.1346) || 挂载数据: 无 ) 
│   │   │   └── Java类包 --> ( 难度等级: [0.133, 0.1346) || 挂载数据: 无 ) 
│   │   │       ├── 类名冲突 --> ( 难度等级: [0.133, 0.1335) || 挂载数据: 无 ) 
│   │   │       ├── 完整的类路径 --> ( 难度等级: [0.1335, 0.1341) || 挂载数据: 无 ) 
│   │   │       └── 创建包 --> ( 难度等级: [0.1341, 0.1346) || 挂载数据: qa: 1 ) 
│   │   ├── 理解static --> ( 难度等级: [0.1346, 0.1362) || 挂载数据: qa: 1 ) 
│   │   ├── final介绍 --> ( 难度等级: [0.1362, 0.1378) || 挂载数据: 无 ) 
│   │   ├── 重新审视数组 --> ( 难度等级: [0.1378, 0.1394) || 挂载数据: 无 ) 
│   │   ├── 嵌套类和内部类 --> ( 难度等级: [0.1394, 0.141) || 挂载数据: 无 ) 
│   │   │   ├── 成员内部类 --> ( 难度等级: [0.1394, 0.1395) || 挂载数据: qa: 1 ) 
│   │   │   ├── 局部内部类 --> ( 难度等级: [0.1395, 0.1396) || 挂载数据: qa: 1 ) 
│   │   │   ├── 静态内部类 --> ( 难度等级: [0.1396, 0.1397) || 挂载数据: qa: 1 ) 
│   │   │   ├── 匿名内部类 --> ( 难度等级: [0.1397, 0.1398) || 挂载数据: qa: 7 ) 
│   │   │   │   └── 再访工厂方法 --> ( 难度等级: [0.1397, 0.1398) || 挂载数据: 无 ) 
│   │   │   ├── 创建内部类 --> ( 难度等级: [0.1398, 0.1399) || 挂载数据: qa: 2 ) 
│   │   │   ├── 链接到外部类 --> ( 难度等级: [0.1399, 0.14) || 挂载数据: qa: 3 ) 
│   │   │   ├── 使用.this与.new --> ( 难度等级: [0.14, 0.1401) || 挂载数据: qa: 10 ) 
│   │   │   ├── 接口内部的类 --> ( 难度等级: [0.1401, 0.1402) || 挂载数据: qa: 2 ) 
│   │   │   ├── 从多层嵌套类中访问外部类的成员 --> ( 难度等级: [0.1402, 0.1403) || 挂载数据: 无 ) 
│   │   │   ├── 内部类的继承 --> ( 难度等级: [0.1403, 0.1404) || 挂载数据: qa: 2 ) 
│   │   │   ├── 内部类可以被覆盖吗 --> ( 难度等级: [0.1404, 0.1405) || 挂载数据: qa: 6 ) 
│   │   │   ├── 内部类标识符 --> ( 难度等级: [0.1405, 0.1406) || 挂载数据: 无 ) 
│   │   │   ├── 非静态内部类 --> ( 难度等级: [0.1406, 0.1406) || 挂载数据: 无 ) 
│   │   │   ├── 使用内部类访问对象状态 --> ( 难度等级: [0.1406, 0.1407) || 挂载数据: qa: 2 ) 
│   │   │   ├── 内部类的特殊语法规则 --> ( 难度等级: [0.1407, 0.1408) || 挂载数据: 无 ) 
│   │   │   ├── 内部类是否有用、必要和 --> ( 难度等级: [0.1408, 0.1409) || 挂载数据: 无 ) 
│   │   │   └── 由外部方法访问变量 --> ( 难度等级: [0.1409, 0.141) || 挂载数据: qa: 1 ) 
│   │   ├── String类介绍 --> ( 难度等级: [0.141, 0.1426) || 挂载数据: 无 ) 
│   │   ├── 使用命令行参数 --> ( 难度等级: [0.1426, 0.1442) || 挂载数据: 无 ) 
│   │   └── varargs：可变长度参数 --> ( 难度等级: [0.1442, 0.1458) || 挂载数据: 无 ) 
│   │       ├── 重载varargs方法 --> ( 难度等级: [0.1442, 0.145) || 挂载数据: 无 ) 
│   │       └── varargs方法与模糊性 --> ( 难度等级: [0.145, 0.1458) || 挂载数据: 无 ) 
│   ├── 继承 --> ( 难度等级: [0.1458, 0.1667) || 挂载数据: qa: 7 ) 
│   │   ├── 继承的基础知识 --> ( 难度等级: [0.1458, 0.1473) || 挂载数据: 无 ) 
│   │   │   ├── 成员访问与继承 --> ( 难度等级: [0.1458, 0.1463) || 挂载数据: 无 ) 
│   │   │   ├── 一个更实际的例子 --> ( 难度等级: [0.1463, 0.1468) || 挂载数据: 无 ) 
│   │   │   └── 超类变量可以引用子类对象 --> ( 难度等级: [0.1468, 0.1473) || 挂载数据: 无 ) 
│   │   ├── 使用super关键字 --> ( 难度等级: [0.1473, 0.1488) || 挂载数据: 无 ) 
│   │   │   ├── 使用super调用超类的构造函数 --> ( 难度等级: [0.1473, 0.1481) || 挂载数据: qa: 5 ) 
│   │   │   └── super的另一种用法 --> ( 难度等级: [0.1481, 0.1488) || 挂载数据: qa: 10 ) 
│   │   ├── 创建多级继承层次 --> ( 难度等级: [0.1488, 0.1503) || 挂载数据: 无 ) 
│   │   ├── 构造函数的调用时机 --> ( 难度等级: [0.1503, 0.1518) || 挂载数据: 无 ) 
│   │   ├── 方法重写 --> ( 难度等级: [0.1518, 0.1533) || 挂载数据: 无 ) 
│   │   ├── 动态方法调度 --> ( 难度等级: [0.1533, 0.1548) || 挂载数据: 无 ) 
│   │   │   ├── 重写方法的目的 --> ( 难度等级: [0.1533, 0.154) || 挂载数据: qa: 1 ) 
│   │   │   └── 应用方法重写 --> ( 难度等级: [0.154, 0.1548) || 挂载数据: qa: 3 ) 
│   │   ├── 使用抽象类 --> ( 难度等级: [0.1548, 0.1562) || 挂载数据: qa: 1 ) 
│   │   │   └── 抽象类的作用 --> ( 难度等级: [0.1548, 0.1562) || 挂载数据: qa: 10 ) 
│   │   ├── 在继承中使用final关键字 --> ( 难度等级: [0.1562, 0.1577) || 挂载数据: 无 ) 
│   │   │   ├── 使用final关键字阻止重写 --> ( 难度等级: [0.1562, 0.157) || 挂载数据: 无 ) 
│   │   │   └── 使用final关键字阻止继承 --> ( 难度等级: [0.157, 0.1577) || 挂载数据: 无 ) 
│   │   ├── Object类 --> ( 难度等级: [0.1577, 0.1592) || 挂载数据: 无 ) 
│   │   ├── “是一个”（is-a）与“像是一个”（is-like-a）关系 --> ( 难度等级: [0.1592, 0.1607) || 挂载数据: qa: 8 ) 
│   │   ├── Object：所有类的超类 --> ( 难度等级: [0.1607, 0.1622) || 挂载数据: qa: 1 ) 
│   │   │   ├── Object类型的变量 --> ( 难度等级: [0.1607, 0.1615) || 挂载数据: qa: 10 ) 
│   │   │   └── hashCode方法 --> ( 难度等级: [0.1615, 0.1622) || 挂载数据: qa: 4 ) 
│   │   ├── 泛型数组列表 --> ( 难度等级: [0.1622, 0.1637) || 挂载数据: 无 ) 
│   │   │   ├── 声明数组列表 --> ( 难度等级: [0.1622, 0.1627) || 挂载数据: 无 ) 
│   │   │   ├── 访问数组列表元素 --> ( 难度等级: [0.1627, 0.1632) || 挂载数据: 无 ) 
│   │   │   └── 类型化与原始数组列表的 --> ( 难度等级: [0.1632, 0.1637) || 挂载数据: 无 ) 
│   │   ├── 参数数量可变的方法 --> ( 难度等级: [0.1637, 0.1652) || 挂载数据: 无 ) 
│   │   └── 继承的设计技巧 --> ( 难度等级: [0.1652, 0.1667) || 挂载数据: 无 ) 
│   ├── 包和接口 --> ( 难度等级: [0.1667, 0.1875) || 挂载数据: 无 ) 
│   │   ├── 包 --> ( 难度等级: [0.1667, 0.1696) || 挂载数据: 无 ) 
│   │   │   ├── 定义包 --> ( 难度等级: [0.1667, 0.1669) || 挂载数据: 无 ) 
│   │   │   ├── 包查找与CLASSPATH --> ( 难度等级: [0.1669, 0.1671) || 挂载数据: qa: 1 ) 
│   │   │   ├── 一个简短的包示例 --> ( 难度等级: [0.1671, 0.1673) || 挂载数据: 无 ) 
│   │   │   ├── 代码组织 --> ( 难度等级: [0.1673, 0.1675) || 挂载数据: 无 ) 
│   │   │   ├── 创建独一无二的包名 --> ( 难度等级: [0.1675, 0.1677) || 挂载数据: 无 ) 
│   │   │   ├── 定制工具库 --> ( 难度等级: [0.1677, 0.1679) || 挂载数据: 无 ) 
│   │   │   ├── 用import改变行为 --> ( 难度等级: [0.1679, 0.1682) || 挂载数据: qa: 7 ) 
│   │   │   ├── 对使用包的忠告 --> ( 难度等级: [0.1682, 0.1684) || 挂载数据: 无 ) 
│   │   │   ├── 包名 --> ( 难度等级: [0.1684, 0.1686) || 挂载数据: 无 ) 
│   │   │   ├── 类的导入 --> ( 难度等级: [0.1686, 0.1688) || 挂载数据: qa: 5 ) 
│   │   │   ├── 在包中增加类 --> ( 难度等级: [0.1688, 0.169) || 挂载数据: 无 ) 
│   │   │   ├── 包访问 --> ( 难度等级: [0.169, 0.1692) || 挂载数据: qa: 8 ) 
│   │   │   ├── 类路径 --> ( 难度等级: [0.1692, 0.1694) || 挂载数据: qa: 3 ) 
│   │   │   └── 设置类路径 --> ( 难度等级: [0.1694, 0.1696) || 挂载数据: qa: 1 ) 
│   │   ├── 访问保护 --> ( 难度等级: [0.1696, 0.1726) || 挂载数据: 无 ) 
│   │   ├── 导入包 --> ( 难度等级: [0.1726, 0.1756) || 挂载数据: qa: 5 ) 
│   │   ├── 接口 --> ( 难度等级: [0.1756, 0.1786) || 挂载数据: qa: 1 ) 
│   │   │   ├── 定义接口 --> ( 难度等级: [0.1756, 0.1758) || 挂载数据: qa: 6 ) 
│   │   │   ├── 实现接口 --> ( 难度等级: [0.1758, 0.1759) || 挂载数据: qa: 10 ) 
│   │   │   ├── 嵌套接口 --> ( 难度等级: [0.1759, 0.1761) || 挂载数据: qa: 3 ) 
│   │   │   ├── 应用接口 --> ( 难度等级: [0.1761, 0.1763) || 挂载数据: 无 ) 
│   │   │   ├── 接口中的变量 --> ( 难度等级: [0.1763, 0.1765) || 挂载数据: 无 ) 
│   │   │   ├── 接口可以扩展 --> ( 难度等级: [0.1765, 0.1766) || 挂载数据: 无 ) 
│   │   │   ├── 完全解耦 --> ( 难度等级: [0.1766, 0.1768) || 挂载数据: qa: 6 ) 
│   │   │   ├── Java中的“多重继承” --> ( 难度等级: [0.1768, 0.177) || 挂载数据: 无 ) 
│   │   │   ├── 通过继承来扩展接口 --> ( 难度等级: [0.177, 0.1772) || 挂载数据: 无 ) 
│   │   │   │   └── 组合接口时的名字冲突 --> ( 难度等级: [0.177, 0.1772) || 挂载数据: qa: 2 ) 
│   │   │   ├── 适配接口 --> ( 难度等级: [0.1772, 0.1773) || 挂载数据: qa: 1 ) 
│   │   │   ├── 接口中的域 --> ( 难度等级: [0.1773, 0.1775) || 挂载数据: 无 ) 
│   │   │   │   └── 初始化接口中的域 --> ( 难度等级: [0.1773, 0.1775) || 挂载数据: qa: 10 ) 
│   │   │   ├── 接口的属性 --> ( 难度等级: [0.1775, 0.1777) || 挂载数据: 无 ) 
│   │   │   ├── 静态和私有方法 --> ( 难度等级: [0.1777, 0.1779) || 挂载数据: 无 ) 
│   │   │   ├── 默认方法 --> ( 难度等级: [0.1779, 0.178) || 挂载数据: 无 ) 
│   │   │   ├── 解决默认方法冲突 --> ( 难度等级: [0.178, 0.1782) || 挂载数据: 无 ) 
│   │   │   ├── Comparator接口 --> ( 难度等级: [0.1782, 0.1784) || 挂载数据: 无 ) 
│   │   │   └── 对象克隆 --> ( 难度等级: [0.1784, 0.1786) || 挂载数据: 无 ) 
│   │   ├── 默认接口方法 --> ( 难度等级: [0.1786, 0.1815) || 挂载数据: 无 ) 
│   │   │   ├── 默认方法的基础知识 --> ( 难度等级: [0.1786, 0.1801) || 挂载数据: 无 ) 
│   │   │   └── 一个更加实用的例子 --> ( 难度等级: [0.1801, 0.1815) || 挂载数据: 无 ) 
│   │   ├── 在接口中使用静态方法 --> ( 难度等级: [0.1815, 0.1845) || 挂载数据: 无 ) 
│   │   └── 关于包和接口的最后说明 --> ( 难度等级: [0.1845, 0.1875) || 挂载数据: 无 ) 
│   ├── 异常处理 --> ( 难度等级: [0.1875, 0.2083) || 挂载数据: qa: 1 ) 
│   │   ├── 异常处理的基础知识 --> ( 难度等级: [0.1875, 0.1882) || 挂载数据: 无 ) 
│   │   ├── 异常类型 --> ( 难度等级: [0.1882, 0.1888) || 挂载数据: qa: 1 ) 
│   │   ├── 未捕获的异常 --> ( 难度等级: [0.1888, 0.1895) || 挂载数据: 无 ) 
│   │   ├── 使用try和catch --> ( 难度等级: [0.1895, 0.1901) || 挂载数据: qa: 1 ) 
│   │   ├── 多条catch子句 --> ( 难度等级: [0.1901, 0.1908) || 挂载数据: 无 ) 
│   │   ├── 嵌套的try语句 --> ( 难度等级: [0.1908, 0.1914) || 挂载数据: 无 ) 
│   │   ├── throw --> ( 难度等级: [0.1914, 0.1921) || 挂载数据: 无 ) 
│   │   ├── throws --> ( 难度等级: [0.1921, 0.1927) || 挂载数据: qa: 1 ) 
│   │   ├── finally --> ( 难度等级: [0.1927, 0.1934) || 挂载数据: 无 ) 
│   │   ├── Java的内置异常 --> ( 难度等级: [0.1934, 0.194) || 挂载数据: 无 ) 
│   │   ├── 创建自己的异常子类 --> ( 难度等级: [0.194, 0.1947) || 挂载数据: 无 ) 
│   │   ├── 链式异常 --> ( 难度等级: [0.1947, 0.1953) || 挂载数据: 无 ) 
│   │   ├── 3个近期添加的异常特性 --> ( 难度等级: [0.1953, 0.196) || 挂载数据: 无 ) 
│   │   ├── 使用异常 --> ( 难度等级: [0.196, 0.1966) || 挂载数据: qa: 1 ) 
│   │   │   ├── 异常的类型 --> ( 难度等级: [0.196, 0.1961) || 挂载数据: qa: 8 ) 
│   │   │   ├── throws关键字 --> ( 难度等级: [0.1961, 0.1962) || 挂载数据: 无 ) 
│   │   │   ├── throw关键字 --> ( 难度等级: [0.1962, 0.1964) || 挂载数据: 无 ) 
│   │   │   ├── 自定义异常 --> ( 难度等级: [0.1964, 0.1965) || 挂载数据: 无 ) 
│   │   │   └── 异常参数 --> ( 难度等级: [0.1965, 0.1966) || 挂载数据: 无 ) 
│   │   ├── 异常概述 --> ( 难度等级: [0.1966, 0.1973) || 挂载数据: 无 ) 
│   │   ├── 捕捉处理异常 --> ( 难度等级: [0.1973, 0.1979) || 挂载数据: 无 ) 
│   │   │   └── try-catch代码块 --> ( 难度等级: [0.1973, 0.1979) || 挂载数据: 无 ) 
│   │   ├── 在方法中抛出异常 --> ( 难度等级: [0.1979, 0.1986) || 挂载数据: 无 ) 
│   │   │   ├── 使用throws关键字抛出异常 --> ( 难度等级: [0.1979, 0.1982) || 挂载数据: qa: 2 ) 
│   │   │   └── 使用throw关键字抛出异常 --> ( 难度等级: [0.1982, 0.1986) || 挂载数据: 无 ) 
│   │   ├── 处理程序异常错误 --> ( 难度等级: [0.1986, 0.1992) || 挂载数据: 无 ) 
│   │   │   └── 错误 --> ( 难度等级: [0.1986, 0.1992) || 挂载数据: 无 ) 
│   │   ├── Java常见异常 --> ( 难度等级: [0.1992, 0.1999) || 挂载数据: 无 ) 
│   │   ├── 运行时异常 --> ( 难度等级: [0.1999, 0.2005) || 挂载数据: 无 ) 
│   │   ├── 异常处理机制 --> ( 难度等级: [0.2005, 0.2012) || 挂载数据: 无 ) 
│   │   │   ├── 使用try...catch捕获异常 --> ( 难度等级: [0.2005, 0.2006) || 挂载数据: qa: 1 ) 
│   │   │   ├── 异常类的继承体系 --> ( 难度等级: [0.2006, 0.2007) || 挂载数据: 无 ) 
│   │   │   ├── 多异常捕获 --> ( 难度等级: [0.2007, 0.2008) || 挂载数据: qa: 1 ) 
│   │   │   ├── 访问异常信息 --> ( 难度等级: [0.2008, 0.2009) || 挂载数据: qa: 3 ) 
│   │   │   ├── 使用finally回收资源 --> ( 难度等级: [0.2009, 0.201) || 挂载数据: 无 ) 
│   │   │   ├── 异常处理的嵌套 --> ( 难度等级: [0.201, 0.2011) || 挂载数据: qa: 6 ) 
│   │   │   └── Java 9增强的自动关闭资源的try语句 --> ( 难度等级: [0.2011, 0.2012) || 挂载数据: 无 ) 
│   │   ├── Checked异常和Runtime异常体系 --> ( 难度等级: [0.2012, 0.2018) || 挂载数据: 无 ) 
│   │   │   ├── 使用throws声明抛出异常 --> ( 难度等级: [0.2012, 0.2015) || 挂载数据: 无 ) 
│   │   │   └── 方法重写时声明抛出异常的限制 --> ( 难度等级: [0.2015, 0.2018) || 挂载数据: 无 ) 
│   │   ├── 使用throw抛出异常 --> ( 难度等级: [0.2018, 0.2025) || 挂载数据: 无 ) 
│   │   │   ├── 自定义异常类 --> ( 难度等级: [0.2018, 0.2021) || 挂载数据: qa: 4 ) 
│   │   │   └── 使用throw语句抛出异常 --> ( 难度等级: [0.2021, 0.2025) || 挂载数据: qa: 4 ) 
│   │   ├── Java的异常跟踪栈 --> ( 难度等级: [0.2025, 0.2031) || 挂载数据: 无 ) 
│   │   ├── 异常处理规则 --> ( 难度等级: [0.2031, 0.2038) || 挂载数据: 无 ) 
│   │   │   ├── 不要过度使用异常 --> ( 难度等级: [0.2031, 0.2033) || 挂载数据: 无 ) 
│   │   │   ├── 不要使用过于庞大的try块 --> ( 难度等级: [0.2033, 0.2035) || 挂载数据: 无 ) 
│   │   │   ├── 避免使用Catch All语句 --> ( 难度等级: [0.2035, 0.2036) || 挂载数据: qa: 1 ) 
│   │   │   └── 不要忽略捕获到的异常 --> ( 难度等级: [0.2036, 0.2038) || 挂载数据: 无 ) 
│   │   ├── Java的异常 --> ( 难度等级: [0.2038, 0.2044) || 挂载数据: 无 ) 
│   │   ├── NullPointerException --> ( 难度等级: [0.2044, 0.2051) || 挂载数据: qa: 6 ) 
│   │   ├── 使用断言 --> ( 难度等级: [0.2051, 0.2057) || 挂载数据: 无 ) 
│   │   ├── 使用JDK Logging --> ( 难度等级: [0.2057, 0.2064) || 挂载数据: 无 ) 
│   │   ├── 使用Commons Logging --> ( 难度等级: [0.2064, 0.207) || 挂载数据: qa: 1 ) 
│   │   ├── 使用Log4j --> ( 难度等级: [0.207, 0.2077) || 挂载数据: qa: 4 ) 
│   │   └── 使用SLF4J和Logback --> ( 难度等级: [0.2077, 0.2083) || 挂载数据: qa: 2 ) 
│   ├── 多线程编程 --> ( 难度等级: [0.2083, 0.2292) || 挂载数据: 无 ) 
│   │   ├── Java线程模型 --> ( 难度等级: [0.2083, 0.2102) || 挂载数据: 无 ) 
│   │   │   ├── 线程优先级 --> ( 难度等级: [0.2083, 0.2088) || 挂载数据: 无 ) 
│   │   │   ├── 同步 --> ( 难度等级: [0.2088, 0.2093) || 挂载数据: 无 ) 
│   │   │   ├── 消息传递 --> ( 难度等级: [0.2093, 0.2098) || 挂载数据: 无 ) 
│   │   │   └── Thread类和Runnable接口 --> ( 难度等级: [0.2098, 0.2102) || 挂载数据: 无 ) 
│   │   ├── 主线程 --> ( 难度等级: [0.2102, 0.2121) || 挂载数据: 无 ) 
│   │   ├── 创建线程 --> ( 难度等级: [0.2121, 0.214) || 挂载数据: 无 ) 
│   │   │   ├── 实现Runnable接口 --> ( 难度等级: [0.2121, 0.2124) || 挂载数据: 无 ) 
│   │   │   ├── 扩展Thread类 --> ( 难度等级: [0.2124, 0.2126) || 挂载数据: 无 ) 
│   │   │   ├── 选择一种创建方式 --> ( 难度等级: [0.2126, 0.2128) || 挂载数据: qa: 2 ) 
│   │   │   ├── Thread类实现多线程 --> ( 难度等级: [0.2128, 0.2131) || 挂载数据: 无 ) 
│   │   │   ├── Runnable接口实现多线程 --> ( 难度等级: [0.2131, 0.2133) || 挂载数据: 无 ) 
│   │   │   ├── Callable接口实现多线程 --> ( 难度等级: [0.2133, 0.2135) || 挂载数据: 无 ) 
│   │   │   ├── 三种实现多线程方式的对比分析 --> ( 难度等级: [0.2135, 0.2138) || 挂载数据: 无 ) 
│   │   │   └── 后台线程 --> ( 难度等级: [0.2138, 0.214) || 挂载数据: qa: 2 ) 
│   │   ├── 创建多个线程 --> ( 难度等级: [0.214, 0.2159) || 挂载数据: 无 ) 
│   │   ├── 使用isAlive和join方法 --> ( 难度等级: [0.2159, 0.2178) || 挂载数据: 无 ) 
│   │   ├── 线程优先级 --> ( 难度等级: [0.2178, 0.2197) || 挂载数据: 无 ) 
│   │   ├── 同步 --> ( 难度等级: [0.2197, 0.2216) || 挂载数据: 无 ) 
│   │   │   ├── 使用同步方法 --> ( 难度等级: [0.2197, 0.2199) || 挂载数据: qa: 1 ) 
│   │   │   ├── synchronized语句 --> ( 难度等级: [0.2199, 0.2201) || 挂载数据: 无 ) 
│   │   │   ├── 竞态条件的一个例子 --> ( 难度等级: [0.2201, 0.2203) || 挂载数据: 无 ) 
│   │   │   ├── 竞态条件详解 --> ( 难度等级: [0.2203, 0.2205) || 挂载数据: 无 ) 
│   │   │   ├── 锁对象 --> ( 难度等级: [0.2205, 0.2206) || 挂载数据: qa: 2 ) 
│   │   │   ├── 条件对象 --> ( 难度等级: [0.2206, 0.2208) || 挂载数据: 无 ) 
│   │   │   ├── synchronized关键字 --> ( 难度等级: [0.2208, 0.221) || 挂载数据: qa: 10 ) 
│   │   │   ├── 监视器概念 --> ( 难度等级: [0.221, 0.2212) || 挂载数据: 无 ) 
│   │   │   ├── volatile字段 --> ( 难度等级: [0.2212, 0.2214) || 挂载数据: 无 ) 
│   │   │   └── 线程局部变量 --> ( 难度等级: [0.2214, 0.2216) || 挂载数据: 无 ) 
│   │   ├── 线程间通信 --> ( 难度等级: [0.2216, 0.2235) || 挂载数据: 无 ) 
│   │   ├── 挂起、恢复与停止线程 --> ( 难度等级: [0.2235, 0.2254) || 挂载数据: qa: 1 ) 
│   │   ├── 获取线程的状态 --> ( 难度等级: [0.2254, 0.2273) || 挂载数据: 无 ) 
│   │   └── 使用多线程 --> ( 难度等级: [0.2273, 0.2292) || 挂载数据: 无 ) 
│   │       ├── 线程概述 --> ( 难度等级: [0.2273, 0.2274) || 挂载数据: 无 ) 
│   │       │   ├── 进程 --> ( 难度等级: [0.2273, 0.2273) || 挂载数据: 无 ) 
│   │       │   │   ├── 建立一个进程 --> ( 难度等级: [0.2273, 0.2273) || 挂载数据: qa: 8 ) 
│   │       │   │   ├── 运行一个进程 --> ( 难度等级: [0.2273, 0.2273) || 挂载数据: qa: 6 ) 
│   │       │   │   └── 进程句柄 --> ( 难度等级: [0.2273, 0.2273) || 挂载数据: 无 ) 
│   │       │   ├── 线程 --> ( 难度等级: [0.2273, 0.2274) || 挂载数据: qa: 10 ) 
│   │       │   └── 多线程的优势 --> ( 难度等级: [0.2274, 0.2274) || 挂载数据: 无 ) 
│   │       ├── 线程的生命周期及状态转换 --> ( 难度等级: [0.2274, 0.2275) || 挂载数据: 无 ) 
│   │       │   ├── 新建和就绪状态 --> ( 难度等级: [0.2274, 0.2275) || 挂载数据: qa: 4 ) 
│   │       │   ├── 运行和阻塞状态 --> ( 难度等级: [0.2275, 0.2275) || 挂载数据: 无 ) 
│   │       │   └── 线程死亡 --> ( 难度等级: [0.2275, 0.2275) || 挂载数据: 无 ) 
│   │       ├── 线程的调度 --> ( 难度等级: [0.2275, 0.2277) || 挂载数据: 无 ) 
│   │       │   ├── 线程休眠 --> ( 难度等级: [0.2275, 0.2276) || 挂载数据: qa: 1 ) 
│   │       │   ├── 线程让步 --> ( 难度等级: [0.2276, 0.2276) || 挂载数据: 无 ) 
│   │       │   └── 线程插队 --> ( 难度等级: [0.2276, 0.2277) || 挂载数据: 无 ) 
│   │       ├── 多线程同步 --> ( 难度等级: [0.2277, 0.2278) || 挂载数据: qa: 3 ) 
│   │       │   ├── 同步代码块 --> ( 难度等级: [0.2277, 0.2277) || 挂载数据: qa: 8 ) 
│   │       │   └── 同步锁 --> ( 难度等级: [0.2277, 0.2278) || 挂载数据: qa: 1 ) 
│   │       ├── 多线程通信 --> ( 难度等级: [0.2278, 0.2279) || 挂载数据: 无 ) 
│   │       ├── 线程池 --> ( 难度等级: [0.2279, 0.2281) || 挂载数据: qa: 1 ) 
│   │       │   ├── Executor接口实现线程池管理 --> ( 难度等级: [0.2279, 0.228) || 挂载数据: 无 ) 
│   │       │   ├── CompletableFuture类实现线程池管理 --> ( 难度等级: [0.228, 0.228) || 挂载数据: 无 ) 
│   │       │   ├── 使用线程池管理线程 --> ( 难度等级: [0.228, 0.2281) || 挂载数据: 无 ) 
│   │       │   └── 使用ForkJoinPool利用多CPU --> ( 难度等级: [0.2281, 0.2281) || 挂载数据: qa: 10 ) 
│   │       ├── 线程简介 --> ( 难度等级: [0.2281, 0.2282) || 挂载数据: 无 ) 
│   │       ├── 实现线程的两种方式 --> ( 难度等级: [0.2282, 0.2284) || 挂载数据: 无 ) 
│   │       │   └── 继承Thread类 --> ( 难度等级: [0.2282, 0.2284) || 挂载数据: qa: 1 ) 
│   │       ├── 操作线程的方法 --> ( 难度等级: [0.2284, 0.2285) || 挂载数据: 无 ) 
│   │       │   ├── 线程的中断 --> ( 难度等级: [0.2284, 0.2284) || 挂载数据: qa: 1 ) 
│   │       │   └── 线程的礼让 --> ( 难度等级: [0.2284, 0.2285) || 挂载数据: 无 ) 
│   │       ├── 线程的同步 --> ( 难度等级: [0.2285, 0.2286) || 挂载数据: qa: 3 ) 
│   │       │   ├── 线程同步机制 --> ( 难度等级: [0.2285, 0.2285) || 挂载数据: qa: 5 ) 
│   │       │   ├── 释放同步监视器的锁定 --> ( 难度等级: [0.2285, 0.2286) || 挂载数据: 无 ) 
│   │       │   └── 同步锁（Lock） --> ( 难度等级: [0.2286, 0.2286) || 挂载数据: qa: 2 ) 
│   │       ├── 控制线程 --> ( 难度等级: [0.2286, 0.2288) || 挂载数据: qa: 1 ) 
│   │       │   ├── join线程 --> ( 难度等级: [0.2286, 0.2287) || 挂载数据: 无 ) 
│   │       │   ├── 线程睡眠：sleep --> ( 难度等级: [0.2287, 0.2287) || 挂载数据: qa: 5 ) 
│   │       │   └── 改变线程优先级 --> ( 难度等级: [0.2287, 0.2288) || 挂载数据: 无 ) 
│   │       ├── 线程通信 --> ( 难度等级: [0.2288, 0.2289) || 挂载数据: 无 ) 
│   │       │   ├── 传统的线程通信 --> ( 难度等级: [0.2288, 0.2288) || 挂载数据: 无 ) 
│   │       │   ├── 使用Condition控制线程通信 --> ( 难度等级: [0.2288, 0.2289) || 挂载数据: 无 ) 
│   │       │   └── 使用阻塞队列（BlockingQueue）控制线程通信 --> ( 难度等级: [0.2289, 0.2289) || 挂载数据: 无 ) 
│   │       ├── 线程组和未处理的异常 --> ( 难度等级: [0.2289, 0.229) || 挂载数据: 无 ) 
│   │       └── 线程相关类 --> ( 难度等级: [0.229, 0.2292) || 挂载数据: 无 ) 
│   │           ├── ThreadLocal类 --> ( 难度等级: [0.229, 0.2291) || 挂载数据: qa: 2 ) 
│   │           ├── 包装线程不安全的集合 --> ( 难度等级: [0.2291, 0.2291) || 挂载数据: qa: 1 ) 
│   │           ├── 线程安全的集合类 --> ( 难度等级: [0.2291, 0.2291) || 挂载数据: qa: 1 ) 
│   │           └── Java 9新增的发布-订阅框架 --> ( 难度等级: [0.2291, 0.2292) || 挂载数据: 无 ) 
│   ├── 枚举、自动装箱与注解(元数据) --> ( 难度等级: [0.2292, 0.25) || 挂载数据: 无 ) 
│   │   ├── 枚举 --> ( 难度等级: [0.2292, 0.2326) || 挂载数据: qa: 2 ) 
│   │   │   ├── 枚举的基础知识 --> ( 难度等级: [0.2292, 0.2299) || 挂载数据: qa: 1 ) 
│   │   │   ├── values和valueOf方法 --> ( 难度等级: [0.2299, 0.2306) || 挂载数据: qa: 1 ) 
│   │   │   ├── Java枚举是类类型 --> ( 难度等级: [0.2306, 0.2313) || 挂载数据: 无 ) 
│   │   │   ├── 枚举继承自Enum类 --> ( 难度等级: [0.2313, 0.2319) || 挂载数据: 无 ) 
│   │   │   └── 另一个枚举示例 --> ( 难度等级: [0.2319, 0.2326) || 挂载数据: 无 ) 
│   │   ├── 类型封装器 --> ( 难度等级: [0.2326, 0.2361) || 挂载数据: 无 ) 
│   │   │   ├── Character封装器 --> ( 难度等级: [0.2326, 0.2338) || 挂载数据: 无 ) 
│   │   │   ├── Boolean封装器 --> ( 难度等级: [0.2338, 0.235) || 挂载数据: 无 ) 
│   │   │   └── 数值类型封装器 --> ( 难度等级: [0.235, 0.2361) || 挂载数据: 无 ) 
│   │   ├── 自动装箱 --> ( 难度等级: [0.2361, 0.2396) || 挂载数据: 无 ) 
│   │   │   ├── 自动装箱与方法 --> ( 难度等级: [0.2361, 0.2368) || 挂载数据: qa: 10 ) 
│   │   │   ├── 表达式中发生的自动装箱/拆箱 --> ( 难度等级: [0.2368, 0.2375) || 挂载数据: 无 ) 
│   │   │   ├── 布尔型和字符型数值的自动装箱/拆箱 --> ( 难度等级: [0.2375, 0.2382) || 挂载数据: 无 ) 
│   │   │   ├── 自动装箱/拆箱有助于防止错误 --> ( 难度等级: [0.2382, 0.2389) || 挂载数据: qa: 2 ) 
│   │   │   └── 一些警告 --> ( 难度等级: [0.2389, 0.2396) || 挂载数据: 无 ) 
│   │   ├── 注解(元数据) --> ( 难度等级: [0.2396, 0.2431) || 挂载数据: 无 ) 
│   │   │   ├── 注解的基础知识 --> ( 难度等级: [0.2396, 0.24) || 挂载数据: 无 ) 
│   │   │   ├── 指定保留策略 --> ( 难度等级: [0.24, 0.2405) || 挂载数据: qa: 2 ) 
│   │   │   ├── 在运行时使用反射获取注解 --> ( 难度等级: [0.2405, 0.2409) || 挂载数据: qa: 2 ) 
│   │   │   ├── AnnotatedElement接口 --> ( 难度等级: [0.2409, 0.2413) || 挂载数据: 无 ) 
│   │   │   ├── 使用默认值 --> ( 难度等级: [0.2413, 0.2418) || 挂载数据: 无 ) 
│   │   │   ├── 标记注解 --> ( 难度等级: [0.2418, 0.2422) || 挂载数据: 无 ) 
│   │   │   ├── 单成员注解 --> ( 难度等级: [0.2422, 0.2426) || 挂载数据: 无 ) 
│   │   │   └── 内置注解 --> ( 难度等级: [0.2426, 0.2431) || 挂载数据: 无 ) 
│   │   ├── 类型注解 --> ( 难度等级: [0.2431, 0.2465) || 挂载数据: 无 ) 
│   │   └── 重复注解 --> ( 难度等级: [0.2465, 0.25) || 挂载数据: qa: 2 ) 
│   ├── I/O、applet以及其他主题 --> ( 难度等级: [0.25, 0.2708) || 挂载数据: 无 ) 
│   │   ├── I/O的基础知识 --> ( 难度等级: [0.25, 0.2509) || 挂载数据: 无 ) 
│   │   │   ├── 流 --> ( 难度等级: [0.25, 0.2503) || 挂载数据: 无 ) 
│   │   │   ├── 字节流和字符流 --> ( 难度等级: [0.2503, 0.2506) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符流概述 --> ( 难度等级: [0.2503, 0.2504) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 字符流操作文件 --> ( 难度等级: [0.2504, 0.2505) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 转换流 --> ( 难度等级: [0.2505, 0.2506) || 挂载数据: qa: 7 ) 
│   │   │   └── 预定义流 --> ( 难度等级: [0.2506, 0.2509) || 挂载数据: 无 ) 
│   │   ├── 读取控制台输入 --> ( 难度等级: [0.2509, 0.2519) || 挂载数据: 无 ) 
│   │   │   ├── 读取字符 --> ( 难度等级: [0.2509, 0.2514) || 挂载数据: qa: 10 ) 
│   │   │   └── 读取字符串 --> ( 难度等级: [0.2514, 0.2519) || 挂载数据: 无 ) 
│   │   ├── 向控制台写输出 --> ( 难度等级: [0.2519, 0.2528) || 挂载数据: 无 ) 
│   │   ├── PrintWriter类 --> ( 难度等级: [0.2528, 0.2538) || 挂载数据: 无 ) 
│   │   ├── 读/写文件 --> ( 难度等级: [0.2538, 0.2547) || 挂载数据: qa: 1 ) 
│   │   ├── 自动关闭文件 --> ( 难度等级: [0.2547, 0.2557) || 挂载数据: 无 ) 
│   │   ├── applet的基础知识 --> ( 难度等级: [0.2557, 0.2566) || 挂载数据: 无 ) 
│   │   ├── transient和volatile修饰符 --> ( 难度等级: [0.2566, 0.2576) || 挂载数据: 无 ) 
│   │   ├── 使用instanceof运算符 --> ( 难度等级: [0.2576, 0.2585) || 挂载数据: 无 ) 
│   │   ├── strictfp --> ( 难度等级: [0.2585, 0.2595) || 挂载数据: 无 ) 
│   │   ├── 本地方法 --> ( 难度等级: [0.2595, 0.2604) || 挂载数据: qa: 3 ) 
│   │   ├── 使用assert --> ( 难度等级: [0.2604, 0.2614) || 挂载数据: 无 ) 
│   │   ├── 静态导入 --> ( 难度等级: [0.2614, 0.2623) || 挂载数据: 无 ) 
│   │   ├── 通过this调用重载的构造函数 --> ( 难度等级: [0.2623, 0.2633) || 挂载数据: qa: 1 ) 
│   │   ├── 紧凑API配置文件 --> ( 难度等级: [0.2633, 0.2642) || 挂载数据: 无 ) 
│   │   ├── 转换数据 --> ( 难度等级: [0.2642, 0.2652) || 挂载数据: qa: 1 ) 
│   │   ├── 获取基本类型 --> ( 难度等级: [0.2652, 0.2661) || 挂载数据: 无 ) 
│   │   ├── 视图缓冲器 --> ( 难度等级: [0.2661, 0.267) || 挂载数据: 无 ) 
│   │   ├── 用缓冲器操纵数据 --> ( 难度等级: [0.267, 0.268) || 挂载数据: 无 ) 
│   │   ├── 缓冲器的细节 --> ( 难度等级: [0.268, 0.2689) || 挂载数据: 无 ) 
│   │   ├── 内存映射文件 --> ( 难度等级: [0.2689, 0.2699) || 挂载数据: 无 ) 
│   │   └── 文件加锁 --> ( 难度等级: [0.2699, 0.2708) || 挂载数据: 无 ) 
│   ├── 泛型 --> ( 难度等级: [0.2708, 0.2917) || 挂载数据: qa: 5 ) 
│   │   ├── 什么是泛型 --> ( 难度等级: [0.2708, 0.2713) || 挂载数据: qa: 1 ) 
│   │   ├── 一个简单的泛型示例 --> ( 难度等级: [0.2713, 0.2718) || 挂载数据: 无 ) 
│   │   │   ├── 泛型只使用引用类型 --> ( 难度等级: [0.2713, 0.2715) || 挂载数据: 无 ) 
│   │   │   ├── 基于不同类型参数的泛型类型是不同的 --> ( 难度等级: [0.2715, 0.2717) || 挂载数据: qa: 3 ) 
│   │   │   └── 泛型提升类型安全性的原理 --> ( 难度等级: [0.2717, 0.2718) || 挂载数据: 无 ) 
│   │   ├── 带两个类型参数的泛型类 --> ( 难度等级: [0.2718, 0.2724) || 挂载数据: 无 ) 
│   │   ├── 泛型类的一般形式 --> ( 难度等级: [0.2724, 0.2729) || 挂载数据: qa: 2 ) 
│   │   ├── 有界类型 --> ( 难度等级: [0.2729, 0.2734) || 挂载数据: 无 ) 
│   │   ├── 使用通配符参数 --> ( 难度等级: [0.2734, 0.2739) || 挂载数据: 无 ) 
│   │   ├── 创建泛型方法 --> ( 难度等级: [0.2739, 0.2744) || 挂载数据: 无 ) 
│   │   ├── 泛型接口 --> ( 难度等级: [0.2744, 0.2749) || 挂载数据: qa: 1 ) 
│   │   ├── 原始类型与遗留代码 --> ( 难度等级: [0.2749, 0.2754) || 挂载数据: 无 ) 
│   │   ├── 泛型类层次 --> ( 难度等级: [0.2754, 0.2759) || 挂载数据: qa: 1 ) 
│   │   │   ├── 使用泛型超类 --> ( 难度等级: [0.2754, 0.2755) || 挂载数据: 无 ) 
│   │   │   ├── 泛型子类 --> ( 难度等级: [0.2755, 0.2756) || 挂载数据: 无 ) 
│   │   │   ├── 泛型层次中的运行时类型比较 --> ( 难度等级: [0.2756, 0.2757) || 挂载数据: 无 ) 
│   │   │   ├── 强制转换 --> ( 难度等级: [0.2757, 0.2758) || 挂载数据: qa: 1 ) 
│   │   │   └── 重写泛型类的方法 --> ( 难度等级: [0.2758, 0.2759) || 挂载数据: 无 ) 
│   │   ├── 泛型的类型推断 --> ( 难度等级: [0.2759, 0.2764) || 挂载数据: 无 ) 
│   │   ├── 擦除 --> ( 难度等级: [0.2764, 0.2769) || 挂载数据: 无 ) 
│   │   ├── 模糊性错误 --> ( 难度等级: [0.2769, 0.2774) || 挂载数据: 无 ) 
│   │   ├── 使用泛型的一些限制 --> ( 难度等级: [0.2774, 0.2779) || 挂载数据: qa: 6 ) 
│   │   │   ├── 对静态成员的一些限制 --> ( 难度等级: [0.2774, 0.2776) || 挂载数据: qa: 1 ) 
│   │   │   ├── 对泛型数组的一些限制 --> ( 难度等级: [0.2776, 0.2778) || 挂载数据: 无 ) 
│   │   │   └── 对泛型异常的限制 --> ( 难度等级: [0.2778, 0.2779) || 挂载数据: qa: 1 ) 
│   │   ├── 定义泛型类 --> ( 难度等级: [0.2779, 0.2785) || 挂载数据: 无 ) 
│   │   ├── 泛型的用法 --> ( 难度等级: [0.2785, 0.279) || 挂载数据: 无 ) 
│   │   ├── 一个元组类库 --> ( 难度等级: [0.279, 0.2795) || 挂载数据: 无 ) 
│   │   ├── 一个栈类 --> ( 难度等级: [0.2795, 0.28) || 挂载数据: 无 ) 
│   │   ├── RandomList --> ( 难度等级: [0.28, 0.2805) || 挂载数据: 无 ) 
│   │   ├── 泛型方法 --> ( 难度等级: [0.2805, 0.281) || 挂载数据: 无 ) 
│   │   │   ├── 利用类型参数推断 --> ( 难度等级: [0.2805, 0.2805) || 挂载数据: 无 ) 
│   │   │   ├── 可变参数与泛型方法 --> ( 难度等级: [0.2805, 0.2806) || 挂载数据: qa: 3 ) 
│   │   │   ├── 用于Generator的泛型方法 --> ( 难度等级: [0.2806, 0.2807) || 挂载数据: 无 ) 
│   │   │   ├── 一个通用的Generator --> ( 难度等级: [0.2807, 0.2807) || 挂载数据: 无 ) 
│   │   │   ├── 简化元组的使用 --> ( 难度等级: [0.2807, 0.2808) || 挂载数据: 无 ) 
│   │   │   ├── 一个Set实用工具 --> ( 难度等级: [0.2808, 0.2808) || 挂载数据: 无 ) 
│   │   │   ├── 定义泛型方法 --> ( 难度等级: [0.2808, 0.2809) || 挂载数据: qa: 1 ) 
│   │   │   ├── “菱形”语法与泛型构造器 --> ( 难度等级: [0.2809, 0.2809) || 挂载数据: 无 ) 
│   │   │   └── 类型推断 --> ( 难度等级: [0.2809, 0.281) || 挂载数据: 无 ) 
│   │   ├── 构建复杂模型 --> ( 难度等级: [0.281, 0.2815) || 挂载数据: 无 ) 
│   │   ├── 擦除的神秘之处 --> ( 难度等级: [0.2815, 0.282) || 挂载数据: 无 ) 
│   │   │   ├── C++的方式 --> ( 难度等级: [0.2815, 0.2817) || 挂载数据: 无 ) 
│   │   │   ├── 迁移的可兼容性 --> ( 难度等级: [0.2817, 0.2818) || 挂载数据: qa: 1 ) 
│   │   │   └── 边界处的动作 --> ( 难度等级: [0.2818, 0.282) || 挂载数据: qa: 1 ) 
│   │   ├── 擦除的补偿 --> ( 难度等级: [0.282, 0.2825) || 挂载数据: 无 ) 
│   │   │   └── 泛型数组 --> ( 难度等级: [0.282, 0.2825) || 挂载数据: qa: 1 ) 
│   │   ├── 边界 --> ( 难度等级: [0.2825, 0.283) || 挂载数据: 无 ) 
│   │   ├── 通配符 --> ( 难度等级: [0.283, 0.2835) || 挂载数据: 无 ) 
│   │   │   ├── 编译器有多聪明？ --> ( 难度等级: [0.283, 0.2832) || 挂载数据: qa: 1 ) 
│   │   │   ├── 抗变 --> ( 难度等级: [0.2832, 0.2833) || 挂载数据: 无 ) 
│   │   │   ├── 无界通配符 --> ( 难度等级: [0.2833, 0.2834) || 挂载数据: 无 ) 
│   │   │   └── 捕获转换 --> ( 难度等级: [0.2834, 0.2835) || 挂载数据: 无 ) 
│   │   ├── 自限定的类型 --> ( 难度等级: [0.2835, 0.284) || 挂载数据: 无 ) 
│   │   │   ├── 离奇的循环泛型 --> ( 难度等级: [0.2835, 0.2837) || 挂载数据: 无 ) 
│   │   │   ├── 自限定 --> ( 难度等级: [0.2837, 0.2839) || 挂载数据: 无 ) 
│   │   │   └── 参数协变 --> ( 难度等级: [0.2839, 0.284) || 挂载数据: 无 ) 
│   │   ├── 动态类型安全 --> ( 难度等级: [0.284, 0.2846) || 挂载数据: 无 ) 
│   │   ├── 混用 --> ( 难度等级: [0.2846, 0.2851) || 挂载数据: 无 ) 
│   │   │   ├── C++中的混用 --> ( 难度等级: [0.2846, 0.2847) || 挂载数据: 无 ) 
│   │   │   ├── 与接口混用 --> ( 难度等级: [0.2847, 0.2848) || 挂载数据: 无 ) 
│   │   │   ├── 使用装饰器模式 --> ( 难度等级: [0.2848, 0.2849) || 挂载数据: 无 ) 
│   │   │   └── 与动态代理混用 --> ( 难度等级: [0.2849, 0.2851) || 挂载数据: 无 ) 
│   │   ├── 潜在类型机制 --> ( 难度等级: [0.2851, 0.2856) || 挂载数据: 无 ) 
│   │   ├── 缺乏潜在类型机制的补偿 --> ( 难度等级: [0.2856, 0.2861) || 挂载数据: 无 ) 
│   │   │   ├── 将一个方法应用于序列 --> ( 难度等级: [0.2856, 0.2857) || 挂载数据: 无 ) 
│   │   │   ├── 当你并未碰巧拥有正确的接口时 --> ( 难度等级: [0.2857, 0.2859) || 挂载数据: 无 ) 
│   │   │   └── 用适配器仿真潜在类型机制 --> ( 难度等级: [0.2859, 0.2861) || 挂载数据: 无 ) 
│   │   ├── 将函数对象用作策略 --> ( 难度等级: [0.2861, 0.2866) || 挂载数据: 无 ) 
│   │   ├── 泛型的常规用法 --> ( 难度等级: [0.2866, 0.2871) || 挂载数据: 无 ) 
│   │   ├── 泛型的高级用法 --> ( 难度等级: [0.2871, 0.2876) || 挂载数据: 无 ) 
│   │   ├── 泛型入门 --> ( 难度等级: [0.2876, 0.2881) || 挂载数据: 无 ) 
│   │   │   ├── 编译时不检查类型的异常 --> ( 难度等级: [0.2876, 0.2879) || 挂载数据: 无 ) 
│   │   │   └── Java 9增强的“菱形”语法 --> ( 难度等级: [0.2879, 0.2881) || 挂载数据: qa: 1 ) 
│   │   ├── 从泛型类派生子类 --> ( 难度等级: [0.2881, 0.2886) || 挂载数据: 无 ) 
│   │   ├── 并不存在泛型类 --> ( 难度等级: [0.2886, 0.2891) || 挂载数据: 无 ) 
│   │   ├── 类型通配符 --> ( 难度等级: [0.2891, 0.2896) || 挂载数据: 无 ) 
│   │   │   ├── 使用类型通配符 --> ( 难度等级: [0.2891, 0.2893) || 挂载数据: 无 ) 
│   │   │   ├── 设定类型通配符的上限 --> ( 难度等级: [0.2893, 0.2894) || 挂载数据: 无 ) 
│   │   │   ├── 设定类型通配符的下限 --> ( 难度等级: [0.2894, 0.2895) || 挂载数据: 无 ) 
│   │   │   └── 设定泛型形参的上限 --> ( 难度等级: [0.2895, 0.2896) || 挂载数据: qa: 1 ) 
│   │   ├── 编写泛型 --> ( 难度等级: [0.2896, 0.2901) || 挂载数据: 无 ) 
│   │   ├── 擦拭法 --> ( 难度等级: [0.2901, 0.2907) || 挂载数据: 无 ) 
│   │   ├── extends通配符 --> ( 难度等级: [0.2907, 0.2912) || 挂载数据: 无 ) 
│   │   └── super通配符 --> ( 难度等级: [0.2912, 0.2917) || 挂载数据: 无 ) 
│   ├── lambda表达式 --> ( 难度等级: [0.2917, 0.3125) || 挂载数据: 无 ) 
│   │   ├── lambda表达式简介 --> ( 难度等级: [0.2917, 0.2934) || 挂载数据: 无 ) 
│   │   │   ├── lambda表达式的基础知识 --> ( 难度等级: [0.2917, 0.2922) || 挂载数据: 无 ) 
│   │   │   ├── 函数式接口 --> ( 难度等级: [0.2922, 0.2928) || 挂载数据: 无 ) 
│   │   │   └── 几个lambda表达式示例 --> ( 难度等级: [0.2928, 0.2934) || 挂载数据: 无 ) 
│   │   ├── 块lambda表达式 --> ( 难度等级: [0.2934, 0.2951) || 挂载数据: 无 ) 
│   │   ├── 泛型函数式接口 --> ( 难度等级: [0.2951, 0.2969) || 挂载数据: 无 ) 
│   │   ├── 作为参数传递lambda表达式 --> ( 难度等级: [0.2969, 0.2986) || 挂载数据: 无 ) 
│   │   ├── lambda表达式与异常 --> ( 难度等级: [0.2986, 0.3003) || 挂载数据: 无 ) 
│   │   ├── lambda表达式和变量捕获 --> ( 难度等级: [0.3003, 0.3021) || 挂载数据: 无 ) 
│   │   ├── 方法引用 --> ( 难度等级: [0.3021, 0.3038) || 挂载数据: 无 ) 
│   │   │   ├── 静态方法的方法引用 --> ( 难度等级: [0.3021, 0.303) || 挂载数据: 无 ) 
│   │   │   └── 泛型中的方法引用 --> ( 难度等级: [0.303, 0.3038) || 挂载数据: qa: 4 ) 
│   │   ├── 构造函数引用 --> ( 难度等级: [0.3038, 0.3056) || 挂载数据: 无 ) 
│   │   ├── 预定义的函数式接口 --> ( 难度等级: [0.3056, 0.3073) || 挂载数据: 无 ) 
│   │   ├── lambda表达式的语法 --> ( 难度等级: [0.3073, 0.309) || 挂载数据: 无 ) 
│   │   ├── 构造器引用 --> ( 难度等级: [0.309, 0.3108) || 挂载数据: 无 ) 
│   │   └── 再谈Comparator --> ( 难度等级: [0.3108, 0.3125) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.3125, 0.3333) || 挂载数据: 无 ) 
│       ├── Java开发入门 --> ( 难度等级: [0.3125, 0.3129) || 挂载数据: 无 ) 
│       │   ├── Java概述 --> ( 难度等级: [0.3125, 0.3126) || 挂载数据: 无 ) 
│       │   │   ├── 什么是Java --> ( 难度等级: [0.3125, 0.3125) || 挂载数据: 无 ) 
│       │   │   └── Java语言的特点 --> ( 难度等级: [0.3125, 0.3126) || 挂载数据: 无 ) 
│       │   ├── JDK的使用 --> ( 难度等级: [0.3126, 0.3126) || 挂载数据: 无 ) 
│       │   │   ├── 什么是JDK --> ( 难度等级: [0.3126, 0.3126) || 挂载数据: qa: 10 ) 
│       │   │   ├── 安装JDK --> ( 难度等级: [0.3126, 0.3126) || 挂载数据: qa: 2 ) 
│       │   │   └── JDK目录介绍 --> ( 难度等级: [0.3126, 0.3126) || 挂载数据: 无 ) 
│       │   ├── 系统环境变量 --> ( 难度等级: [0.3126, 0.3127) || 挂载数据: 无 ) 
│       │   │   ├── PATH环境变量 --> ( 难度等级: [0.3126, 0.3127) || 挂载数据: qa: 1 ) 
│       │   │   └── CLASSPATH环境变量 --> ( 难度等级: [0.3127, 0.3127) || 挂载数据: qa: 9 ) 
│       │   ├── 第一个Java程序 --> ( 难度等级: [0.3127, 0.3128) || 挂载数据: 无 ) 
│       │   │   ├── 编辑Java源代码 --> ( 难度等级: [0.3127, 0.3127) || 挂载数据: 无 ) 
│       │   │   ├── 编译Java程序 --> ( 难度等级: [0.3127, 0.3128) || 挂载数据: qa: 10 ) 
│       │   │   └── 根据CLASSPATH环境变量定位类 --> ( 难度等级: [0.3128, 0.3128) || 挂载数据: 无 ) 
│       │   ├── Java的运行机制 --> ( 难度等级: [0.3128, 0.3128) || 挂载数据: 无 ) 
│       │   └── Eclipse开发工具 --> ( 难度等级: [0.3128, 0.3129) || 挂载数据: qa: 1 ) 
│       │       ├── Eclipse概述 --> ( 难度等级: [0.3128, 0.3129) || 挂载数据: 无 ) 
│       │       ├── Eclipse的安装与启动 --> ( 难度等级: [0.3129, 0.3129) || 挂载数据: qa: 1 ) 
│       │       └── 使用Eclipse进行程序开发 --> ( 难度等级: [0.3129, 0.3129) || 挂载数据: qa: 1 ) 
│       ├── Java编程基础 --> ( 难度等级: [0.3129, 0.3133) || 挂载数据: 无 ) 
│       │   ├── Java的基本语法 --> ( 难度等级: [0.3129, 0.313) || 挂载数据: 无 ) 
│       │   │   ├── Java的基本语法格式 --> ( 难度等级: [0.3129, 0.3129) || 挂载数据: qa: 5 ) 
│       │   │   ├── Java中的注释 --> ( 难度等级: [0.3129, 0.313) || 挂载数据: 无 ) 
│       │   │   ├── Java中的关键字 --> ( 难度等级: [0.313, 0.313) || 挂载数据: 无 ) 
│       │   │   └── Java中的标识符 --> ( 难度等级: [0.313, 0.313) || 挂载数据: qa: 1 ) 
│       │   ├── Java中的变量与常量 --> ( 难度等级: [0.313, 0.3131) || 挂载数据: 无 ) 
│       │   │   ├── 变量的定义 --> ( 难度等级: [0.313, 0.313) || 挂载数据: qa: 5 ) 
│       │   │   ├── 变量的数据类型 --> ( 难度等级: [0.313, 0.313) || 挂载数据: 无 ) 
│       │   │   ├── 变量的类型转换32目录Java基础入门(第2版)2.2.4变量的作用域 --> ( 难度等级: [0.313, 0.313) || 挂载数据: 无 ) 
│       │   │   ├── Java中的常量 --> ( 难度等级: [0.313, 0.3131) || 挂载数据: qa: 3 ) 
│       │   │   └── 指数记数法 --> ( 难度等级: [0.3131, 0.3131) || 挂载数据: 无 ) 
│       │   ├── Java中的运算符 --> ( 难度等级: [0.3131, 0.3132) || 挂载数据: 无 ) 
│       │   │   ├── 比较运算符 --> ( 难度等级: [0.3131, 0.3131) || 挂载数据: qa: 2 ) 
│       │   │   ├── 逻辑运算符 --> ( 难度等级: [0.3131, 0.3131) || 挂载数据: qa: 2 ) 
│       │   │   └── 条件运算符 --> ( 难度等级: [0.3131, 0.3132) || 挂载数据: qa: 1 ) 
│       │   ├── 选择结构语句 --> ( 难度等级: [0.3132, 0.3133) || 挂载数据: 无 ) 
│       │   │   ├── if条件语句 --> ( 难度等级: [0.3132, 0.3132) || 挂载数据: qa: 10 ) 
│       │   │   └── switch条件语句 --> ( 难度等级: [0.3132, 0.3133) || 挂载数据: 无 ) 
│       │   └── 循环结构语句 --> ( 难度等级: [0.3133, 0.3133) || 挂载数据: 无 ) 
│       │       ├── do…while循环语句 --> ( 难度等级: [0.3133, 0.3133) || 挂载数据: qa: 5 ) 
│       │       └── for循环语句 --> ( 难度等级: [0.3133, 0.3133) || 挂载数据: qa: 2 ) 
│       ├── 集合 --> ( 难度等级: [0.3133, 0.3137) || 挂载数据: qa: 4 ) 
│       │   ├── 集合概述 --> ( 难度等级: [0.3133, 0.3134) || 挂载数据: 无 ) 
│       │   ├── Collection接口 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   ├── List接口 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   │   ├── List接口简介 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   │   ├── ArrayList集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: qa: 10 ) 
│       │   │   └── LinkedList集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: qa: 1 ) 
│       │   ├── Collection集合遍历 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   │   ├── Iterator遍历集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: qa: 10 ) 
│       │   │   ├── foreach遍历集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: qa: 2 ) 
│       │   │   └── JDK 8的forEach遍历集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   ├── Set接口 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   │   ├── Set接口简介 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   │   ├── HashSet集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   │   └── TreeSet集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   ├── Map接口 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   │   ├── Map接口简介 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: qa: 1 ) 
│       │   │   ├── HashMap集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: qa: 10 ) 
│       │   │   ├── Map集合遍历 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: qa: 5 ) 
│       │   │   ├── TreeMap集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: qa: 1 ) 
│       │   │   └── Properties集合 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: 无 ) 
│       │   ├── 常用工具类 --> ( 难度等级: [0.3134, 0.3135) || 挂载数据: 无 ) 
│       │   │   ├── Collections工具类 --> ( 难度等级: [0.3134, 0.3134) || 挂载数据: qa: 3 ) 
│       │   │   └── Arrays工具类 --> ( 难度等级: [0.3134, 0.3135) || 挂载数据: qa: 4 ) 
│       │   ├── 聚合操作 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: 无 ) 
│       │   │   ├── 聚合操作简介 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: 无 ) 
│       │   │   ├── 创建Stream流对象 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: 无 ) 
│       │   │   ├── Stream流的常用方法 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: 无 ) 
│       │   │   └── Parallel Stream（并行流） --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: 无 ) 
│       │   ├── Java集合框架 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: 无 ) 
│       │   │   ├── 集合接口与实现分离 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: qa: 4 ) 
│       │   │   └── 泛型实用方法 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: 无 ) 
│       │   ├── 集合框架中的接口 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: 无 ) 
│       │   ├── 链表 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: qa: 2 ) 
│       │   ├── 数组列表 --> ( 难度等级: [0.3135, 0.3135) || 挂载数据: 无 ) 
│       │   ├── 散列集 --> ( 难度等级: [0.3135, 0.3136) || 挂载数据: 无 ) 
│       │   ├── 树集 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   ├── 优先队列 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   ├── 映射 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   ├── 基本映射操作 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: qa: 1 ) 
│       │   │   ├── 更新映射条目 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   ├── 映射视图 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   ├── 弱散列映射 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   ├── 链接散列集与映射 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   ├── 枚举集与映射 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   └── 标识散列映射 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   ├── 算法 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: qa: 4 ) 
│       │   │   ├── 二分查找 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   ├── 简单算法 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: qa: 10 ) 
│       │   │   ├── 批操作 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   └── 编写自己的算法 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: qa: 2 ) 
│       │   ├── 遗留的集合 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   ├── 属性映射 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   │   ├── 栈 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: qa: 2 ) 
│       │   │   └── 位集 --> ( 难度等级: [0.3136, 0.3136) || 挂载数据: 无 ) 
│       │   ├── Java集合简介 --> ( 难度等级: [0.3136, 0.3137) || 挂载数据: 无 ) 
│       │   ├── 编写equals方法 --> ( 难度等级: [0.3137, 0.3137) || 挂载数据: 无 ) 
│       │   ├── 编写equals和hashCode --> ( 难度等级: [0.3137, 0.3137) || 挂载数据: qa: 4 ) 
│       │   ├── 使用TreeMap --> ( 难度等级: [0.3137, 0.3137) || 挂载数据: qa: 4 ) 
│       │   ├── 使用Properties --> ( 难度等级: [0.3137, 0.3137) || 挂载数据: 无 ) 
│       │   └── 使用Deque --> ( 难度等级: [0.3137, 0.3137) || 挂载数据: 无 ) 
│       ├── I/O流 --> ( 难度等级: [0.3137, 0.3142) || 挂载数据: 无 ) 
│       │   ├── I/O流概述 --> ( 难度等级: [0.3137, 0.3138) || 挂载数据: 无 ) 
│       │   ├── 字节流 --> ( 难度等级: [0.3138, 0.3139) || 挂载数据: 无 ) 
│       │   │   ├── 字节流概述 --> ( 难度等级: [0.3138, 0.3138) || 挂载数据: qa: 1 ) 
│       │   │   ├── 字节流读写文件 --> ( 难度等级: [0.3138, 0.3138) || 挂载数据: qa: 2 ) 
│       │   │   ├── 文件的拷贝 --> ( 难度等级: [0.3138, 0.3138) || 挂载数据: qa: 1 ) 
│       │   │   ├── 字节流的缓冲区 --> ( 难度等级: [0.3138, 0.3139) || 挂载数据: qa: 3 ) 
│       │   │   └── 字节缓冲流 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: qa: 1 ) 
│       │   ├── File类 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: 无 ) 
│       │   │   ├── File类的常用方法 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: qa: 10 ) 
│       │   │   ├── 遍历目录下的文件 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: qa: 1 ) 
│       │   │   ├── 删除文件及目录 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: qa: 1 ) 
│       │   │   ├── 创建文件对象 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: 无 ) 
│       │   │   ├── 文件操作 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: qa: 2 ) 
│       │   │   ├── 文件夹操作 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: qa: 1 ) 
│       │   │   ├── 目录列表器 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: 无 ) 
│       │   │   ├── 目录实用工具 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: 无 ) 
│       │   │   ├── 目录的检查及创建 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: 无 ) 
│       │   │   ├── 文件的创建与删除 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: qa: 5 ) 
│       │   │   └── 获取文件信息 --> ( 难度等级: [0.3139, 0.3139) || 挂载数据: 无 ) 
│       │   ├── RandomAccessFile --> ( 难度等级: [0.3139, 0.314) || 挂载数据: qa: 3 ) 
│       │   ├── 对象序列化 --> ( 难度等级: [0.314, 0.314) || 挂载数据: 无 ) 
│       │   │   ├── 寻找类 --> ( 难度等级: [0.314, 0.314) || 挂载数据: 无 ) 
│       │   │   ├── 序列化的控制 --> ( 难度等级: [0.314, 0.314) || 挂载数据: qa: 3 ) 
│       │   │   └── 使用“持久性” --> ( 难度等级: [0.314, 0.314) || 挂载数据: 无 ) 
│       │   ├── NIO --> ( 难度等级: [0.314, 0.3141) || 挂载数据: 无 ) 
│       │   │   ├── NIO概述 --> ( 难度等级: [0.314, 0.3141) || 挂载数据: qa: 6 ) 
│       │   │   ├── Buffer（缓冲器） --> ( 难度等级: [0.3141, 0.3141) || 挂载数据: 无 ) 
│       │   │   ├── Channel（通道） --> ( 难度等级: [0.3141, 0.3141) || 挂载数据: 无 ) 
│       │   │   ├── Java新IO概述 --> ( 难度等级: [0.3141, 0.3141) || 挂载数据: qa: 8 ) 
│       │   │   ├── 使用Buffer --> ( 难度等级: [0.3141, 0.3141) || 挂载数据: 无 ) 
│       │   │   ├── 使用Channel --> ( 难度等级: [0.3141, 0.3141) || 挂载数据: qa: 2 ) 
│       │   │   ├── 字符集和Charset --> ( 难度等级: [0.3141, 0.3141) || 挂载数据: qa: 2 ) 
│       │   │   └── 文件锁 --> ( 难度等级: [0.3141, 0.3141) || 挂载数据: 无 ) 
│       │   └── NIO. --> ( 难度等级: [0.3141, 0.3142) || 挂载数据: 无 ) 
│       │       ├── Path接口 --> ( 难度等级: [0.3141, 0.3141) || 挂载数据: 无 ) 
│       │       └── Files工具类 --> ( 难度等级: [0.3141, 0.3142) || 挂载数据: 无 ) 
│       ├── GUI（图形用户接口） --> ( 难度等级: [0.3142, 0.3146) || 挂载数据: 无 ) 
│       │   ├── Swing概述 --> ( 难度等级: [0.3142, 0.3142) || 挂载数据: 无 ) 
│       │   │   ├── Swing特点 --> ( 难度等级: [0.3142, 0.3142) || 挂载数据: qa: 1 ) 
│       │   │   ├── Swing包 --> ( 难度等级: [0.3142, 0.3142) || 挂载数据: qa: 1 ) 
│       │   │   └── 常用Swing组件概述 --> ( 难度等级: [0.3142, 0.3142) || 挂载数据: 无 ) 
│       │   ├── Swing顶级容器 --> ( 难度等级: [0.3142, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── JFrame --> ( 难度等级: [0.3142, 0.3143) || 挂载数据: qa: 9 ) 
│       │   │   └── JDialog --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: qa: 2 ) 
│       │   ├── 布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── BorderLayout --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── FlowLayout --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── GridLayout --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: qa: 1 ) 
│       │   │   ├── FlowLayout流布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── BorderLayout边界布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── GridLayout网格布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── 绝对布局 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: qa: 1 ) 
│       │   │   ├── 流布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── 边界布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── 网格布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── 网格组布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── FlowLayout布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: qa: 1 ) 
│       │   │   ├── BorderLayout布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: qa: 3 ) 
│       │   │   ├── GridLayout布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── GridBagLayout布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── CardLayout布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   └── BoxLayout布局管理器 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   ├── 事件处理 --> ( 难度等级: [0.3143, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 事件处理机制 --> ( 难度等级: [0.3143, 0.3143) || 挂载数据: 无 ) 
│       │   │   ├── Swing常用事件处理 --> ( 难度等级: [0.3143, 0.3144) || 挂载数据: qa: 1 ) 
│       │   │   ├── Java事件模型的流程 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 事件适配器 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 使用内部类实现监听器 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 使用外部类实现监听器 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 类本身作为事件监听器类 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 匿名内部类实现监听器 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 基本事件处理概念 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 简洁地指定监听器 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 适配器类 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 动作 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   └── AWT事件继承层次 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   ├── Swing常用组件 --> ( 难度等级: [0.3144, 0.3145) || 挂载数据: 无 ) 
│       │   │   ├── 面板组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 文本组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   │   ├── JTextField文本框组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── JPasswordField密码框组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   │   ├── JTextArea文本域组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   │   ├── 文本框组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 密码框组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   │   └── 文本域组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 标签组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   ├── 按钮组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   │   ├── JButton按钮组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── JRadioButton单选按钮组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── JCheckBox复选框组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   │   ├── 提交按钮组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 单选按钮组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: 无 ) 
│       │   │   │   └── 复选框组件 --> ( 难度等级: [0.3144, 0.3144) || 挂载数据: qa: 8 ) 
│       │   │   ├── 下拉框组件 --> ( 难度等级: [0.3144, 0.3145) || 挂载数据: qa: 1 ) 
│       │   │   └── 菜单组件 --> ( 难度等级: [0.3145, 0.3145) || 挂载数据: 无 ) 
│       │   ├── Swing组件的整合使用——QQ登录 --> ( 难度等级: [0.3145, 0.3145) || 挂载数据: 无 ) 
│       │   │   ├── 案例分析 --> ( 难度等级: [0.3145, 0.3145) || 挂载数据: 无 ) 
│       │   │   └── 案例实现 --> ( 难度等级: [0.3145, 0.3145) || 挂载数据: 无 ) 
│       │   └── JavaFX图形用户界面工具 --> ( 难度等级: [0.3145, 0.3146) || 挂载数据: 无 ) 
│       │       ├── JavaFX概述 --> ( 难度等级: [0.3145, 0.3145) || 挂载数据: 无 ) 
│       │       ├── JavaFX开发环境配置 --> ( 难度等级: [0.3145, 0.3146) || 挂载数据: qa: 1 ) 
│       │       ├── JavaFX基础入门 --> ( 难度等级: [0.3146, 0.3146) || 挂载数据: 无 ) 
│       │       └── JavaFX可视化管理工具 --> ( 难度等级: [0.3146, 0.3146) || 挂载数据: 无 ) 
│       ├── JDBC --> ( 难度等级: [0.3146, 0.315) || 挂载数据: qa: 1 ) 
│       │   ├── 什么是JDBC --> ( 难度等级: [0.3146, 0.3147) || 挂载数据: 无 ) 
│       │   ├── JDBC常用API --> ( 难度等级: [0.3147, 0.3148) || 挂载数据: 无 ) 
│       │   │   ├── Driver接口 --> ( 难度等级: [0.3147, 0.3147) || 挂载数据: qa: 2 ) 
│       │   │   ├── DriverManager类 --> ( 难度等级: [0.3147, 0.3147) || 挂载数据: 无 ) 
│       │   │   ├── Connection接口 --> ( 难度等级: [0.3147, 0.3147) || 挂载数据: qa: 10 ) 
│       │   │   ├── Statement接口 --> ( 难度等级: [0.3147, 0.3148) || 挂载数据: qa: 2 ) 
│       │   │   ├── PreparedStatement接口 --> ( 难度等级: [0.3148, 0.3148) || 挂载数据: qa: 6 ) 
│       │   │   └── ResultSet接口 --> ( 难度等级: [0.3148, 0.3148) || 挂载数据: qa: 5 ) 
│       │   ├── JDBC编程 --> ( 难度等级: [0.3148, 0.3149) || 挂载数据: 无 ) 
│       │   │   ├── JDBC的编程步骤 --> ( 难度等级: [0.3148, 0.3148) || 挂载数据: qa: 2 ) 
│       │   │   └── 实现第一个JDBC程序 --> ( 难度等级: [0.3148, 0.3149) || 挂载数据: qa: 10 ) 
│       │   └── 案例——使用JDBC实现QQ登录 --> ( 难度等级: [0.3149, 0.315) || 挂载数据: qa: 9 ) 
│       ├── 网络编程 --> ( 难度等级: [0.315, 0.3154) || 挂载数据: qa: 1 ) 
│       │   ├── 网络编程基础 --> ( 难度等级: [0.315, 0.315) || 挂载数据: qa: 2 ) 
│       │   │   ├── 网络通信协议 --> ( 难度等级: [0.315, 0.315) || 挂载数据: 无 ) 
│       │   │   ├── IP地址和端口号 --> ( 难度等级: [0.315, 0.315) || 挂载数据: 无 ) 
│       │   │   ├── InetAddress --> ( 难度等级: [0.315, 0.315) || 挂载数据: 无 ) 
│       │   │   └── UDP与TCP协议 --> ( 难度等级: [0.315, 0.315) || 挂载数据: 无 ) 
│       │   ├── UDP通信 --> ( 难度等级: [0.315, 0.3151) || 挂载数据: 无 ) 
│       │   │   ├── UDP通信简介 --> ( 难度等级: [0.315, 0.3151) || 挂载数据: qa: 2 ) 
│       │   │   ├── DatagramPacket --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│       │   │   ├── DatagramSocket --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 1 ) 
│       │   │   ├── UDP网络程序 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│       │   │   └── UDP案例——聊天程序 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 4 ) 
│       │   ├── TCP通信 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│       │   │   ├── TCP通信简介 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 7 ) 
│       │   │   ├── ServerSocket --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 3 ) 
│       │   │   ├── Socket --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 10 ) 
│       │   │   ├── 简单的TCP网络程序 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 1 ) 
│       │   │   ├── 多线程的TCP网络程序 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│       │   │   └── TCP案例——文件上传 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 1 ) 
│       │   ├── 网络编程的基础知识 --> ( 难度等级: [0.3151, 0.3152) || 挂载数据: 无 ) 
│       │   │   └── 网络基础知识 --> ( 难度等级: [0.3151, 0.3152) || 挂载数据: qa: 10 ) 
│       │   ├── Java的基本网络支持 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: 无 ) 
│       │   │   ├── 使用URLDecoder和URLEncoder --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: qa: 1 ) 
│       │   │   └── URL、URLConnection和URLPermission --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: 无 ) 
│       │   ├── 基于TCP协议的网络编程 --> ( 难度等级: [0.3152, 0.3153) || 挂载数据: 无 ) 
│       │   │   ├── TCP协议基础 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用ServerSocket创建TCP服务器端 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: 无 ) 
│       │   │   ├── 使用Socket进行通信 --> ( 难度等级: [0.3152, 0.3153) || 挂载数据: qa: 4 ) 
│       │   │   ├── 记录用户信息 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 5 ) 
│       │   │   ├── 半关闭的Socket --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│       │   │   ├── 使用NIO实现非阻塞Socket通信 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用AIO实现非阻塞通信 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│       │   ├── 基于UDP协议的网络编程 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│       │   │   ├── UDP协议基础 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│       │   │   ├── 使用DatagramSocket发送、接收数据 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│       │   │   └── 使用MulticastSocket实现多点广播 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│       │   ├── 使用代理服务器 --> ( 难度等级: [0.3153, 0.3154) || 挂载数据: 无 ) 
│       │   │   ├── 直接使用Proxy创建连接 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│       │   │   └── 使用ProxySelector自动选择代理服务器 --> ( 难度等级: [0.3153, 0.3154) || 挂载数据: qa: 1 ) 
│       │   └── Java 11标准化的HTTP Client --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│       │       ├── 发送同步GET请求 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: qa: 3 ) 
│       │       ├── 发送带请求体的请求 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: qa: 1 ) 
│       │       ├── 发送异步请求 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│       │       ├── WebSocket客户端支持 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│       │       └── 基于WebSocket的多人实时聊天 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│       ├── 初识Java --> ( 难度等级: [0.3154, 0.3158) || 挂载数据: 无 ) 
│       │   ├── Java简介 --> ( 难度等级: [0.3154, 0.3155) || 挂载数据: 无 ) 
│       │   │   ├── Java的版本 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│       │   │   ├── JavaAPI文档 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│       │   │   ├── Java的应用领域 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│       │   │   ├── 怎样学好Java --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│       │   │   ├── Java API文档 --> ( 难度等级: [0.3154, 0.3155) || 挂载数据: 无 ) 
│       │   │   ├── Java代码助手 --> ( 难度等级: [0.3155, 0.3155) || 挂载数据: 无 ) 
│       │   │   ├── 使用IDE --> ( 难度等级: [0.3155, 0.3155) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用IDE练习插件 --> ( 难度等级: [0.3155, 0.3155) || 挂载数据: 无 ) 
│       │   ├── 搭建Java环境 --> ( 难度等级: [0.3155, 0.3155) || 挂载数据: 无 ) 
│       │   │   ├── JDK的下载 --> ( 难度等级: [0.3155, 0.3155) || 挂载数据: 无 ) 
│       │   │   ├── 配置JDK --> ( 难度等级: [0.3155, 0.3155) || 挂载数据: 无 ) 
│       │   │   ├── 测试开发环境 --> ( 难度等级: [0.3155, 0.3155) || 挂载数据: qa: 5 ) 
│       │   │   └── Windows系统的JDK环境 --> ( 难度等级: [0.3155, 0.3155) || 挂载数据: qa: 1 ) 
│       │   ├── Eclipse开发环境 --> ( 难度等级: [0.3155, 0.3156) || 挂载数据: 无 ) 
│       │   │   ├── Eclipse简介 --> ( 难度等级: [0.3155, 0.3156) || 挂载数据: 无 ) 
│       │   │   ├── 下载Eclipse --> ( 难度等级: [0.3156, 0.3156) || 挂载数据: qa: 10 ) 
│       │   │   └── Eclipse工作台 --> ( 难度等级: [0.3156, 0.3156) || 挂载数据: 无 ) 
│       │   ├── Eclipse的使用 --> ( 难度等级: [0.3156, 0.3157) || 挂载数据: 无 ) 
│       │   │   ├── 创建Java类文件 --> ( 难度等级: [0.3156, 0.3156) || 挂载数据: 无 ) 
│       │   │   ├── 使用编辑器编写程序代码 --> ( 难度等级: [0.3156, 0.3156) || 挂载数据: qa: 1 ) 
│       │   │   └── 运行Java程序 --> ( 难度等级: [0.3156, 0.3157) || 挂载数据: qa: 10 ) 
│       │   ├── 程序调试 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: 无 ) 
│       │   ├── 难点解答 --> ( 难度等级: [0.3157, 0.3158) || 挂载数据: 无 ) 
│       │   │   ├── JDK常用的基本组件 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: 无 ) 
│       │   │   ├── 配置环境变量后，javac运行正常，但编译的时候仍找不到文件 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: qa: 9 ) 
│       │   │   ├── Java中变量一定要初始化吗？ --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: 无 ) 
│       │   │   ├── switch多分支语句后expression表达式的数据类型 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: 无 ) 
│       │   │   ├── 多维数组的长度 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: qa: 1 ) 
│       │   │   ├── StringBuffer与String的不同之处 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: 无 ) 
│       │   │   ├── 把数据抽象成类 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: 无 ) 
│       │   │   ├── 局部变量和全局变量 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: qa: 1 ) 
│       │   │   ├── 类的三大特性 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: 无 ) 
│       │   │   ├── 什么情况下会使用匿名内部类？ --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: qa: 6 ) 
│       │   │   ├── 异常的使用原则 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: 无 ) 
│       │   │   ├── 注意随机数的取值范围 --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: qa: 5 ) 
│       │   │   ├── “装箱”与“拆箱” --> ( 难度等级: [0.3157, 0.3157) || 挂载数据: 无 ) 
│       │   │   ├── 集合的使用场合 --> ( 难度等级: [0.3157, 0.3158) || 挂载数据: 无 ) 
│       │   │   ├── 集合的元素数量是变化的 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │   │   ├── Swing组件的层级关系 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │   │   ├── 布局的使用 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │   │   ├── 输入/输出流的使用 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │   │   ├── 线程的核心方法：run方法 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: qa: 8 ) 
│       │   │   ├── 线程的启动 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: qa: 2 ) 
│       │   │   ├── 无法连接数据库 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: qa: 1 ) 
│       │   │   ├── SQL语句的使用 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │   │   └── AWT与Swing组件的区别 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │   └── Java语言的特性 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │       ├── 简单 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │       ├── 分布性 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │       ├── 解释型 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: 无 ) 
│       │       └── 动态 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: qa: 2 ) 
│       ├── Java语言基础 --> ( 难度等级: [0.3158, 0.3162) || 挂载数据: 无 ) 
│       │   ├── 代码注释 --> ( 难度等级: [0.3158, 0.3159) || 挂载数据: qa: 1 ) 
│       │   │   └── 文档注释 --> ( 难度等级: [0.3158, 0.3159) || 挂载数据: qa: 1 ) 
│       │   │       ├── 注释的插入 --> ( 难度等级: [0.3158, 0.3158) || 挂载数据: qa: 5 ) 
│       │   │       ├── 类注释 --> ( 难度等级: [0.3158, 0.3159) || 挂载数据: 无 ) 
│       │   │       ├── 方法注释 --> ( 难度等级: [0.3159, 0.3159) || 挂载数据: qa: 2 ) 
│       │   │       ├── 字段注释 --> ( 难度等级: [0.3159, 0.3159) || 挂载数据: qa: 2 ) 
│       │   │       ├── 通用注释 --> ( 难度等级: [0.3159, 0.3159) || 挂载数据: 无 ) 
│       │   │       ├── 包注释 --> ( 难度等级: [0.3159, 0.3159) || 挂载数据: qa: 10 ) 
│       │   │       └── 注释抽取 --> ( 难度等级: [0.3159, 0.3159) || 挂载数据: 无 ) 
│       │   ├── 基本数据类型 --> ( 难度等级: [0.3159, 0.316) || 挂载数据: qa: 4 ) 
│       │   │   ├── 整数类型 --> ( 难度等级: [0.3159, 0.316) || 挂载数据: 无 ) 
│       │   │   ├── 浮点类型 --> ( 难度等级: [0.316, 0.316) || 挂载数据: 无 ) 
│       │   │   ├── 字符类型 --> ( 难度等级: [0.316, 0.316) || 挂载数据: qa: 1 ) 
│       │   │   ├── 布尔类型 --> ( 难度等级: [0.316, 0.316) || 挂载数据: 无 ) 
│       │   │   ├── 数值中使用下画线分隔 --> ( 难度等级: [0.316, 0.316) || 挂载数据: 无 ) 
│       │   │   └── 使用var定义变量 --> ( 难度等级: [0.316, 0.316) || 挂载数据: 无 ) 
│       │   ├── 数据类型转换 --> ( 难度等级: [0.316, 0.3161) || 挂载数据: qa: 2 ) 
│       │   │   ├── 隐式转换 --> ( 难度等级: [0.316, 0.3161) || 挂载数据: 无 ) 
│       │   │   ├── 显式转换 --> ( 难度等级: [0.3161, 0.3161) || 挂载数据: 无 ) 
│       │   │   ├── 隐式类型转换 --> ( 难度等级: [0.3161, 0.3161) || 挂载数据: qa: 1 ) 
│       │   │   └── 显式类型转换 --> ( 难度等级: [0.3161, 0.3161) || 挂载数据: qa: 6 ) 
│       │   └── Java主类结构 --> ( 难度等级: [0.3161, 0.3162) || 挂载数据: qa: 1 ) 
│       │       ├── 包声明 --> ( 难度等级: [0.3161, 0.3162) || 挂载数据: 无 ) 
│       │       ├── 编写主方法 --> ( 难度等级: [0.3162, 0.3162) || 挂载数据: 无 ) 
│       │       └── 导入API类库 --> ( 难度等级: [0.3162, 0.3162) || 挂载数据: 无 ) 
│       ├── 流程控制 --> ( 难度等级: [0.3162, 0.3167) || 挂载数据: qa: 1 ) 
│       │   ├── 程序结构 --> ( 难度等级: [0.3162, 0.3163) || 挂载数据: 无 ) 
│       │   ├── 条件语句 --> ( 难度等级: [0.3163, 0.3163) || 挂载数据: 无 ) 
│       │   │   └── switch多分支语句 --> ( 难度等级: [0.3163, 0.3163) || 挂载数据: 无 ) 
│       │   ├── 循环语句 --> ( 难度等级: [0.3163, 0.3164) || 挂载数据: qa: 1 ) 
│       │   │   ├── foreach语句 --> ( 难度等级: [0.3163, 0.3164) || 挂载数据: qa: 5 ) 
│       │   │   └── 循环语句的嵌套 --> ( 难度等级: [0.3164, 0.3164) || 挂载数据: qa: 10 ) 
│       │   ├── 复合语句 --> ( 难度等级: [0.3164, 0.3164) || 挂载数据: qa: 1 ) 
│       │   ├── 循环控制 --> ( 难度等级: [0.3164, 0.3165) || 挂载数据: qa: 7 ) 
│       │   ├── 循环 --> ( 难度等级: [0.3165, 0.3165) || 挂载数据: qa: 1 ) 
│       │   ├── 中断控制流程的语句 --> ( 难度等级: [0.3165, 0.3165) || 挂载数据: 无 ) 
│       │   ├── if判断 --> ( 难度等级: [0.3165, 0.3166) || 挂载数据: qa: 10 ) 
│       │   ├── switch多重选择 --> ( 难度等级: [0.3166, 0.3166) || 挂载数据: 无 ) 
│       │   └── while循环 --> ( 难度等级: [0.3166, 0.3167) || 挂载数据: qa: 5 ) 
│       ├── 面向对象编程基础 --> ( 难度等级: [0.3167, 0.3171) || 挂载数据: 无 ) 
│       │   └── 类的主方法 --> ( 难度等级: [0.3167, 0.3171) || 挂载数据: 无 ) 
│       ├── 面向对象核心技术 --> ( 难度等级: [0.3171, 0.3175) || 挂载数据: 无 ) 
│       │   └── 类的多态 --> ( 难度等级: [0.3171, 0.3175) || 挂载数据: 无 ) 
│       │       ├── 向上转型 --> ( 难度等级: [0.3171, 0.3172) || 挂载数据: qa: 3 ) 
│       │       │   └── 忘记对象类型 --> ( 难度等级: [0.3171, 0.3172) || 挂载数据: qa: 1 ) 
│       │       ├── 向下转型 --> ( 难度等级: [0.3172, 0.3174) || 挂载数据: qa: 1 ) 
│       │       └── instanceof关键字 --> ( 难度等级: [0.3174, 0.3175) || 挂载数据: qa: 1 ) 
│       ├── Swing程序设计 --> ( 难度等级: [0.3175, 0.3179) || 挂载数据: 无 ) 
│       │   ├── 常用窗体 --> ( 难度等级: [0.3175, 0.3176) || 挂载数据: 无 ) 
│       │   │   ├── JFrame窗体 --> ( 难度等级: [0.3175, 0.3175) || 挂载数据: 无 ) 
│       │   │   ├── JDialog对话框窗体 --> ( 难度等级: [0.3175, 0.3176) || 挂载数据: 无 ) 
│       │   │   └── JDialog窗体 --> ( 难度等级: [0.3176, 0.3176) || 挂载数据: qa: 4 ) 
│       │   ├── 常用面板 --> ( 难度等级: [0.3176, 0.3177) || 挂载数据: 无 ) 
│       │   │   ├── JPanel面板 --> ( 难度等级: [0.3176, 0.3176) || 挂载数据: qa: 10 ) 
│       │   │   ├── JScrollPane滚动面板 --> ( 难度等级: [0.3176, 0.3177) || 挂载数据: 无 ) 
│       │   │   └── JScrollPane面板 --> ( 难度等级: [0.3177, 0.3177) || 挂载数据: qa: 1 ) 
│       │   ├── 列表组件 --> ( 难度等级: [0.3177, 0.3178) || 挂载数据: 无 ) 
│       │   │   ├── JComboBox下拉列表框组件 --> ( 难度等级: [0.3177, 0.3177) || 挂载数据: 无 ) 
│       │   │   ├── JList列表框组件 --> ( 难度等级: [0.3177, 0.3178) || 挂载数据: 无 ) 
│       │   │   ├── 下拉列表框组件 --> ( 难度等级: [0.3178, 0.3178) || 挂载数据: 无 ) 
│       │   │   └── 列表框组件 --> ( 难度等级: [0.3178, 0.3178) || 挂载数据: 无 ) 
│       │   └── 事件监听器 --> ( 难度等级: [0.3178, 0.3179) || 挂载数据: 无 ) 
│       │       ├── 动作事件监听器 --> ( 难度等级: [0.3178, 0.3178) || 挂载数据: 无 ) 
│       │       ├── 键盘事件 --> ( 难度等级: [0.3178, 0.3178) || 挂载数据: qa: 2 ) 
│       │       ├── 鼠标事件 --> ( 难度等级: [0.3178, 0.3179) || 挂载数据: qa: 3 ) 
│       │       ├── 窗体事件 --> ( 难度等级: [0.3179, 0.3179) || 挂载数据: 无 ) 
│       │       │   ├── 捕获窗体焦点变化事件 --> ( 难度等级: [0.3179, 0.3179) || 挂载数据: 无 ) 
│       │       │   ├── 捕获窗体状态变化事件 --> ( 难度等级: [0.3179, 0.3179) || 挂载数据: 无 ) 
│       │       │   └── 捕获其他窗体事件 --> ( 难度等级: [0.3179, 0.3179) || 挂载数据: qa: 8 ) 
│       │       ├── 监听事件简介 --> ( 难度等级: [0.3179, 0.3179) || 挂载数据: qa: 4 ) 
│       │       └── 焦点事件监听器 --> ( 难度等级: [0.3179, 0.3179) || 挂载数据: 无 ) 
│       ├── I/O（输入/输出） --> ( 难度等级: [0.3179, 0.3183) || 挂载数据: 无 ) 
│       │   ├── 流概述 --> ( 难度等级: [0.3179, 0.318) || 挂载数据: 无 ) 
│       │   ├── 输入/输出流 --> ( 难度等级: [0.318, 0.318) || 挂载数据: 无 ) 
│       │   │   ├── 输入流 --> ( 难度等级: [0.318, 0.318) || 挂载数据: qa: 10 ) 
│       │   │   └── 输出流 --> ( 难度等级: [0.318, 0.318) || 挂载数据: qa: 10 ) 
│       │   ├── 文件输入/输出流 --> ( 难度等级: [0.318, 0.3181) || 挂载数据: qa: 2 ) 
│       │   │   ├── FileInputStream类与FileOutputStream类 --> ( 难度等级: [0.318, 0.3181) || 挂载数据: qa: 3 ) 
│       │   │   └── FileReader类与FileWriter类 --> ( 难度等级: [0.3181, 0.3181) || 挂载数据: 无 ) 
│       │   ├── 带缓冲的输入/输出流 --> ( 难度等级: [0.3181, 0.3182) || 挂载数据: 无 ) 
│       │   │   ├── BufferedInputStream类与BufferedOutputStream类 --> ( 难度等级: [0.3181, 0.3181) || 挂载数据: qa: 1 ) 
│       │   │   └── BufferedReader类与BufferedWriter类 --> ( 难度等级: [0.3181, 0.3182) || 挂载数据: qa: 1 ) 
│       │   ├── 带缓存的输入/输出流 --> ( 难度等级: [0.3182, 0.3182) || 挂载数据: 无 ) 
│       │   ├── 数据输入/输出流 --> ( 难度等级: [0.3182, 0.3183) || 挂载数据: 无 ) 
│       │   └── ZIP压缩输入/输出流 --> ( 难度等级: [0.3183, 0.3183) || 挂载数据: 无 ) 
│       │       ├── 压缩文件 --> ( 难度等级: [0.3183, 0.3183) || 挂载数据: qa: 1 ) 
│       │       └── 解压缩ZIP文件 --> ( 难度等级: [0.3183, 0.3183) || 挂载数据: qa: 4 ) 
│       ├── 使用JDBC操作数据库 --> ( 难度等级: [0.3183, 0.3187) || 挂载数据: 无 ) 
│       │   ├── JDBC概述 --> ( 难度等级: [0.3183, 0.3185) || 挂载数据: 无 ) 
│       │   │   ├── JDBC-ODBC桥 --> ( 难度等级: [0.3183, 0.3184) || 挂载数据: 无 ) 
│       │   │   ├── JDBC技术 --> ( 难度等级: [0.3184, 0.3185) || 挂载数据: qa: 10 ) 
│       │   │   └── JDBC驱动程序的类型 --> ( 难度等级: [0.3185, 0.3185) || 挂载数据: 无 ) 
│       │   └── 数据库操作 --> ( 难度等级: [0.3185, 0.3187) || 挂载数据: 无 ) 
│       │       ├── 数据库基础 --> ( 难度等级: [0.3185, 0.3186) || 挂载数据: 无 ) 
│       │       ├── 数据查询 --> ( 难度等级: [0.3186, 0.3186) || 挂载数据: qa: 10 ) 
│       │       ├── 动态查询 --> ( 难度等级: [0.3186, 0.3186) || 挂载数据: qa: 1 ) 
│       │       ├── 添加、修改、删除记录 --> ( 难度等级: [0.3186, 0.3186) || 挂载数据: qa: 2 ) 
│       │       ├── 数据库基础知识 --> ( 难度等级: [0.3186, 0.3186) || 挂载数据: 无 ) 
│       │       │   ├── 什么是数据库 --> ( 难度等级: [0.3186, 0.3186) || 挂载数据: qa: 10 ) 
│       │       │   ├── 数据库的种类及功能 --> ( 难度等级: [0.3186, 0.3186) || 挂载数据: qa: 1 ) 
│       │       │   └── SQL语言 --> ( 难度等级: [0.3186, 0.3186) || 挂载数据: qa: 10 ) 
│       │       ├── 向数据库发送SQL语句 --> ( 难度等级: [0.3186, 0.3187) || 挂载数据: qa: 6 ) 
│       │       ├── 处理查询结果集 --> ( 难度等级: [0.3187, 0.3187) || 挂载数据: 无 ) 
│       │       ├── 顺序查询 --> ( 难度等级: [0.3187, 0.3187) || 挂载数据: 无 ) 
│       │       ├── 模糊查询 --> ( 难度等级: [0.3187, 0.3187) || 挂载数据: qa: 2 ) 
│       │       └── 预处理语句 --> ( 难度等级: [0.3187, 0.3187) || 挂载数据: 无 ) 
│       ├── Java绘图 --> ( 难度等级: [0.3187, 0.3192) || 挂载数据: 无 ) 
│       │   ├── Java绘图基础 --> ( 难度等级: [0.3187, 0.3188) || 挂载数据: 无 ) 
│       │   │   ├── Graphics绘图类 --> ( 难度等级: [0.3187, 0.3188) || 挂载数据: 无 ) 
│       │   │   ├── Graphics2D绘图类 --> ( 难度等级: [0.3188, 0.3188) || 挂载数据: qa: 1 ) 
│       │   │   └── Canvas画布类 --> ( 难度等级: [0.3188, 0.3188) || 挂载数据: 无 ) 
│       │   ├── 绘制几何图形 --> ( 难度等级: [0.3188, 0.3189) || 挂载数据: 无 ) 
│       │   ├── 设置颜色与画笔 --> ( 难度等级: [0.3189, 0.319) || 挂载数据: 无 ) 
│       │   │   ├── 设置颜色 --> ( 难度等级: [0.3189, 0.3189) || 挂载数据: qa: 2 ) 
│       │   │   └── 设置画笔 --> ( 难度等级: [0.3189, 0.319) || 挂载数据: qa: 10 ) 
│       │   ├── 图像处理 --> ( 难度等级: [0.319, 0.319) || 挂载数据: 无 ) 
│       │   │   ├── 绘制图像 --> ( 难度等级: [0.319, 0.319) || 挂载数据: 无 ) 
│       │   │   ├── 图像缩放 --> ( 难度等级: [0.319, 0.319) || 挂载数据: qa: 1 ) 
│       │   │   ├── 放大与缩小 --> ( 难度等级: [0.319, 0.319) || 挂载数据: 无 ) 
│       │   │   ├── 图像翻转 --> ( 难度等级: [0.319, 0.319) || 挂载数据: 无 ) 
│       │   │   ├── 图像旋转 --> ( 难度等级: [0.319, 0.319) || 挂载数据: qa: 1 ) 
│       │   │   └── 图像倾斜 --> ( 难度等级: [0.319, 0.319) || 挂载数据: 无 ) 
│       │   ├── Graphics --> ( 难度等级: [0.319, 0.3191) || 挂载数据: 无 ) 
│       │   └── Graphics2D --> ( 难度等级: [0.3191, 0.3192) || 挂载数据: 无 ) 
│       ├── 坦克大战游戏 --> ( 难度等级: [0.3192, 0.3196) || 挂载数据: qa: 5 ) 
│       │   ├── 开发背景 --> ( 难度等级: [0.3192, 0.3192) || 挂载数据: 无 ) 
│       │   ├── 系统开发环境要求 --> ( 难度等级: [0.3192, 0.3193) || 挂载数据: 无 ) 
│       │   ├── 系统功能设计 --> ( 难度等级: [0.3193, 0.3193) || 挂载数据: 无 ) 
│       │   │   ├── 系统功能结构 --> ( 难度等级: [0.3193, 0.3193) || 挂载数据: qa: 1 ) 
│       │   │   └── 系统业务流程 --> ( 难度等级: [0.3193, 0.3193) || 挂载数据: qa: 8 ) 
│       │   ├── 枚举设计 --> ( 难度等级: [0.3193, 0.3194) || 挂载数据: 无 ) 
│       │   │   ├── 方向枚举 --> ( 难度等级: [0.3193, 0.3193) || 挂载数据: qa: 1 ) 
│       │   │   ├── 游戏模式枚举 --> ( 难度等级: [0.3193, 0.3193) || 挂载数据: 无 ) 
│       │   │   ├── 坦克类型枚举 --> ( 难度等级: [0.3193, 0.3193) || 挂载数据: 无 ) 
│       │   │   └── 墙块类型枚举 --> ( 难度等级: [0.3193, 0.3194) || 挂载数据: 无 ) 
│       │   ├── 公共类设计 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: 无 ) 
│       │   │   ├── 绘图工具类 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: 无 ) 
│       │   │   └── 地图工具类 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: 无 ) 
│       │   ├── 模型类设计 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: 无 ) 
│       │   │   ├── 可显示图像的抽象类 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: 无 ) 
│       │   │   ├── 玩家坦克类 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: 无 ) 
│       │   │   ├── 电脑坦克类 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: qa: 2 ) 
│       │   │   ├── 子弹类 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: qa: 1 ) 
│       │   │   ├── 基地类 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: 无 ) 
│       │   │   ├── 爆炸效果类 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: qa: 1 ) 
│       │   │   └── 地图类 --> ( 难度等级: [0.3194, 0.3194) || 挂载数据: qa: 1 ) 
│       │   ├── 墙块设计 --> ( 难度等级: [0.3194, 0.3195) || 挂载数据: 无 ) 
│       │   │   ├── 墙块抽象类 --> ( 难度等级: [0.3194, 0.3195) || 挂载数据: 无 ) 
│       │   │   └── 墙块实体类 --> ( 难度等级: [0.3195, 0.3195) || 挂载数据: qa: 4 ) 
│       │   ├── 窗体类设计 --> ( 难度等级: [0.3195, 0.3195) || 挂载数据: 无 ) 
│       │   │   ├── 主窗体 --> ( 难度等级: [0.3195, 0.3195) || 挂载数据: 无 ) 
│       │   │   ├── 登录面板 --> ( 难度等级: [0.3195, 0.3195) || 挂载数据: qa: 10 ) 
│       │   │   ├── 显示关卡面板 --> ( 难度等级: [0.3195, 0.3195) || 挂载数据: 无 ) 
│       │   │   └── 游戏面板 --> ( 难度等级: [0.3195, 0.3195) || 挂载数据: qa: 8 ) 
│       │   └── 游戏核心功能设计 --> ( 难度等级: [0.3195, 0.3196) || 挂载数据: 无 ) 
│       │       ├── 碰撞检测 --> ( 难度等级: [0.3195, 0.3196) || 挂载数据: qa: 1 ) 
│       │       └── 刷新帧 --> ( 难度等级: [0.3196, 0.3196) || 挂载数据: qa: 2 ) 
│       ├── 对象导论 --> ( 难度等级: [0.3196, 0.32) || 挂载数据: 无 ) 
│       │   ├── 抽象过程 --> ( 难度等级: [0.3196, 0.3196) || 挂载数据: 无 ) 
│       │   ├── 每个对象都有一个接口 --> ( 难度等级: [0.3196, 0.3197) || 挂载数据: qa: 1 ) 
│       │   ├── 每个对象都提供服务 --> ( 难度等级: [0.3197, 0.3197) || 挂载数据: 无 ) 
│       │   ├── 被隐藏的具体实现 --> ( 难度等级: [0.3197, 0.3198) || 挂载数据: qa: 2 ) 
│       │   ├── 复用具体实现 --> ( 难度等级: [0.3198, 0.3198) || 挂载数据: 无 ) 
│       │   ├── 伴随多态的可互换对象 --> ( 难度等级: [0.3198, 0.3199) || 挂载数据: 无 ) 
│       │   ├── 单根继承结构 --> ( 难度等级: [0.3199, 0.3199) || 挂载数据: 无 ) 
│       │   ├── 容器 --> ( 难度等级: [0.3199, 0.32) || 挂载数据: 无 ) 
│       │   │   └── 参数化类型（范型） --> ( 难度等级: [0.3199, 0.32) || 挂载数据: qa: 1 ) 
│       │   └── 并发编程 --> ( 难度等级: [0.32, 0.32) || 挂载数据: qa: 2 ) 
│       ├── 操作符 --> ( 难度等级: [0.32, 0.3204) || 挂载数据: 无 ) 
│       │   ├── 更简单的打印语句 --> ( 难度等级: [0.32, 0.32) || 挂载数据: 无 ) 
│       │   ├── 使用Java操作符 --> ( 难度等级: [0.32, 0.3201) || 挂载数据: qa: 1 ) 
│       │   ├── 优先级 --> ( 难度等级: [0.3201, 0.3201) || 挂载数据: qa: 2 ) 
│       │   ├── 赋值 --> ( 难度等级: [0.3201, 0.3201) || 挂载数据: qa: 6 ) 
│       │   ├── 算术操作符 --> ( 难度等级: [0.3201, 0.3201) || 挂载数据: 无 ) 
│       │   │   └── 一元加、减操作符 --> ( 难度等级: [0.3201, 0.3201) || 挂载数据: qa: 1 ) 
│       │   ├── 自动递增和递减 --> ( 难度等级: [0.3201, 0.3202) || 挂载数据: qa: 1 ) 
│       │   ├── 关系操作符 --> ( 难度等级: [0.3202, 0.3202) || 挂载数据: 无 ) 
│       │   │   └── 测试对象的等价性 --> ( 难度等级: [0.3202, 0.3202) || 挂载数据: 无 ) 
│       │   ├── 逻辑操作符 --> ( 难度等级: [0.3202, 0.3202) || 挂载数据: 无 ) 
│       │   │   └── 短路 --> ( 难度等级: [0.3202, 0.3202) || 挂载数据: 无 ) 
│       │   ├── 按位操作符 --> ( 难度等级: [0.3202, 0.3203) || 挂载数据: 无 ) 
│       │   ├── 移位操作符 --> ( 难度等级: [0.3203, 0.3203) || 挂载数据: 无 ) 
│       │   ├── 三元操作符if-else --> ( 难度等级: [0.3203, 0.3203) || 挂载数据: 无 ) 
│       │   ├── 字符串操作符 + 和 += --> ( 难度等级: [0.3203, 0.3203) || 挂载数据: 无 ) 
│       │   ├── 使用操作符时常犯的错误 --> ( 难度等级: [0.3203, 0.3204) || 挂载数据: 无 ) 
│       │   ├── 类型转换操作符 --> ( 难度等级: [0.3204, 0.3204) || 挂载数据: 无 ) 
│       │   │   ├── 截尾和舍入 --> ( 难度等级: [0.3204, 0.3204) || 挂载数据: 无 ) 
│       │   │   └── 提升 --> ( 难度等级: [0.3204, 0.3204) || 挂载数据: qa: 1 ) 
│       │   └── Java没有“sizeof” --> ( 难度等级: [0.3204, 0.3204) || 挂载数据: 无 ) 
│       ├── 控制执行流程 --> ( 难度等级: [0.3204, 0.3208) || 挂载数据: 无 ) 
│       │   ├── true和false --> ( 难度等级: [0.3204, 0.3205) || 挂载数据: qa: 9 ) 
│       │   ├── if-else --> ( 难度等级: [0.3205, 0.3205) || 挂载数据: qa: 10 ) 
│       │   ├── 迭代 --> ( 难度等级: [0.3205, 0.3206) || 挂载数据: 无 ) 
│       │   │   ├── do-while --> ( 难度等级: [0.3205, 0.3205) || 挂载数据: qa: 10 ) 
│       │   │   └── 逗号操作符 --> ( 难度等级: [0.3205, 0.3206) || 挂载数据: 无 ) 
│       │   ├── Foreach语法 --> ( 难度等级: [0.3206, 0.3206) || 挂载数据: 无 ) 
│       │   ├── return --> ( 难度等级: [0.3206, 0.3207) || 挂载数据: qa: 10 ) 
│       │   ├── break和continue --> ( 难度等级: [0.3207, 0.3207) || 挂载数据: qa: 5 ) 
│       │   ├── 臭名昭著的“goto” --> ( 难度等级: [0.3207, 0.3208) || 挂载数据: 无 ) 
│       │   └── switch --> ( 难度等级: [0.3208, 0.3208) || 挂载数据: qa: 7 ) 
│       ├── 初始化与清理 --> ( 难度等级: [0.3208, 0.3212) || 挂载数据: 无 ) 
│       │   ├── 用构造器确保初始化 --> ( 难度等级: [0.3208, 0.3209) || 挂载数据: 无 ) 
│       │   ├── 缺省构造器 --> ( 难度等级: [0.3209, 0.321) || 挂载数据: 无 ) 
│       │   ├── 成员初始化 --> ( 难度等级: [0.321, 0.321) || 挂载数据: 无 ) 
│       │   │   └── 指定初始化 --> ( 难度等级: [0.321, 0.321) || 挂载数据: qa: 10 ) 
│       │   ├── 构造器初始化 --> ( 难度等级: [0.321, 0.3211) || 挂载数据: 无 ) 
│       │   │   ├── 初始化顺序 --> ( 难度等级: [0.321, 0.321) || 挂载数据: qa: 2 ) 
│       │   │   ├── 静态数据的初始化 --> ( 难度等级: [0.321, 0.3211) || 挂载数据: 无 ) 
│       │   │   └── 显式的静态初始化 --> ( 难度等级: [0.3211, 0.3211) || 挂载数据: qa: 2 ) 
│       │   ├── 数组初始化 --> ( 难度等级: [0.3211, 0.3211) || 挂载数据: qa: 2 ) 
│       │   │   └── 可变参数列表 --> ( 难度等级: [0.3211, 0.3211) || 挂载数据: qa: 5 ) 
│       │   ├── 枚举类型 --> ( 难度等级: [0.3211, 0.3212) || 挂载数据: 无 ) 
│       │   │   ├── 基本enum特性 --> ( 难度等级: [0.3211, 0.3211) || 挂载数据: 无 ) 
│       │   │   │   └── 将静态导入用于enum --> ( 难度等级: [0.3211, 0.3211) || 挂载数据: 无 ) 
│       │   │   ├── 向enum中添加新方法 --> ( 难度等级: [0.3211, 0.3211) || 挂载数据: 无 ) 
│       │   │   │   └── 覆盖enum的方法 --> ( 难度等级: [0.3211, 0.3211) || 挂载数据: qa: 9 ) 
│       │   │   ├── switch语句中的enum --> ( 难度等级: [0.3211, 0.3211) || 挂载数据: 无 ) 
│       │   │   ├── values（）的神秘之处 --> ( 难度等级: [0.3211, 0.3212) || 挂载数据: 无 ) 
│       │   │   ├── 实现但不继承随机选取 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: qa: 1 ) 
│       │   │   ├── 为组织而使用接口 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: 无 ) 
│       │   │   ├── 使用EnumSet替代标志 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: 无 ) 
│       │   │   ├── 使用EnumMap --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: 无 ) 
│       │   │   ├── 常数相关的方法 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用enum的职责链 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: 无 ) 
│       │   │   │   └── 使用enum的状态机 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: 无 ) 
│       │   │   ├── 多路分发 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用enum分发 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: 无 ) 
│       │   │   │   └── 使用EnumMap分发 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: 无 ) 
│       │   │   ├── 使用枚举类型设置常量 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用枚举类型的优势 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: qa: 1 ) 
│       │   └── 类初始化块 --> ( 难度等级: [0.3212, 0.3212) || 挂载数据: qa: 1 ) 
│       ├── 访问权限控制 --> ( 难度等级: [0.3212, 0.3217) || 挂载数据: 无 ) 
│       │   ├── Java访问权限修饰词 --> ( 难度等级: [0.3212, 0.3215) || 挂载数据: 无 ) 
│       │   │   ├── 包访问权限 --> ( 难度等级: [0.3212, 0.3213) || 挂载数据: qa: 10 ) 
│       │   │   ├── public:接口访问权限 --> ( 难度等级: [0.3213, 0.3214) || 挂载数据: qa: 9 ) 
│       │   │   ├── private: 你无法访问 --> ( 难度等级: [0.3214, 0.3214) || 挂载数据: qa: 9 ) 
│       │   │   └── protected：继承访问权限 --> ( 难度等级: [0.3214, 0.3215) || 挂载数据: qa: 2 ) 
│       │   └── 类的访问权限 --> ( 难度等级: [0.3215, 0.3217) || 挂载数据: 无 ) 
│       ├── 复用类 --> ( 难度等级: [0.3217, 0.3221) || 挂载数据: 无 ) 
│       │   ├── 组合语法 --> ( 难度等级: [0.3217, 0.3217) || 挂载数据: 无 ) 
│       │   ├── 继承语法 --> ( 难度等级: [0.3217, 0.3218) || 挂载数据: 无 ) 
│       │   │   └── 初始化基类 --> ( 难度等级: [0.3217, 0.3218) || 挂载数据: 无 ) 
│       │   ├── 代理 --> ( 难度等级: [0.3218, 0.3219) || 挂载数据: 无 ) 
│       │   │   ├── 创建代理对象 --> ( 难度等级: [0.3218, 0.3219) || 挂载数据: 无 ) 
│       │   │   └── 代理类的特性 --> ( 难度等级: [0.3219, 0.3219) || 挂载数据: qa: 2 ) 
│       │   ├── 在组合与继承之间选择 --> ( 难度等级: [0.3219, 0.322) || 挂载数据: 无 ) 
│       │   └── protected关键字 --> ( 难度等级: [0.322, 0.3221) || 挂载数据: qa: 1 ) 
│       ├── 持有对象 --> ( 难度等级: [0.3221, 0.3225) || 挂载数据: 无 ) 
│       │   ├── 基本概念 --> ( 难度等级: [0.3221, 0.3221) || 挂载数据: 无 ) 
│       │   ├── 添加一组元素 --> ( 难度等级: [0.3221, 0.3222) || 挂载数据: 无 ) 
│       │   ├── 容器的打印 --> ( 难度等级: [0.3222, 0.3222) || 挂载数据: 无 ) 
│       │   ├── List --> ( 难度等级: [0.3222, 0.3222) || 挂载数据: 无 ) 
│       │   ├── 迭代器 --> ( 难度等级: [0.3222, 0.3223) || 挂载数据: 无 ) 
│       │   │   └── ListIterator --> ( 难度等级: [0.3222, 0.3223) || 挂载数据: qa: 1 ) 
│       │   ├── LinkedList --> ( 难度等级: [0.3223, 0.3223) || 挂载数据: qa: 5 ) 
│       │   ├── Stack --> ( 难度等级: [0.3223, 0.3223) || 挂载数据: qa: 3 ) 
│       │   ├── Set --> ( 难度等级: [0.3223, 0.3224) || 挂载数据: 无 ) 
│       │   ├── Map --> ( 难度等级: [0.3224, 0.3224) || 挂载数据: 无 ) 
│       │   ├── Queue --> ( 难度等级: [0.3224, 0.3224) || 挂载数据: 无 ) 
│       │   │   └── PriorityQueue --> ( 难度等级: [0.3224, 0.3224) || 挂载数据: 无 ) 
│       │   ├── Collection和Iterator --> ( 难度等级: [0.3224, 0.3225) || 挂载数据: qa: 2 ) 
│       │   └── Foreach与迭代器 --> ( 难度等级: [0.3225, 0.3225) || 挂载数据: 无 ) 
│       │       └── 适配器方法惯用法 --> ( 难度等级: [0.3225, 0.3225) || 挂载数据: 无 ) 
│       ├── 通过异常处理错误 --> ( 难度等级: [0.3225, 0.3229) || 挂载数据: 无 ) 
│       │   ├── 概念 --> ( 难度等级: [0.3225, 0.3225) || 挂载数据: qa: 1 ) 
│       │   ├── 捕获异常 --> ( 难度等级: [0.3225, 0.3226) || 挂载数据: 无 ) 
│       │   │   ├── try块 --> ( 难度等级: [0.3225, 0.3225) || 挂载数据: qa: 1 ) 
│       │   │   ├── 异常处理程序 --> ( 难度等级: [0.3225, 0.3226) || 挂载数据: qa: 1 ) 
│       │   │   ├── f?inally子句 --> ( 难度等级: [0.3226, 0.3226) || 挂载数据: 无 ) 
│       │   │   ├── try-with-Resources语句 --> ( 难度等级: [0.3226, 0.3226) || 挂载数据: 无 ) 
│       │   │   └── 分析堆栈轨迹元素 --> ( 难度等级: [0.3226, 0.3226) || 挂载数据: 无 ) 
│       │   ├── 创建自定义异常 --> ( 难度等级: [0.3226, 0.3226) || 挂载数据: 无 ) 
│       │   ├── 异常说明 --> ( 难度等级: [0.3226, 0.3227) || 挂载数据: 无 ) 
│       │   ├── 捕获所有异常 --> ( 难度等级: [0.3227, 0.3227) || 挂载数据: 无 ) 
│       │   │   ├── 栈轨迹 --> ( 难度等级: [0.3227, 0.3227) || 挂载数据: 无 ) 
│       │   │   ├── 重新抛出异常 --> ( 难度等级: [0.3227, 0.3227) || 挂载数据: qa: 10 ) 
│       │   │   └── 异常链 --> ( 难度等级: [0.3227, 0.3227) || 挂载数据: 无 ) 
│       │   ├── Java标准异常 --> ( 难度等级: [0.3227, 0.3227) || 挂载数据: 无 ) 
│       │   │   └── 特例: RuntimeException（运行时异常） --> ( 难度等级: [0.3227, 0.3227) || 挂载数据: qa: 2 ) 
│       │   ├── 使用finally进行清理 --> ( 难度等级: [0.3227, 0.3228) || 挂载数据: 无 ) 
│       │   │   ├── finally用来做什么 --> ( 难度等级: [0.3227, 0.3227) || 挂载数据: qa: 10 ) 
│       │   │   ├── 在return中使用finally --> ( 难度等级: [0.3227, 0.3228) || 挂载数据: qa: 1 ) 
│       │   │   └── 缺憾：异常丢失 --> ( 难度等级: [0.3228, 0.3228) || 挂载数据: 无 ) 
│       │   ├── 构造器 --> ( 难度等级: [0.3228, 0.3228) || 挂载数据: 无 ) 
│       │   │   ├── 使用构造器执行初始化 --> ( 难度等级: [0.3228, 0.3228) || 挂载数据: qa: 5 ) 
│       │   │   └── 构造器重载 --> ( 难度等级: [0.3228, 0.3228) || 挂载数据: qa: 2 ) 
│       │   ├── 异常匹配 --> ( 难度等级: [0.3228, 0.3228) || 挂载数据: qa: 1 ) 
│       │   ├── 其他可选方式 --> ( 难度等级: [0.3228, 0.3229) || 挂载数据: qa: 2 ) 
│       │   │   ├── 历史 --> ( 难度等级: [0.3228, 0.3229) || 挂载数据: 无 ) 
│       │   │   ├── 观点 --> ( 难度等级: [0.3229, 0.3229) || 挂载数据: 无 ) 
│       │   │   ├── 把异常传递给控制台 --> ( 难度等级: [0.3229, 0.3229) || 挂载数据: 无 ) 
│       │   │   └── 把“受检查异常”转换为“不受检查的异常” --> ( 难度等级: [0.3229, 0.3229) || 挂载数据: 无 ) 
│       │   └── 异常使用指南 --> ( 难度等级: [0.3229, 0.3229) || 挂载数据: 无 ) 
│       ├── 类型信息 --> ( 难度等级: [0.3229, 0.3233) || 挂载数据: 无 ) 
│       │   ├── Class对象 --> ( 难度等级: [0.3229, 0.323) || 挂载数据: 无 ) 
│       │   │   ├── 类字面常量 --> ( 难度等级: [0.3229, 0.3229) || 挂载数据: 无 ) 
│       │   │   ├── 泛化的Class引用 --> ( 难度等级: [0.3229, 0.323) || 挂载数据: qa: 10 ) 
│       │   │   └── 新的转型语法 --> ( 难度等级: [0.323, 0.323) || 挂载数据: 无 ) 
│       │   ├── 类型转换前先做检查 --> ( 难度等级: [0.323, 0.323) || 挂载数据: 无 ) 
│       │   │   ├── 使用类字面常量 --> ( 难度等级: [0.323, 0.323) || 挂载数据: 无 ) 
│       │   │   ├── 动态instanceof --> ( 难度等级: [0.323, 0.323) || 挂载数据: qa: 1 ) 
│       │   │   └── 递归计数 --> ( 难度等级: [0.323, 0.323) || 挂载数据: 无 ) 
│       │   ├── 注册工厂 --> ( 难度等级: [0.323, 0.3231) || 挂载数据: 无 ) 
│       │   ├── instanceof与Class的等价性 --> ( 难度等级: [0.3231, 0.3232) || 挂载数据: 无 ) 
│       │   ├── 反射：运行时类信息 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: 无 ) 
│       │   │   ├── 类方法抽取器 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: 无 ) 
│       │   │   ├── Class类与Java反射 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: 无 ) 
│       │   │   │   ├── 访问构造方法 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 访问成员变量 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 访问方法 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: 无 ) 
│       │   │   ├── 使用Annotation功能 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 定义Annotation类型 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: qa: 5 ) 
│       │   │   │   └── 访问Annotation信息 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: qa: 10 ) 
│       │   │   ├── 声明异常入门 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: 无 ) 
│       │   │   ├── 资源 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: 无 ) 
│       │   │   ├── 利用反射分析类的能力 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: qa: 2 ) 
│       │   │   ├── 使用反射在运行时分析 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: 无 ) 
│       │   │   ├── 使用反射编写泛型数组 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: 无 ) 
│       │   │   ├── 访问字段 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: 无 ) 
│       │   │   ├── 调用方法 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: qa: 3 ) 
│       │   │   ├── 调用构造方法 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: qa: 3 ) 
│       │   │   └── 获取继承关系 --> ( 难度等级: [0.3232, 0.3232) || 挂载数据: qa: 2 ) 
│       │   ├── 动态代理 --> ( 难度等级: [0.3232, 0.3233) || 挂载数据: 无 ) 
│       │   └── 空对象 --> ( 难度等级: [0.3233, 0.3233) || 挂载数据: 无 ) 
│       │       └── 模拟对象与桩 --> ( 难度等级: [0.3233, 0.3233) || 挂载数据: 无 ) 
│       ├── 容器深入研究 --> ( 难度等级: [0.3233, 0.3237) || 挂载数据: 无 ) 
│       │   ├── 完整的容器分类法 --> ( 难度等级: [0.3233, 0.3234) || 挂载数据: 无 ) 
│       │   ├── 填充容器 --> ( 难度等级: [0.3234, 0.3234) || 挂载数据: qa: 1 ) 
│       │   │   ├── 一种Generator解决方案 --> ( 难度等级: [0.3234, 0.3234) || 挂载数据: qa: 1 ) 
│       │   │   ├── Map生成器 --> ( 难度等级: [0.3234, 0.3234) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用Abstract类 --> ( 难度等级: [0.3234, 0.3234) || 挂载数据: qa: 1 ) 
│       │   ├── Collection的功能方法 --> ( 难度等级: [0.3234, 0.3234) || 挂载数据: 无 ) 
│       │   ├── 可选操作 --> ( 难度等级: [0.3234, 0.3235) || 挂载数据: 无 ) 
│       │   │   └── 未获支持的操作 --> ( 难度等级: [0.3234, 0.3235) || 挂载数据: 无 ) 
│       │   ├── List的功能方法 --> ( 难度等级: [0.3235, 0.3235) || 挂载数据: 无 ) 
│       │   ├── 队列 --> ( 难度等级: [0.3235, 0.3235) || 挂载数据: qa: 1 ) 
│       │   │   ├── 优先级队列 --> ( 难度等级: [0.3235, 0.3235) || 挂载数据: qa: 7 ) 
│       │   │   └── 双向队列 --> ( 难度等级: [0.3235, 0.3235) || 挂载数据: 无 ) 
│       │   ├── 理解Map --> ( 难度等级: [0.3235, 0.3236) || 挂载数据: 无 ) 
│       │   │   ├── 性能 --> ( 难度等级: [0.3235, 0.3236) || 挂载数据: qa: 1 ) 
│       │   │   ├── SortedMap --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   │   └── LinkedHashMap --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: qa: 3 ) 
│       │   ├── 散列与散列码 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   │   ├── 理解hashCode（） --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: qa: 10 ) 
│       │   │   ├── 为速度而散列 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: qa: 1 ) 
│       │   │   └── 覆盖hashCode（） --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   ├── 选择接口的不同实现 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   │   ├── 性能测试框架 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   │   ├── 对List的选择 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: qa: 7 ) 
│       │   │   ├── 微基准测试的危险 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   │   ├── 对Set的选择 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   │   └── 对Map的选择 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   ├── 实用方法 --> ( 难度等级: [0.3236, 0.3237) || 挂载数据: qa: 1 ) 
│       │   │   ├── List的排序和查询 --> ( 难度等级: [0.3236, 0.3237) || 挂载数据: 无 ) 
│       │   │   ├── 设定Collection或Map为不可修改 --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: 无 ) 
│       │   │   └── Collection或Map的同步控制 --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: 无 ) 
│       │   ├── 持有引用 --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: 无 ) 
│       │   │   └── WeakHashMap --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: 无 ) 
│       │   └── Java 1.0/1.1 的容器 --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: 无 ) 
│       │       ├── Vector和Enumeration --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: qa: 3 ) 
│       │       ├── Hashtable --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: 无 ) 
│       │       └── BitSet --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: 无 ) 
│       ├── Java I/O系统 --> ( 难度等级: [0.3237, 0.3242) || 挂载数据: 无 ) 
│       │   ├── 输入和输出 --> ( 难度等级: [0.3237, 0.3238) || 挂载数据: qa: 1 ) 
│       │   │   ├── InputStream类型 --> ( 难度等级: [0.3237, 0.3238) || 挂载数据: 无 ) 
│       │   │   ├── OutputStream类型 --> ( 难度等级: [0.3238, 0.3238) || 挂载数据: 无 ) 
│       │   │   └── 读取输入 --> ( 难度等级: [0.3238, 0.3238) || 挂载数据: qa: 2 ) 
│       │   ├── 添加属性和有用的接口 --> ( 难度等级: [0.3238, 0.3238) || 挂载数据: 无 ) 
│       │   │   ├── 通过FilterInputStream从InputStream读取 --> ( 难度等级: [0.3238, 0.3238) || 挂载数据: qa: 1 ) 
│       │   │   └── 通过FilterOutPutStream向OutputStream写入 --> ( 难度等级: [0.3238, 0.3238) || 挂载数据: qa: 1 ) 
│       │   ├── Reader和Writer --> ( 难度等级: [0.3238, 0.3239) || 挂载数据: 无 ) 
│       │   │   ├── 数据的来源和去处 --> ( 难度等级: [0.3238, 0.3238) || 挂载数据: 无 ) 
│       │   │   ├── 更改流的行为 --> ( 难度等级: [0.3238, 0.3239) || 挂载数据: qa: 1 ) 
│       │   │   └── 未发生变化的类 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: 无 ) 
│       │   ├── I/O流的典型使用方式 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: 无 ) 
│       │   │   ├── 缓冲的输入文件 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: qa: 1 ) 
│       │   │   ├── 从内存中输入 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: 无 ) 
│       │   │   ├── 格式化的内存输入 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: 无 ) 
│       │   │   ├── 基本文件输出 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: 无 ) 
│       │   │   ├── 存储和恢复数据 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: 无 ) 
│       │   │   ├── 读取和写入随机访问文件 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: qa: 1 ) 
│       │   │   └── 管道流 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: qa: 1 ) 
│       │   ├── 文件读写的实用工具 --> ( 难度等级: [0.3239, 0.324) || 挂载数据: 无 ) 
│       │   │   └── 读取二进制文件 --> ( 难度等级: [0.3239, 0.324) || 挂载数据: qa: 10 ) 
│       │   ├── 标准I/O --> ( 难度等级: [0.324, 0.324) || 挂载数据: 无 ) 
│       │   │   ├── 从标准输入中读取 --> ( 难度等级: [0.324, 0.324) || 挂载数据: 无 ) 
│       │   │   ├── 将System.out转换成PrintWriter --> ( 难度等级: [0.324, 0.324) || 挂载数据: 无 ) 
│       │   │   └── 标准I/O重定向 --> ( 难度等级: [0.324, 0.324) || 挂载数据: qa: 10 ) 
│       │   ├── 进程控制 --> ( 难度等级: [0.324, 0.324) || 挂载数据: 无 ) 
│       │   ├── 压缩 --> ( 难度等级: [0.324, 0.3241) || 挂载数据: 无 ) 
│       │   │   ├── 用GZIP进行简单压缩 --> ( 难度等级: [0.324, 0.3241) || 挂载数据: qa: 4 ) 
│       │   │   ├── 用Zip进行多文件存储 --> ( 难度等级: [0.3241, 0.3241) || 挂载数据: 无 ) 
│       │   │   └── Java档案文件 --> ( 难度等级: [0.3241, 0.3241) || 挂载数据: 无 ) 
│       │   ├── XML --> ( 难度等级: [0.3241, 0.3241) || 挂载数据: 无 ) 
│       │   └── Preferences --> ( 难度等级: [0.3241, 0.3242) || 挂载数据: 无 ) 
│       ├── 注解 --> ( 难度等级: [0.3242, 0.3246) || 挂载数据: 无 ) 
│       │   ├── 基本语法 --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: 无 ) 
│       │   │   ├── 定义注解 --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: 无 ) 
│       │   │   └── 元注解 --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: 无 ) 
│       │   ├── 编写注解处理器 --> ( 难度等级: [0.3242, 0.3243) || 挂载数据: 无 ) 
│       │   │   ├── 注解元素 --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: qa: 6 ) 
│       │   │   ├── 缺省值限制 --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: 无 ) 
│       │   │   ├── 生成外部文件 --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: qa: 9 ) 
│       │   │   ├── 注解不支持继承 --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: 无 ) 
│       │   │   └── 实现处理器 --> ( 难度等级: [0.3242, 0.3243) || 挂载数据: 无 ) 
│       │   ├── 使用apt处理注解 --> ( 难度等级: [0.3243, 0.3243) || 挂载数据: 无 ) 
│       │   ├── 将观察者模式用于apt --> ( 难度等级: [0.3243, 0.3244) || 挂载数据: qa: 1 ) 
│       │   ├── 基于注解的单元测试 --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   │   ├── 将@Unit用于泛型 --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   │   ├── 不需要任何“套件” --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   │   ├── 实现@Unit --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   │   └── 移除测试代码 --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: qa: 2 ) 
│       │   ├── 限定重写父类方法：@Override --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   ├── Java 9增强的@Deprecated --> ( 难度等级: [0.3244, 0.3245) || 挂载数据: 无 ) 
│       │   ├── 抑制编译器警告：@SuppressWarnings --> ( 难度等级: [0.3245, 0.3245) || 挂载数据: 无 ) 
│       │   └── “堆污染”警告与Java 9增强的@SafeVarargs --> ( 难度等级: [0.3245, 0.3246) || 挂载数据: 无 ) 
│       ├── 并发 --> ( 难度等级: [0.3246, 0.325) || 挂载数据: qa: 1 ) 
│       │   ├── 并发的多面性 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: qa: 1 ) 
│       │   │   ├── 更快的执行 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   └── 改进代码设计 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   ├── 基本的线程机制 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── 定义任务让步 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── 使用Executor --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── 从任务产生返回值 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── 休眠 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── 让步 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── 编码的变体 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── 术语 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   └── 创建有响应的用户界面 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   ├── 共享受限资源 --> ( 难度等级: [0.3246, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 不正确地访问资源 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: qa: 2 ) 
│       │   │   ├── 解决共享资源竞争 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── 原子性与易变性 --> ( 难度等级: [0.3246, 0.3247) || 挂载数据: qa: 1 ) 
│       │   │   ├── 原子类 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 临界资源 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 在其他对象上同步 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   └── 线程局部存储 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   ├── 终结任务 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 装饰性花园 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 在阻塞时终结 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 中断 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: qa: 1 ) 
│       │   │   └── 检查中断 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   ├── 线程之间的协作 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── wait（）与notifyAll（） --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── notify（）与notifyAll（） --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: qa: 1 ) 
│       │   │   ├── 生产者与消费者 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   └── 任务间使用管道进行输入/输出 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   ├── 死锁 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   ├── 新类库中的构件 --> ( 难度等级: [0.3247, 0.3248) || 挂载数据: qa: 1 ) 
│       │   │   ├── CountDownLatch --> ( 难度等级: [0.3247, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── CyclicBarrier --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── DelayQueue --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── PriorityBlockingQueue --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── 使用ScheduledExecutor的温室控制器 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── Semaphore --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   └── Exchange --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   ├── 仿真 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── 银行出纳仿真 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── 饭店仿真 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   └── 分发工作 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: qa: 2 ) 
│       │   ├── 性能调优 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── 比较各类互斥技术 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── 免锁容器 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── 乐观锁 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   │   └── ReadWriteLock --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │   ├── 活动对象 --> ( 难度等级: [0.3248, 0.3249) || 挂载数据: 无 ) 
│       │   ├── 进阶读物 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: 无 ) 
│       │   ├── 线程状态 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: 无 ) 
│       │   │   ├── 新建线程 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: qa: 2 ) 
│       │   │   ├── 可运行线程 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: qa: 4 ) 
│       │   │   ├── 阻塞和等待线程 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: qa: 4 ) 
│       │   │   └── 终止线程 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: 无 ) 
│       │   ├── 线程属性 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: 无 ) 
│       │   │   ├── 中断线程 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: 无 ) 
│       │   │   ├── 守护线程 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: 无 ) 
│       │   │   ├── 线程名 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: qa: 1 ) 
│       │   │   └── 未捕获异常的处理器 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: 无 ) 
│       │   ├── 线程安全的集合 --> ( 难度等级: [0.3249, 0.325) || 挂载数据: 无 ) 
│       │   │   ├── 阻塞队列 --> ( 难度等级: [0.3249, 0.3249) || 挂载数据: 无 ) 
│       │   │   ├── 映射条目的原子更新 --> ( 难度等级: [0.3249, 0.325) || 挂载数据: 无 ) 
│       │   │   ├── 对并发散列映射的批操作 --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │   │   ├── 并发集视图 --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │   │   ├── 写数组的拷贝 --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │   │   ├── 并行数组算法 --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │   │   └── 较早的线程安全集合 --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │   └── 异步计算 --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │       ├── 可完成Future --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │       ├── 组合可完成Future --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │       └── 用户界面回调中的长时间运行任务 --> ( 难度等级: [0.325, 0.325) || 挂载数据: qa: 1 ) 
│       ├── 图形化用户界面 --> ( 难度等级: [0.325, 0.3254) || 挂载数据: 无 ) 
│       │   ├── Swing基础 --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │   │   └── 一个显示框架 --> ( 难度等级: [0.325, 0.325) || 挂载数据: 无 ) 
│       │   ├── 创建按钮 --> ( 难度等级: [0.325, 0.3251) || 挂载数据: 无 ) 
│       │   ├── 捕获事件 --> ( 难度等级: [0.3251, 0.3251) || 挂载数据: 无 ) 
│       │   ├── 文本区域 --> ( 难度等级: [0.3251, 0.3251) || 挂载数据: 无 ) 
│       │   ├── 控制布局 --> ( 难度等级: [0.3251, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── GridBagLayout --> ( 难度等级: [0.3251, 0.3252) || 挂载数据: qa: 1 ) 
│       │   │   ├── 绝对定位 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 1 ) 
│       │   │   └── BoxLayout --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   ├── Swing事件模型 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 事件与监听器的类型 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   └── 跟踪多个事件 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   ├── Swing组件一览 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 按钮 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 图标 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 1 ) 
│       │   │   ├── 工具提示 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 10 ) 
│       │   │   ├── 文本域 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 边框 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 滚动面板 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 一个迷你编辑器 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 复选框 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 2 ) 
│       │   │   ├── 单选按钮 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 组合框（下拉列表） --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 列表框 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 页签面板 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 1 ) 
│       │   │   ├── 消息框 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 6 ) 
│       │   │   ├── 菜单 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   │   ├── 创建菜单栏 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   │   ├── 创建弹出式菜单 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   │   ├── 定制个性化菜单 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   │   ├── 菜单构建 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 6 ) 
│       │   │   │   ├── 菜单项中的图标 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   │   ├── 弹出菜单 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 键盘助记符和加速器 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   │   ├── 启用和禁用菜单项 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 工具条 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 弹出式菜单 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 绘图 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 对话框 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   │   ├── 选项对话框 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   │   ├── 创建对话框 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 数据交换 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 文件对话框 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 1 ) 
│       │   │   ├── Swing组件上的HTML --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 滑块与进度条 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   ├── 选择外观 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │   └── 树、表格和剪贴板 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │       ├── 传递文本 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: qa: 1 ) 
│       │   │       ├── 使用系统剪贴板传递图像 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │       ├── 使用本地剪贴板传递对象引用 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   │       └── 通过系统剪贴板传递Java对象 --> ( 难度等级: [0.3252, 0.3252) || 挂载数据: 无 ) 
│       │   ├── JNLP与Java Web Start --> ( 难度等级: [0.3252, 0.3253) || 挂载数据: 无 ) 
│       │   ├── 可视化编程与JavaBean --> ( 难度等级: [0.3253, 0.3253) || 挂载数据: 无 ) 
│       │   │   ├── JavaBean是什么 --> ( 难度等级: [0.3253, 0.3253) || 挂载数据: qa: 10 ) 
│       │   │   ├── 使用Introspector抽取出BeanInfo --> ( 难度等级: [0.3253, 0.3253) || 挂载数据: 无 ) 
│       │   │   ├── 一个更复杂的Bean --> ( 难度等级: [0.3253, 0.3253) || 挂载数据: 无 ) 
│       │   │   ├── 把Bean打包 --> ( 难度等级: [0.3253, 0.3253) || 挂载数据: qa: 4 ) 
│       │   │   ├── 对更复杂的Bean的支持 --> ( 难度等级: [0.3253, 0.3253) || 挂载数据: qa: 3 ) 
│       │   │   └── 更多有关Bean的读物 --> ( 难度等级: [0.3253, 0.3253) || 挂载数据: 无 ) 
│       │   ├── Swing的可替换选择 --> ( 难度等级: [0.3253, 0.3253) || 挂载数据: 无 ) 
│       │   ├── 用Flex构建Flash Web客户端 --> ( 难度等级: [0.3253, 0.3254) || 挂载数据: 无 ) 
│       │   │   ├── Hello, Flex --> ( 难度等级: [0.3253, 0.3254) || 挂载数据: qa: 4 ) 
│       │   │   ├── 编译MXML --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: qa: 10 ) 
│       │   │   ├── MXML与ActionScript --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │   │   ├── 效果与风格 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │   │   ├── 事件 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: qa: 1 ) 
│       │   │   ├── 连接到Java --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │   │   ├── 数据模型与数据绑定 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: qa: 1 ) 
│       │   │   └── 构建和部署 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │   └── 创建SWT应用 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │       ├── 安装SWT --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │       ├── Hello, SWT --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: qa: 2 ) 
│       │       ├── 根除冗余代码 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │       ├── 菜单 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │       ├── 页签面板、按钮和事件 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │       ├── 图形 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: qa: 1 ) 
│       │       ├── SWT中的并发 --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       │       └── SWT还是Swing --> ( 难度等级: [0.3254, 0.3254) || 挂载数据: 无 ) 
│       ├── 基础知识 --> ( 难度等级: [0.3254, 0.3258) || 挂载数据: qa: 1 ) 
│       │   ├── 熟悉Eclipse开发工具 --> ( 难度等级: [0.3254, 0.3256) || 挂载数据: 无 ) 
│       │   │   └── 熟悉Eclipse --> ( 难度等级: [0.3254, 0.3256) || 挂载数据: 无 ) 
│       │   │       ├── 安装Eclipse的中文语言包 --> ( 难度等级: [0.3254, 0.3255) || 挂载数据: qa: 10 ) 
│       │   │       ├── 透视图与视图 --> ( 难度等级: [0.3255, 0.3255) || 挂载数据: 无 ) 
│       │   │       ├── 菜单栏 --> ( 难度等级: [0.3255, 0.3255) || 挂载数据: 无 ) 
│       │   │       ├── 工具栏 --> ( 难度等级: [0.3255, 0.3256) || 挂载数据: 无 ) 
│       │   │       ├── “包资源管理器”视图 --> ( 难度等级: [0.3256, 0.3256) || 挂载数据: 无 ) 
│       │   │       └── “控制台”视图 --> ( 难度等级: [0.3256, 0.3256) || 挂载数据: 无 ) 
│       │   └── 数字处理类 --> ( 难度等级: [0.3256, 0.3258) || 挂载数据: 无 ) 
│       │       ├── 数字格式化 --> ( 难度等级: [0.3256, 0.3257) || 挂载数据: 无 ) 
│       │       ├── 数学运算 --> ( 难度等级: [0.3257, 0.3257) || 挂载数据: 无 ) 
│       │       ├── 随机数 --> ( 难度等级: [0.3257, 0.3258) || 挂载数据: qa: 6 ) 
│       │       │   └── Math.random方法 --> ( 难度等级: [0.3257, 0.3258) || 挂载数据: 无 ) 
│       │       └── 大数字运算 --> ( 难度等级: [0.3258, 0.3258) || 挂载数据: qa: 10 ) 
│       │           ├── BigInteger --> ( 难度等级: [0.3258, 0.3258) || 挂载数据: 无 ) 
│       │           └── BigDecimal --> ( 难度等级: [0.3258, 0.3258) || 挂载数据: qa: 2 ) 
│       ├── 核心技术 --> ( 难度等级: [0.3258, 0.3262) || 挂载数据: qa: 1 ) 
│       │   ├── 类的高级特性 --> ( 难度等级: [0.3258, 0.326) || 挂载数据: 无 ) 
│       │   │   └── final变量 --> ( 难度等级: [0.3258, 0.326) || 挂载数据: 无 ) 
│       │   ├── 集合类 --> ( 难度等级: [0.326, 0.3261) || 挂载数据: qa: 1 ) 
│       │   │   ├── 集合类概述 --> ( 难度等级: [0.326, 0.326) || 挂载数据: qa: 1 ) 
│       │   │   ├── List集合 --> ( 难度等级: [0.326, 0.326) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── List接口的实现类 --> ( 难度等级: [0.326, 0.326) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 改进的List接口和ListIterator接口 --> ( 难度等级: [0.326, 0.326) || 挂载数据: 无 ) 
│       │   │   │   ├── ArrayList和Vector实现类 --> ( 难度等级: [0.326, 0.326) || 挂载数据: qa: 6 ) 
│       │   │   │   └── 固定长度的List --> ( 难度等级: [0.326, 0.326) || 挂载数据: 无 ) 
│       │   │   ├── Set集合 --> ( 难度等级: [0.326, 0.3261) || 挂载数据: 无 ) 
│       │   │   │   ├── HashSet类 --> ( 难度等级: [0.326, 0.326) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── LinkedHashSet类 --> ( 难度等级: [0.326, 0.3261) || 挂载数据: 无 ) 
│       │   │   │   ├── TreeSet类 --> ( 难度等级: [0.3261, 0.3261) || 挂载数据: qa: 5 ) 
│       │   │   │   ├── EnumSet类 --> ( 难度等级: [0.3261, 0.3261) || 挂载数据: 无 ) 
│       │   │   │   └── 各Set实现类的性能分析 --> ( 难度等级: [0.3261, 0.3261) || 挂载数据: qa: 10 ) 
│       │   │   └── Map集合 --> ( 难度等级: [0.3261, 0.3261) || 挂载数据: 无 ) 
│       │   │       └── Map接口的实现类 --> ( 难度等级: [0.3261, 0.3261) || 挂载数据: qa: 10 ) 
│       │   └── 网络通信 --> ( 难度等级: [0.3261, 0.3262) || 挂载数据: 无 ) 
│       │       ├── 网络程序设计基础 --> ( 难度等级: [0.3261, 0.3262) || 挂载数据: 无 ) 
│       │       │   ├── 局域网与因特网 --> ( 难度等级: [0.3261, 0.3261) || 挂载数据: qa: 1 ) 
│       │       │   ├── 网络协议 --> ( 难度等级: [0.3261, 0.3261) || 挂载数据: 无 ) 
│       │       │   └── 端口和套接字 --> ( 难度等级: [0.3261, 0.3262) || 挂载数据: 无 ) 
│       │       ├── TCP程序设计基础 --> ( 难度等级: [0.3262, 0.3262) || 挂载数据: 无 ) 
│       │       │   ├── InetAddress类 --> ( 难度等级: [0.3262, 0.3262) || 挂载数据: 无 ) 
│       │       │   └── ServerSocket类 --> ( 难度等级: [0.3262, 0.3262) || 挂载数据: qa: 1 ) 
│       │       └── UDP程序设计基础 --> ( 难度等级: [0.3262, 0.3262) || 挂载数据: 无 ) 
│       │           ├── DatagramPacket类 --> ( 难度等级: [0.3262, 0.3262) || 挂载数据: 无 ) 
│       │           └── DatagramSocket类 --> ( 难度等级: [0.3262, 0.3262) || 挂载数据: 无 ) 
│       ├── 高级应用 --> ( 难度等级: [0.3262, 0.3267) || 挂载数据: 无 ) 
│       │   ├── Swing表格组件 --> ( 难度等级: [0.3262, 0.3263) || 挂载数据: 无 ) 
│       │   │   ├── 利用JTable类直接创建表格 --> ( 难度等级: [0.3262, 0.3263) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 创建表格 --> ( 难度等级: [0.3262, 0.3263) || 挂载数据: 无 ) 
│       │   │   │   ├── 定制表格 --> ( 难度等级: [0.3263, 0.3263) || 挂载数据: 无 ) 
│       │   │   │   └── 操纵表格 --> ( 难度等级: [0.3263, 0.3263) || 挂载数据: 无 ) 
│       │   │   └── 提供行标题栏的表格 --> ( 难度等级: [0.3263, 0.3263) || 挂载数据: qa: 3 ) 
│       │   ├── Swing树组件 --> ( 难度等级: [0.3263, 0.3264) || 挂载数据: 无 ) 
│       │   │   ├── 处理选中节点事件 --> ( 难度等级: [0.3263, 0.3263) || 挂载数据: 无 ) 
│       │   │   ├── 遍历树节点 --> ( 难度等级: [0.3263, 0.3264) || 挂载数据: qa: 4 ) 
│       │   │   ├── 定制树 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: 无 ) 
│       │   │   ├── 维护树模型 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: 无 ) 
│       │   │   └── 处理展开节点事件 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: 无 ) 
│       │   ├── Swing其他高级组件 --> ( 难度等级: [0.3264, 0.3265) || 挂载数据: 无 ) 
│       │   │   ├── 高级组件面板 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: 无 ) 
│       │   │   │   ├── 分割面板 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 选项卡面板 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: 无 ) 
│       │   │   │   └── 桌面面板和内部窗体 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: 无 ) 
│       │   │   ├── 文件选择器 --> ( 难度等级: [0.3264, 0.3265) || 挂载数据: 无 ) 
│       │   │   │   ├── 文件选择对话框 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 使用文件过滤器 --> ( 难度等级: [0.3264, 0.3265) || 挂载数据: 无 ) 
│       │   │   ├── 系统托盘 --> ( 难度等级: [0.3265, 0.3265) || 挂载数据: 无 ) 
│       │   │   └── 桌面集成控件 --> ( 难度等级: [0.3265, 0.3265) || 挂载数据: 无 ) 
│       │   ├── 高级事件处理 --> ( 难度等级: [0.3265, 0.3266) || 挂载数据: 无 ) 
│       │   │   ├── 选项事件 --> ( 难度等级: [0.3265, 0.3265) || 挂载数据: 无 ) 
│       │   │   └── 表格模型事件 --> ( 难度等级: [0.3265, 0.3266) || 挂载数据: 无 ) 
│       │   └── AWT绘图 --> ( 难度等级: [0.3266, 0.3267) || 挂载数据: 无 ) 
│       │       ├── 绘制图形 --> ( 难度等级: [0.3266, 0.3266) || 挂载数据: 无 ) 
│       │       ├── 绘图颜色与画笔属性 --> ( 难度等级: [0.3266, 0.3266) || 挂载数据: 无 ) 
│       │       │   └── 画笔属性 --> ( 难度等级: [0.3266, 0.3266) || 挂载数据: qa: 2 ) 
│       │       ├── 绘制文本 --> ( 难度等级: [0.3266, 0.3266) || 挂载数据: 无 ) 
│       │       │   ├── 设置字体 --> ( 难度等级: [0.3266, 0.3266) || 挂载数据: qa: 1 ) 
│       │       │   └── 显示文字 --> ( 难度等级: [0.3266, 0.3266) || 挂载数据: qa: 9 ) 
│       │       └── 绘制图片 --> ( 难度等级: [0.3266, 0.3267) || 挂载数据: qa: 1 ) 
│       ├── 理解面向对象 --> ( 难度等级: [0.3267, 0.3271) || 挂载数据: 无 ) 
│       │   ├── UML（统一建模语言）介绍 --> ( 难度等级: [0.3267, 0.3269) || 挂载数据: 无 ) 
│       │   │   ├── 用例图 --> ( 难度等级: [0.3267, 0.3267) || 挂载数据: 无 ) 
│       │   │   ├── 类图 --> ( 难度等级: [0.3267, 0.3267) || 挂载数据: 无 ) 
│       │   │   ├── 组件图 --> ( 难度等级: [0.3267, 0.3268) || 挂载数据: 无 ) 
│       │   │   ├── 部署图 --> ( 难度等级: [0.3268, 0.3268) || 挂载数据: 无 ) 
│       │   │   ├── 顺序图 --> ( 难度等级: [0.3268, 0.3268) || 挂载数据: 无 ) 
│       │   │   ├── 活动图 --> ( 难度等级: [0.3268, 0.3268) || 挂载数据: qa: 8 ) 
│       │   │   └── 状态机图 --> ( 难度等级: [0.3268, 0.3269) || 挂载数据: 无 ) 
│       │   └── Java的面向对象特征 --> ( 难度等级: [0.3269, 0.3271) || 挂载数据: 无 ) 
│       ├── Java基础类库 --> ( 难度等级: [0.3271, 0.3275) || 挂载数据: 无 ) 
│       │   ├── 与用户互动 --> ( 难度等级: [0.3271, 0.3272) || 挂载数据: qa: 4 ) 
│       │   │   ├── 运行Java程序的参数 --> ( 难度等级: [0.3271, 0.3271) || 挂载数据: 无 ) 
│       │   │   └── 使用Scanner获取键盘输入 --> ( 难度等级: [0.3271, 0.3272) || 挂载数据: qa: 2 ) 
│       │   ├── 系统相关 --> ( 难度等级: [0.3272, 0.3273) || 挂载数据: qa: 5 ) 
│       │   ├── Java 11改进的国际化与格式化 --> ( 难度等级: [0.3273, 0.3274) || 挂载数据: 无 ) 
│       │   │   ├── Java国际化的思路 --> ( 难度等级: [0.3273, 0.3273) || 挂载数据: qa: 7 ) 
│       │   │   ├── Java支持的国家和语言 --> ( 难度等级: [0.3273, 0.3273) || 挂载数据: qa: 1 ) 
│       │   │   ├── 完成程序国际化 --> ( 难度等级: [0.3273, 0.3273) || 挂载数据: 无 ) 
│       │   │   ├── 使用MessageFormat处理包含占位符的字符串 --> ( 难度等级: [0.3273, 0.3273) || 挂载数据: 无 ) 
│       │   │   ├── 使用类文件代替资源文件 --> ( 难度等级: [0.3273, 0.3273) || 挂载数据: 无 ) 
│       │   │   ├── Java 9新增的日志API --> ( 难度等级: [0.3273, 0.3274) || 挂载数据: 无 ) 
│       │   │   ├── 使用NumberFormat格式化数字 --> ( 难度等级: [0.3274, 0.3274) || 挂载数据: 无 ) 
│       │   │   ├── 使用DateFormat格式化日期、时间 --> ( 难度等级: [0.3274, 0.3274) || 挂载数据: 无 ) 
│       │   │   └── 使用SimpleDateFormat格式化日期 --> ( 难度等级: [0.3274, 0.3274) || 挂载数据: qa: 1 ) 
│       │   └── Java 8新增的日期、时间格式器 --> ( 难度等级: [0.3274, 0.3275) || 挂载数据: qa: 1 ) 
│       │       ├── 使用DateTimeFormatter完成格式化 --> ( 难度等级: [0.3274, 0.3274) || 挂载数据: 无 ) 
│       │       └── 使用DateTimeFormatter解析字符串 --> ( 难度等级: [0.3274, 0.3275) || 挂载数据: qa: 4 ) 
│       ├── Java集合 --> ( 难度等级: [0.3275, 0.3279) || 挂载数据: 无 ) 
│       │   ├── Java集合概述 --> ( 难度等级: [0.3275, 0.3276) || 挂载数据: 无 ) 
│       │   ├── Java 11增强的Collection和Iterator接口 --> ( 难度等级: [0.3276, 0.3276) || 挂载数据: 无 ) 
│       │   │   ├── 使用Lambda表达式遍历集合 --> ( 难度等级: [0.3276, 0.3276) || 挂载数据: 无 ) 
│       │   │   ├── 使用Iterator遍历集合元素 --> ( 难度等级: [0.3276, 0.3276) || 挂载数据: qa: 7 ) 
│       │   │   ├── 使用Lambda表达式遍历Iterator --> ( 难度等级: [0.3276, 0.3276) || 挂载数据: 无 ) 
│       │   │   ├── 使用foreach循环遍历集合元素 --> ( 难度等级: [0.3276, 0.3276) || 挂载数据: 无 ) 
│       │   │   ├── 使用Predicate操作集合 --> ( 难度等级: [0.3276, 0.3276) || 挂载数据: 无 ) 
│       │   │   └── 使用Stream操作集合 --> ( 难度等级: [0.3276, 0.3276) || 挂载数据: 无 ) 
│       │   ├── Queue集合 --> ( 难度等级: [0.3276, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── PriorityQueue实现类 --> ( 难度等级: [0.3276, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── Deque接口与ArrayDeque实现类 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── LinkedList实现类 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   └── 各种线性表的性能分析 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   ├── 增强的Map集合 --> ( 难度等级: [0.3277, 0.3278) || 挂载数据: 无 ) 
│       │   │   ├── Java 8为Map新增的方法 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 改进的HashMap和Hashtable实现类 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: qa: 1 ) 
│       │   │   ├── LinkedHashMap实现类 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 使用Properties读写属性文件 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── SortedMap接口和TreeMap实现类 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── WeakHashMap实现类 --> ( 难度等级: [0.3277, 0.3278) || 挂载数据: 无 ) 
│       │   │   ├── IdentityHashMap实现类 --> ( 难度等级: [0.3278, 0.3278) || 挂载数据: 无 ) 
│       │   │   ├── EnumMap实现类 --> ( 难度等级: [0.3278, 0.3278) || 挂载数据: 无 ) 
│       │   │   └── 各Map实现类的性能分析 --> ( 难度等级: [0.3278, 0.3278) || 挂载数据: 无 ) 
│       │   ├── HashSet和HashMap的性能选项 --> ( 难度等级: [0.3278, 0.3278) || 挂载数据: 无 ) 
│       │   └── 操作集合的工具类：Collections --> ( 难度等级: [0.3278, 0.3279) || 挂载数据: 无 ) 
│       │       ├── 排序操作 --> ( 难度等级: [0.3278, 0.3279) || 挂载数据: 无 ) 
│       │       ├── 同步控制 --> ( 难度等级: [0.3279, 0.3279) || 挂载数据: 无 ) 
│       │       ├── 设置不可变集合 --> ( 难度等级: [0.3279, 0.3279) || 挂载数据: 无 ) 
│       │       └── Java 9新增的不可变集合 --> ( 难度等级: [0.3279, 0.3279) || 挂载数据: 无 ) 
│       ├── AWT编程 --> ( 难度等级: [0.3279, 0.3283) || 挂载数据: 无 ) 
│       │   ├── AWT容器 --> ( 难度等级: [0.3279, 0.328) || 挂载数据: qa: 7 ) 
│       │   ├── AWT常用组件 --> ( 难度等级: [0.328, 0.3281) || 挂载数据: 无 ) 
│       │   │   ├── 基本组件 --> ( 难度等级: [0.328, 0.328) || 挂载数据: 无 ) 
│       │   │   └── 对话框（Dialog） --> ( 难度等级: [0.328, 0.3281) || 挂载数据: qa: 3 ) 
│       │   ├── AWT菜单 --> ( 难度等级: [0.3281, 0.3281) || 挂载数据: 无 ) 
│       │   │   └── 右键菜单 --> ( 难度等级: [0.3281, 0.3281) || 挂载数据: qa: 1 ) 
│       │   ├── 在AWT中绘图 --> ( 难度等级: [0.3281, 0.3282) || 挂载数据: 无 ) 
│       │   │   ├── 画图的实现原理 --> ( 难度等级: [0.3281, 0.3282) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用Graphics类 --> ( 难度等级: [0.3282, 0.3282) || 挂载数据: qa: 1 ) 
│       │   ├── 处理位图 --> ( 难度等级: [0.3282, 0.3283) || 挂载数据: 无 ) 
│       │   │   ├── Image抽象类和BufferedImage实现类 --> ( 难度等级: [0.3282, 0.3282) || 挂载数据: 无 ) 
│       │   │   └── Java 9增强的ImageIO --> ( 难度等级: [0.3282, 0.3283) || 挂载数据: qa: 1 ) 
│       │   └── 拖放功能 --> ( 难度等级: [0.3283, 0.3283) || 挂载数据: 无 ) 
│       │       ├── 拖放目标 --> ( 难度等级: [0.3283, 0.3283) || 挂载数据: 无 ) 
│       │       └── 拖放源 --> ( 难度等级: [0.3283, 0.3283) || 挂载数据: qa: 1 ) 
│       ├── Swing编程 --> ( 难度等级: [0.3283, 0.3287) || 挂载数据: 无 ) 
│       │   ├── Swing基本组件的用法 --> ( 难度等级: [0.3283, 0.3284) || 挂载数据: 无 ) 
│       │   │   ├── AWT组件的Swing实现 --> ( 难度等级: [0.3283, 0.3283) || 挂载数据: qa: 10 ) 
│       │   │   ├── 为组件设置边框 --> ( 难度等级: [0.3283, 0.3283) || 挂载数据: 无 ) 
│       │   │   ├── Swing组件的双缓冲和键盘驱动 --> ( 难度等级: [0.3283, 0.3284) || 挂载数据: 无 ) 
│       │   │   ├── 使用JToolBar创建工具条 --> ( 难度等级: [0.3284, 0.3284) || 挂载数据: 无 ) 
│       │   │   ├── 使用JFileChooser和JColorChooser --> ( 难度等级: [0.3284, 0.3284) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用JOptionPane --> ( 难度等级: [0.3284, 0.3284) || 挂载数据: 无 ) 
│       │   ├── Swing中的特殊容器 --> ( 难度等级: [0.3284, 0.3284) || 挂载数据: 无 ) 
│       │   │   ├── 使用JSplitPane --> ( 难度等级: [0.3284, 0.3284) || 挂载数据: 无 ) 
│       │   │   ├── 使用JTabbedPane --> ( 难度等级: [0.3284, 0.3284) || 挂载数据: 无 ) 
│       │   │   └── 使用JLayeredPane、JDesktopPane和JInternalFrame --> ( 难度等级: [0.3284, 0.3284) || 挂载数据: 无 ) 
│       │   ├── Swing简化的拖放功能 --> ( 难度等级: [0.3284, 0.3284) || 挂载数据: 无 ) 
│       │   ├── Java 7新增的Swing功能 --> ( 难度等级: [0.3284, 0.3285) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用JLayer装饰组件 --> ( 难度等级: [0.3284, 0.3285) || 挂载数据: 无 ) 
│       │   │   └── 创建透明、不规则形状窗口 --> ( 难度等级: [0.3285, 0.3285) || 挂载数据: 无 ) 
│       │   ├── 使用JProgressBar、ProgressMonitor和BoundedRangeModel创建进度条 --> ( 难度等级: [0.3285, 0.3285) || 挂载数据: 无 ) 
│       │   │   ├── 创建进度条 --> ( 难度等级: [0.3285, 0.3285) || 挂载数据: qa: 1 ) 
│       │   │   └── 创建进度对话框 --> ( 难度等级: [0.3285, 0.3285) || 挂载数据: 无 ) 
│       │   ├── 使用JSlider和BoundedRangeModel创建滑动条 --> ( 难度等级: [0.3285, 0.3286) || 挂载数据: 无 ) 
│       │   ├── 使用JSpinner和SpinnerModel创建微调控制器 --> ( 难度等级: [0.3286, 0.3286) || 挂载数据: 无 ) 
│       │   ├── 使用JList、JComboBox创建列表框 --> ( 难度等级: [0.3286, 0.3286) || 挂载数据: 无 ) 
│       │   │   ├── 不强制存储列表项的ListModel和ComboBoxModel --> ( 难度等级: [0.3286, 0.3286) || 挂载数据: 无 ) 
│       │   │   ├── 强制存储列表项的DefaultListModel和DefaultComboBoxModel --> ( 难度等级: [0.3286, 0.3286) || 挂载数据: 无 ) 
│       │   │   └── 使用ListCellRenderer改变列表项外观 --> ( 难度等级: [0.3286, 0.3286) || 挂载数据: 无 ) 
│       │   ├── 使用JTree和TreeModel创建树 --> ( 难度等级: [0.3286, 0.3287) || 挂载数据: 无 ) 
│       │   │   ├── 创建树 --> ( 难度等级: [0.3286, 0.3286) || 挂载数据: qa: 7 ) 
│       │   │   ├── 拖动、编辑树节点 --> ( 难度等级: [0.3286, 0.3286) || 挂载数据: 无 ) 
│       │   │   ├── 监听节点事件 --> ( 难度等级: [0.3286, 0.3287) || 挂载数据: 无 ) 
│       │   │   ├── 使用DefaultTreeCellRenderer改变节点外观 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │   │   ├── 扩展DefaultTreeCellRenderer改变节点外观 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │   │   └── 实现TreeCellRenderer改变节点外观 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │   ├── 使用JTable和TableModel创建表格 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │   │   ├── TableModel和监听器 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │   │   ├── TableColumnModel和监听器 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │   │   ├── 实现排序 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: qa: 1 ) 
│       │   │   ├── 绘制单元格内容 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │   │   └── 编辑单元格内容 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │   └── 使用JFormattedTextField和JTextPane创建格式文本 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │       ├── 监听Document的变化 --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │       ├── 使用JPasswordField --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │       ├── 使用JFormattedTextField --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │       ├── 使用JEditorPane --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       │       └── 使用JTextPane --> ( 难度等级: [0.3287, 0.3287) || 挂载数据: 无 ) 
│       ├── 注解（Annotation） --> ( 难度等级: [0.3287, 0.3292) || 挂载数据: 无 ) 
│       │   ├── JDK的元注解 --> ( 难度等级: [0.3287, 0.3289) || 挂载数据: 无 ) 
│       │   │   ├── 使用@Retention --> ( 难度等级: [0.3287, 0.3288) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用@Target --> ( 难度等级: [0.3288, 0.3288) || 挂载数据: 无 ) 
│       │   │   ├── 使用@Documented --> ( 难度等级: [0.3288, 0.3289) || 挂载数据: 无 ) 
│       │   │   └── 使用@Inherited --> ( 难度等级: [0.3289, 0.3289) || 挂载数据: 无 ) 
│       │   ├── 自定义注解 --> ( 难度等级: [0.3289, 0.329) || 挂载数据: 无 ) 
│       │   │   ├── 提取注解信息 --> ( 难度等级: [0.3289, 0.329) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用注解的示例 --> ( 难度等级: [0.329, 0.329) || 挂载数据: qa: 6 ) 
│       │   └── 编译时处理注解 --> ( 难度等级: [0.329, 0.3292) || 挂载数据: 无 ) 
│       ├── 输入/输出 --> ( 难度等级: [0.3292, 0.3296) || 挂载数据: 无 ) 
│       │   ├── 理解Java的IO流 --> ( 难度等级: [0.3292, 0.3292) || 挂载数据: 无 ) 
│       │   │   ├── 流的分类 --> ( 难度等级: [0.3292, 0.3292) || 挂载数据: qa: 10 ) 
│       │   │   └── 流的概念模型 --> ( 难度等级: [0.3292, 0.3292) || 挂载数据: 无 ) 
│       │   ├── 输入/输出流体系 --> ( 难度等级: [0.3292, 0.3293) || 挂载数据: 无 ) 
│       │   │   ├── 处理流的用法 --> ( 难度等级: [0.3292, 0.3293) || 挂载数据: qa: 3 ) 
│       │   │   ├── 输入/输出流体系 --> ( 难度等级: [0.3293, 0.3293) || 挂载数据: 无 ) 
│       │   │   └── 推回输入流 --> ( 难度等级: [0.3293, 0.3293) || 挂载数据: 无 ) 
│       │   ├── 重定向标准输入/输出 --> ( 难度等级: [0.3293, 0.3294) || 挂载数据: 无 ) 
│       │   ├── Java虚拟机读写其他进程的数据 --> ( 难度等级: [0.3294, 0.3294) || 挂载数据: 无 ) 
│       │   ├── Java 9改进的对象序列化 --> ( 难度等级: [0.3294, 0.3295) || 挂载数据: 无 ) 
│       │   │   ├── 序列化的含义和意义 --> ( 难度等级: [0.3294, 0.3295) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用对象流实现序列化 --> ( 难度等级: [0.3295, 0.3295) || 挂载数据: qa: 1 ) 
│       │   │   ├── 对象引用的序列化 --> ( 难度等级: [0.3295, 0.3295) || 挂载数据: qa: 2 ) 
│       │   │   ├── Java 9增加的过滤功能 --> ( 难度等级: [0.3295, 0.3295) || 挂载数据: qa: 1 ) 
│       │   │   ├── 自定义序列化 --> ( 难度等级: [0.3295, 0.3295) || 挂载数据: 无 ) 
│       │   │   ├── 另一种自定义序列化机制 --> ( 难度等级: [0.3295, 0.3295) || 挂载数据: 无 ) 
│       │   │   └── 版本 --> ( 难度等级: [0.3295, 0.3295) || 挂载数据: qa: 5 ) 
│       │   └── NIO.2的功能和用法 --> ( 难度等级: [0.3295, 0.3296) || 挂载数据: 无 ) 
│       │       ├── Path、Paths和Files核心API --> ( 难度等级: [0.3295, 0.3295) || 挂载数据: 无 ) 
│       │       ├── 使用WatchService监控文件变化 --> ( 难度等级: [0.3295, 0.3296) || 挂载数据: 无 ) 
│       │       └── 访问文件属性 --> ( 难度等级: [0.3296, 0.3296) || 挂载数据: 无 ) 
│       ├── Java程序设计概述 --> ( 难度等级: [0.3296, 0.33) || 挂载数据: 无 ) 
│       │   ├── Java程序设计平台 --> ( 难度等级: [0.3296, 0.3297) || 挂载数据: qa: 9 ) 
│       │   ├── Java“白皮书”的关键术语 --> ( 难度等级: [0.3297, 0.3298) || 挂载数据: 无 ) 
│       │   │   └── 解释型 --> ( 难度等级: [0.3297, 0.3298) || 挂载数据: 无 ) 
│       │   ├── Java发展简史 --> ( 难度等级: [0.3298, 0.3299) || 挂载数据: 无 ) 
│       │   └── 关于Java的常见误解 --> ( 难度等级: [0.3299, 0.33) || 挂载数据: 无 ) 
│       ├── Java程序设计环境 --> ( 难度等级: [0.33, 0.3304) || 挂载数据: 无 ) 
│       │   ├── 安装Java开发工具包 --> ( 难度等级: [0.33, 0.3301) || 挂载数据: 无 ) 
│       │   │   ├── 设置JDK --> ( 难度等级: [0.33, 0.3301) || 挂载数据: 无 ) 
│       │   │   └── 安装库源文件和文档 --> ( 难度等级: [0.3301, 0.3301) || 挂载数据: 无 ) 
│       │   ├── 使用命令行工具 --> ( 难度等级: [0.3301, 0.3302) || 挂载数据: qa: 1 ) 
│       │   ├── 使用集成开发环境 --> ( 难度等级: [0.3302, 0.3303) || 挂载数据: 无 ) 
│       │   └── JShell --> ( 难度等级: [0.3303, 0.3304) || 挂载数据: 无 ) 
│       ├── Java的基本程序设计结构 --> ( 难度等级: [0.3304, 0.3308) || 挂载数据: 无 ) 
│       │   ├── 一个简单的Java应用程序 --> ( 难度等级: [0.3304, 0.3306) || 挂载数据: 无 ) 
│       │   └── 大数 --> ( 难度等级: [0.3306, 0.3308) || 挂载数据: 无 ) 
│       ├── 泛型程序设计 --> ( 难度等级: [0.3308, 0.3312) || 挂载数据: 无 ) 
│       │   ├── 定义简单泛型类 --> ( 难度等级: [0.3308, 0.3309) || 挂载数据: 无 ) 
│       │   ├── 类型变量的限定 --> ( 难度等级: [0.3309, 0.331) || 挂载数据: 无 ) 
│       │   ├── 泛型代码和虚拟机 --> ( 难度等级: [0.331, 0.331) || 挂载数据: qa: 2 ) 
│       │   │   ├── 类型擦除 --> ( 难度等级: [0.331, 0.331) || 挂载数据: qa: 5 ) 
│       │   │   ├── 转换泛型表达式 --> ( 难度等级: [0.331, 0.331) || 挂载数据: 无 ) 
│       │   │   ├── 转换泛型方法 --> ( 难度等级: [0.331, 0.331) || 挂载数据: qa: 4 ) 
│       │   │   └── 调用遗留代码 --> ( 难度等级: [0.331, 0.331) || 挂载数据: 无 ) 
│       │   ├── 限制与局限性 --> ( 难度等级: [0.331, 0.3311) || 挂载数据: 无 ) 
│       │   │   ├── 运行时类型查询只适用于原始类型 --> ( 难度等级: [0.331, 0.331) || 挂载数据: 无 ) 
│       │   │   ├── 不能创建参数化类型的数组 --> ( 难度等级: [0.331, 0.331) || 挂载数据: 无 ) 
│       │   │   ├── Varargs警告 --> ( 难度等级: [0.331, 0.331) || 挂载数据: 无 ) 
│       │   │   ├── 不能构造泛型数组 --> ( 难度等级: [0.331, 0.331) || 挂载数据: 无 ) 
│       │   │   ├── 泛型类的静态上下文中类型变量无效 --> ( 难度等级: [0.331, 0.3311) || 挂载数据: qa: 1 ) 
│       │   │   ├── 可以取消对检查型异常的检查 --> ( 难度等级: [0.3311, 0.3311) || 挂载数据: 无 ) 
│       │   │   └── 注意擦除后的冲突 --> ( 难度等级: [0.3311, 0.3311) || 挂载数据: 无 ) 
│       │   ├── 泛型类型的继承规则 --> ( 难度等级: [0.3311, 0.3311) || 挂载数据: 无 ) 
│       │   ├── 通配符类型 --> ( 难度等级: [0.3311, 0.3312) || 挂载数据: 无 ) 
│       │   │   ├── 通配符概念 --> ( 难度等级: [0.3311, 0.3311) || 挂载数据: 无 ) 
│       │   │   ├── 通配符的超类型限定 --> ( 难度等级: [0.3311, 0.3312) || 挂载数据: 无 ) 
│       │   │   ├── 无限定通配符 --> ( 难度等级: [0.3312, 0.3312) || 挂载数据: qa: 1 ) 
│       │   │   └── 通配符捕获 --> ( 难度等级: [0.3312, 0.3312) || 挂载数据: qa: 1 ) 
│       │   └── 反射和泛型 --> ( 难度等级: [0.3312, 0.3312) || 挂载数据: 无 ) 
│       │       ├── 泛型Class类 --> ( 难度等级: [0.3312, 0.3312) || 挂载数据: 无 ) 
│       │       ├── 使用Class<T>参数进行类型匹配 --> ( 难度等级: [0.3312, 0.3312) || 挂载数据: qa: 1 ) 
│       │       ├── 虚拟机中的泛型类型信息 --> ( 难度等级: [0.3312, 0.3312) || 挂载数据: 无 ) 
│       │       └── 类型字面量 --> ( 难度等级: [0.3312, 0.3312) || 挂载数据: qa: 1 ) 
│       ├── 图形用户界面程序设计 --> ( 难度等级: [0.3312, 0.3317) || 挂载数据: 无 ) 
│       │   ├── Java用户界面工具包简史 --> ( 难度等级: [0.3312, 0.3314) || 挂载数据: 无 ) 
│       │   ├── 显示窗体 --> ( 难度等级: [0.3314, 0.3315) || 挂载数据: 无 ) 
│       │   │   ├── 创建窗体 --> ( 难度等级: [0.3314, 0.3314) || 挂载数据: qa: 2 ) 
│       │   │   └── 窗体属性 --> ( 难度等级: [0.3314, 0.3315) || 挂载数据: 无 ) 
│       │   ├── 在组件中显示信息 --> ( 难度等级: [0.3315, 0.3316) || 挂载数据: 无 ) 
│       │   │   ├── 处理2D图形 --> ( 难度等级: [0.3315, 0.3315) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用颜色 --> ( 难度等级: [0.3315, 0.3315) || 挂载数据: 无 ) 
│       │   │   ├── 使用字体 --> ( 难度等级: [0.3315, 0.3315) || 挂载数据: 无 ) 
│       │   │   └── 显示图像 --> ( 难度等级: [0.3315, 0.3316) || 挂载数据: 无 ) 
│       │   └── 首选项API --> ( 难度等级: [0.3316, 0.3317) || 挂载数据: 无 ) 
│       ├── Swing用户界面组件 --> ( 难度等级: [0.3317, 0.3321) || 挂载数据: 无 ) 
│       │   ├── 布局管理概述 --> ( 难度等级: [0.3317, 0.3318) || 挂载数据: 无 ) 
│       │   │   ├── 边框布局 --> ( 难度等级: [0.3317, 0.3317) || 挂载数据: 无 ) 
│       │   │   └── 网格布局 --> ( 难度等级: [0.3317, 0.3318) || 挂载数据: 无 ) 
│       │   ├── 文本输入 --> ( 难度等级: [0.3318, 0.3319) || 挂载数据: 无 ) 
│       │   │   ├── 密码域 --> ( 难度等级: [0.3318, 0.3318) || 挂载数据: 无 ) 
│       │   │   ├── 文本区 --> ( 难度等级: [0.3318, 0.3318) || 挂载数据: qa: 3 ) 
│       │   │   └── 滚动窗格 --> ( 难度等级: [0.3318, 0.3319) || 挂载数据: 无 ) 
│       │   ├── 选择组件 --> ( 难度等级: [0.3319, 0.332) || 挂载数据: 无 ) 
│       │   │   ├── 组合框 --> ( 难度等级: [0.3319, 0.3319) || 挂载数据: qa: 1 ) 
│       │   │   └── 滑动条 --> ( 难度等级: [0.3319, 0.332) || 挂载数据: 无 ) 
│       │   └── 复杂的布局管理 --> ( 难度等级: [0.332, 0.3321) || 挂载数据: 无 ) 
│       │       ├── 网格包布局 --> ( 难度等级: [0.332, 0.332) || 挂载数据: 无 ) 
│       │       └── 定制布局管理器 --> ( 难度等级: [0.332, 0.3321) || 挂载数据: 无 ) 
│       ├── Java快速入门 --> ( 难度等级: [0.3321, 0.3325) || 挂载数据: 无 ) 
│       │   ├── Java程序基础 --> ( 难度等级: [0.3321, 0.3323) || 挂载数据: 无 ) 
│       │   │   ├── Java程序基本结构 --> ( 难度等级: [0.3321, 0.3321) || 挂载数据: 无 ) 
│       │   │   ├── 整数运算 --> ( 难度等级: [0.3321, 0.3322) || 挂载数据: qa: 8 ) 
│       │   │   ├── 浮点数运算 --> ( 难度等级: [0.3322, 0.3322) || 挂载数据: qa: 3 ) 
│       │   │   ├── 布尔运算 --> ( 难度等级: [0.3322, 0.3322) || 挂载数据: 无 ) 
│       │   │   └── 数组类型 --> ( 难度等级: [0.3322, 0.3323) || 挂载数据: qa: 2 ) 
│       │   └── 数组操作 --> ( 难度等级: [0.3323, 0.3325) || 挂载数据: 无 ) 
│       ├── IO --> ( 难度等级: [0.3325, 0.3329) || 挂载数据: qa: 5 ) 
│       │   ├── File对象 --> ( 难度等级: [0.3325, 0.3325) || 挂载数据: qa: 1 ) 
│       │   ├── InputStream --> ( 难度等级: [0.3325, 0.3326) || 挂载数据: qa: 1 ) 
│       │   ├── OutputStream --> ( 难度等级: [0.3326, 0.3326) || 挂载数据: 无 ) 
│       │   ├── Filter模式 --> ( 难度等级: [0.3326, 0.3327) || 挂载数据: 无 ) 
│       │   ├── 操作Zip --> ( 难度等级: [0.3327, 0.3327) || 挂载数据: qa: 1 ) 
│       │   ├── 读取classpath资源 --> ( 难度等级: [0.3327, 0.3328) || 挂载数据: qa: 1 ) 
│       │   ├── 序列化 --> ( 难度等级: [0.3328, 0.3328) || 挂载数据: 无 ) 
│       │   ├── PrintStream和PrintWriter --> ( 难度等级: [0.3328, 0.3329) || 挂载数据: qa: 2 ) 
│       │   └── 使用Files --> ( 难度等级: [0.3329, 0.3329) || 挂载数据: qa: 1 ) 
│       └── 单元测试 --> ( 难度等级: [0.3329, 0.3333) || 挂载数据: 无 ) 
│           ├── 编写JUnit测试 --> ( 难度等级: [0.3329, 0.333) || 挂载数据: 无 ) 
│           ├── 使用Fixture --> ( 难度等级: [0.333, 0.3331) || 挂载数据: 无 ) 
│           ├── 异常测试 --> ( 难度等级: [0.3331, 0.3332) || 挂载数据: 无 ) 
│           └── 参数化测试 --> ( 难度等级: [0.3332, 0.3333) || 挂载数据: 无 ) 
├── java中阶 --> ( 难度等级: [0.3333, 0.6667) || 挂载数据: 无 ) 
│   ├── 字符串处理 --> ( 难度等级: [0.3333, 0.3542) || 挂载数据: 无 ) 
│   │   ├── String类的构造函数 --> ( 难度等级: [0.3333, 0.3349) || 挂载数据: 无 ) 
│   │   ├── 字符串的长度 --> ( 难度等级: [0.3349, 0.3365) || 挂载数据: 无 ) 
│   │   ├── 特殊的字符串操作 --> ( 难度等级: [0.3365, 0.3381) || 挂载数据: 无 ) 
│   │   │   ├── 字符串字面值 --> ( 难度等级: [0.3365, 0.3369) || 挂载数据: 无 ) 
│   │   │   ├── 字符串连接 --> ( 难度等级: [0.3369, 0.3373) || 挂载数据: 无 ) 
│   │   │   ├── 字符串和其他数据类型的连接 --> ( 难度等级: [0.3373, 0.3377) || 挂载数据: 无 ) 
│   │   │   └── 字符串转换和toString方法 --> ( 难度等级: [0.3377, 0.3381) || 挂载数据: qa: 5 ) 
│   │   ├── 提取字符 --> ( 难度等级: [0.3381, 0.3397) || 挂载数据: qa: 1 ) 
│   │   │   ├── charAt --> ( 难度等级: [0.3381, 0.3385) || 挂载数据: qa: 1 ) 
│   │   │   ├── getChars --> ( 难度等级: [0.3385, 0.3389) || 挂载数据: 无 ) 
│   │   │   ├── getBytes --> ( 难度等级: [0.3389, 0.3393) || 挂载数据: 无 ) 
│   │   │   └── toCharArray --> ( 难度等级: [0.3393, 0.3397) || 挂载数据: qa: 1 ) 
│   │   ├── 比较字符串 --> ( 难度等级: [0.3397, 0.3413) || 挂载数据: 无 ) 
│   │   │   ├── equals和equalsIgnoreCase --> ( 难度等级: [0.3397, 0.3401) || 挂载数据: 无 ) 
│   │   │   ├── regionMatches --> ( 难度等级: [0.3401, 0.3404) || 挂载数据: 无 ) 
│   │   │   ├── startsWith和endsWith --> ( 难度等级: [0.3404, 0.3407) || 挂载数据: 无 ) 
│   │   │   ├── equals与== --> ( 难度等级: [0.3407, 0.341) || 挂载数据: qa: 5 ) 
│   │   │   └── compareTo --> ( 难度等级: [0.341, 0.3413) || 挂载数据: qa: 4 ) 
│   │   ├── 查找字符串 --> ( 难度等级: [0.3413, 0.3429) || 挂载数据: 无 ) 
│   │   ├── 修改字符串 --> ( 难度等级: [0.3429, 0.3446) || 挂载数据: 无 ) 
│   │   │   ├── substring --> ( 难度等级: [0.3429, 0.3433) || 挂载数据: 无 ) 
│   │   │   ├── concat --> ( 难度等级: [0.3433, 0.3438) || 挂载数据: 无 ) 
│   │   │   ├── replace --> ( 难度等级: [0.3438, 0.3442) || 挂载数据: 无 ) 
│   │   │   └── trim --> ( 难度等级: [0.3442, 0.3446) || 挂载数据: qa: 1 ) 
│   │   ├── 使用valueOf转换数据 --> ( 难度等级: [0.3446, 0.3462) || 挂载数据: 无 ) 
│   │   ├── 改变字符串中字符的大小写 --> ( 难度等级: [0.3462, 0.3478) || 挂载数据: 无 ) 
│   │   ├── 连接字符串 --> ( 难度等级: [0.3478, 0.3494) || 挂载数据: 无 ) 
│   │   ├── 其他String方法 --> ( 难度等级: [0.3494, 0.351) || 挂载数据: 无 ) 
│   │   ├── StringBuffer类 --> ( 难度等级: [0.351, 0.3526) || 挂载数据: 无 ) 
│   │   │   ├── StringBuffer类的构造函数 --> ( 难度等级: [0.351, 0.3511) || 挂载数据: 无 ) 
│   │   │   ├── length与capacity --> ( 难度等级: [0.3511, 0.3512) || 挂载数据: qa: 4 ) 
│   │   │   ├── ensureCapacity --> ( 难度等级: [0.3512, 0.3513) || 挂载数据: 无 ) 
│   │   │   ├── setLength --> ( 难度等级: [0.3513, 0.3515) || 挂载数据: 无 ) 
│   │   │   ├── charAt与setCharAt --> ( 难度等级: [0.3515, 0.3516) || 挂载数据: 无 ) 
│   │   │   ├── getChars --> ( 难度等级: [0.3516, 0.3517) || 挂载数据: 无 ) 
│   │   │   ├── append --> ( 难度等级: [0.3517, 0.3518) || 挂载数据: qa: 3 ) 
│   │   │   ├── insert --> ( 难度等级: [0.3518, 0.3519) || 挂载数据: 无 ) 
│   │   │   ├── reverse --> ( 难度等级: [0.3519, 0.3521) || 挂载数据: 无 ) 
│   │   │   ├── delete与deleteCharAt --> ( 难度等级: [0.3521, 0.3522) || 挂载数据: 无 ) 
│   │   │   ├── replace --> ( 难度等级: [0.3522, 0.3523) || 挂载数据: 无 ) 
│   │   │   ├── substring --> ( 难度等级: [0.3523, 0.3524) || 挂载数据: qa: 3 ) 
│   │   │   └── 其他StringBuffer方法 --> ( 难度等级: [0.3524, 0.3526) || 挂载数据: 无 ) 
│   │   └── StringBuilder类 --> ( 难度等级: [0.3526, 0.3542) || 挂载数据: 无 ) 
│   ├── 探究java.lang --> ( 难度等级: [0.3542, 0.375) || 挂载数据: 无 ) 
│   │   ├── 基本类型封装器 --> ( 难度等级: [0.3542, 0.3549) || 挂载数据: 无 ) 
│   │   │   ├── Number --> ( 难度等级: [0.3542, 0.3543) || 挂载数据: 无 ) 
│   │   │   ├── Double与Float --> ( 难度等级: [0.3543, 0.3544) || 挂载数据: qa: 5 ) 
│   │   │   ├── 理解isInfinite与isNaN --> ( 难度等级: [0.3544, 0.3545) || 挂载数据: 无 ) 
│   │   │   ├── Byte、Short、Integer和Long --> ( 难度等级: [0.3545, 0.3546) || 挂载数据: qa: 1 ) 
│   │   │   ├── Character --> ( 难度等级: [0.3546, 0.3547) || 挂载数据: 无 ) 
│   │   │   ├── 对Unicode代码点的附加支持 --> ( 难度等级: [0.3547, 0.3548) || 挂载数据: qa: 1 ) 
│   │   │   └── Boolean --> ( 难度等级: [0.3548, 0.3549) || 挂载数据: 无 ) 
│   │   ├── Void类 --> ( 难度等级: [0.3549, 0.3556) || 挂载数据: qa: 2 ) 
│   │   ├── Process类 --> ( 难度等级: [0.3556, 0.3562) || 挂载数据: 无 ) 
│   │   ├── Runtime类 --> ( 难度等级: [0.3562, 0.3569) || 挂载数据: 无 ) 
│   │   │   ├── 内存管理 --> ( 难度等级: [0.3562, 0.3566) || 挂载数据: 无 ) 
│   │   │   └── 执行其他程序 --> ( 难度等级: [0.3566, 0.3569) || 挂载数据: qa: 3 ) 
│   │   ├── ProcessBuilder类 --> ( 难度等级: [0.3569, 0.3576) || 挂载数据: 无 ) 
│   │   ├── System类 --> ( 难度等级: [0.3576, 0.3583) || 挂载数据: 无 ) 
│   │   │   ├── 使用currentTimeMillis计时程序的执行 --> ( 难度等级: [0.3576, 0.3579) || 挂载数据: 无 ) 
│   │   │   ├── 使用arraycopy --> ( 难度等级: [0.3579, 0.3581) || 挂载数据: 无 ) 
│   │   │   └── 环境属性 --> ( 难度等级: [0.3581, 0.3583) || 挂载数据: 无 ) 
│   │   ├── Object类 --> ( 难度等级: [0.3583, 0.359) || 挂载数据: 无 ) 
│   │   ├── 使用clone方法和Cloneable接口 --> ( 难度等级: [0.359, 0.3597) || 挂载数据: qa: 1 ) 
│   │   ├── Class类 --> ( 难度等级: [0.3597, 0.3604) || 挂载数据: 无 ) 
│   │   ├── ClassLoader类 --> ( 难度等级: [0.3604, 0.3611) || 挂载数据: 无 ) 
│   │   ├── Math类 --> ( 难度等级: [0.3611, 0.3618) || 挂载数据: 无 ) 
│   │   │   ├── 三角函数 --> ( 难度等级: [0.3611, 0.3613) || 挂载数据: 无 ) 
│   │   │   ├── 指数函数 --> ( 难度等级: [0.3613, 0.3615) || 挂载数据: 无 ) 
│   │   │   ├── 舍入函数 --> ( 难度等级: [0.3615, 0.3616) || 挂载数据: 无 ) 
│   │   │   └── 其他数学方法 --> ( 难度等级: [0.3616, 0.3618) || 挂载数据: 无 ) 
│   │   ├── StrictMath类 --> ( 难度等级: [0.3618, 0.3625) || 挂载数据: 无 ) 
│   │   ├── Compiler类 --> ( 难度等级: [0.3625, 0.3632) || 挂载数据: qa: 1 ) 
│   │   ├── Thread类、ThreadGroup类和Runnable接口 --> ( 难度等级: [0.3632, 0.3639) || 挂载数据: 无 ) 
│   │   │   ├── Runnable接口 --> ( 难度等级: [0.3632, 0.3634) || 挂载数据: qa: 9 ) 
│   │   │   ├── Thread类 --> ( 难度等级: [0.3634, 0.3637) || 挂载数据: qa: 10 ) 
│   │   │   └── ThreadGroup类 --> ( 难度等级: [0.3637, 0.3639) || 挂载数据: 无 ) 
│   │   ├── ThreadLocal和InheritableThreadLocal类 --> ( 难度等级: [0.3639, 0.3646) || 挂载数据: 无 ) 
│   │   ├── Package类 --> ( 难度等级: [0.3646, 0.3653) || 挂载数据: qa: 7 ) 
│   │   ├── RuntimePermission类 --> ( 难度等级: [0.3653, 0.366) || 挂载数据: 无 ) 
│   │   ├── Throwable类 --> ( 难度等级: [0.366, 0.3667) || 挂载数据: 无 ) 
│   │   ├── SecurityManager类 --> ( 难度等级: [0.3667, 0.3674) || 挂载数据: 无 ) 
│   │   ├── StackTraceElement类 --> ( 难度等级: [0.3674, 0.3681) || 挂载数据: qa: 1 ) 
│   │   ├── Enum类 --> ( 难度等级: [0.3681, 0.3687) || 挂载数据: 无 ) 
│   │   ├── ClassValue类 --> ( 难度等级: [0.3687, 0.3694) || 挂载数据: 无 ) 
│   │   ├── CharSequence接口 --> ( 难度等级: [0.3694, 0.3701) || 挂载数据: 无 ) 
│   │   ├── Comparable接口 --> ( 难度等级: [0.3701, 0.3708) || 挂载数据: qa: 3 ) 
│   │   ├── Appendable接口 --> ( 难度等级: [0.3708, 0.3715) || 挂载数据: 无 ) 
│   │   ├── Iterable接口 --> ( 难度等级: [0.3715, 0.3722) || 挂载数据: 无 ) 
│   │   ├── Readable接口 --> ( 难度等级: [0.3722, 0.3729) || 挂载数据: 无 ) 
│   │   ├── AutoCloseable接口 --> ( 难度等级: [0.3729, 0.3736) || 挂载数据: 无 ) 
│   │   ├── Thread.UncaughtExceptionHandler接口 --> ( 难度等级: [0.3736, 0.3743) || 挂载数据: 无 ) 
│   │   └── java.lang子包 --> ( 难度等级: [0.3743, 0.375) || 挂载数据: 无 ) 
│   │       ├── java.lang.annotation --> ( 难度等级: [0.3743, 0.3744) || 挂载数据: qa: 10 ) 
│   │       ├── java.lang.instrument --> ( 难度等级: [0.3744, 0.3745) || 挂载数据: 无 ) 
│   │       ├── java.lang.invoke --> ( 难度等级: [0.3745, 0.3747) || 挂载数据: qa: 3 ) 
│   │       ├── java.lang.management --> ( 难度等级: [0.3747, 0.3748) || 挂载数据: 无 ) 
│   │       ├── java.lang.ref --> ( 难度等级: [0.3748, 0.3749) || 挂载数据: 无 ) 
│   │       └── java.lang.reflect --> ( 难度等级: [0.3749, 0.375) || 挂载数据: qa: 1 ) 
│   ├── java.util第1部分：集合框架 --> ( 难度等级: [0.375, 0.3958) || 挂载数据: 无 ) 
│   │   ├── 集合概述 --> ( 难度等级: [0.375, 0.3766) || 挂载数据: 无 ) 
│   │   ├── JDK 5对集合框架的修改 --> ( 难度等级: [0.3766, 0.3782) || 挂载数据: 无 ) 
│   │   │   ├── 泛型从根本上改变了集合框架 --> ( 难度等级: [0.3766, 0.3771) || 挂载数据: 无 ) 
│   │   │   ├── 自动装箱使得使用基本类型更加容易 --> ( 难度等级: [0.3771, 0.3777) || 挂载数据: 无 ) 
│   │   │   └── for-each风格的for循环 --> ( 难度等级: [0.3777, 0.3782) || 挂载数据: 无 ) 
│   │   ├── 集合接口 --> ( 难度等级: [0.3782, 0.3798) || 挂载数据: 无 ) 
│   │   │   ├── Collection接口 --> ( 难度等级: [0.3782, 0.3784) || 挂载数据: qa: 1 ) 
│   │   │   ├── List接口 --> ( 难度等级: [0.3784, 0.3787) || 挂载数据: 无 ) 
│   │   │   ├── Set接口 --> ( 难度等级: [0.3787, 0.3789) || 挂载数据: 无 ) 
│   │   │   ├── SortedSet接口 --> ( 难度等级: [0.3789, 0.3791) || 挂载数据: 无 ) 
│   │   │   ├── NavigableSet接口 --> ( 难度等级: [0.3791, 0.3793) || 挂载数据: 无 ) 
│   │   │   ├── Queue接口 --> ( 难度等级: [0.3793, 0.3796) || 挂载数据: 无 ) 
│   │   │   └── Deque接口 --> ( 难度等级: [0.3796, 0.3798) || 挂载数据: 无 ) 
│   │   ├── 集合类 --> ( 难度等级: [0.3798, 0.3814) || 挂载数据: 无 ) 
│   │   │   ├── ArrayList类 --> ( 难度等级: [0.3798, 0.38) || 挂载数据: qa: 2 ) 
│   │   │   ├── LinkedList类 --> ( 难度等级: [0.38, 0.3802) || 挂载数据: qa: 1 ) 
│   │   │   ├── HashSet类 --> ( 难度等级: [0.3802, 0.3804) || 挂载数据: 无 ) 
│   │   │   ├── LinkedHashSet类 --> ( 难度等级: [0.3804, 0.3806) || 挂载数据: 无 ) 
│   │   │   ├── TreeSet类 --> ( 难度等级: [0.3806, 0.3808) || 挂载数据: 无 ) 
│   │   │   ├── PriorityQueue类 --> ( 难度等级: [0.3808, 0.381) || 挂载数据: 无 ) 
│   │   │   ├── ArrayDeque类 --> ( 难度等级: [0.381, 0.3812) || 挂载数据: 无 ) 
│   │   │   └── EnumSet类 --> ( 难度等级: [0.3812, 0.3814) || 挂载数据: 无 ) 
│   │   ├── 通过迭代器访问集合 --> ( 难度等级: [0.3814, 0.383) || 挂载数据: 无 ) 
│   │   │   ├── 使用迭代器 --> ( 难度等级: [0.3814, 0.3822) || 挂载数据: qa: 1 ) 
│   │   │   └── 使用for-each循环替代迭代器 --> ( 难度等级: [0.3822, 0.383) || 挂载数据: qa: 1 ) 
│   │   ├── Spliterator --> ( 难度等级: [0.383, 0.3846) || 挂载数据: 无 ) 
│   │   │   └── 拆分过程 --> ( 难度等级: [0.383, 0.3846) || 挂载数据: 无 ) 
│   │   ├── 在集合中存储用户定义的类 --> ( 难度等级: [0.3846, 0.3862) || 挂载数据: 无 ) 
│   │   ├── RandomAccess接口 --> ( 难度等级: [0.3862, 0.3878) || 挂载数据: 无 ) 
│   │   ├── 使用映射 --> ( 难度等级: [0.3878, 0.3894) || 挂载数据: 无 ) 
│   │   │   ├── 映射接口 --> ( 难度等级: [0.3878, 0.3882) || 挂载数据: 无 ) 
│   │   │   ├── 映射类 --> ( 难度等级: [0.3882, 0.3886) || 挂载数据: 无 ) 
│   │   │   ├── 对流中每一个元素应用函数 --> ( 难度等级: [0.3886, 0.389) || 挂载数据: 无 ) 
│   │   │   └── 流的扁平化 --> ( 难度等级: [0.389, 0.3894) || 挂载数据: 无 ) 
│   │   ├── 比较器 --> ( 难度等级: [0.3894, 0.391) || 挂载数据: 无 ) 
│   │   ├── 集合算法 --> ( 难度等级: [0.391, 0.3926) || 挂载数据: 无 ) 
│   │   ├── Arrays类 --> ( 难度等级: [0.3926, 0.3942) || 挂载数据: 无 ) 
│   │   └── 遗留的类和接口 --> ( 难度等级: [0.3942, 0.3958) || 挂载数据: 无 ) 
│   │       ├── Enumeration接口 --> ( 难度等级: [0.3942, 0.3945) || 挂载数据: 无 ) 
│   │       ├── Vector类 --> ( 难度等级: [0.3945, 0.3947) || 挂载数据: 无 ) 
│   │       ├── Stack类 --> ( 难度等级: [0.3947, 0.3949) || 挂载数据: qa: 1 ) 
│   │       ├── Dictionary类 --> ( 难度等级: [0.3949, 0.3951) || 挂载数据: 无 ) 
│   │       ├── Hashtable类 --> ( 难度等级: [0.3951, 0.3954) || 挂载数据: 无 ) 
│   │       ├── Properties类 --> ( 难度等级: [0.3954, 0.3956) || 挂载数据: 无 ) 
│   │       └── 使用store和load --> ( 难度等级: [0.3956, 0.3958) || 挂载数据: qa: 1 ) 
│   ├── java.util第2部分：更多实用工具类 --> ( 难度等级: [0.3958, 0.4167) || 挂载数据: 无 ) 
│   │   ├── StringTokenizer类 --> ( 难度等级: [0.3958, 0.397) || 挂载数据: 无 ) 
│   │   ├── BitSet类 --> ( 难度等级: [0.397, 0.3981) || 挂载数据: 无 ) 
│   │   ├── Optional、OptionalDouble、OptionalInt和OptionalLong --> ( 难度等级: [0.3981, 0.3993) || 挂载数据: 无 ) 
│   │   ├── Date类 --> ( 难度等级: [0.3993, 0.4005) || 挂载数据: 无 ) 
│   │   ├── Calendar类 --> ( 难度等级: [0.4005, 0.4016) || 挂载数据: 无 ) 
│   │   ├── GregorianCalendar类 --> ( 难度等级: [0.4016, 0.4028) || 挂载数据: 无 ) 
│   │   ├── TimeZone类 --> ( 难度等级: [0.4028, 0.4039) || 挂载数据: 无 ) 
│   │   ├── SimpleTimeZone类 --> ( 难度等级: [0.4039, 0.4051) || 挂载数据: 无 ) 
│   │   ├── Locale类 --> ( 难度等级: [0.4051, 0.4062) || 挂载数据: 无 ) 
│   │   ├── Random类 --> ( 难度等级: [0.4062, 0.4074) || 挂载数据: 无 ) 
│   │   ├── Observable类 --> ( 难度等级: [0.4074, 0.4086) || 挂载数据: 无 ) 
│   │   │   ├── Observer接口 --> ( 难度等级: [0.4074, 0.408) || 挂载数据: 无 ) 
│   │   │   └── Observer示例 --> ( 难度等级: [0.408, 0.4086) || 挂载数据: 无 ) 
│   │   ├── Timer和TimerTask类 --> ( 难度等级: [0.4086, 0.4097) || 挂载数据: qa: 2 ) 
│   │   ├── Currency类 --> ( 难度等级: [0.4097, 0.4109) || 挂载数据: 无 ) 
│   │   ├── Formatter类 --> ( 难度等级: [0.4109, 0.412) || 挂载数据: 无 ) 
│   │   │   ├── Formatter类的构造函数 --> ( 难度等级: [0.4109, 0.4109) || 挂载数据: 无 ) 
│   │   │   ├── Formatter类的方法 --> ( 难度等级: [0.4109, 0.411) || 挂载数据: 无 ) 
│   │   │   ├── 格式化的基础知识 --> ( 难度等级: [0.411, 0.4111) || 挂载数据: 无 ) 
│   │   │   ├── 格式化字符串和字符 --> ( 难度等级: [0.4111, 0.4111) || 挂载数据: 无 ) 
│   │   │   ├── 格式化数字 --> ( 难度等级: [0.4111, 0.4112) || 挂载数据: 无 ) 
│   │   │   ├── 格式化时间和日期 --> ( 难度等级: [0.4112, 0.4113) || 挂载数据: 无 ) 
│   │   │   ├── %n和%%说明符 --> ( 难度等级: [0.4113, 0.4113) || 挂载数据: qa: 1 ) 
│   │   │   ├── 指定最小字段宽度 --> ( 难度等级: [0.4113, 0.4114) || 挂载数据: 无 ) 
│   │   │   ├── 指定精度 --> ( 难度等级: [0.4114, 0.4115) || 挂载数据: 无 ) 
│   │   │   ├── 使用格式标志 --> ( 难度等级: [0.4115, 0.4115) || 挂载数据: 无 ) 
│   │   │   ├── 对齐输出 --> ( 难度等级: [0.4115, 0.4116) || 挂载数据: 无 ) 
│   │   │   ├── 空格、“+”、“0”以及“(”标志 --> ( 难度等级: [0.4116, 0.4117) || 挂载数据: 无 ) 
│   │   │   ├── 逗号标志 --> ( 难度等级: [0.4117, 0.4117) || 挂载数据: 无 ) 
│   │   │   ├── “#”标志 --> ( 难度等级: [0.4117, 0.4118) || 挂载数据: 无 ) 
│   │   │   ├── 大写选项 --> ( 难度等级: [0.4118, 0.4118) || 挂载数据: 无 ) 
│   │   │   ├── 使用参数索引 --> ( 难度等级: [0.4118, 0.4119) || 挂载数据: 无 ) 
│   │   │   ├── 关闭Formatter对象 --> ( 难度等级: [0.4119, 0.412) || 挂载数据: 无 ) 
│   │   │   └── printf方法 --> ( 难度等级: [0.412, 0.412) || 挂载数据: 无 ) 
│   │   ├── Scanner类 --> ( 难度等级: [0.412, 0.4132) || 挂载数据: 无 ) 
│   │   │   ├── Scanner类的构造函数 --> ( 难度等级: [0.412, 0.4123) || 挂载数据: qa: 2 ) 
│   │   │   ├── 扫描的基础知识 --> ( 难度等级: [0.4123, 0.4125) || 挂载数据: 无 ) 
│   │   │   ├── 一些Scanner示例 --> ( 难度等级: [0.4125, 0.4127) || 挂载数据: qa: 10 ) 
│   │   │   ├── 设置定界符 --> ( 难度等级: [0.4127, 0.413) || 挂载数据: 无 ) 
│   │   │   └── 其他Scanner特性 --> ( 难度等级: [0.413, 0.4132) || 挂载数据: 无 ) 
│   │   ├── ResourceBundle、ListResourceBundle和 --> ( 难度等级: [0.4132, 0.4144) || 挂载数据: 无 ) 
│   │   ├── 其他实用工具类和接口 --> ( 难度等级: [0.4144, 0.4155) || 挂载数据: 无 ) 
│   │   └── java.util子包 --> ( 难度等级: [0.4155, 0.4167) || 挂载数据: 无 ) 
│   │       ├── java.util.concurrent、java.util.concurrent.atomic和java.util.concurrent.locks --> ( 难度等级: [0.4155, 0.4156) || 挂载数据: qa: 1 ) 
│   │       ├── java.util.function --> ( 难度等级: [0.4156, 0.4158) || 挂载数据: qa: 5 ) 
│   │       ├── java.util.jar --> ( 难度等级: [0.4158, 0.4159) || 挂载数据: qa: 1 ) 
│   │       ├── java.util.logging --> ( 难度等级: [0.4159, 0.416) || 挂载数据: 无 ) 
│   │       ├── java.util.prefs --> ( 难度等级: [0.416, 0.4162) || 挂载数据: qa: 1 ) 
│   │       ├── java.util.regex --> ( 难度等级: [0.4162, 0.4163) || 挂载数据: 无 ) 
│   │       ├── java.util.spi --> ( 难度等级: [0.4163, 0.4164) || 挂载数据: qa: 1 ) 
│   │       ├── java.util.stream --> ( 难度等级: [0.4164, 0.4165) || 挂载数据: 无 ) 
│   │       └── java.util.zip --> ( 难度等级: [0.4165, 0.4167) || 挂载数据: 无 ) 
│   ├── 输入/输出：探究java.io --> ( 难度等级: [0.4167, 0.4375) || 挂载数据: 无 ) 
│   │   ├── I/O类和接口 --> ( 难度等级: [0.4167, 0.4186) || 挂载数据: 无 ) 
│   │   ├── File类 --> ( 难度等级: [0.4186, 0.4205) || 挂载数据: 无 ) 
│   │   │   ├── 目录 --> ( 难度等级: [0.4186, 0.419) || 挂载数据: qa: 2 ) 
│   │   │   ├── 使用FilenameFilter接口 --> ( 难度等级: [0.419, 0.4195) || 挂载数据: 无 ) 
│   │   │   ├── listFiles方法 --> ( 难度等级: [0.4195, 0.42) || 挂载数据: qa: 1 ) 
│   │   │   └── 创建目录 --> ( 难度等级: [0.42, 0.4205) || 挂载数据: 无 ) 
│   │   ├── AutoCloseable、Closeable和Flushable接口 --> ( 难度等级: [0.4205, 0.4223) || 挂载数据: 无 ) 
│   │   ├── I/O异常 --> ( 难度等级: [0.4223, 0.4242) || 挂载数据: 无 ) 
│   │   ├── 关闭流的两种方式 --> ( 难度等级: [0.4242, 0.4261) || 挂载数据: 无 ) 
│   │   ├── 流类 --> ( 难度等级: [0.4261, 0.428) || 挂载数据: 无 ) 
│   │   ├── 字节流 --> ( 难度等级: [0.428, 0.4299) || 挂载数据: 无 ) 
│   │   │   ├── InputStream类 --> ( 难度等级: [0.428, 0.4282) || 挂载数据: 无 ) 
│   │   │   ├── OutputStream类 --> ( 难度等级: [0.4282, 0.4283) || 挂载数据: 无 ) 
│   │   │   ├── FileInputStream类 --> ( 难度等级: [0.4283, 0.4285) || 挂载数据: qa: 2 ) 
│   │   │   ├── FileOutputStream类 --> ( 难度等级: [0.4285, 0.4287) || 挂载数据: qa: 1 ) 
│   │   │   ├── ByteArrayInputStream类 --> ( 难度等级: [0.4287, 0.4288) || 挂载数据: 无 ) 
│   │   │   ├── ByteArrayOutputStream类 --> ( 难度等级: [0.4288, 0.429) || 挂载数据: 无 ) 
│   │   │   ├── 过滤的字节流 --> ( 难度等级: [0.429, 0.4291) || 挂载数据: 无 ) 
│   │   │   ├── 缓冲的字节流 --> ( 难度等级: [0.4291, 0.4293) || 挂载数据: 无 ) 
│   │   │   ├── SequenceInputStream类 --> ( 难度等级: [0.4293, 0.4295) || 挂载数据: 无 ) 
│   │   │   ├── PrintStream类 --> ( 难度等级: [0.4295, 0.4296) || 挂载数据: 无 ) 
│   │   │   ├── DataOutputStream和DataInputStream类 --> ( 难度等级: [0.4296, 0.4298) || 挂载数据: 无 ) 
│   │   │   └── RandomAccessFile类 --> ( 难度等级: [0.4298, 0.4299) || 挂载数据: 无 ) 
│   │   ├── 字符流 --> ( 难度等级: [0.4299, 0.4318) || 挂载数据: 无 ) 
│   │   │   ├── Reader类 --> ( 难度等级: [0.4299, 0.4301) || 挂载数据: 无 ) 
│   │   │   ├── Writer类 --> ( 难度等级: [0.4301, 0.4303) || 挂载数据: 无 ) 
│   │   │   ├── FileReader类 --> ( 难度等级: [0.4303, 0.4305) || 挂载数据: qa: 2 ) 
│   │   │   ├── FileWriter类 --> ( 难度等级: [0.4305, 0.4307) || 挂载数据: 无 ) 
│   │   │   ├── CharArrayReader类 --> ( 难度等级: [0.4307, 0.4309) || 挂载数据: qa: 1 ) 
│   │   │   ├── CharArrayWriter类 --> ( 难度等级: [0.4309, 0.4311) || 挂载数据: 无 ) 
│   │   │   ├── BufferedReader类 --> ( 难度等级: [0.4311, 0.4313) || 挂载数据: qa: 1 ) 
│   │   │   ├── BufferedWriter类 --> ( 难度等级: [0.4313, 0.4314) || 挂载数据: qa: 6 ) 
│   │   │   ├── PushbackReader类 --> ( 难度等级: [0.4314, 0.4316) || 挂载数据: 无 ) 
│   │   │   └── PrintWriter类 --> ( 难度等级: [0.4316, 0.4318) || 挂载数据: 无 ) 
│   │   ├── Console类 --> ( 难度等级: [0.4318, 0.4337) || 挂载数据: qa: 1 ) 
│   │   ├── 串行化 --> ( 难度等级: [0.4337, 0.4356) || 挂载数据: 无 ) 
│   │   │   ├── Serializable接口 --> ( 难度等级: [0.4337, 0.434) || 挂载数据: qa: 2 ) 
│   │   │   ├── Externalizable接口 --> ( 难度等级: [0.434, 0.4343) || 挂载数据: 无 ) 
│   │   │   ├── ObjectOutput接口 --> ( 难度等级: [0.4343, 0.4345) || 挂载数据: 无 ) 
│   │   │   ├── ObjectOutputStream类 --> ( 难度等级: [0.4345, 0.4348) || 挂载数据: qa: 2 ) 
│   │   │   ├── ObjectInput接口 --> ( 难度等级: [0.4348, 0.4351) || 挂载数据: 无 ) 
│   │   │   ├── ObjectInputStream类 --> ( 难度等级: [0.4351, 0.4353) || 挂载数据: 无 ) 
│   │   │   └── 串行化示例 --> ( 难度等级: [0.4353, 0.4356) || 挂载数据: 无 ) 
│   │   └── 流的优点 --> ( 难度等级: [0.4356, 0.4375) || 挂载数据: 无 ) 
│   ├── 探究NIO --> ( 难度等级: [0.4375, 0.4583) || 挂载数据: 无 ) 
│   │   ├── NIO类 --> ( 难度等级: [0.4375, 0.4417) || 挂载数据: 无 ) 
│   │   ├── NIO的基础知识 --> ( 难度等级: [0.4417, 0.4458) || 挂载数据: 无 ) 
│   │   │   ├── 缓冲区 --> ( 难度等级: [0.4417, 0.4431) || 挂载数据: 无 ) 
│   │   │   ├── 通道 --> ( 难度等级: [0.4431, 0.4444) || 挂载数据: 无 ) 
│   │   │   └── 字符集和选择器 --> ( 难度等级: [0.4444, 0.4458) || 挂载数据: 无 ) 
│   │   ├── JDK 7对NIO的增强 --> ( 难度等级: [0.4458, 0.45) || 挂载数据: 无 ) 
│   │   │   ├── Path接口 --> ( 难度等级: [0.4458, 0.4467) || 挂载数据: 无 ) 
│   │   │   ├── Files类 --> ( 难度等级: [0.4467, 0.4475) || 挂载数据: 无 ) 
│   │   │   ├── Path接口 --> ( 难度等级: [0.4475, 0.4483) || 挂载数据: 无 ) 
│   │   │   ├── 文件属性接口 --> ( 难度等级: [0.4483, 0.4492) || 挂载数据: 无 ) 
│   │   │   └── FileSystem、FileSystems和FileStore类 --> ( 难度等级: [0.4492, 0.45) || 挂载数据: 无 ) 
│   │   ├── 使用NIO系统 --> ( 难度等级: [0.45, 0.4542) || 挂载数据: 无 ) 
│   │   │   ├── 为基于通道的I/O使用NIO --> ( 难度等级: [0.45, 0.4514) || 挂载数据: 无 ) 
│   │   │   ├── 为基于流的I/O使用NIO --> ( 难度等级: [0.4514, 0.4528) || 挂载数据: 无 ) 
│   │   │   └── 为路径和文件系统操作使用NIO --> ( 难度等级: [0.4528, 0.4542) || 挂载数据: 无 ) 
│   │   └── JDK 7之前基于通道的例子 --> ( 难度等级: [0.4542, 0.4583) || 挂载数据: 无 ) 
│   │       ├── 读文件(JDK 7之前) --> ( 难度等级: [0.4542, 0.4562) || 挂载数据: qa: 1 ) 
│   │       └── 写文件(JDK 7之前) --> ( 难度等级: [0.4562, 0.4583) || 挂载数据: qa: 3 ) 
│   ├── 联网 --> ( 难度等级: [0.4583, 0.4792) || 挂载数据: 无 ) 
│   │   ├── 联网的基础知识 --> ( 难度等级: [0.4583, 0.4601) || 挂载数据: 无 ) 
│   │   ├── 联网类和接口 --> ( 难度等级: [0.4601, 0.4618) || 挂载数据: 无 ) 
│   │   ├── InetAddress类 --> ( 难度等级: [0.4618, 0.4635) || 挂载数据: 无 ) 
│   │   │   └── 工厂方法 --> ( 难度等级: [0.4618, 0.4635) || 挂载数据: 无 ) 
│   │   ├── Inet4Address类和Inet6Address类 --> ( 难度等级: [0.4635, 0.4653) || 挂载数据: 无 ) 
│   │   ├── TCP/IP客户端套接字 --> ( 难度等级: [0.4653, 0.467) || 挂载数据: qa: 10 ) 
│   │   ├── URL类 --> ( 难度等级: [0.467, 0.4688) || 挂载数据: 无 ) 
│   │   ├── URLConnection类 --> ( 难度等级: [0.4688, 0.4705) || 挂载数据: 无 ) 
│   │   ├── HttpURLConnection类 --> ( 难度等级: [0.4705, 0.4722) || 挂载数据: qa: 2 ) 
│   │   ├── URI类 --> ( 难度等级: [0.4722, 0.474) || 挂载数据: 无 ) 
│   │   ├── cookie --> ( 难度等级: [0.474, 0.4757) || 挂载数据: qa: 3 ) 
│   │   ├── TCP/IP服务器套接字 --> ( 难度等级: [0.4757, 0.4774) || 挂载数据: 无 ) 
│   │   └── 数据报 --> ( 难度等级: [0.4774, 0.4792) || 挂载数据: 无 ) 
│   │       ├── DatagramSocket类 --> ( 难度等级: [0.4774, 0.478) || 挂载数据: 无 ) 
│   │       ├── DatagramPacket类 --> ( 难度等级: [0.478, 0.4786) || 挂载数据: 无 ) 
│   │       └── 数据报示例 --> ( 难度等级: [0.4786, 0.4792) || 挂载数据: qa: 8 ) 
│   ├── Applet类 --> ( 难度等级: [0.4792, 0.5) || 挂载数据: 无 ) 
│   │   ├── applet的两种类型 --> ( 难度等级: [0.4792, 0.4807) || 挂载数据: 无 ) 
│   │   ├── applet的基础知识 --> ( 难度等级: [0.4807, 0.4821) || 挂载数据: 无 ) 
│   │   ├── applet的架构 --> ( 难度等级: [0.4821, 0.4836) || 挂载数据: 无 ) 
│   │   ├── applet的骨架 --> ( 难度等级: [0.4836, 0.4851) || 挂载数据: 无 ) 
│   │   │   ├── applet的初始化和终止 --> ( 难度等级: [0.4836, 0.4844) || 挂载数据: qa: 6 ) 
│   │   │   └── 重写update方法 --> ( 难度等级: [0.4844, 0.4851) || 挂载数据: 无 ) 
│   │   ├── 简单的applet显示方法 --> ( 难度等级: [0.4851, 0.4866) || 挂载数据: 无 ) 
│   │   ├── 请求重画 --> ( 难度等级: [0.4866, 0.4881) || 挂载数据: 无 ) 
│   │   ├── 使用状态栏窗口 --> ( 难度等级: [0.4881, 0.4896) || 挂载数据: 无 ) 
│   │   ├── HTML APPLET标记 --> ( 难度等级: [0.4896, 0.4911) || 挂载数据: 无 ) 
│   │   ├── 向applet传递参数 --> ( 难度等级: [0.4911, 0.4926) || 挂载数据: 无 ) 
│   │   ├── getDocumentBase和getCodeBase --> ( 难度等级: [0.4926, 0.494) || 挂载数据: 无 ) 
│   │   ├── AppletContext接口和showDocument方法 --> ( 难度等级: [0.494, 0.4955) || 挂载数据: 无 ) 
│   │   ├── AudioClip接口 --> ( 难度等级: [0.4955, 0.497) || 挂载数据: 无 ) 
│   │   ├── AppletStub接口 --> ( 难度等级: [0.497, 0.4985) || 挂载数据: 无 ) 
│   │   └── 向控制台输出 --> ( 难度等级: [0.4985, 0.5) || 挂载数据: qa: 1 ) 
│   ├── 事件处理 --> ( 难度等级: [0.5, 0.5208) || 挂载数据: 无 ) 
│   │   ├── 两种事件处理机制 --> ( 难度等级: [0.5, 0.5026) || 挂载数据: 无 ) 
│   │   ├── 委托事件模型 --> ( 难度等级: [0.5026, 0.5052) || 挂载数据: 无 ) 
│   │   │   ├── 事件 --> ( 难度等级: [0.5026, 0.5035) || 挂载数据: 无 ) 
│   │   │   ├── 事件源 --> ( 难度等级: [0.5035, 0.5043) || 挂载数据: 无 ) 
│   │   │   └── 事件监听器 --> ( 难度等级: [0.5043, 0.5052) || 挂载数据: 无 ) 
│   │   ├── 事件类 --> ( 难度等级: [0.5052, 0.5078) || 挂载数据: 无 ) 
│   │   │   ├── ActionEvent类 --> ( 难度等级: [0.5052, 0.5054) || 挂载数据: 无 ) 
│   │   │   ├── AdjustmentEvent类 --> ( 难度等级: [0.5054, 0.5056) || 挂载数据: 无 ) 
│   │   │   ├── ComponentEvent类 --> ( 难度等级: [0.5056, 0.5059) || 挂载数据: 无 ) 
│   │   │   ├── ContainerEvent类 --> ( 难度等级: [0.5059, 0.5061) || 挂载数据: 无 ) 
│   │   │   ├── FocusEvent类 --> ( 难度等级: [0.5061, 0.5063) || 挂载数据: 无 ) 
│   │   │   ├── InputEvent类 --> ( 难度等级: [0.5063, 0.5065) || 挂载数据: 无 ) 
│   │   │   ├── ItemEvent类 --> ( 难度等级: [0.5065, 0.5067) || 挂载数据: 无 ) 
│   │   │   ├── KeyEvent类 --> ( 难度等级: [0.5067, 0.5069) || 挂载数据: 无 ) 
│   │   │   ├── MouseEvent类 --> ( 难度等级: [0.5069, 0.5072) || 挂载数据: qa: 1 ) 
│   │   │   ├── MouseWheelEvent类 --> ( 难度等级: [0.5072, 0.5074) || 挂载数据: 无 ) 
│   │   │   ├── TextEvent类 --> ( 难度等级: [0.5074, 0.5076) || 挂载数据: 无 ) 
│   │   │   └── WindowEvent类 --> ( 难度等级: [0.5076, 0.5078) || 挂载数据: 无 ) 
│   │   ├── 事件源 --> ( 难度等级: [0.5078, 0.5104) || 挂载数据: 无 ) 
│   │   ├── 事件监听器接口 --> ( 难度等级: [0.5104, 0.513) || 挂载数据: 无 ) 
│   │   │   ├── ActionListener接口 --> ( 难度等级: [0.5104, 0.5106) || 挂载数据: qa: 2 ) 
│   │   │   ├── AdjustmentListener接口 --> ( 难度等级: [0.5106, 0.5108) || 挂载数据: 无 ) 
│   │   │   ├── ComponentListener接口 --> ( 难度等级: [0.5108, 0.511) || 挂载数据: 无 ) 
│   │   │   ├── ContainerListener接口 --> ( 难度等级: [0.511, 0.5112) || 挂载数据: 无 ) 
│   │   │   ├── FocusListener接口 --> ( 难度等级: [0.5112, 0.5114) || 挂载数据: 无 ) 
│   │   │   ├── ItemListener接口 --> ( 难度等级: [0.5114, 0.5116) || 挂载数据: 无 ) 
│   │   │   ├── KeyListener接口 --> ( 难度等级: [0.5116, 0.5118) || 挂载数据: qa: 1 ) 
│   │   │   ├── MouseListener接口 --> ( 难度等级: [0.5118, 0.512) || 挂载数据: 无 ) 
│   │   │   ├── MouseMotionListener接口 --> ( 难度等级: [0.512, 0.5122) || 挂载数据: 无 ) 
│   │   │   ├── MouseWheelListener接口 --> ( 难度等级: [0.5122, 0.5124) || 挂载数据: 无 ) 
│   │   │   ├── TextListener接口 --> ( 难度等级: [0.5124, 0.5126) || 挂载数据: 无 ) 
│   │   │   ├── WindowFocusListener接口 --> ( 难度等级: [0.5126, 0.5128) || 挂载数据: 无 ) 
│   │   │   └── WindowListener接口 --> ( 难度等级: [0.5128, 0.513) || 挂载数据: 无 ) 
│   │   ├── 使用委托事件模型 --> ( 难度等级: [0.513, 0.5156) || 挂载数据: 无 ) 
│   │   │   ├── 处理鼠标事件 --> ( 难度等级: [0.513, 0.5143) || 挂载数据: 无 ) 
│   │   │   └── 处理键盘事件 --> ( 难度等级: [0.5143, 0.5156) || 挂载数据: 无 ) 
│   │   ├── 适配器类 --> ( 难度等级: [0.5156, 0.5182) || 挂载数据: 无 ) 
│   │   └── 内部类 --> ( 难度等级: [0.5182, 0.5208) || 挂载数据: qa: 1 ) 
│   ├── AWT介绍：使用窗口、图形和文本 --> ( 难度等级: [0.5208, 0.5417) || 挂载数据: 无 ) 
│   │   ├── AWT类 --> ( 难度等级: [0.5208, 0.5227) || 挂载数据: 无 ) 
│   │   ├── 窗口基本元素 --> ( 难度等级: [0.5227, 0.5246) || 挂载数据: 无 ) 
│   │   │   ├── Component类 --> ( 难度等级: [0.5227, 0.523) || 挂载数据: qa: 2 ) 
│   │   │   ├── Container类 --> ( 难度等级: [0.523, 0.5234) || 挂载数据: 无 ) 
│   │   │   ├── Panel类 --> ( 难度等级: [0.5234, 0.5237) || 挂载数据: qa: 2 ) 
│   │   │   ├── Window类 --> ( 难度等级: [0.5237, 0.524) || 挂载数据: qa: 3 ) 
│   │   │   ├── Frame类 --> ( 难度等级: [0.524, 0.5243) || 挂载数据: qa: 2 ) 
│   │   │   └── Canvas类 --> ( 难度等级: [0.5243, 0.5246) || 挂载数据: 无 ) 
│   │   ├── 使用框架窗口 --> ( 难度等级: [0.5246, 0.5265) || 挂载数据: 无 ) 
│   │   │   ├── 设置窗口的尺寸 --> ( 难度等级: [0.5246, 0.5251) || 挂载数据: qa: 5 ) 
│   │   │   ├── 隐藏和显示窗口 --> ( 难度等级: [0.5251, 0.5256) || 挂载数据: qa: 6 ) 
│   │   │   ├── 设置窗口的标题 --> ( 难度等级: [0.5256, 0.526) || 挂载数据: 无 ) 
│   │   │   └── 关闭框架窗口 --> ( 难度等级: [0.526, 0.5265) || 挂载数据: qa: 1 ) 
│   │   ├── 在基于AWT的applet中创建框架窗口 --> ( 难度等级: [0.5265, 0.5284) || 挂载数据: 无 ) 
│   │   ├── 创建基于窗口的程序 --> ( 难度等级: [0.5284, 0.5303) || 挂载数据: qa: 1 ) 
│   │   ├── 在窗口中显示信息 --> ( 难度等级: [0.5303, 0.5322) || 挂载数据: 无 ) 
│   │   ├── 使用图形 --> ( 难度等级: [0.5322, 0.5341) || 挂载数据: 无 ) 
│   │   │   ├── 绘制直线 --> ( 难度等级: [0.5322, 0.5325) || 挂载数据: 无 ) 
│   │   │   ├── 绘制矩形 --> ( 难度等级: [0.5325, 0.5327) || 挂载数据: 无 ) 
│   │   │   ├── 绘制椭圆和圆 --> ( 难度等级: [0.5327, 0.533) || 挂载数据: 无 ) 
│   │   │   ├── 绘制弧形 --> ( 难度等级: [0.533, 0.5333) || 挂载数据: 无 ) 
│   │   │   ├── 绘制多边形 --> ( 难度等级: [0.5333, 0.5335) || 挂载数据: 无 ) 
│   │   │   ├── 演示绘制方法 --> ( 难度等级: [0.5335, 0.5338) || 挂载数据: 无 ) 
│   │   │   └── 改变图形的大小 --> ( 难度等级: [0.5338, 0.5341) || 挂载数据: qa: 8 ) 
│   │   ├── 使用颜色 --> ( 难度等级: [0.5341, 0.536) || 挂载数据: 无 ) 
│   │   │   ├── Color类的方法 --> ( 难度等级: [0.5341, 0.5347) || 挂载数据: 无 ) 
│   │   │   ├── 设置当前图形的颜色 --> ( 难度等级: [0.5347, 0.5354) || 挂载数据: 无 ) 
│   │   │   └── 一个演示颜色的applet --> ( 难度等级: [0.5354, 0.536) || 挂载数据: qa: 1 ) 
│   │   ├── 设置绘图模式 --> ( 难度等级: [0.536, 0.5379) || 挂载数据: 无 ) 
│   │   ├── 使用字体 --> ( 难度等级: [0.5379, 0.5398) || 挂载数据: 无 ) 
│   │   │   ├── 确定可用字体 --> ( 难度等级: [0.5379, 0.5385) || 挂载数据: 无 ) 
│   │   │   ├── 创建和选择字体 --> ( 难度等级: [0.5385, 0.5391) || 挂载数据: 无 ) 
│   │   │   └── 获取字体信息 --> ( 难度等级: [0.5391, 0.5398) || 挂载数据: 无 ) 
│   │   └── 使用FontMetrics管理文本输出 --> ( 难度等级: [0.5398, 0.5417) || 挂载数据: 无 ) 
│   │       ├── 显示多行文本 --> ( 难度等级: [0.5398, 0.5404) || 挂载数据: 无 ) 
│   │       ├── 居中显示文本 --> ( 难度等级: [0.5404, 0.541) || 挂载数据: qa: 1 ) 
│   │       └── 对齐多行文本 --> ( 难度等级: [0.541, 0.5417) || 挂载数据: qa: 8 ) 
│   ├── 使用AWT控件、布局管理器和菜单 --> ( 难度等级: [0.5417, 0.5625) || 挂载数据: 无 ) 
│   │   ├── AWT控件的基础知识 --> ( 难度等级: [0.5417, 0.5431) || 挂载数据: 无 ) 
│   │   │   ├── 添加和移除控件 --> ( 难度等级: [0.5417, 0.5421) || 挂载数据: 无 ) 
│   │   │   ├── 响应控件 --> ( 难度等级: [0.5421, 0.5426) || 挂载数据: qa: 4 ) 
│   │   │   └── HeadlessException异常 --> ( 难度等级: [0.5426, 0.5431) || 挂载数据: 无 ) 
│   │   ├── 使用标签 --> ( 难度等级: [0.5431, 0.5444) || 挂载数据: qa: 7 ) 
│   │   ├── 使用命令按钮 --> ( 难度等级: [0.5444, 0.5458) || 挂载数据: 无 ) 
│   │   ├── 使用复选框 --> ( 难度等级: [0.5458, 0.5472) || 挂载数据: 无 ) 
│   │   ├── 使用复选框组 --> ( 难度等级: [0.5472, 0.5486) || 挂载数据: 无 ) 
│   │   ├── 使用下拉列表 --> ( 难度等级: [0.5486, 0.55) || 挂载数据: 无 ) 
│   │   ├── 使用列表框 --> ( 难度等级: [0.55, 0.5514) || 挂载数据: 无 ) 
│   │   ├── 管理滚动条 --> ( 难度等级: [0.5514, 0.5528) || 挂载数据: 无 ) 
│   │   ├── 使用TextField --> ( 难度等级: [0.5528, 0.5542) || 挂载数据: qa: 1 ) 
│   │   ├── 使用TextArea --> ( 难度等级: [0.5542, 0.5556) || 挂载数据: 无 ) 
│   │   ├── 理解布局管理器 --> ( 难度等级: [0.5556, 0.5569) || 挂载数据: 无 ) 
│   │   │   ├── FlowLayout布局管理器 --> ( 难度等级: [0.5556, 0.5558) || 挂载数据: 无 ) 
│   │   │   ├── BorderLayout布局管理器 --> ( 难度等级: [0.5558, 0.556) || 挂载数据: 无 ) 
│   │   │   ├── 使用Insets --> ( 难度等级: [0.556, 0.5563) || 挂载数据: 无 ) 
│   │   │   ├── GridLayout布局管理器 --> ( 难度等级: [0.5563, 0.5565) || 挂载数据: 无 ) 
│   │   │   ├── CardLayout布局管理器 --> ( 难度等级: [0.5565, 0.5567) || 挂载数据: 无 ) 
│   │   │   └── GridBagLayout布局管理器 --> ( 难度等级: [0.5567, 0.5569) || 挂载数据: 无 ) 
│   │   ├── 菜单栏和菜单 --> ( 难度等级: [0.5569, 0.5583) || 挂载数据: 无 ) 
│   │   ├── 对话框 --> ( 难度等级: [0.5583, 0.5597) || 挂载数据: 无 ) 
│   │   ├── FileDialog类 --> ( 难度等级: [0.5597, 0.5611) || 挂载数据: 无 ) 
│   │   └── 关于重写paint方法 --> ( 难度等级: [0.5611, 0.5625) || 挂载数据: qa: 3 ) 
│   ├── 图像 --> ( 难度等级: [0.5625, 0.5833) || 挂载数据: 无 ) 
│   │   ├── 文件格式 --> ( 难度等级: [0.5625, 0.5648) || 挂载数据: 无 ) 
│   │   ├── 图像基础：创建、加载与显示 --> ( 难度等级: [0.5648, 0.5671) || 挂载数据: 无 ) 
│   │   │   ├── 创建Image对象 --> ( 难度等级: [0.5648, 0.5656) || 挂载数据: qa: 1 ) 
│   │   │   ├── 加载图像 --> ( 难度等级: [0.5656, 0.5664) || 挂载数据: qa: 5 ) 
│   │   │   └── 显示图像 --> ( 难度等级: [0.5664, 0.5671) || 挂载数据: qa: 10 ) 
│   │   ├── ImageObserver接口 --> ( 难度等级: [0.5671, 0.5694) || 挂载数据: 无 ) 
│   │   ├── 双缓冲 --> ( 难度等级: [0.5694, 0.5718) || 挂载数据: 无 ) 
│   │   ├── MediaTracker类 --> ( 难度等级: [0.5718, 0.5741) || 挂载数据: 无 ) 
│   │   ├── ImageProducer接口 --> ( 难度等级: [0.5741, 0.5764) || 挂载数据: 无 ) 
│   │   ├── ImageConsumer接口 --> ( 难度等级: [0.5764, 0.5787) || 挂载数据: 无 ) 
│   │   ├── ImageFilter类 --> ( 难度等级: [0.5787, 0.581) || 挂载数据: 无 ) 
│   │   │   ├── CropImageFilter类 --> ( 难度等级: [0.5787, 0.5799) || 挂载数据: 无 ) 
│   │   │   └── RGBImageFilter类 --> ( 难度等级: [0.5799, 0.581) || 挂载数据: 无 ) 
│   │   └── 其他图像类 --> ( 难度等级: [0.581, 0.5833) || 挂载数据: 无 ) 
│   ├── 并发实用工具 --> ( 难度等级: [0.5833, 0.6042) || 挂载数据: 无 ) 
│   │   ├── 并发API包 --> ( 难度等级: [0.5833, 0.5856) || 挂载数据: 无 ) 
│   │   │   ├── java.util.concurrent包 --> ( 难度等级: [0.5833, 0.5841) || 挂载数据: 无 ) 
│   │   │   ├── java.util.concurrent.atomic包 --> ( 难度等级: [0.5841, 0.5849) || 挂载数据: 无 ) 
│   │   │   └── java.util.concurrent.locks包 --> ( 难度等级: [0.5849, 0.5856) || 挂载数据: 无 ) 
│   │   ├── 使用同步对象 --> ( 难度等级: [0.5856, 0.588) || 挂载数据: 无 ) 
│   │   │   ├── Semaphore类 --> ( 难度等级: [0.5856, 0.5861) || 挂载数据: 无 ) 
│   │   │   ├── CountDownLatch类 --> ( 难度等级: [0.5861, 0.5866) || 挂载数据: 无 ) 
│   │   │   ├── CyclicBarrier类 --> ( 难度等级: [0.5866, 0.587) || 挂载数据: 无 ) 
│   │   │   ├── Exchanger类 --> ( 难度等级: [0.587, 0.5875) || 挂载数据: 无 ) 
│   │   │   └── Phaser类 --> ( 难度等级: [0.5875, 0.588) || 挂载数据: 无 ) 
│   │   ├── 使用执行器 --> ( 难度等级: [0.588, 0.5903) || 挂载数据: 无 ) 
│   │   │   ├── 一个简单的执行器示例 --> ( 难度等级: [0.588, 0.5891) || 挂载数据: 无 ) 
│   │   │   └── 使用Callable和Future接口 --> ( 难度等级: [0.5891, 0.5903) || 挂载数据: 无 ) 
│   │   │       ├── Future接口的局限性 --> ( 难度等级: [0.5891, 0.5897) || 挂载数据: qa: 2 ) 
│   │   │       └── 使用CompletableFuture构建异步应用 --> ( 难度等级: [0.5897, 0.5903) || 挂载数据: 无 ) 
│   │   ├── TimeUnit枚举 --> ( 难度等级: [0.5903, 0.5926) || 挂载数据: qa: 1 ) 
│   │   ├── 并发集合 --> ( 难度等级: [0.5926, 0.5949) || 挂载数据: 无 ) 
│   │   ├── 锁 --> ( 难度等级: [0.5949, 0.5972) || 挂载数据: 无 ) 
│   │   ├── 原子操作 --> ( 难度等级: [0.5972, 0.5995) || 挂载数据: 无 ) 
│   │   ├── 通过Fork/Join框架进行并行编程 --> ( 难度等级: [0.5995, 0.6019) || 挂载数据: 无 ) 
│   │   │   ├── 主要的Fork/Join类 --> ( 难度等级: [0.5995, 0.5997) || 挂载数据: 无 ) 
│   │   │   ├── 分而治之的策略 --> ( 难度等级: [0.5997, 0.6) || 挂载数据: 无 ) 
│   │   │   ├── 一个简单的Fork/Join示例 --> ( 难度等级: [0.6, 0.6002) || 挂载数据: 无 ) 
│   │   │   ├── 理解并行级别带来的影响 --> ( 难度等级: [0.6002, 0.6004) || 挂载数据: 无 ) 
│   │   │   ├── 一个使用RecursiveTask[V]的例子 --> ( 难度等级: [0.6004, 0.6006) || 挂载数据: 无 ) 
│   │   │   ├── 异步执行任务 --> ( 难度等级: [0.6006, 0.6008) || 挂载数据: 无 ) 
│   │   │   ├── 取消任务 --> ( 难度等级: [0.6008, 0.601) || 挂载数据: 无 ) 
│   │   │   ├── 确定任务的完成状态 --> ( 难度等级: [0.601, 0.6012) || 挂载数据: 无 ) 
│   │   │   ├── 重新启动任务 --> ( 难度等级: [0.6012, 0.6014) || 挂载数据: 无 ) 
│   │   │   ├── 深入研究 --> ( 难度等级: [0.6014, 0.6016) || 挂载数据: 无 ) 
│   │   │   └── 关于Fork/Join框架的一些提示 --> ( 难度等级: [0.6016, 0.6019) || 挂载数据: 无 ) 
│   │   └── 并发实用工具与Java传统方式的比较 --> ( 难度等级: [0.6019, 0.6042) || 挂载数据: 无 ) 
│   ├── 流API --> ( 难度等级: [0.6042, 0.625) || 挂载数据: 无 ) 
│   │   ├── 流的基础知识 --> ( 难度等级: [0.6042, 0.6071) || 挂载数据: 无 ) 
│   │   │   ├── 流接口 --> ( 难度等级: [0.6042, 0.6052) || 挂载数据: 无 ) 
│   │   │   ├── 如何获得流 --> ( 难度等级: [0.6052, 0.6062) || 挂载数据: 无 ) 
│   │   │   └── 一个简单的流示例 --> ( 难度等级: [0.6062, 0.6071) || 挂载数据: 无 ) 
│   │   ├── 缩减操作 --> ( 难度等级: [0.6071, 0.6101) || 挂载数据: 无 ) 
│   │   ├── 使用并行流 --> ( 难度等级: [0.6101, 0.6131) || 挂载数据: 无 ) 
│   │   │   ├── 将顺序流转换为并行流 --> ( 难度等级: [0.6101, 0.6111) || 挂载数据: 无 ) 
│   │   │   ├── 测量流性能 --> ( 难度等级: [0.6111, 0.6121) || 挂载数据: 无 ) 
│   │   │   └── 高效使用并行流 --> ( 难度等级: [0.6121, 0.6131) || 挂载数据: qa: 1 ) 
│   │   ├── 映射 --> ( 难度等级: [0.6131, 0.6161) || 挂载数据: 无 ) 
│   │   ├── 收集 --> ( 难度等级: [0.6161, 0.619) || 挂载数据: 无 ) 
│   │   ├── 迭代器和流 --> ( 难度等级: [0.619, 0.622) || 挂载数据: 无 ) 
│   │   │   ├── 对流使用迭代器 --> ( 难度等级: [0.619, 0.6193) || 挂载数据: 无 ) 
│   │   │   ├── 使用Spliterator --> ( 难度等级: [0.6193, 0.6196) || 挂载数据: 无 ) 
│   │   │   ├── 筛选 --> ( 难度等级: [0.6196, 0.6199) || 挂载数据: 无 ) 
│   │   │   │   ├── 用谓词筛选 --> ( 难度等级: [0.6196, 0.6198) || 挂载数据: qa: 2 ) 
│   │   │   │   └── 筛选各异的元素 --> ( 难度等级: [0.6198, 0.6199) || 挂载数据: 无 ) 
│   │   │   ├── 流的切片 --> ( 难度等级: [0.6199, 0.6202) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用谓词对流进行切片 --> ( 难度等级: [0.6199, 0.62) || 挂载数据: 无 ) 
│   │   │   │   ├── 截短流 --> ( 难度等级: [0.62, 0.6201) || 挂载数据: qa: 8 ) 
│   │   │   │   └── 跳过元素 --> ( 难度等级: [0.6201, 0.6202) || 挂载数据: qa: 3 ) 
│   │   │   ├── 查找和匹配 --> ( 难度等级: [0.6202, 0.6205) || 挂载数据: 无 ) 
│   │   │   │   ├── 检查谓词是否至少匹配一个元素 --> ( 难度等级: [0.6202, 0.6203) || 挂载数据: 无 ) 
│   │   │   │   ├── 检查谓词是否匹配所有元素 --> ( 难度等级: [0.6203, 0.6204) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 查找元素 --> ( 难度等级: [0.6204, 0.6205) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 查找第一个元素 --> ( 难度等级: [0.6205, 0.6205) || 挂载数据: 无 ) 
│   │   │   ├── 归约 --> ( 难度等级: [0.6205, 0.6208) || 挂载数据: 无 ) 
│   │   │   │   ├── 元素求和 --> ( 难度等级: [0.6205, 0.6207) || 挂载数据: 无 ) 
│   │   │   │   └── 最大值和最小值 --> ( 难度等级: [0.6207, 0.6208) || 挂载数据: qa: 1 ) 
│   │   │   ├── 付诸实践 --> ( 难度等级: [0.6208, 0.6211) || 挂载数据: 无 ) 
│   │   │   │   ├── 领域：交易员和交易 --> ( 难度等级: [0.6208, 0.621) || 挂载数据: 无 ) 
│   │   │   │   └── 解答 --> ( 难度等级: [0.621, 0.6211) || 挂载数据: 无 ) 
│   │   │   ├── 数值流 --> ( 难度等级: [0.6211, 0.6214) || 挂载数据: 无 ) 
│   │   │   │   ├── 原始类型流特化 --> ( 难度等级: [0.6211, 0.6212) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值范围 --> ( 难度等级: [0.6212, 0.6213) || 挂载数据: qa: 5 ) 
│   │   │   │   └── 数值流应用：勾股数 --> ( 难度等级: [0.6213, 0.6214) || 挂载数据: 无 ) 
│   │   │   ├── 构建流 --> ( 难度等级: [0.6214, 0.6217) || 挂载数据: 无 ) 
│   │   │   │   ├── 由值创建流 --> ( 难度等级: [0.6214, 0.6215) || 挂载数据: 无 ) 
│   │   │   │   ├── 由可空对象创建流 --> ( 难度等级: [0.6215, 0.6215) || 挂载数据: 无 ) 
│   │   │   │   ├── 由数组创建流 --> ( 难度等级: [0.6215, 0.6216) || 挂载数据: 无 ) 
│   │   │   │   ├── 由文件生成流 --> ( 难度等级: [0.6216, 0.6217) || 挂载数据: qa: 5 ) 
│   │   │   │   └── 由函数生成流：创建无限流 --> ( 难度等级: [0.6217, 0.6217) || 挂载数据: 无 ) 
│   │   │   └── 概述 --> ( 难度等级: [0.6217, 0.622) || 挂载数据: 无 ) 
│   │   └── 流API中更多值得探究的地方 --> ( 难度等级: [0.622, 0.625) || 挂载数据: qa: 1 ) 
│   ├── 正则表达式和其他包 --> ( 难度等级: [0.625, 0.6458) || 挂载数据: 无 ) 
│   │   ├── 核心Java API包 --> ( 难度等级: [0.625, 0.6263) || 挂载数据: 无 ) 
│   │   ├── 正则表达式处理 --> ( 难度等级: [0.6263, 0.6276) || 挂载数据: 无 ) 
│   │   │   ├── Pattern类 --> ( 难度等级: [0.6263, 0.6265) || 挂载数据: 无 ) 
│   │   │   ├── Matcher类 --> ( 难度等级: [0.6265, 0.6267) || 挂载数据: 无 ) 
│   │   │   ├── 正则表达式的语法 --> ( 难度等级: [0.6267, 0.627) || 挂载数据: 无 ) 
│   │   │   ├── 演示模式匹配 --> ( 难度等级: [0.627, 0.6272) || 挂载数据: 无 ) 
│   │   │   ├── 模式匹配的两个选项 --> ( 难度等级: [0.6272, 0.6274) || 挂载数据: 无 ) 
│   │   │   └── 探究正则表达式 --> ( 难度等级: [0.6274, 0.6276) || 挂载数据: qa: 10 ) 
│   │   ├── 反射 --> ( 难度等级: [0.6276, 0.6289) || 挂载数据: qa: 1 ) 
│   │   ├── 远程方法调用 --> ( 难度等级: [0.6289, 0.6302) || 挂载数据: 无 ) 
│   │   ├── 使用java.text格式化日期和时间 --> ( 难度等级: [0.6302, 0.6315) || 挂载数据: qa: 1 ) 
│   │   │   ├── DateFormat类 --> ( 难度等级: [0.6302, 0.6309) || 挂载数据: 无 ) 
│   │   │   └── SimpleDateFormat类 --> ( 难度等级: [0.6309, 0.6315) || 挂载数据: 无 ) 
│   │   ├── JDK 8新增的时间和日期API --> ( 难度等级: [0.6315, 0.6328) || 挂载数据: 无 ) 
│   │   │   ├── 时间和日期的基础知识 --> ( 难度等级: [0.6315, 0.6319) || 挂载数据: 无 ) 
│   │   │   ├── 格式化日期和时间 --> ( 难度等级: [0.6319, 0.6324) || 挂载数据: 无 ) 
│   │   │   └── 解析日期和时间字符串 --> ( 难度等级: [0.6324, 0.6328) || 挂载数据: 无 ) 
│   │   ├── 探究java.time包的其他方面 --> ( 难度等级: [0.6328, 0.6341) || 挂载数据: 无 ) 
│   │   ├── 匹配字符串 --> ( 难度等级: [0.6341, 0.6354) || 挂载数据: 无 ) 
│   │   ├── 找出多个匹配 --> ( 难度等级: [0.6354, 0.6367) || 挂载数据: 无 ) 
│   │   ├── 用分隔符来分割 --> ( 难度等级: [0.6367, 0.638) || 挂载数据: 无 ) 
│   │   ├── 替换匹配 --> ( 难度等级: [0.638, 0.6393) || 挂载数据: qa: 1 ) 
│   │   ├── 正则表达式简介 --> ( 难度等级: [0.6393, 0.6406) || 挂载数据: 无 ) 
│   │   ├── 匹配规则 --> ( 难度等级: [0.6406, 0.6419) || 挂载数据: 无 ) 
│   │   ├── 分组匹配 --> ( 难度等级: [0.6419, 0.6432) || 挂载数据: 无 ) 
│   │   ├── 非贪婪匹配 --> ( 难度等级: [0.6432, 0.6445) || 挂载数据: 无 ) 
│   │   └── 搜索和替换 --> ( 难度等级: [0.6445, 0.6458) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.6458, 0.6667) || 挂载数据: 无 ) 
│       ├── 并发编程的挑战 --> ( 难度等级: [0.6458, 0.6466) || 挂载数据: 无 ) 
│       │   ├── 上下文切换 --> ( 难度等级: [0.6458, 0.6461) || 挂载数据: 无 ) 
│       │   │   ├── 多线程一定快吗 --> ( 难度等级: [0.6458, 0.6459) || 挂载数据: 无 ) 
│       │   │   │   ├── 多线程基础 --> ( 难度等级: [0.6458, 0.6458) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 创建新线程 --> ( 难度等级: [0.6458, 0.6458) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 中断线程 --> ( 难度等级: [0.6458, 0.6459) || 挂载数据: 无 ) 
│       │   │   │   ├── 守护线程 --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: 无 ) 
│       │   │   │   ├── 线程同步 --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: 无 ) 
│       │   │   │   ├── 同步方法 --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用wait和notify --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 使用ReentrantLock --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 使用Condition --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用ReadWriteLock --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用StampedLock --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用Concurrent集合 --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用Atomic --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 使用ForkJoin --> ( 难度等级: [0.6459, 0.6459) || 挂载数据: 无 ) 
│       │   │   ├── 测试上下文切换次数和时长 --> ( 难度等级: [0.6459, 0.646) || 挂载数据: 无 ) 
│       │   │   └── 如何减少上下文切换 --> ( 难度等级: [0.646, 0.6461) || 挂载数据: qa: 2 ) 
│       │   ├── 死锁 --> ( 难度等级: [0.6461, 0.6463) || 挂载数据: 无 ) 
│       │   └── 资源限制的挑战 --> ( 难度等级: [0.6463, 0.6466) || 挂载数据: 无 ) 
│       ├── Java并发机制的底层实现原理 --> ( 难度等级: [0.6466, 0.6473) || 挂载数据: 无 ) 
│       │   ├── volatile的应用 --> ( 难度等级: [0.6466, 0.6468) || 挂载数据: qa: 1 ) 
│       │   ├── synchronized的实现原理与应用 --> ( 难度等级: [0.6468, 0.6471) || 挂载数据: qa: 9 ) 
│       │   │   ├── Java对象头 --> ( 难度等级: [0.6468, 0.6469) || 挂载数据: qa: 1 ) 
│       │   │   └── 锁的升级与对比 --> ( 难度等级: [0.6469, 0.6471) || 挂载数据: qa: 2 ) 
│       │   └── 原子操作的实现原理 --> ( 难度等级: [0.6471, 0.6473) || 挂载数据: 无 ) 
│       ├── Java内存模型 --> ( 难度等级: [0.6473, 0.6481) || 挂载数据: 无 ) 
│       │   ├── Java内存模型的基础 --> ( 难度等级: [0.6473, 0.6474) || 挂载数据: 无 ) 
│       │   │   ├── Java内存模型的抽象结构 --> ( 难度等级: [0.6473, 0.6473) || 挂载数据: qa: 1 ) 
│       │   │   ├── 从源代码到指令序列的重排序 --> ( 难度等级: [0.6473, 0.6474) || 挂载数据: qa: 1 ) 
│       │   │   ├── 并发编程模型的分类 --> ( 难度等级: [0.6474, 0.6474) || 挂载数据: 无 ) 
│       │   │   └── happens-before简介 --> ( 难度等级: [0.6474, 0.6474) || 挂载数据: 无 ) 
│       │   ├── 重排序 --> ( 难度等级: [0.6474, 0.6475) || 挂载数据: 无 ) 
│       │   │   ├── 数据依赖性 --> ( 难度等级: [0.6474, 0.6474) || 挂载数据: qa: 1 ) 
│       │   │   ├── as-if-serial语义 --> ( 难度等级: [0.6474, 0.6474) || 挂载数据: qa: 1 ) 
│       │   │   ├── 程序顺序规则 --> ( 难度等级: [0.6474, 0.6475) || 挂载数据: 无 ) 
│       │   │   └── 重排序对多线程的影响 --> ( 难度等级: [0.6475, 0.6475) || 挂载数据: qa: 10 ) 
│       │   ├── 顺序一致性 --> ( 难度等级: [0.6475, 0.6476) || 挂载数据: 无 ) 
│       │   │   ├── 数据竞争与顺序一致性 --> ( 难度等级: [0.6475, 0.6475) || 挂载数据: qa: 4 ) 
│       │   │   ├── 顺序一致性内存模型 --> ( 难度等级: [0.6475, 0.6475) || 挂载数据: 无 ) 
│       │   │   ├── 同步程序的顺序一致性效果 --> ( 难度等级: [0.6475, 0.6475) || 挂载数据: 无 ) 
│       │   │   └── 未同步程序的执行特性 --> ( 难度等级: [0.6475, 0.6476) || 挂载数据: 无 ) 
│       │   ├── volatile的内存语义 --> ( 难度等级: [0.6476, 0.6477) || 挂载数据: 无 ) 
│       │   │   ├── volatile的特性 --> ( 难度等级: [0.6476, 0.6476) || 挂载数据: qa: 10 ) 
│       │   │   ├── volatile写-读建立的happens-before关系 --> ( 难度等级: [0.6476, 0.6476) || 挂载数据: 无 ) 
│       │   │   ├── volatile写-读的内存语义 --> ( 难度等级: [0.6476, 0.6476) || 挂载数据: 无 ) 
│       │   │   └── volatile内存语义的实现 --> ( 难度等级: [0.6476, 0.6477) || 挂载数据: qa: 10 ) 
│       │   ├── 锁的内存语义 --> ( 难度等级: [0.6477, 0.6477) || 挂载数据: 无 ) 
│       │   │   ├── 锁的释放-获取建立的 --> ( 难度等级: [0.6477, 0.6477) || 挂载数据: 无 ) 
│       │   │   ├── 锁的释放和获取的内存语义 --> ( 难度等级: [0.6477, 0.6477) || 挂载数据: qa: 3 ) 
│       │   │   ├── 锁内存语义的实现 --> ( 难度等级: [0.6477, 0.6477) || 挂载数据: 无 ) 
│       │   │   └── concurrent包的实现 --> ( 难度等级: [0.6477, 0.6477) || 挂载数据: 无 ) 
│       │   ├── final域的内存语义 --> ( 难度等级: [0.6477, 0.6478) || 挂载数据: 无 ) 
│       │   │   ├── final域的重排序规则 --> ( 难度等级: [0.6477, 0.6478) || 挂载数据: 无 ) 
│       │   │   ├── 写final域的重排序规则 --> ( 难度等级: [0.6478, 0.6478) || 挂载数据: 无 ) 
│       │   │   ├── 读final域的重排序规则 --> ( 难度等级: [0.6478, 0.6478) || 挂载数据: 无 ) 
│       │   │   ├── final域为引用类型 --> ( 难度等级: [0.6478, 0.6478) || 挂载数据: 无 ) 
│       │   │   └── final语义在处理器中的实现 --> ( 难度等级: [0.6478, 0.6478) || 挂载数据: 无 ) 
│       │   ├── happens-before --> ( 难度等级: [0.6478, 0.6479) || 挂载数据: 无 ) 
│       │   │   ├── JMM的设计 --> ( 难度等级: [0.6478, 0.6478) || 挂载数据: 无 ) 
│       │   │   ├── happens-before的定义 --> ( 难度等级: [0.6478, 0.6479) || 挂载数据: qa: 10 ) 
│       │   │   └── happens-before规则 --> ( 难度等级: [0.6479, 0.6479) || 挂载数据: 无 ) 
│       │   ├── 双重检查锁定与延迟初始化 --> ( 难度等级: [0.6479, 0.648) || 挂载数据: 无 ) 
│       │   │   ├── 双重检查锁定的由来 --> ( 难度等级: [0.6479, 0.6479) || 挂载数据: 无 ) 
│       │   │   ├── 基于volatile的解决方案 --> ( 难度等级: [0.6479, 0.648) || 挂载数据: 无 ) 
│       │   │   └── 基于类初始化的解决方案 --> ( 难度等级: [0.648, 0.648) || 挂载数据: 无 ) 
│       │   └── Java内存模型综述 --> ( 难度等级: [0.648, 0.6481) || 挂载数据: 无 ) 
│       │       ├── 处理器的内存模型 --> ( 难度等级: [0.648, 0.648) || 挂载数据: 无 ) 
│       │       ├── 各种内存模型之间的关系 --> ( 难度等级: [0.648, 0.648) || 挂载数据: qa: 7 ) 
│       │       ├── JMM的内存可见性保证 --> ( 难度等级: [0.648, 0.648) || 挂载数据: 无 ) 
│       │       └── JSR-133对旧内存模型的修补 --> ( 难度等级: [0.648, 0.6481) || 挂载数据: 无 ) 
│       ├── Java并发编程基础 --> ( 难度等级: [0.6481, 0.6488) || 挂载数据: 无 ) 
│       │   ├── 线程简介 --> ( 难度等级: [0.6481, 0.6483) || 挂载数据: 无 ) 
│       │   │   ├── 什么是线程 --> ( 难度等级: [0.6481, 0.6481) || 挂载数据: qa: 3 ) 
│       │   │   ├── 线程优先级 --> ( 难度等级: [0.6481, 0.6482) || 挂载数据: 无 ) 
│       │   │   ├── 线程的状态 --> ( 难度等级: [0.6482, 0.6483) || 挂载数据: 无 ) 
│       │   │   └── Daemon线程 --> ( 难度等级: [0.6483, 0.6483) || 挂载数据: 无 ) 
│       │   ├── 启动和终止线程 --> ( 难度等级: [0.6483, 0.6486) || 挂载数据: 无 ) 
│       │   │   ├── 构造线程 --> ( 难度等级: [0.6483, 0.6484) || 挂载数据: 无 ) 
│       │   │   ├── 启动线程 --> ( 难度等级: [0.6484, 0.6484) || 挂载数据: qa: 10 ) 
│       │   │   ├── 理解中断 --> ( 难度等级: [0.6484, 0.6485) || 挂载数据: 无 ) 
│       │   │   ├── 过期的suspend、resume和stop --> ( 难度等级: [0.6485, 0.6485) || 挂载数据: 无 ) 
│       │   │   └── 安全地终止线程 --> ( 难度等级: [0.6485, 0.6486) || 挂载数据: qa: 5 ) 
│       │   └── 线程间通信 --> ( 难度等级: [0.6486, 0.6488) || 挂载数据: 无 ) 
│       │       ├── 等待/通知机制 --> ( 难度等级: [0.6486, 0.6486) || 挂载数据: 无 ) 
│       │       ├── 等待/通知的经典范式 --> ( 难度等级: [0.6486, 0.6487) || 挂载数据: 无 ) 
│       │       ├── 管道输入/输出流 --> ( 难度等级: [0.6487, 0.6487) || 挂载数据: 无 ) 
│       │       └── Thread.join的使用 --> ( 难度等级: [0.6487, 0.6488) || 挂载数据: 无 ) 
│       ├── Java中的锁 --> ( 难度等级: [0.6488, 0.6496) || 挂载数据: 无 ) 
│       │   ├── Lock接口 --> ( 难度等级: [0.6488, 0.6489) || 挂载数据: qa: 1 ) 
│       │   ├── 队列同步器 --> ( 难度等级: [0.6489, 0.6491) || 挂载数据: 无 ) 
│       │   │   ├── 队列同步器的接口与示例 --> ( 难度等级: [0.6489, 0.649) || 挂载数据: 无 ) 
│       │   │   │   ├── Windows注册表概述 --> ( 难度等级: [0.6489, 0.649) || 挂载数据: 无 ) 
│       │   │   │   ├── 访问注册表的Java平台接口 --> ( 难度等级: [0.649, 0.649) || 挂载数据: 无 ) 
│       │   │   │   └── 以本地方法实现注册表访问函数 --> ( 难度等级: [0.649, 0.649) || 挂载数据: 无 ) 
│       │   │   └── 队列同步器的实现分析 --> ( 难度等级: [0.649, 0.6491) || 挂载数据: qa: 1 ) 
│       │   ├── 重入锁 --> ( 难度等级: [0.6491, 0.6492) || 挂载数据: qa: 1 ) 
│       │   ├── 读写锁 --> ( 难度等级: [0.6492, 0.6493) || 挂载数据: 无 ) 
│       │   │   ├── 读写锁的接口与示例 --> ( 难度等级: [0.6492, 0.6492) || 挂载数据: 无 ) 
│       │   │   └── 读写锁的实现分析 --> ( 难度等级: [0.6492, 0.6493) || 挂载数据: qa: 2 ) 
│       │   ├── LockSupport工具 --> ( 难度等级: [0.6493, 0.6494) || 挂载数据: 无 ) 
│       │   └── Condition接口 --> ( 难度等级: [0.6494, 0.6496) || 挂载数据: 无 ) 
│       │       ├── Condition接口与示例 --> ( 难度等级: [0.6494, 0.6495) || 挂载数据: 无 ) 
│       │       └── Condition的实现分析 --> ( 难度等级: [0.6495, 0.6496) || 挂载数据: qa: 1 ) 
│       ├── Java并发容器和框架 --> ( 难度等级: [0.6496, 0.6503) || 挂载数据: 无 ) 
│       │   ├── ConcurrentHashMap的实现原理与使用 --> ( 难度等级: [0.6496, 0.6497) || 挂载数据: 无 ) 
│       │   │   ├── ConcurrentHashMap的结构 --> ( 难度等级: [0.6496, 0.6496) || 挂载数据: 无 ) 
│       │   │   ├── ConcurrentHashMap的初始化 --> ( 难度等级: [0.6496, 0.6496) || 挂载数据: 无 ) 
│       │   │   ├── 定位Segment --> ( 难度等级: [0.6496, 0.6497) || 挂载数据: 无 ) 
│       │   │   └── ConcurrentHashMap的操作 --> ( 难度等级: [0.6497, 0.6497) || 挂载数据: qa: 1 ) 
│       │   ├── ConcurrentLinkedQueue --> ( 难度等级: [0.6497, 0.6499) || 挂载数据: 无 ) 
│       │   │   ├── ConcurrentLinkedQueue的结构 --> ( 难度等级: [0.6497, 0.6498) || 挂载数据: 无 ) 
│       │   │   ├── 入队列 --> ( 难度等级: [0.6498, 0.6499) || 挂载数据: qa: 1 ) 
│       │   │   └── 出队列 --> ( 难度等级: [0.6499, 0.6499) || 挂载数据: qa: 5 ) 
│       │   ├── Java中的阻塞队列 --> ( 难度等级: [0.6499, 0.6501) || 挂载数据: 无 ) 
│       │   │   ├── 什么是阻塞队列 --> ( 难度等级: [0.6499, 0.65) || 挂载数据: 无 ) 
│       │   │   ├── Java里的阻塞队列 --> ( 难度等级: [0.65, 0.65) || 挂载数据: 无 ) 
│       │   │   └── 阻塞队列的实现原理 --> ( 难度等级: [0.65, 0.6501) || 挂载数据: 无 ) 
│       │   └── Fork/Join框架 --> ( 难度等级: [0.6501, 0.6503) || 挂载数据: 无 ) 
│       │       ├── 什么是Fork/Join框架 --> ( 难度等级: [0.6501, 0.6501) || 挂载数据: qa: 3 ) 
│       │       ├── 工作窃取算法 --> ( 难度等级: [0.6501, 0.6502) || 挂载数据: 无 ) 
│       │       ├── Fork/Join框架的设计 --> ( 难度等级: [0.6502, 0.6502) || 挂载数据: 无 ) 
│       │       ├── 使用Fork/Join框架 --> ( 难度等级: [0.6502, 0.6502) || 挂载数据: 无 ) 
│       │       ├── Fork/Join框架的异常处理 --> ( 难度等级: [0.6502, 0.6503) || 挂载数据: qa: 2 ) 
│       │       └── Fork/Join框架的实现原理 --> ( 难度等级: [0.6503, 0.6503) || 挂载数据: qa: 1 ) 
│       ├── Java中的13个原子操作类 --> ( 难度等级: [0.6503, 0.651) || 挂载数据: 无 ) 
│       │   ├── 原子更新基本类型类 --> ( 难度等级: [0.6503, 0.6505) || 挂载数据: 无 ) 
│       │   ├── 原子更新数组 --> ( 难度等级: [0.6505, 0.6507) || 挂载数据: 无 ) 
│       │   ├── 原子更新引用类型 --> ( 难度等级: [0.6507, 0.6509) || 挂载数据: 无 ) 
│       │   └── 原子更新字段类 --> ( 难度等级: [0.6509, 0.651) || 挂载数据: 无 ) 
│       ├── Java中的并发工具类 --> ( 难度等级: [0.651, 0.6518) || 挂载数据: 无 ) 
│       │   ├── 等待多线程完成的CountDownLatch --> ( 难度等级: [0.651, 0.6512) || 挂载数据: 无 ) 
│       │   ├── 同步屏障CyclicBarrier --> ( 难度等级: [0.6512, 0.6514) || 挂载数据: 无 ) 
│       │   │   ├── CyclicBarrier简介 --> ( 难度等级: [0.6512, 0.6513) || 挂载数据: 无 ) 
│       │   │   ├── CyclicBarrier的应用场景 --> ( 难度等级: [0.6513, 0.6514) || 挂载数据: 无 ) 
│       │   │   └── CyclicBarrier和CountDownLatch的区别 --> ( 难度等级: [0.6514, 0.6514) || 挂载数据: qa: 1 ) 
│       │   ├── 控制并发线程数的Semaphore --> ( 难度等级: [0.6514, 0.6516) || 挂载数据: qa: 2 ) 
│       │   └── 线程间交换数据的Exchanger --> ( 难度等级: [0.6516, 0.6518) || 挂载数据: qa: 1 ) 
│       ├── Java中的线程池 --> ( 难度等级: [0.6518, 0.6525) || 挂载数据: 无 ) 
│       │   ├── 线程池的实现原理 --> ( 难度等级: [0.6518, 0.6522) || 挂载数据: 无 ) 
│       │   └── 线程池的使用 --> ( 难度等级: [0.6522, 0.6525) || 挂载数据: 无 ) 
│       │       ├── 线程池的创建 --> ( 难度等级: [0.6522, 0.6522) || 挂载数据: qa: 2 ) 
│       │       ├── 向线程池提交任务 --> ( 难度等级: [0.6522, 0.6523) || 挂载数据: 无 ) 
│       │       ├── 关闭线程池 --> ( 难度等级: [0.6523, 0.6524) || 挂载数据: qa: 10 ) 
│       │       ├── 合理地配置线程池 --> ( 难度等级: [0.6524, 0.6525) || 挂载数据: 无 ) 
│       │       └── 线程池的监控 --> ( 难度等级: [0.6525, 0.6525) || 挂载数据: 无 ) 
│       ├── Executor框架 --> ( 难度等级: [0.6525, 0.6533) || 挂载数据: 无 ) 
│       │   ├── Executor框架简介 --> ( 难度等级: [0.6525, 0.6527) || 挂载数据: 无 ) 
│       │   │   ├── Executor框架的两级调度模型 --> ( 难度等级: [0.6525, 0.6526) || 挂载数据: 无 ) 
│       │   │   └── Executor框架的结构与成员 --> ( 难度等级: [0.6526, 0.6527) || 挂载数据: qa: 10 ) 
│       │   ├── ThreadPoolExecutor详解 --> ( 难度等级: [0.6527, 0.6529) || 挂载数据: 无 ) 
│       │   │   ├── FixedThreadPool详解 --> ( 难度等级: [0.6527, 0.6528) || 挂载数据: 无 ) 
│       │   │   ├── SingleThreadExecutor详解 --> ( 难度等级: [0.6528, 0.6528) || 挂载数据: 无 ) 
│       │   │   └── CachedThreadPool详解 --> ( 难度等级: [0.6528, 0.6529) || 挂载数据: 无 ) 
│       │   ├── ScheduledThreadPoolExecutor详解 --> ( 难度等级: [0.6529, 0.6531) || 挂载数据: 无 ) 
│       │   │   ├── ScheduledThreadPoolExecutor的运行机制 --> ( 难度等级: [0.6529, 0.653) || 挂载数据: 无 ) 
│       │   │   └── ScheduledThreadPoolExecutor的实现 --> ( 难度等级: [0.653, 0.6531) || 挂载数据: 无 ) 
│       │   └── FutureTask详解 --> ( 难度等级: [0.6531, 0.6533) || 挂载数据: 无 ) 
│       │       ├── FutureTask简介 --> ( 难度等级: [0.6531, 0.6531) || 挂载数据: 无 ) 
│       │       ├── FutureTask的使用 --> ( 难度等级: [0.6531, 0.6532) || 挂载数据: 无 ) 
│       │       └── FutureTask的实现 --> ( 难度等级: [0.6532, 0.6533) || 挂载数据: 无 ) 
│       ├── Java并发编程实践 --> ( 难度等级: [0.6533, 0.654) || 挂载数据: 无 ) 
│       │   ├── 生产者和消费者模式 --> ( 难度等级: [0.6533, 0.6535) || 挂载数据: 无 ) 
│       │   │   └── 多生产者和多消费者场景 --> ( 难度等级: [0.6533, 0.6535) || 挂载数据: qa: 7 ) 
│       │   ├── 性能测试 --> ( 难度等级: [0.6535, 0.6538) || 挂载数据: 无 ) 
│       │   └── 异步任务池 --> ( 难度等级: [0.6538, 0.654) || 挂载数据: 无 ) 
│       ├── 基础知识 --> ( 难度等级: [0.654, 0.6548) || 挂载数据: 无 ) 
│       │   ├── Java 8、9、10以及11的变化 --> ( 难度等级: [0.654, 0.6543) || 挂载数据: 无 ) 
│       │   │   ├── Java怎么还在变 --> ( 难度等级: [0.654, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   ├── Java在编程语言生态系统中的位置 --> ( 难度等级: [0.654, 0.654) || 挂载数据: 无 ) 
│       │   │   │   ├── 用行为参数化把代码传递给方法 --> ( 难度等级: [0.654, 0.654) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 并行与共享的可变数据 --> ( 难度等级: [0.654, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   └── Java需要演变 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   ├── Java中的函数 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   ├── 方法和Lambda作为一等值 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 从Java程序中调用C函数 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: qa: 10 ) 
│       │   │   │   │   ├── 数值参数与返回值 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 字符串参数 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 访问域 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   │   │   └── 访问静态域 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: qa: 5 ) 
│       │   │   │   │   ├── 编码签名 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: qa: 5 ) 
│       │   │   │   │   ├── 调用Java方法 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   │   │   ├── 静态方法 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: qa: 4 ) 
│       │   │   │   │   │   ├── 构造器 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   │   │   └── 另一种方法调用 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: qa: 10 ) 
│       │   │   │   │   ├── 访问数组元素 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: qa: 1 ) 
│       │   │   │   │   └── 使用调用API --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   ├── 传递代码：一个例子 --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   └── 从传递方法到Lambda --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   ├── 默认方法及Java模块 --> ( 难度等级: [0.6541, 0.6542) || 挂载数据: 无 ) 
│       │   │   │   ├── 不断演进的API --> ( 难度等级: [0.6541, 0.6542) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 初始版本的API --> ( 难度等级: [0.6541, 0.6541) || 挂载数据: 无 ) 
│       │   │   │   │   └── 第二版API --> ( 难度等级: [0.6541, 0.6542) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 概述默认方法 --> ( 难度等级: [0.6542, 0.6542) || 挂载数据: qa: 6 ) 
│       │   │   │   ├── 默认方法的使用模式 --> ( 难度等级: [0.6542, 0.6542) || 挂载数据: 无 ) 
│       │   │   │   │   └── 行为的多继承 --> ( 难度等级: [0.6542, 0.6542) || 挂载数据: 无 ) 
│       │   │   │   └── 解决冲突的规则 --> ( 难度等级: [0.6542, 0.6542) || 挂载数据: qa: 3 ) 
│       │   │   │       ├── 选择提供了最具体实现的默认方法的接口 --> ( 难度等级: [0.6542, 0.6542) || 挂载数据: 无 ) 
│       │   │   │       └── 冲突及如何显式地消除歧义 --> ( 难度等级: [0.6542, 0.6542) || 挂载数据: qa: 1 ) 
│       │   │   └── 来自函数式编程的其他好思想 --> ( 难度等级: [0.6542, 0.6543) || 挂载数据: 无 ) 
│       │   ├── 通过行为参数化传递代码 --> ( 难度等级: [0.6543, 0.6545) || 挂载数据: 无 ) 
│       │   │   ├── 应对不断变化的需求 --> ( 难度等级: [0.6543, 0.6543) || 挂载数据: 无 ) 
│       │   │   │   ├── 初试牛刀：筛选绿苹果 --> ( 难度等级: [0.6543, 0.6543) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 再展身手：把颜色作为参数 --> ( 难度等级: [0.6543, 0.6543) || 挂载数据: 无 ) 
│       │   │   │   └── 第三次尝试：对你能想到的每个属性做筛选 --> ( 难度等级: [0.6543, 0.6543) || 挂载数据: qa: 1 ) 
│       │   │   ├── 行为参数化 --> ( 难度等级: [0.6543, 0.6544) || 挂载数据: qa: 3 ) 
│       │   │   ├── 对付啰唆 --> ( 难度等级: [0.6544, 0.6545) || 挂载数据: 无 ) 
│       │   │   │   ├── 匿名类 --> ( 难度等级: [0.6544, 0.6544) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 第五次尝试：使用匿名类 --> ( 难度等级: [0.6544, 0.6544) || 挂载数据: 无 ) 
│       │   │   │   ├── 第六次尝试：使用Lambda表达式 --> ( 难度等级: [0.6544, 0.6544) || 挂载数据: 无 ) 
│       │   │   │   └── 第七次尝试：将List类型抽象化 --> ( 难度等级: [0.6544, 0.6545) || 挂载数据: 无 ) 
│       │   │   └── 真实的例子 --> ( 难度等级: [0.6545, 0.6545) || 挂载数据: 无 ) 
│       │   │       ├── 用Comparator来排序 --> ( 难度等级: [0.6545, 0.6545) || 挂载数据: qa: 4 ) 
│       │   │       ├── 用Runnable执行代码块 --> ( 难度等级: [0.6545, 0.6545) || 挂载数据: 无 ) 
│       │   │       ├── 通过Callable返回结果 --> ( 难度等级: [0.6545, 0.6545) || 挂载数据: qa: 4 ) 
│       │   │       └── GUI事件处理 --> ( 难度等级: [0.6545, 0.6545) || 挂载数据: qa: 10 ) 
│       │   └── Lambda表达式 --> ( 难度等级: [0.6545, 0.6548) || 挂载数据: 无 ) 
│       │       ├── Lambda管中窥豹 --> ( 难度等级: [0.6545, 0.6545) || 挂载数据: 无 ) 
│       │       ├── 在哪里以及如何使用Lambda --> ( 难度等级: [0.6545, 0.6546) || 挂载数据: 无 ) 
│       │       │   ├── 函数式接口 --> ( 难度等级: [0.6545, 0.6545) || 挂载数据: 无 ) 
│       │       │   └── 函数描述符 --> ( 难度等级: [0.6545, 0.6546) || 挂载数据: 无 ) 
│       │       ├── 把Lambda付诸实践：环绕执行模式 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: 无 ) 
│       │       │   ├── 第 1 步：记得行为参数化 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: qa: 1 ) 
│       │       │   ├── 第 2 步：使用函数式接口来传递行为 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: 无 ) 
│       │       │   ├── 第 3 步：执行一个行为 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: qa: 10 ) 
│       │       │   └── 第 4 步：传递Lambda --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: qa: 9 ) 
│       │       ├── 使用函数式接口 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: 无 ) 
│       │       │   ├── Predicate --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: 无 ) 
│       │       │   ├── Consumer --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: qa: 1 ) 
│       │       │   └── Function --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: qa: 3 ) 
│       │       ├── 类型检查、类型推断以及限制 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: 无 ) 
│       │       │   ├── 类型检查 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: qa: 2 ) 
│       │       │   ├── 同样的Lambda，不同的函数式接口 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: 无 ) 
│       │       │   ├── 类型推断 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: qa: 10 ) 
│       │       │   └── 使用局部变量 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: qa: 3 ) 
│       │       ├── 方法引用 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: 无 ) 
│       │       │   ├── 管中窥豹 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: 无 ) 
│       │       │   └── 构造函数引用 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: qa: 10 ) 
│       │       ├── 复合Lambda表达式的有用方法 --> ( 难度等级: [0.6546, 0.6547) || 挂载数据: 无 ) 
│       │       │   ├── 比较器复合 --> ( 难度等级: [0.6546, 0.6546) || 挂载数据: 无 ) 
│       │       │   ├── 谓词复合 --> ( 难度等级: [0.6546, 0.6547) || 挂载数据: 无 ) 
│       │       │   └── 函数复合 --> ( 难度等级: [0.6547, 0.6547) || 挂载数据: 无 ) 
│       │       ├── 数学中的类似思想 --> ( 难度等级: [0.6547, 0.6547) || 挂载数据: qa: 1 ) 
│       │       │   ├── 积分 --> ( 难度等级: [0.6547, 0.6547) || 挂载数据: 无 ) 
│       │       │   └── 与Java 8的Lambda联系起来 --> ( 难度等级: [0.6547, 0.6547) || 挂载数据: 无 ) 
│       │       ├── 测试可见Lambda函数的行为 --> ( 难度等级: [0.6547, 0.6547) || 挂载数据: 无 ) 
│       │       ├── 测试使用Lambda的方法的行为 --> ( 难度等级: [0.6547, 0.6547) || 挂载数据: 无 ) 
│       │       ├── 将复杂的Lambda表达式分为不同的方法 --> ( 难度等级: [0.6547, 0.6547) || 挂载数据: qa: 1 ) 
│       │       └── 高阶函数的测试 --> ( 难度等级: [0.6547, 0.6548) || 挂载数据: 无 ) 
│       ├── 使用流进行函数式数据处理 --> ( 难度等级: [0.6548, 0.6555) || 挂载数据: 无 ) 
│       │   ├── 引入流 --> ( 难度等级: [0.6548, 0.6551) || 挂载数据: 无 ) 
│       │   │   ├── 流简介 --> ( 难度等级: [0.6548, 0.6549) || 挂载数据: 无 ) 
│       │   │   ├── 流操作 --> ( 难度等级: [0.6549, 0.655) || 挂载数据: 无 ) 
│       │   │   │   ├── 中间操作 --> ( 难度等级: [0.6549, 0.6549) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 终端操作 --> ( 难度等级: [0.6549, 0.655) || 挂载数据: 无 ) 
│       │   │   └── 路线图 --> ( 难度等级: [0.655, 0.6551) || 挂载数据: 无 ) 
│       │   └── 用流收集数据 --> ( 难度等级: [0.6551, 0.6555) || 挂载数据: 无 ) 
│       │       ├── 收集器简介 --> ( 难度等级: [0.6551, 0.6552) || 挂载数据: 无 ) 
│       │       │   ├── 收集器用作高级归约 --> ( 难度等级: [0.6551, 0.6552) || 挂载数据: qa: 1 ) 
│       │       │   └── 预定义收集器 --> ( 难度等级: [0.6552, 0.6552) || 挂载数据: 无 ) 
│       │       ├── 分组 --> ( 难度等级: [0.6552, 0.6553) || 挂载数据: 无 ) 
│       │       │   ├── 操作分组的元素 --> ( 难度等级: [0.6552, 0.6552) || 挂载数据: 无 ) 
│       │       │   ├── 多级分组 --> ( 难度等级: [0.6552, 0.6553) || 挂载数据: qa: 8 ) 
│       │       │   └── 按子组收集数据 --> ( 难度等级: [0.6553, 0.6553) || 挂载数据: 无 ) 
│       │       ├── 分区 --> ( 难度等级: [0.6553, 0.6554) || 挂载数据: 无 ) 
│       │       │   ├── 分区的优势 --> ( 难度等级: [0.6553, 0.6553) || 挂载数据: qa: 3 ) 
│       │       │   └── 将数字按质数和非质数分区 --> ( 难度等级: [0.6553, 0.6554) || 挂载数据: 无 ) 
│       │       ├── 收集器接口 --> ( 难度等级: [0.6554, 0.6554) || 挂载数据: 无 ) 
│       │       │   ├── 理解Collector接口声明的方法 --> ( 难度等级: [0.6554, 0.6554) || 挂载数据: qa: 1 ) 
│       │       │   └── 全部融合到一起 --> ( 难度等级: [0.6554, 0.6554) || 挂载数据: 无 ) 
│       │       └── 开发你自己的收集器以获得更好的性能 --> ( 难度等级: [0.6554, 0.6555) || 挂载数据: 无 ) 
│       │           ├── 仅用质数做除数 --> ( 难度等级: [0.6554, 0.6555) || 挂载数据: 无 ) 
│       │           └── 比较收集器的性能 --> ( 难度等级: [0.6555, 0.6555) || 挂载数据: qa: 3 ) 
│       ├── 无所不在的Java --> ( 难度等级: [0.6555, 0.6562) || 挂载数据: 无 ) 
│       │   ├── 用Optional取代null --> ( 难度等级: [0.6555, 0.6559) || 挂载数据: 无 ) 
│       │   │   ├── 如何为缺失的值建模 --> ( 难度等级: [0.6555, 0.6556) || 挂载数据: 无 ) 
│       │   │   │   ├── 采用防御式检查减少NullPointerException --> ( 难度等级: [0.6555, 0.6556) || 挂载数据: 无 ) 
│       │   │   │   └── 其他语言中null的替代品 --> ( 难度等级: [0.6556, 0.6556) || 挂载数据: qa: 10 ) 
│       │   │   ├── Optional类入门 --> ( 难度等级: [0.6556, 0.6558) || 挂载数据: 无 ) 
│       │   │   └── 应用Optional的几种模式 --> ( 难度等级: [0.6558, 0.6559) || 挂载数据: 无 ) 
│       │   │       ├── 创建Optional对象 --> ( 难度等级: [0.6558, 0.6558) || 挂载数据: 无 ) 
│       │   │       ├── 使用map从Optional对象中提取和转换值 --> ( 难度等级: [0.6558, 0.6558) || 挂载数据: 无 ) 
│       │   │       ├── 使用flatMap链接Optional对象 --> ( 难度等级: [0.6558, 0.6558) || 挂载数据: 无 ) 
│       │   │       ├── 操纵由Optional对象构成的Stream --> ( 难度等级: [0.6558, 0.6558) || 挂载数据: 无 ) 
│       │   │       ├── 默认行为及解引用Optional对象 --> ( 难度等级: [0.6558, 0.6558) || 挂载数据: 无 ) 
│       │   │       ├── 两个Optional对象的组合 --> ( 难度等级: [0.6558, 0.6559) || 挂载数据: qa: 1 ) 
│       │   │       └── 使用filter剔除特定的值 --> ( 难度等级: [0.6559, 0.6559) || 挂载数据: qa: 1 ) 
│       │   └── Java模块系统 --> ( 难度等级: [0.6559, 0.6562) || 挂载数据: 无 ) 
│       │       ├── 模块化的驱动力：软件的推理 --> ( 难度等级: [0.6559, 0.6559) || 挂载数据: 无 ) 
│       │       │   ├── 关注点分离 --> ( 难度等级: [0.6559, 0.6559) || 挂载数据: qa: 2 ) 
│       │       │   ├── 信息隐藏 --> ( 难度等级: [0.6559, 0.6559) || 挂载数据: 无 ) 
│       │       │   └── Java软件 --> ( 难度等级: [0.6559, 0.6559) || 挂载数据: qa: 8 ) 
│       │       ├── 使用Java模块系统开发应用 --> ( 难度等级: [0.6559, 0.656) || 挂载数据: 无 ) 
│       │       │   ├── 从头开始搭建一个应用 --> ( 难度等级: [0.6559, 0.656) || 挂载数据: 无 ) 
│       │       │   ├── 细粒度和粗粒度的模块化 --> ( 难度等级: [0.656, 0.656) || 挂载数据: 无 ) 
│       │       │   └── Java模块系统基础 --> ( 难度等级: [0.656, 0.656) || 挂载数据: qa: 10 ) 
│       │       ├── 使用多个模块 --> ( 难度等级: [0.656, 0.6561) || 挂载数据: qa: 1 ) 
│       │       │   ├── exports子句 --> ( 难度等级: [0.656, 0.656) || 挂载数据: 无 ) 
│       │       │   ├── requires子句 --> ( 难度等级: [0.656, 0.656) || 挂载数据: 无 ) 
│       │       │   └── 命名 --> ( 难度等级: [0.656, 0.6561) || 挂载数据: qa: 1 ) 
│       │       ├── 编译及打包 --> ( 难度等级: [0.6561, 0.6561) || 挂载数据: 无 ) 
│       │       ├── 自动模块 --> ( 难度等级: [0.6561, 0.6562) || 挂载数据: qa: 1 ) 
│       │       └── 模块声明及子句 --> ( 难度等级: [0.6562, 0.6562) || 挂载数据: 无 ) 
│       │           ├── requires --> ( 难度等级: [0.6562, 0.6562) || 挂载数据: 无 ) 
│       │           ├── exports --> ( 难度等级: [0.6562, 0.6562) || 挂载数据: 无 ) 
│       │           ├── requires的传递 --> ( 难度等级: [0.6562, 0.6562) || 挂载数据: 无 ) 
│       │           ├── exports to --> ( 难度等级: [0.6562, 0.6562) || 挂载数据: qa: 4 ) 
│       │           ├── open和opens --> ( 难度等级: [0.6562, 0.6562) || 挂载数据: qa: 4 ) 
│       │           └── uses和provides --> ( 难度等级: [0.6562, 0.6562) || 挂载数据: 无 ) 
│       ├── 提升Java的并发性 --> ( 难度等级: [0.6562, 0.657) || 挂载数据: 无 ) 
│       │   ├── CompletableFuture及反应式编程背后的概念 --> ( 难度等级: [0.6562, 0.6565) || 挂载数据: 无 ) 
│       │   │   ├── 为支持并发而不断演进的Java --> ( 难度等级: [0.6562, 0.6563) || 挂载数据: 无 ) 
│       │   │   │   ├── 其他的线程抽象：非嵌套方法调用 --> ( 难度等级: [0.6562, 0.6563) || 挂载数据: 无 ) 
│       │   │   │   └── 你希望线程为你带来什么 --> ( 难度等级: [0.6563, 0.6563) || 挂载数据: qa: 10 ) 
│       │   │   ├── 同步及异步API --> ( 难度等级: [0.6563, 0.6563) || 挂载数据: 无 ) 
│       │   │   │   ├── Future风格的API --> ( 难度等级: [0.6563, 0.6563) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 反应式风格的API --> ( 难度等级: [0.6563, 0.6563) || 挂载数据: 无 ) 
│       │   │   │   ├── 有害的睡眠及其他阻塞式操作 --> ( 难度等级: [0.6563, 0.6563) || 挂载数据: 无 ) 
│       │   │   │   └── 如何使用异步API进行异常处理 --> ( 难度等级: [0.6563, 0.6563) || 挂载数据: 无 ) 
│       │   │   ├── “线框–管道”模型 --> ( 难度等级: [0.6563, 0.6564) || 挂载数据: 无 ) 
│       │   │   ├── 为并发而生的CompletableFuture和结合器 --> ( 难度等级: [0.6564, 0.6564) || 挂载数据: qa: 1 ) 
│       │   │   ├── “发布–订阅”以及反应式编程 --> ( 难度等级: [0.6564, 0.6565) || 挂载数据: 无 ) 
│       │   │   │   ├── 背压 --> ( 难度等级: [0.6564, 0.6564) || 挂载数据: 无 ) 
│       │   │   │   └── 一种简单的真实背压 --> ( 难度等级: [0.6564, 0.6565) || 挂载数据: 无 ) 
│       │   │   └── 反应式系统和反应式编程 --> ( 难度等级: [0.6565, 0.6565) || 挂载数据: 无 ) 
│       │   ├── CompletableFuture：组合式异步编程 --> ( 难度等级: [0.6565, 0.6567) || 挂载数据: 无 ) 
│       │   │   ├── 实现异步API --> ( 难度等级: [0.6565, 0.6566) || 挂载数据: 无 ) 
│       │   │   │   ├── 将同步方法转换为异步方法 --> ( 难度等级: [0.6565, 0.6565) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 错误处理 --> ( 难度等级: [0.6565, 0.6566) || 挂载数据: 无 ) 
│       │   │   ├── 让你的代码免受阻塞之苦 --> ( 难度等级: [0.6566, 0.6566) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用并行流对请求进行并行操作 --> ( 难度等级: [0.6566, 0.6566) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用CompletableFuture发起异步请求 --> ( 难度等级: [0.6566, 0.6566) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 寻找更好的方案 --> ( 难度等级: [0.6566, 0.6566) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 使用定制的执行器 --> ( 难度等级: [0.6566, 0.6566) || 挂载数据: 无 ) 
│       │   │   ├── 对多个异步任务进行流水线操作 --> ( 难度等级: [0.6566, 0.6567) || 挂载数据: 无 ) 
│       │   │   │   ├── 实现折扣服务 --> ( 难度等级: [0.6566, 0.6566) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用Discount服务 --> ( 难度等级: [0.6566, 0.6566) || 挂载数据: qa: 6 ) 
│       │   │   │   ├── 构造同步和异步操作 --> ( 难度等级: [0.6566, 0.6567) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 将两个CompletableFuture对象整合起来，无论它们是否存在依赖 --> ( 难度等级: [0.6567, 0.6567) || 挂载数据: 无 ) 
│       │   │   │   ├── 对Future和Completable-Future的回顾 --> ( 难度等级: [0.6567, 0.6567) || 挂载数据: 无 ) 
│       │   │   │   └── 高效地使用超时机制 --> ( 难度等级: [0.6567, 0.6567) || 挂载数据: 无 ) 
│       │   │   └── 响应CompletableFuture的completion事件 --> ( 难度等级: [0.6567, 0.6567) || 挂载数据: 无 ) 
│       │   │       └── 对最佳价格查询器应用的优化 --> ( 难度等级: [0.6567, 0.6567) || 挂载数据: qa: 1 ) 
│       │   └── 反应式编程 --> ( 难度等级: [0.6567, 0.657) || 挂载数据: 无 ) 
│       │       ├── 反应式宣言 --> ( 难度等级: [0.6567, 0.6568) || 挂载数据: 无 ) 
│       │       │   ├── 应用层的反应式编程 --> ( 难度等级: [0.6567, 0.6568) || 挂载数据: 无 ) 
│       │       │   └── 反应式系统 --> ( 难度等级: [0.6568, 0.6568) || 挂载数据: 无 ) 
│       │       ├── 反应式流以及Flow API --> ( 难度等级: [0.6568, 0.6569) || 挂载数据: 无 ) 
│       │       │   ├── Flow类 --> ( 难度等级: [0.6568, 0.6569) || 挂载数据: 无 ) 
│       │       │   ├── 创建你的第一个反应式应用 --> ( 难度等级: [0.6569, 0.6569) || 挂载数据: 无 ) 
│       │       │   └── 使用Processor转换数据 --> ( 难度等级: [0.6569, 0.6569) || 挂载数据: qa: 1 ) 
│       │       └── 使用反应式库RxJava --> ( 难度等级: [0.6569, 0.657) || 挂载数据: qa: 3 ) 
│       │           └── 转换及整合多个Observable --> ( 难度等级: [0.6569, 0.657) || 挂载数据: qa: 3 ) 
│       ├── 函数式编程以及Java未来的演进 --> ( 难度等级: [0.657, 0.6577) || 挂载数据: 无 ) 
│       │   ├── 函数式的思考 --> ( 难度等级: [0.657, 0.6571) || 挂载数据: qa: 1 ) 
│       │   │   ├── 实现和维护系统 --> ( 难度等级: [0.657, 0.657) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 声明式编程 --> ( 难度等级: [0.657, 0.657) || 挂载数据: 无 ) 
│       │   │   ├── 什么是函数式编程 --> ( 难度等级: [0.657, 0.6571) || 挂载数据: 无 ) 
│       │   │   │   ├── 函数式Java编程 --> ( 难度等级: [0.657, 0.6571) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 引用透明性 --> ( 难度等级: [0.6571, 0.6571) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 面向对象的编程和函数式编程的对比 --> ( 难度等级: [0.6571, 0.6571) || 挂载数据: qa: 1 ) 
│       │   │   └── 递归和迭代 --> ( 难度等级: [0.6571, 0.6571) || 挂载数据: 无 ) 
│       │   ├── 函数式编程的技巧 --> ( 难度等级: [0.6571, 0.6573) || 挂载数据: 无 ) 
│       │   │   ├── 无处不在的函数 --> ( 难度等级: [0.6571, 0.6572) || 挂载数据: 无 ) 
│       │   │   │   └── 柯里化 --> ( 难度等级: [0.6571, 0.6572) || 挂载数据: 无 ) 
│       │   │   ├── 持久化数据结构 --> ( 难度等级: [0.6572, 0.6572) || 挂载数据: 无 ) 
│       │   │   │   ├── 破坏式更新和函数式更新的比较 --> ( 难度等级: [0.6572, 0.6572) || 挂载数据: 无 ) 
│       │   │   │   ├── 另一个使用Tree的例子 --> ( 难度等级: [0.6572, 0.6572) || 挂载数据: qa: 4 ) 
│       │   │   │   └── 采用函数式的方法 --> ( 难度等级: [0.6572, 0.6572) || 挂载数据: qa: 1 ) 
│       │   │   ├── Stream的延迟计算 --> ( 难度等级: [0.6572, 0.6572) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义的Stream --> ( 难度等级: [0.6572, 0.6572) || 挂载数据: qa: 8 ) 
│       │   │   │   └── 创建你自己的延迟列表 --> ( 难度等级: [0.6572, 0.6572) || 挂载数据: 无 ) 
│       │   │   ├── 模式匹配 --> ( 难度等级: [0.6572, 0.6573) || 挂载数据: 无 ) 
│       │   │   │   ├── 访问者模式 --> ( 难度等级: [0.6572, 0.6572) || 挂载数据: 无 ) 
│       │   │   │   └── 用模式匹配力挽狂澜 --> ( 难度等级: [0.6572, 0.6573) || 挂载数据: 无 ) 
│       │   │   └── 杂项 --> ( 难度等级: [0.6573, 0.6573) || 挂载数据: 无 ) 
│       │   │       ├── 缓存或记忆表 --> ( 难度等级: [0.6573, 0.6573) || 挂载数据: qa: 4 ) 
│       │   │       └── “返回同样的对象”意味着什么 --> ( 难度等级: [0.6573, 0.6573) || 挂载数据: 无 ) 
│       │   ├── 结论以及Java的未来 --> ( 难度等级: [0.6573, 0.6574) || 挂载数据: 无 ) 
│       │   │   ├── 回顾Java 8的语言特性 --> ( 难度等级: [0.6573, 0.6573) || 挂载数据: 无 ) 
│       │   │   ├── Java 10的局部变量类型推断 --> ( 难度等级: [0.6573, 0.6574) || 挂载数据: 无 ) 
│       │   │   ├── Java的未来 --> ( 难度等级: [0.6574, 0.6574) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 声明处型变 --> ( 难度等级: [0.6574, 0.6574) || 挂载数据: 无 ) 
│       │   │   │   ├── 模式匹配 --> ( 难度等级: [0.6574, 0.6574) || 挂载数据: 无 ) 
│       │   │   │   ├── 更加丰富的泛型形式 --> ( 难度等级: [0.6574, 0.6574) || 挂载数据: 无 ) 
│       │   │   │   ├── 对不变性的更深层支持 --> ( 难度等级: [0.6574, 0.6574) || 挂载数据: 无 ) 
│       │   │   │   └── 值类型 --> ( 难度等级: [0.6574, 0.6574) || 挂载数据: qa: 10 ) 
│       │   │   ├── 让Java发展得更快 --> ( 难度等级: [0.6574, 0.6574) || 挂载数据: 无 ) 
│       │   │   └── 写在最后的话 --> ( 难度等级: [0.6574, 0.6574) || 挂载数据: qa: 10 ) 
│       │   ├── Lambda基础 --> ( 难度等级: [0.6574, 0.6576) || 挂载数据: 无 ) 
│       │   └── 使用Stream --> ( 难度等级: [0.6576, 0.6577) || 挂载数据: qa: 1 ) 
│       │       ├── 创建Stream --> ( 难度等级: [0.6576, 0.6576) || 挂载数据: qa: 3 ) 
│       │       ├── 使用filter --> ( 难度等级: [0.6576, 0.6577) || 挂载数据: qa: 4 ) 
│       │       ├── 使用reduce --> ( 难度等级: [0.6577, 0.6577) || 挂载数据: 无 ) 
│       │       └── 输出集合 --> ( 难度等级: [0.6577, 0.6577) || 挂载数据: qa: 2 ) 
│       ├── Java 8的流库 --> ( 难度等级: [0.6577, 0.6585) || 挂载数据: 无 ) 
│       │   ├── 从迭代到流的操作 --> ( 难度等级: [0.6577, 0.6578) || 挂载数据: 无 ) 
│       │   ├── 流的创建 --> ( 难度等级: [0.6578, 0.6579) || 挂载数据: 无 ) 
│       │   ├── f?ilter、map和f?latMap方法 --> ( 难度等级: [0.6579, 0.6579) || 挂载数据: 无 ) 
│       │   ├── 抽取子流和组合流 --> ( 难度等级: [0.6579, 0.658) || 挂载数据: 无 ) 
│       │   ├── 其他的流转换 --> ( 难度等级: [0.658, 0.6581) || 挂载数据: 无 ) 
│       │   ├── 简单约简 --> ( 难度等级: [0.6581, 0.6581) || 挂载数据: 无 ) 
│       │   ├── Optional类型 --> ( 难度等级: [0.6581, 0.6582) || 挂载数据: 无 ) 
│       │   │   ├── 获取Optional值 --> ( 难度等级: [0.6581, 0.6582) || 挂载数据: qa: 6 ) 
│       │   │   ├── 消费Optional值 --> ( 难度等级: [0.6582, 0.6582) || 挂载数据: 无 ) 
│       │   │   ├── 管道化Optional值 --> ( 难度等级: [0.6582, 0.6582) || 挂载数据: 无 ) 
│       │   │   ├── 不适合使用Optional值的方式 --> ( 难度等级: [0.6582, 0.6582) || 挂载数据: 无 ) 
│       │   │   ├── 创建Optional值 --> ( 难度等级: [0.6582, 0.6582) || 挂载数据: 无 ) 
│       │   │   ├── 用f?latMap构建Optional值的函数 --> ( 难度等级: [0.6582, 0.6582) || 挂载数据: 无 ) 
│       │   │   └── 将Optional转换为流 --> ( 难度等级: [0.6582, 0.6582) || 挂载数据: 无 ) 
│       │   ├── 收集到映射表中 --> ( 难度等级: [0.6582, 0.6583) || 挂载数据: 无 ) 
│       │   ├── 下游收集器 --> ( 难度等级: [0.6583, 0.6583) || 挂载数据: 无 ) 
│       │   ├── 约简操作 --> ( 难度等级: [0.6583, 0.6584) || 挂载数据: 无 ) 
│       │   └── 基本类型流 --> ( 难度等级: [0.6584, 0.6585) || 挂载数据: 无 ) 
│       ├── 输入与输出 --> ( 难度等级: [0.6585, 0.6592) || 挂载数据: 无 ) 
│       │   ├── 输入/输出流 --> ( 难度等级: [0.6585, 0.6586) || 挂载数据: 无 ) 
│       │   │   ├── 读写字节 --> ( 难度等级: [0.6585, 0.6585) || 挂载数据: 无 ) 
│       │   │   ├── 完整的流家族 --> ( 难度等级: [0.6585, 0.6585) || 挂载数据: 无 ) 
│       │   │   ├── 组合输入/输出流过滤器 --> ( 难度等级: [0.6585, 0.6585) || 挂载数据: 无 ) 
│       │   │   ├── 文本输入与输出 --> ( 难度等级: [0.6585, 0.6585) || 挂载数据: qa: 10 ) 
│       │   │   ├── 如何写出文本输出 --> ( 难度等级: [0.6585, 0.6586) || 挂载数据: 无 ) 
│       │   │   ├── 如何读入文本输入 --> ( 难度等级: [0.6586, 0.6586) || 挂载数据: 无 ) 
│       │   │   ├── 以文本格式存储对象 --> ( 难度等级: [0.6586, 0.6586) || 挂载数据: 无 ) 
│       │   │   └── 字符编码方式 --> ( 难度等级: [0.6586, 0.6586) || 挂载数据: 无 ) 
│       │   ├── 读写二进制数据 --> ( 难度等级: [0.6586, 0.6587) || 挂载数据: qa: 1 ) 
│       │   │   ├── DataInput和DataOutput接口 --> ( 难度等级: [0.6586, 0.6586) || 挂载数据: 无 ) 
│       │   │   ├── 随机访问文件 --> ( 难度等级: [0.6586, 0.6587) || 挂载数据: qa: 1 ) 
│       │   │   └── ZIP文档 --> ( 难度等级: [0.6587, 0.6587) || 挂载数据: 无 ) 
│       │   ├── 对象输入/输出流与序列化 --> ( 难度等级: [0.6587, 0.6589) || 挂载数据: 无 ) 
│       │   │   ├── 保存和加载序列化对象 --> ( 难度等级: [0.6587, 0.6588) || 挂载数据: qa: 2 ) 
│       │   │   ├── 理解对象序列化的文件格式 --> ( 难度等级: [0.6588, 0.6588) || 挂载数据: 无 ) 
│       │   │   ├── 修改默认的序列化机制 --> ( 难度等级: [0.6588, 0.6588) || 挂载数据: 无 ) 
│       │   │   ├── 序列化单例和类型安全的枚举 --> ( 难度等级: [0.6588, 0.6588) || 挂载数据: 无 ) 
│       │   │   ├── 版本管理 --> ( 难度等级: [0.6588, 0.6588) || 挂载数据: qa: 1 ) 
│       │   │   └── 为克隆使用序列化 --> ( 难度等级: [0.6588, 0.6589) || 挂载数据: 无 ) 
│       │   ├── 操作文件 --> ( 难度等级: [0.6589, 0.659) || 挂载数据: 无 ) 
│       │   │   ├── Path --> ( 难度等级: [0.6589, 0.6589) || 挂载数据: qa: 2 ) 
│       │   │   ├── 读写文件 --> ( 难度等级: [0.6589, 0.6589) || 挂载数据: qa: 10 ) 
│       │   │   ├── 复制、移动和删除文件 --> ( 难度等级: [0.6589, 0.6589) || 挂载数据: qa: 1 ) 
│       │   │   ├── 获取文件信息 --> ( 难度等级: [0.6589, 0.6589) || 挂载数据: qa: 10 ) 
│       │   │   ├── 访问目录中的项 --> ( 难度等级: [0.6589, 0.6589) || 挂载数据: 无 ) 
│       │   │   ├── 使用目录流 --> ( 难度等级: [0.6589, 0.659) || 挂载数据: 无 ) 
│       │   │   └── ZIP文件系统 --> ( 难度等级: [0.659, 0.659) || 挂载数据: 无 ) 
│       │   ├── 内存映射文件 --> ( 难度等级: [0.659, 0.6591) || 挂载数据: 无 ) 
│       │   │   ├── 内存映射文件的性能 --> ( 难度等级: [0.659, 0.659) || 挂载数据: 无 ) 
│       │   │   └── 缓冲区数据结构 --> ( 难度等级: [0.659, 0.6591) || 挂载数据: 无 ) 
│       │   └── 文件加锁机制 --> ( 难度等级: [0.6591, 0.6592) || 挂载数据: 无 ) 
│       ├── XML --> ( 难度等级: [0.6592, 0.66) || 挂载数据: 无 ) 
│       │   ├── XML概述 --> ( 难度等级: [0.6592, 0.6593) || 挂载数据: 无 ) 
│       │   ├── XML文档的结构 --> ( 难度等级: [0.6593, 0.6594) || 挂载数据: 无 ) 
│       │   ├── 解析XML文档 --> ( 难度等级: [0.6594, 0.6595) || 挂载数据: 无 ) 
│       │   ├── 验证XML文档 --> ( 难度等级: [0.6595, 0.6596) || 挂载数据: 无 ) 
│       │   │   ├── 文档类型定义 --> ( 难度等级: [0.6595, 0.6595) || 挂载数据: 无 ) 
│       │   │   ├── XML Schema --> ( 难度等级: [0.6595, 0.6595) || 挂载数据: qa: 10 ) 
│       │   │   └── 一个实践示例 --> ( 难度等级: [0.6595, 0.6596) || 挂载数据: 无 ) 
│       │   ├── 使用XPath来定位信息 --> ( 难度等级: [0.6596, 0.6596) || 挂载数据: qa: 1 ) 
│       │   ├── 使用命名空间 --> ( 难度等级: [0.6596, 0.6597) || 挂载数据: qa: 1 ) 
│       │   ├── 流机制解析器 --> ( 难度等级: [0.6597, 0.6598) || 挂载数据: 无 ) 
│       │   │   ├── 使用SAX解析器 --> ( 难度等级: [0.6597, 0.6598) || 挂载数据: 无 ) 
│       │   │   └── 使用StAX解析器 --> ( 难度等级: [0.6598, 0.6598) || 挂载数据: 无 ) 
│       │   ├── 生成XML文档 --> ( 难度等级: [0.6598, 0.6599) || 挂载数据: 无 ) 
│       │   │   ├── 不带命名空间的文档 --> ( 难度等级: [0.6598, 0.6598) || 挂载数据: 无 ) 
│       │   │   ├── 带命名空间的文档 --> ( 难度等级: [0.6598, 0.6598) || 挂载数据: 无 ) 
│       │   │   ├── 写出文档 --> ( 难度等级: [0.6598, 0.6599) || 挂载数据: qa: 10 ) 
│       │   │   └── 使用StAX写出XML文档 --> ( 难度等级: [0.6599, 0.6599) || 挂载数据: qa: 2 ) 
│       │   └── XSL转换 --> ( 难度等级: [0.6599, 0.66) || 挂载数据: 无 ) 
│       ├── 网络 --> ( 难度等级: [0.66, 0.6607) || 挂载数据: 无 ) 
│       │   ├── 连接到服务器 --> ( 难度等级: [0.66, 0.6601) || 挂载数据: 无 ) 
│       │   │   ├── 使用telnet --> ( 难度等级: [0.66, 0.66) || 挂载数据: qa: 1 ) 
│       │   │   ├── 用Java连接到服务器 --> ( 难度等级: [0.66, 0.66) || 挂载数据: qa: 5 ) 
│       │   │   ├── 套接字超时 --> ( 难度等级: [0.66, 0.6601) || 挂载数据: 无 ) 
│       │   │   └── 因特网地址 --> ( 难度等级: [0.6601, 0.6601) || 挂载数据: qa: 1 ) 
│       │   ├── 实现服务器 --> ( 难度等级: [0.6601, 0.6603) || 挂载数据: 无 ) 
│       │   │   ├── 服务器套接字 --> ( 难度等级: [0.6601, 0.6602) || 挂载数据: qa: 10 ) 
│       │   │   ├── 为多个客户端服务 --> ( 难度等级: [0.6602, 0.6602) || 挂载数据: qa: 3 ) 
│       │   │   ├── 半关闭 --> ( 难度等级: [0.6602, 0.6602) || 挂载数据: qa: 3 ) 
│       │   │   └── 可中断套接字 --> ( 难度等级: [0.6602, 0.6603) || 挂载数据: 无 ) 
│       │   ├── 获取Web数据 --> ( 难度等级: [0.6603, 0.6604) || 挂载数据: 无 ) 
│       │   │   ├── URL和URI --> ( 难度等级: [0.6603, 0.6603) || 挂载数据: qa: 2 ) 
│       │   │   ├── 使用URLConnection获取信息 --> ( 难度等级: [0.6603, 0.6604) || 挂载数据: qa: 1 ) 
│       │   │   └── 提交表单数据 --> ( 难度等级: [0.6604, 0.6604) || 挂载数据: qa: 10 ) 
│       │   ├── HTTP客户端 --> ( 难度等级: [0.6604, 0.6606) || 挂载数据: 无 ) 
│       │   └── 发送E-mail --> ( 难度等级: [0.6606, 0.6607) || 挂载数据: qa: 5 ) 
│       ├── 数据库编程 --> ( 难度等级: [0.6607, 0.6615) || 挂载数据: 无 ) 
│       │   ├── JDBC的设计 --> ( 难度等级: [0.6607, 0.6608) || 挂载数据: 无 ) 
│       │   │   ├── JDBC驱动程序类型 --> ( 难度等级: [0.6607, 0.6608) || 挂载数据: 无 ) 
│       │   │   └── JDBC的典型用法 --> ( 难度等级: [0.6608, 0.6608) || 挂载数据: 无 ) 
│       │   ├── 结构化查询语言 --> ( 难度等级: [0.6608, 0.6609) || 挂载数据: 无 ) 
│       │   ├── JDBC配置 --> ( 难度等级: [0.6609, 0.6609) || 挂载数据: 无 ) 
│       │   │   ├── 数据库URL --> ( 难度等级: [0.6609, 0.6609) || 挂载数据: 无 ) 
│       │   │   ├── 驱动程序JAR文件 --> ( 难度等级: [0.6609, 0.6609) || 挂载数据: 无 ) 
│       │   │   ├── 启动数据库 --> ( 难度等级: [0.6609, 0.6609) || 挂载数据: 无 ) 
│       │   │   ├── 注册驱动器类 --> ( 难度等级: [0.6609, 0.6609) || 挂载数据: 无 ) 
│       │   │   └── 连接到数据库 --> ( 难度等级: [0.6609, 0.6609) || 挂载数据: qa: 9 ) 
│       │   ├── 使用JDBC语句 --> ( 难度等级: [0.6609, 0.661) || 挂载数据: 无 ) 
│       │   │   ├── 执行SQL语句 --> ( 难度等级: [0.6609, 0.661) || 挂载数据: qa: 10 ) 
│       │   │   ├── 管理连接、语句和结果集 --> ( 难度等级: [0.661, 0.661) || 挂载数据: qa: 1 ) 
│       │   │   ├── 分析SQL异常 --> ( 难度等级: [0.661, 0.661) || 挂载数据: qa: 1 ) 
│       │   │   └── 组装数据库 --> ( 难度等级: [0.661, 0.661) || 挂载数据: 无 ) 
│       │   ├── 执行查询操作 --> ( 难度等级: [0.661, 0.6611) || 挂载数据: qa: 1 ) 
│       │   │   ├── 预备语句 --> ( 难度等级: [0.661, 0.661) || 挂载数据: 无 ) 
│       │   │   ├── 读写LOB --> ( 难度等级: [0.661, 0.661) || 挂载数据: 无 ) 
│       │   │   ├── SQL转义 --> ( 难度等级: [0.661, 0.6611) || 挂载数据: qa: 5 ) 
│       │   │   ├── 多结果集 --> ( 难度等级: [0.6611, 0.6611) || 挂载数据: 无 ) 
│       │   │   └── 获取自动生成的键 --> ( 难度等级: [0.6611, 0.6611) || 挂载数据: qa: 5 ) 
│       │   ├── 可滚动和可更新的结果集 --> ( 难度等级: [0.6611, 0.6612) || 挂载数据: 无 ) 
│       │   │   ├── 可滚动的结果集 --> ( 难度等级: [0.6611, 0.6611) || 挂载数据: 无 ) 
│       │   │   └── 可更新的结果集 --> ( 难度等级: [0.6611, 0.6612) || 挂载数据: qa: 9 ) 
│       │   ├── 行集 --> ( 难度等级: [0.6612, 0.6612) || 挂载数据: 无 ) 
│       │   │   ├── 构建行集 --> ( 难度等级: [0.6612, 0.6612) || 挂载数据: 无 ) 
│       │   │   └── 被缓存的行集 --> ( 难度等级: [0.6612, 0.6612) || 挂载数据: 无 ) 
│       │   ├── 元数据 --> ( 难度等级: [0.6612, 0.6613) || 挂载数据: qa: 3 ) 
│       │   ├── 事务 --> ( 难度等级: [0.6613, 0.6614) || 挂载数据: 无 ) 
│       │   │   ├── 用JDBC对事务编程 --> ( 难度等级: [0.6613, 0.6613) || 挂载数据: qa: 3 ) 
│       │   │   ├── 批量更新 --> ( 难度等级: [0.6613, 0.6614) || 挂载数据: qa: 1 ) 
│       │   │   └── 高级SQL类型 --> ( 难度等级: [0.6614, 0.6614) || 挂载数据: qa: 2 ) 
│       │   └── Web与企业应用中的连接管理 --> ( 难度等级: [0.6614, 0.6615) || 挂载数据: 无 ) 
│       ├── 国际化 --> ( 难度等级: [0.6615, 0.6622) || 挂载数据: 无 ) 
│       │   ├── locale --> ( 难度等级: [0.6615, 0.6616) || 挂载数据: 无 ) 
│       │   │   ├── 指定locale --> ( 难度等级: [0.6615, 0.6615) || 挂载数据: 无 ) 
│       │   │   ├── 默认locale --> ( 难度等级: [0.6615, 0.6616) || 挂载数据: 无 ) 
│       │   │   └── 显示名字 --> ( 难度等级: [0.6616, 0.6616) || 挂载数据: qa: 1 ) 
│       │   ├── 数字格式 --> ( 难度等级: [0.6616, 0.6618) || 挂载数据: 无 ) 
│       │   │   ├── 格式化数字值 --> ( 难度等级: [0.6616, 0.6617) || 挂载数据: qa: 1 ) 
│       │   │   └── 货币 --> ( 难度等级: [0.6617, 0.6618) || 挂载数据: 无 ) 
│       │   ├── 排序和规范化 --> ( 难度等级: [0.6618, 0.6619) || 挂载数据: 无 ) 
│       │   ├── 消息格式化 --> ( 难度等级: [0.6619, 0.6621) || 挂载数据: 无 ) 
│       │   │   └── 选择格式 --> ( 难度等级: [0.6619, 0.6621) || 挂载数据: qa: 2 ) 
│       │   └── 资源包 --> ( 难度等级: [0.6621, 0.6622) || 挂载数据: 无 ) 
│       │       ├── 定位资源包 --> ( 难度等级: [0.6621, 0.6621) || 挂载数据: qa: 1 ) 
│       │       ├── 属性文件 --> ( 难度等级: [0.6621, 0.6622) || 挂载数据: 无 ) 
│       │       └── 包类 --> ( 难度等级: [0.6622, 0.6622) || 挂载数据: 无 ) 
│       ├── Java平台模块系统 --> ( 难度等级: [0.6622, 0.6629) || 挂载数据: 无 ) 
│       │   ├── 模块的概念 --> ( 难度等级: [0.6622, 0.6623) || 挂载数据: 无 ) 
│       │   ├── 对模块命名 --> ( 难度等级: [0.6623, 0.6623) || 挂载数据: 无 ) 
│       │   ├── 模块化的“Hello, World!”程序 --> ( 难度等级: [0.6623, 0.6624) || 挂载数据: qa: 3 ) 
│       │   ├── 对模块的需求 --> ( 难度等级: [0.6624, 0.6625) || 挂载数据: qa: 2 ) 
│       │   ├── 导出包 --> ( 难度等级: [0.6625, 0.6625) || 挂载数据: qa: 3 ) 
│       │   ├── 模块化的JAR --> ( 难度等级: [0.6625, 0.6626) || 挂载数据: qa: 1 ) 
│       │   ├── 不具名模块 --> ( 难度等级: [0.6626, 0.6626) || 挂载数据: 无 ) 
│       │   ├── 用于迁移的命令行标识 --> ( 难度等级: [0.6626, 0.6627) || 挂载数据: 无 ) 
│       │   ├── 传递的需求和静态的需求 --> ( 难度等级: [0.6627, 0.6628) || 挂载数据: 无 ) 
│       │   ├── 限定导出和开放 --> ( 难度等级: [0.6628, 0.6628) || 挂载数据: 无 ) 
│       │   ├── 服务加载 --> ( 难度等级: [0.6628, 0.6629) || 挂载数据: 无 ) 
│       │   └── 操作模块的工具 --> ( 难度等级: [0.6629, 0.6629) || 挂载数据: 无 ) 
│       ├── 安全 --> ( 难度等级: [0.6629, 0.6637) || 挂载数据: 无 ) 
│       │   ├── 类加载器 --> ( 难度等级: [0.6629, 0.6631) || 挂载数据: 无 ) 
│       │   │   ├── 类加载过程 --> ( 难度等级: [0.6629, 0.663) || 挂载数据: qa: 10 ) 
│       │   │   ├── 类加载器的层次结构 --> ( 难度等级: [0.663, 0.663) || 挂载数据: qa: 1 ) 
│       │   │   ├── 将类加载器用作命名空间 --> ( 难度等级: [0.663, 0.663) || 挂载数据: 无 ) 
│       │   │   ├── 编写你自己的类加载器 --> ( 难度等级: [0.663, 0.6631) || 挂载数据: 无 ) 
│       │   │   └── 字节码校验 --> ( 难度等级: [0.6631, 0.6631) || 挂载数据: qa: 1 ) 
│       │   ├── 安全管理器与访问权限 --> ( 难度等级: [0.6631, 0.6632) || 挂载数据: 无 ) 
│       │   │   ├── 权限检查 --> ( 难度等级: [0.6631, 0.6631) || 挂载数据: 无 ) 
│       │   │   ├── Java平台安全性 --> ( 难度等级: [0.6631, 0.6632) || 挂载数据: qa: 1 ) 
│       │   │   ├── 安全策略文件 --> ( 难度等级: [0.6632, 0.6632) || 挂载数据: 无 ) 
│       │   │   ├── 定制权限 --> ( 难度等级: [0.6632, 0.6632) || 挂载数据: qa: 1 ) 
│       │   │   └── 实现权限类 --> ( 难度等级: [0.6632, 0.6632) || 挂载数据: 无 ) 
│       │   ├── 用户认证 --> ( 难度等级: [0.6632, 0.6634) || 挂载数据: qa: 1 ) 
│       │   │   ├── JAAS框架 --> ( 难度等级: [0.6632, 0.6633) || 挂载数据: 无 ) 
│       │   │   └── JAAS登录模块 --> ( 难度等级: [0.6633, 0.6634) || 挂载数据: qa: 5 ) 
│       │   ├── 数字签名 --> ( 难度等级: [0.6634, 0.6635) || 挂载数据: qa: 1 ) 
│       │   │   ├── 消息摘要 --> ( 难度等级: [0.6634, 0.6634) || 挂载数据: qa: 1 ) 
│       │   │   ├── 消息签名 --> ( 难度等级: [0.6634, 0.6634) || 挂载数据: 无 ) 
│       │   │   ├── 校验签名 --> ( 难度等级: [0.6634, 0.6635) || 挂载数据: qa: 4 ) 
│       │   │   ├── 证书签名 --> ( 难度等级: [0.6635, 0.6635) || 挂载数据: qa: 1 ) 
│       │   │   ├── 证书请求 --> ( 难度等级: [0.6635, 0.6635) || 挂载数据: qa: 1 ) 
│       │   │   └── 代码签名 --> ( 难度等级: [0.6635, 0.6635) || 挂载数据: qa: 2 ) 
│       │   └── 加密 --> ( 难度等级: [0.6635, 0.6637) || 挂载数据: qa: 8 ) 
│       │       ├── 对称密码 --> ( 难度等级: [0.6635, 0.6636) || 挂载数据: 无 ) 
│       │       ├── 密钥生成 --> ( 难度等级: [0.6636, 0.6636) || 挂载数据: qa: 9 ) 
│       │       ├── 密码流 --> ( 难度等级: [0.6636, 0.6637) || 挂载数据: 无 ) 
│       │       └── 公共密钥密码 --> ( 难度等级: [0.6637, 0.6637) || 挂载数据: 无 ) 
│       ├── 高级Swing和图形化编程 --> ( 难度等级: [0.6637, 0.6644) || 挂载数据: 无 ) 
│       │   ├── 表格 --> ( 难度等级: [0.6637, 0.6638) || 挂载数据: 无 ) 
│       │   │   ├── 一个简单表格 --> ( 难度等级: [0.6637, 0.6637) || 挂载数据: qa: 10 ) 
│       │   │   ├── 表格模型 --> ( 难度等级: [0.6637, 0.6638) || 挂载数据: 无 ) 
│       │   │   ├── 对行和列的操作 --> ( 难度等级: [0.6638, 0.6638) || 挂载数据: qa: 1 ) 
│       │   │   └── 单元格的绘制和编辑 --> ( 难度等级: [0.6638, 0.6638) || 挂载数据: qa: 1 ) 
│       │   ├── 树 --> ( 难度等级: [0.6638, 0.664) || 挂载数据: 无 ) 
│       │   │   ├── 简单的树 --> ( 难度等级: [0.6638, 0.6639) || 挂载数据: qa: 2 ) 
│       │   │   ├── 节点枚举 --> ( 难度等级: [0.6639, 0.6639) || 挂载数据: 无 ) 
│       │   │   ├── 绘制节点 --> ( 难度等级: [0.6639, 0.6639) || 挂载数据: 无 ) 
│       │   │   ├── 监听树事件 --> ( 难度等级: [0.6639, 0.664) || 挂载数据: 无 ) 
│       │   │   └── 定制树模型 --> ( 难度等级: [0.664, 0.664) || 挂载数据: 无 ) 
│       │   ├── 高级AWT --> ( 难度等级: [0.664, 0.6641) || 挂载数据: 无 ) 
│       │   │   ├── 绘图操作流程 --> ( 难度等级: [0.664, 0.664) || 挂载数据: 无 ) 
│       │   │   ├── 形状 --> ( 难度等级: [0.664, 0.664) || 挂载数据: 无 ) 
│       │   │   ├── 区域 --> ( 难度等级: [0.664, 0.664) || 挂载数据: 无 ) 
│       │   │   ├── 笔画 --> ( 难度等级: [0.664, 0.6641) || 挂载数据: 无 ) 
│       │   │   ├── 着色 --> ( 难度等级: [0.6641, 0.6641) || 挂载数据: 无 ) 
│       │   │   ├── 坐标变换 --> ( 难度等级: [0.6641, 0.6641) || 挂载数据: qa: 1 ) 
│       │   │   ├── 剪切 --> ( 难度等级: [0.6641, 0.6641) || 挂载数据: 无 ) 
│       │   │   └── 透明与组合 --> ( 难度等级: [0.6641, 0.6641) || 挂载数据: qa: 2 ) 
│       │   ├── 像素图 --> ( 难度等级: [0.6641, 0.6643) || 挂载数据: 无 ) 
│       │   │   ├── 图像的读取器和写入器 --> ( 难度等级: [0.6641, 0.6642) || 挂载数据: 无 ) 
│       │   │   └── 图像处理 --> ( 难度等级: [0.6642, 0.6643) || 挂载数据: 无 ) 
│       │   └── 打印 --> ( 难度等级: [0.6643, 0.6644) || 挂载数据: qa: 1 ) 
│       │       ├── 图形打印 --> ( 难度等级: [0.6643, 0.6643) || 挂载数据: qa: 10 ) 
│       │       ├── 打印多页文件 --> ( 难度等级: [0.6643, 0.6643) || 挂载数据: qa: 1 ) 
│       │       ├── 打印服务程序 --> ( 难度等级: [0.6643, 0.6644) || 挂载数据: 无 ) 
│       │       ├── 流打印服务程序 --> ( 难度等级: [0.6644, 0.6644) || 挂载数据: 无 ) 
│       │       └── 打印属性 --> ( 难度等级: [0.6644, 0.6644) || 挂载数据: qa: 1 ) 
│       ├── Maven基础 --> ( 难度等级: [0.6644, 0.6652) || 挂载数据: 无 ) 
│       │   ├── Maven介绍 --> ( 难度等级: [0.6644, 0.6645) || 挂载数据: 无 ) 
│       │   ├── 依赖管理 --> ( 难度等级: [0.6645, 0.6646) || 挂载数据: 无 ) 
│       │   ├── 构建流程 --> ( 难度等级: [0.6646, 0.6648) || 挂载数据: 无 ) 
│       │   ├── 使用插件 --> ( 难度等级: [0.6648, 0.6649) || 挂载数据: 无 ) 
│       │   ├── 模块管理 --> ( 难度等级: [0.6649, 0.665) || 挂载数据: 无 ) 
│       │   ├── 使用mvnw --> ( 难度等级: [0.665, 0.6651) || 挂载数据: 无 ) 
│       │   └── 发布Artifact --> ( 难度等级: [0.6651, 0.6652) || 挂载数据: 无 ) 
│       ├── 网络编程 --> ( 难度等级: [0.6652, 0.6659) || 挂载数据: 无 ) 
│       │   ├── 网络编程基础 --> ( 难度等级: [0.6652, 0.6653) || 挂载数据: 无 ) 
│       │   ├── TCP编程 --> ( 难度等级: [0.6653, 0.6654) || 挂载数据: 无 ) 
│       │   ├── UDP编程 --> ( 难度等级: [0.6654, 0.6655) || 挂载数据: 无 ) 
│       │   ├── 发送Email --> ( 难度等级: [0.6655, 0.6656) || 挂载数据: qa: 2 ) 
│       │   ├── 接收Email --> ( 难度等级: [0.6656, 0.6657) || 挂载数据: 无 ) 
│       │   ├── HTTP编程 --> ( 难度等级: [0.6657, 0.6658) || 挂载数据: qa: 2 ) 
│       │   └── RMI远程调用 --> ( 难度等级: [0.6658, 0.6659) || 挂载数据: qa: 4 ) 
│       └── JDBC编程 --> ( 难度等级: [0.6659, 0.6667) || 挂载数据: 无 ) 
│           ├── JDBC简介 --> ( 难度等级: [0.6659, 0.666) || 挂载数据: 无 ) 
│           ├── JDBC查询 --> ( 难度等级: [0.666, 0.6662) || 挂载数据: 无 ) 
│           ├── JDBC更新 --> ( 难度等级: [0.6662, 0.6663) || 挂载数据: 无 ) 
│           ├── JDBC事务 --> ( 难度等级: [0.6663, 0.6664) || 挂载数据: 无 ) 
│           ├── JDBC Batch --> ( 难度等级: [0.6664, 0.6665) || 挂载数据: 无 ) 
│           └── JDBC连接池 --> ( 难度等级: [0.6665, 0.6667) || 挂载数据: qa: 3 ) 
├── java高阶 --> ( 难度等级: [0.6667, 1.0) || 挂载数据: 无 ) 
│   ├── Swing简介 --> ( 难度等级: [0.6667, 0.7037) || 挂载数据: 无 ) 
│   │   ├── Swing的起源 --> ( 难度等级: [0.6667, 0.6704) || 挂载数据: 无 ) 
│   │   ├── Swing以AWT为基础 --> ( 难度等级: [0.6704, 0.6741) || 挂载数据: 无 ) 
│   │   ├── 两个关键的Swing特性 --> ( 难度等级: [0.6741, 0.6778) || 挂载数据: 无 ) 
│   │   │   ├── Swing组件是轻量级的 --> ( 难度等级: [0.6741, 0.6759) || 挂载数据: 无 ) 
│   │   │   └── Swing支持可插入外观 --> ( 难度等级: [0.6759, 0.6778) || 挂载数据: 无 ) 
│   │   ├── MVC连接 --> ( 难度等级: [0.6778, 0.6815) || 挂载数据: 无 ) 
│   │   ├── 组件与容器 --> ( 难度等级: [0.6815, 0.6852) || 挂载数据: 无 ) 
│   │   │   ├── 组件 --> ( 难度等级: [0.6815, 0.6827) || 挂载数据: 无 ) 
│   │   │   ├── 容器 --> ( 难度等级: [0.6827, 0.684) || 挂载数据: qa: 4 ) 
│   │   │   └── 顶级容器窗格 --> ( 难度等级: [0.684, 0.6852) || 挂载数据: 无 ) 
│   │   ├── Swing包 --> ( 难度等级: [0.6852, 0.6889) || 挂载数据: 无 ) 
│   │   ├── 一个简单的Swing应用程序 --> ( 难度等级: [0.6889, 0.6926) || 挂载数据: 无 ) 
│   │   ├── 事件处理 --> ( 难度等级: [0.6926, 0.6963) || 挂载数据: 无 ) 
│   │   ├── 创建Swing applet --> ( 难度等级: [0.6963, 0.7) || 挂载数据: 无 ) 
│   │   └── 在Swing中绘图 --> ( 难度等级: [0.7, 0.7037) || 挂载数据: 无 ) 
│   │       ├── 绘图的基础知识 --> ( 难度等级: [0.7, 0.7012) || 挂载数据: 无 ) 
│   │       ├── 计算可绘制区域 --> ( 难度等级: [0.7012, 0.7025) || 挂载数据: 无 ) 
│   │       └── 一个绘图示例 --> ( 难度等级: [0.7025, 0.7037) || 挂载数据: 无 ) 
│   ├── 探究Swing --> ( 难度等级: [0.7037, 0.7407) || 挂载数据: 无 ) 
│   │   ├── JLabel与ImageIcon --> ( 难度等级: [0.7037, 0.7078) || 挂载数据: qa: 2 ) 
│   │   ├── JTextField --> ( 难度等级: [0.7078, 0.7119) || 挂载数据: 无 ) 
│   │   ├── Swing按钮 --> ( 难度等级: [0.7119, 0.716) || 挂载数据: 无 ) 
│   │   │   ├── JButton --> ( 难度等级: [0.7119, 0.713) || 挂载数据: qa: 3 ) 
│   │   │   ├── JToggleButton --> ( 难度等级: [0.713, 0.714) || 挂载数据: 无 ) 
│   │   │   ├── 复选框 --> ( 难度等级: [0.714, 0.715) || 挂载数据: 无 ) 
│   │   │   └── 单选按钮 --> ( 难度等级: [0.715, 0.716) || 挂载数据: qa: 10 ) 
│   │   ├── JTabbedPane --> ( 难度等级: [0.716, 0.7202) || 挂载数据: 无 ) 
│   │   ├── JScrollPane --> ( 难度等级: [0.7202, 0.7243) || 挂载数据: 无 ) 
│   │   ├── JList --> ( 难度等级: [0.7243, 0.7284) || 挂载数据: 无 ) 
│   │   ├── JComboBox --> ( 难度等级: [0.7284, 0.7325) || 挂载数据: qa: 1 ) 
│   │   ├── 树 --> ( 难度等级: [0.7325, 0.7366) || 挂载数据: 无 ) 
│   │   └── JTable --> ( 难度等级: [0.7366, 0.7407) || 挂载数据: qa: 6 ) 
│   ├── Swing菜单简介 --> ( 难度等级: [0.7407, 0.7778) || 挂载数据: 无 ) 
│   │   ├── 菜单的基础知识 --> ( 难度等级: [0.7407, 0.7441) || 挂载数据: 无 ) 
│   │   ├── JMenuBar、JMenu和JMenuItem概述 --> ( 难度等级: [0.7441, 0.7475) || 挂载数据: 无 ) 
│   │   │   ├── JMenuBar --> ( 难度等级: [0.7441, 0.7452) || 挂载数据: 无 ) 
│   │   │   ├── JMenu --> ( 难度等级: [0.7452, 0.7464) || 挂载数据: 无 ) 
│   │   │   └── JMenuItem --> ( 难度等级: [0.7464, 0.7475) || 挂载数据: 无 ) 
│   │   ├── 创建主菜单 --> ( 难度等级: [0.7475, 0.7508) || 挂载数据: 无 ) 
│   │   ├── 向菜单项添加助记符和加速键 --> ( 难度等级: [0.7508, 0.7542) || 挂载数据: 无 ) 
│   │   ├── 向菜单项添加图片和工具提示 --> ( 难度等级: [0.7542, 0.7576) || 挂载数据: 无 ) 
│   │   ├── 使用JRadioButtonMenuItem和JCheckBoxMenuItem --> ( 难度等级: [0.7576, 0.7609) || 挂载数据: 无 ) 
│   │   ├── 创建弹出菜单 --> ( 难度等级: [0.7609, 0.7643) || 挂载数据: 无 ) 
│   │   ├── 创建工具栏 --> ( 难度等级: [0.7643, 0.7677) || 挂载数据: 无 ) 
│   │   ├── 使用动作 --> ( 难度等级: [0.7677, 0.771) || 挂载数据: 无 ) 
│   │   ├── 完整演示MenuDemo程序 --> ( 难度等级: [0.771, 0.7744) || 挂载数据: 无 ) 
│   │   └── 继续探究Swing --> ( 难度等级: [0.7744, 0.7778) || 挂载数据: 无 ) 
│   ├── JavaFX GUI编程简介 --> ( 难度等级: [0.7778, 0.8148) || 挂载数据: 无 ) 
│   │   ├── JavaFX的基础概念 --> ( 难度等级: [0.7778, 0.7831) || 挂载数据: 无 ) 
│   │   │   ├── JavaFX包 --> ( 难度等级: [0.7778, 0.7787) || 挂载数据: qa: 10 ) 
│   │   │   ├── Stage和Scene类 --> ( 难度等级: [0.7787, 0.7795) || 挂载数据: 无 ) 
│   │   │   ├── 节点和场景图 --> ( 难度等级: [0.7795, 0.7804) || 挂载数据: 无 ) 
│   │   │   ├── 布局 --> ( 难度等级: [0.7804, 0.7813) || 挂载数据: 无 ) 
│   │   │   ├── Application类和生命周期方法 --> ( 难度等级: [0.7813, 0.7822) || 挂载数据: 无 ) 
│   │   │   └── 启动JavaFX应用程序 --> ( 难度等级: [0.7822, 0.7831) || 挂载数据: 无 ) 
│   │   ├── JavaFX应用程序的骨架 --> ( 难度等级: [0.7831, 0.7884) || 挂载数据: 无 ) 
│   │   ├── 编译和运行JavaFX程序 --> ( 难度等级: [0.7884, 0.7937) || 挂载数据: qa: 1 ) 
│   │   ├── 应用程序线程 --> ( 难度等级: [0.7937, 0.7989) || 挂载数据: 无 ) 
│   │   ├── 一个简单的JavaFX控件：Label --> ( 难度等级: [0.7989, 0.8042) || 挂载数据: 无 ) 
│   │   ├── 使用按钮和事件 --> ( 难度等级: [0.8042, 0.8095) || 挂载数据: 无 ) 
│   │   │   ├── 事件的基础知识 --> ( 难度等级: [0.8042, 0.806) || 挂载数据: qa: 2 ) 
│   │   │   ├── 按钮控件简介 --> ( 难度等级: [0.806, 0.8078) || 挂载数据: qa: 1 ) 
│   │   │   └── 演示事件处理和按钮 --> ( 难度等级: [0.8078, 0.8095) || 挂载数据: 无 ) 
│   │   └── 直接在画布上绘制 --> ( 难度等级: [0.8095, 0.8148) || 挂载数据: 无 ) 
│   ├── 探究JavaFX控件 --> ( 难度等级: [0.8148, 0.8519) || 挂载数据: 无 ) 
│   │   ├── 使用Image和ImageView --> ( 难度等级: [0.8148, 0.8179) || 挂载数据: qa: 2 ) 
│   │   │   ├── 向标签添加图片 --> ( 难度等级: [0.8148, 0.8164) || 挂载数据: qa: 2 ) 
│   │   │   └── 在按钮中使用图片 --> ( 难度等级: [0.8164, 0.8179) || 挂载数据: qa: 10 ) 
│   │   ├── ToggleButton --> ( 难度等级: [0.8179, 0.821) || 挂载数据: 无 ) 
│   │   ├── RadioButton --> ( 难度等级: [0.821, 0.8241) || 挂载数据: 无 ) 
│   │   │   ├── 处理开关组中的变化事件 --> ( 难度等级: [0.821, 0.8225) || 挂载数据: 无 ) 
│   │   │   └── 处理单选按钮的另一种方式 --> ( 难度等级: [0.8225, 0.8241) || 挂载数据: 无 ) 
│   │   ├── CheckBox --> ( 难度等级: [0.8241, 0.8272) || 挂载数据: qa: 2 ) 
│   │   ├── ListView --> ( 难度等级: [0.8272, 0.8302) || 挂载数据: 无 ) 
│   │   │   ├── ListView的滚动条 --> ( 难度等级: [0.8272, 0.8287) || 挂载数据: qa: 5 ) 
│   │   │   └── 启用多项选择 --> ( 难度等级: [0.8287, 0.8302) || 挂载数据: 无 ) 
│   │   ├── ComboBox --> ( 难度等级: [0.8302, 0.8333) || 挂载数据: qa: 2 ) 
│   │   ├── TextField --> ( 难度等级: [0.8333, 0.8364) || 挂载数据: 无 ) 
│   │   ├── ScrollPane --> ( 难度等级: [0.8364, 0.8395) || 挂载数据: 无 ) 
│   │   ├── TreeView --> ( 难度等级: [0.8395, 0.8426) || 挂载数据: 无 ) 
│   │   ├── 效果和变换简介 --> ( 难度等级: [0.8426, 0.8457) || 挂载数据: 无 ) 
│   │   │   ├── 效果 --> ( 难度等级: [0.8426, 0.8436) || 挂载数据: qa: 2 ) 
│   │   │   ├── 变换 --> ( 难度等级: [0.8436, 0.8447) || 挂载数据: 无 ) 
│   │   │   └── 演示效果和变换 --> ( 难度等级: [0.8447, 0.8457) || 挂载数据: 无 ) 
│   │   ├── 添加工具提示 --> ( 难度等级: [0.8457, 0.8488) || 挂载数据: 无 ) 
│   │   └── 禁用控件 --> ( 难度等级: [0.8488, 0.8519) || 挂载数据: 无 ) 
│   ├── JavaFX菜单简介 --> ( 难度等级: [0.8519, 0.8889) || 挂载数据: 无 ) 
│   │   ├── 菜单的基础知识 --> ( 难度等级: [0.8519, 0.8556) || 挂载数据: 无 ) 
│   │   ├── MenuBar、Menu和MenuItem概述 --> ( 难度等级: [0.8556, 0.8593) || 挂载数据: 无 ) 
│   │   │   ├── MenuBar --> ( 难度等级: [0.8556, 0.8568) || 挂载数据: 无 ) 
│   │   │   ├── Menu --> ( 难度等级: [0.8568, 0.858) || 挂载数据: qa: 2 ) 
│   │   │   └── MenuItem --> ( 难度等级: [0.858, 0.8593) || 挂载数据: 无 ) 
│   │   ├── 创建主菜单 --> ( 难度等级: [0.8593, 0.863) || 挂载数据: 无 ) 
│   │   ├── 向菜单项添加助记符和加速键 --> ( 难度等级: [0.863, 0.8667) || 挂载数据: 无 ) 
│   │   ├── 向菜单项添加图片 --> ( 难度等级: [0.8667, 0.8704) || 挂载数据: 无 ) 
│   │   ├── 使用RadioMenuItem和CheckMenuItem --> ( 难度等级: [0.8704, 0.8741) || 挂载数据: 无 ) 
│   │   ├── 创建上下文菜单 --> ( 难度等级: [0.8741, 0.8778) || 挂载数据: 无 ) 
│   │   ├── 创建工具栏 --> ( 难度等级: [0.8778, 0.8815) || 挂载数据: 无 ) 
│   │   ├── 完整的MenuDemo程序 --> ( 难度等级: [0.8815, 0.8852) || 挂载数据: 无 ) 
│   │   └── 继续探究JavaFX --> ( 难度等级: [0.8852, 0.8889) || 挂载数据: 无 ) 
│   ├── Java Bean --> ( 难度等级: [0.8889, 0.9259) || 挂载数据: 无 ) 
│   │   ├── Java Bean是什么 --> ( 难度等级: [0.8889, 0.8935) || 挂载数据: 无 ) 
│   │   ├── Java Bean的优势 --> ( 难度等级: [0.8935, 0.8981) || 挂载数据: 无 ) 
│   │   ├── 内省 --> ( 难度等级: [0.8981, 0.9028) || 挂载数据: 无 ) 
│   │   │   ├── 属性的设计模式 --> ( 难度等级: [0.8981, 0.8993) || 挂载数据: 无 ) 
│   │   │   ├── 事件的设计模式 --> ( 难度等级: [0.8993, 0.9005) || 挂载数据: qa: 5 ) 
│   │   │   ├── 方法与设计模式 --> ( 难度等级: [0.9005, 0.9016) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建型模式 --> ( 难度等级: [0.9005, 0.9008) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 工厂方法 --> ( 难度等级: [0.9005, 0.9005) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 抽象工厂 --> ( 难度等级: [0.9005, 0.9006) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 生成器 --> ( 难度等级: [0.9006, 0.9007) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 原型 --> ( 难度等级: [0.9007, 0.9008) || 挂载数据: 无 ) 
│   │   │   │   │   └── 单例 --> ( 难度等级: [0.9008, 0.9008) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 结构型模式 --> ( 难度等级: [0.9008, 0.9012) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 适配器 --> ( 难度等级: [0.9008, 0.9009) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 桥接 --> ( 难度等级: [0.9009, 0.901) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 组合 --> ( 难度等级: [0.901, 0.901) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 装饰器 --> ( 难度等级: [0.901, 0.9011) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 外观 --> ( 难度等级: [0.9011, 0.9011) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 享元 --> ( 难度等级: [0.9011, 0.9012) || 挂载数据: 无 ) 
│   │   │   │   │   └── 代理 --> ( 难度等级: [0.9012, 0.9012) || 挂载数据: 无 ) 
│   │   │   │   └── 行为型模式 --> ( 难度等级: [0.9012, 0.9016) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 责任链 --> ( 难度等级: [0.9012, 0.9013) || 挂载数据: 无 ) 
│   │   │   │       ├── 命令 --> ( 难度等级: [0.9013, 0.9013) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 解释器 --> ( 难度等级: [0.9013, 0.9013) || 挂载数据: 无 ) 
│   │   │   │       ├── 迭代器 --> ( 难度等级: [0.9013, 0.9014) || 挂载数据: 无 ) 
│   │   │   │       ├── 中介 --> ( 难度等级: [0.9014, 0.9014) || 挂载数据: 无 ) 
│   │   │   │       ├── 备忘录 --> ( 难度等级: [0.9014, 0.9014) || 挂载数据: 无 ) 
│   │   │   │       ├── 观察者 --> ( 难度等级: [0.9014, 0.9015) || 挂载数据: 无 ) 
│   │   │   │       ├── 状态 --> ( 难度等级: [0.9015, 0.9015) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 策略 --> ( 难度等级: [0.9015, 0.9016) || 挂载数据: 无 ) 
│   │   │   │       ├── 模板方法 --> ( 难度等级: [0.9016, 0.9016) || 挂载数据: qa: 1 ) 
│   │   │   │       └── 访问者 --> ( 难度等级: [0.9016, 0.9016) || 挂载数据: 无 ) 
│   │   │   └── 使用BeanInfo接口 --> ( 难度等级: [0.9016, 0.9028) || 挂载数据: qa: 1 ) 
│   │   ├── 绑定属性与约束属性 --> ( 难度等级: [0.9028, 0.9074) || 挂载数据: 无 ) 
│   │   ├── 持久性 --> ( 难度等级: [0.9074, 0.912) || 挂载数据: 无 ) 
│   │   ├── 定制器 --> ( 难度等级: [0.912, 0.9167) || 挂载数据: 无 ) 
│   │   ├── Java Bean API --> ( 难度等级: [0.9167, 0.9213) || 挂载数据: 无 ) 
│   │   │   ├── Introspector类 --> ( 难度等级: [0.9167, 0.9178) || 挂载数据: 无 ) 
│   │   │   ├── PropertyDescriptor类 --> ( 难度等级: [0.9178, 0.919) || 挂载数据: 无 ) 
│   │   │   ├── EventSetDescriptor类 --> ( 难度等级: [0.919, 0.9201) || 挂载数据: 无 ) 
│   │   │   └── MethodDescriptor类 --> ( 难度等级: [0.9201, 0.9213) || 挂载数据: 无 ) 
│   │   └── 一个Bean示例 --> ( 难度等级: [0.9213, 0.9259) || 挂载数据: 无 ) 
│   ├── servlet --> ( 难度等级: [0.9259, 0.963) || 挂载数据: qa: 1 ) 
│   │   ├── 背景 --> ( 难度等级: [0.9259, 0.929) || 挂载数据: qa: 1 ) 
│   │   ├── servelet的生命周期 --> ( 难度等级: [0.929, 0.9321) || 挂载数据: qa: 1 ) 
│   │   ├── servlet开发选项 --> ( 难度等级: [0.9321, 0.9352) || 挂载数据: 无 ) 
│   │   ├── 使用Tomcat --> ( 难度等级: [0.9352, 0.9383) || 挂载数据: qa: 1 ) 
│   │   ├── 一个简单的servlet --> ( 难度等级: [0.9383, 0.9414) || 挂载数据: 无 ) 
│   │   │   ├── 创建和编译servlet源代码 --> ( 难度等级: [0.9383, 0.9393) || 挂载数据: qa: 10 ) 
│   │   │   ├── 启动Tomcat --> ( 难度等级: [0.9393, 0.9403) || 挂载数据: qa: 10 ) 
│   │   │   └── 启动Web浏览器并请求servlet --> ( 难度等级: [0.9403, 0.9414) || 挂载数据: qa: 8 ) 
│   │   ├── Servlet API --> ( 难度等级: [0.9414, 0.9444) || 挂载数据: 无 ) 
│   │   ├── javax.servlet包 --> ( 难度等级: [0.9444, 0.9475) || 挂载数据: qa: 1 ) 
│   │   │   ├── Servlet接口 --> ( 难度等级: [0.9444, 0.9448) || 挂载数据: qa: 1 ) 
│   │   │   ├── ServletConfig接口 --> ( 难度等级: [0.9448, 0.9451) || 挂载数据: 无 ) 
│   │   │   ├── ServletContext接口 --> ( 难度等级: [0.9451, 0.9455) || 挂载数据: qa: 2 ) 
│   │   │   ├── ServletRequest接口 --> ( 难度等级: [0.9455, 0.9458) || 挂载数据: qa: 1 ) 
│   │   │   ├── ServletResponse接口 --> ( 难度等级: [0.9458, 0.9462) || 挂载数据: qa: 1 ) 
│   │   │   ├── GenericServlet类 --> ( 难度等级: [0.9462, 0.9465) || 挂载数据: qa: 1 ) 
│   │   │   ├── ServletInputStream类 --> ( 难度等级: [0.9465, 0.9468) || 挂载数据: 无 ) 
│   │   │   ├── ServletOutputStream类 --> ( 难度等级: [0.9468, 0.9472) || 挂载数据: 无 ) 
│   │   │   └── servlet异常类 --> ( 难度等级: [0.9472, 0.9475) || 挂载数据: qa: 4 ) 
│   │   ├── 读取servlet参数 --> ( 难度等级: [0.9475, 0.9506) || 挂载数据: 无 ) 
│   │   ├── javax.servlet.http包 --> ( 难度等级: [0.9506, 0.9537) || 挂载数据: 无 ) 
│   │   │   ├── HttpServletRequest接口 --> ( 难度等级: [0.9506, 0.9512) || 挂载数据: qa: 1 ) 
│   │   │   ├── HttpServletResponse接口 --> ( 难度等级: [0.9512, 0.9519) || 挂载数据: 无 ) 
│   │   │   ├── HttpSession接口 --> ( 难度等级: [0.9519, 0.9525) || 挂载数据: 无 ) 
│   │   │   ├── Cookie类 --> ( 难度等级: [0.9525, 0.9531) || 挂载数据: qa: 6 ) 
│   │   │   └── HttpServlet类 --> ( 难度等级: [0.9531, 0.9537) || 挂载数据: qa: 2 ) 
│   │   ├── 处理HTTP请求和响应 --> ( 难度等级: [0.9537, 0.9568) || 挂载数据: 无 ) 
│   │   │   ├── 处理HTTP GET请求 --> ( 难度等级: [0.9537, 0.9552) || 挂载数据: qa: 10 ) 
│   │   │   └── 处理HTTP POST请求 --> ( 难度等级: [0.9552, 0.9568) || 挂载数据: qa: 10 ) 
│   │   ├── 使用cookie --> ( 难度等级: [0.9568, 0.9599) || 挂载数据: 无 ) 
│   │   └── 会话跟踪 --> ( 难度等级: [0.9599, 0.963) || 挂载数据: qa: 3 ) 
│   └── 其他 --> ( 难度等级: [0.963, 1.0) || 挂载数据: 无 ) 
│       ├── 入门和技术基础 --> ( 难度等级: [0.963, 0.9644) || 挂载数据: 无 ) 
│       │   ├── 认识SSM框架和Redis --> ( 难度等级: [0.963, 0.9637) || 挂载数据: 无 ) 
│       │   │   ├── Spring框架 --> ( 难度等级: [0.963, 0.963) || 挂载数据: 无 ) 
│       │   │   │   ├── Spring IoC简介 --> ( 难度等级: [0.963, 0.963) || 挂载数据: 无 ) 
│       │   │   │   └── Spring AOP --> ( 难度等级: [0.963, 0.963) || 挂载数据: qa: 1 ) 
│       │   │   ├── MyBatis简介 --> ( 难度等级: [0.963, 0.9631) || 挂载数据: 无 ) 
│       │   │   │   ├── Hibernate简介 --> ( 难度等级: [0.963, 0.963) || 挂载数据: qa: 9 ) 
│       │   │   │   ├── MyBatis --> ( 难度等级: [0.963, 0.9631) || 挂载数据: qa: 1 ) 
│       │   │   │   └── Hibernate和MyBatis的区别 --> ( 难度等级: [0.9631, 0.9631) || 挂载数据: qa: 6 ) 
│       │   │   ├── Spring MVC简介 --> ( 难度等级: [0.9631, 0.9631) || 挂载数据: 无 ) 
│       │   │   ├── 最流行的NoSQL——Redis --> ( 难度等级: [0.9631, 0.9632) || 挂载数据: 无 ) 
│       │   │   ├── SSM+Redis结构框图及概述 --> ( 难度等级: [0.9632, 0.9632) || 挂载数据: qa: 10 ) 
│       │   │   ├── Redis概述 --> ( 难度等级: [0.9632, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis在Java Web中的应用 --> ( 难度等级: [0.9632, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   │   └── 高速读/写场合 --> ( 难度等级: [0.9632, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis基本安装和使用 --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 在Windows下安装Redis --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: qa: 3 ) 
│       │   │   │   │   └── 在Linux下安装Redis --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── Redis的Java API --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 在Java程序中使用Redis --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   │   └── 在Spring中使用Redis --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 简介Redis的6种数据类型 --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: 无 ) 
│       │   │   ├── Redis数据结构常用命令 --> ( 难度等级: [0.9633, 0.9634) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis数据结构——字符串 --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis数据结构——哈希 --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: qa: 5 ) 
│       │   │   │   ├── Redis数据结构——链表（linked-list） --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── Redis数据结构——集合 --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis数据结构——有序集合 --> ( 难度等级: [0.9633, 0.9634) || 挂载数据: 无 ) 
│       │   │   │   │   ├── Redis基础命令 --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   │   ├── spring-data-redis对有序集合的封装 --> ( 难度等级: [0.9633, 0.9633) || 挂载数据: 无 ) 
│       │   │   │   │   └── 使用Spring操作有序集合 --> ( 难度等级: [0.9633, 0.9634) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 基数——HyperLogLog --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   ├── Redis的一些常用技术 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis的基础事务 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   │   ├── 探索Redis事务回滚 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 使用watch命令监控事务 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   │   ├── 流水线（pipelined） --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   │   ├── 发布订阅 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 超时命令 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   │   └── 使用Lua语言 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   │       ├── 执行输入Lua程序代码 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   │       └── 执行Lua文件 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: qa: 3 ) 
│       │   │   ├── Redis配置 --> ( 难度等级: [0.9634, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis基础配置文件 --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis备份（持久化） --> ( 难度等级: [0.9634, 0.9634) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis内存回收策略 --> ( 难度等级: [0.9634, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   ├── 复制 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: qa: 2 ) 
│       │   │   │   │   ├── 主从同步基础概念 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   │   ├── Redis主从同步配置 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   │   └── Redis主从同步的过程 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   └── 哨兵（Sentinel）模式 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │       ├── 哨兵模式概述 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: qa: 1 ) 
│       │   │   │       ├── 搭建哨兵模式 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │       ├── 在Java中使用哨兵模式 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │       └── 哨兵模式的其他配置项 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   ├── 使用redis-cli --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   ├── 安全设置 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 基本操作 --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   ├── keys --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis List --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   ├── Redis Hash --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── Set --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   │   └── Pub/Sub --> ( 难度等级: [0.9635, 0.9635) || 挂载数据: 无 ) 
│       │   │   ├── Spring Boot集成Redis --> ( 难度等级: [0.9635, 0.9636) || 挂载数据: 无 ) 
│       │   │   ├── 使用StringRedisTemplate --> ( 难度等级: [0.9636, 0.9636) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── opsFor --> ( 难度等级: [0.9636, 0.9636) || 挂载数据: 无 ) 
│       │   │   │   ├── 绑定Key的操作 --> ( 难度等级: [0.9636, 0.9636) || 挂载数据: 无 ) 
│       │   │   │   └── RedisConnection --> ( 难度等级: [0.9636, 0.9636) || 挂载数据: 无 ) 
│       │   │   └── 序列化策略 --> ( 难度等级: [0.9636, 0.9637) || 挂载数据: 无 ) 
│       │   │       ├── 默认序列化策略 --> ( 难度等级: [0.9636, 0.9637) || 挂载数据: 无 ) 
│       │   │       └── 自定义序列化策略 --> ( 难度等级: [0.9637, 0.9637) || 挂载数据: 无 ) 
│       │   └── Java设计模式 --> ( 难度等级: [0.9637, 0.9644) || 挂载数据: 无 ) 
│       │       ├── Java反射技术 --> ( 难度等级: [0.9637, 0.9639) || 挂载数据: 无 ) 
│       │       │   ├── 通过反射构建对象 --> ( 难度等级: [0.9637, 0.9638) || 挂载数据: 无 ) 
│       │       │   └── 反射方法 --> ( 难度等级: [0.9638, 0.9639) || 挂载数据: qa: 9 ) 
│       │       ├── 动态代理模式和责任链模式 --> ( 难度等级: [0.9639, 0.964) || 挂载数据: 无 ) 
│       │       │   ├── JDK动态代理 --> ( 难度等级: [0.9639, 0.9639) || 挂载数据: 无 ) 
│       │       │   ├── CGLIB动态代理 --> ( 难度等级: [0.9639, 0.9639) || 挂载数据: qa: 6 ) 
│       │       │   ├── 拦截器 --> ( 难度等级: [0.9639, 0.964) || 挂载数据: 无 ) 
│       │       │   │   ├── 拦截器的定义 --> ( 难度等级: [0.9639, 0.9639) || 挂载数据: qa: 4 ) 
│       │       │   │   ├── 拦截器的执行流程 --> ( 难度等级: [0.9639, 0.9639) || 挂载数据: 无 ) 
│       │       │   │   ├── 开发拦截器 --> ( 难度等级: [0.9639, 0.964) || 挂载数据: qa: 5 ) 
│       │       │   │   └── 多个拦截器执行的顺序 --> ( 难度等级: [0.964, 0.964) || 挂载数据: qa: 5 ) 
│       │       │   └── 责任链模式 --> ( 难度等级: [0.964, 0.964) || 挂载数据: qa: 2 ) 
│       │       ├── 观察者（Observer）模式 --> ( 难度等级: [0.964, 0.9641) || 挂载数据: 无 ) 
│       │       │   └── 概述 --> ( 难度等级: [0.964, 0.9641) || 挂载数据: 无 ) 
│       │       ├── 工厂模式和抽象工厂模式 --> ( 难度等级: [0.9641, 0.9643) || 挂载数据: 无 ) 
│       │       │   ├── 普通工厂（Simple Factory）模式 --> ( 难度等级: [0.9641, 0.9642) || 挂载数据: 无 ) 
│       │       │   └── 抽象工厂（Abstract Factory）模式 --> ( 难度等级: [0.9642, 0.9643) || 挂载数据: qa: 3 ) 
│       │       └── 建造者（Builder）模式 --> ( 难度等级: [0.9643, 0.9644) || 挂载数据: qa: 1 ) 
│       │           └── 概述 --> ( 难度等级: [0.9643, 0.9644) || 挂载数据: 无 ) 
│       ├── 互联网持久框架——MyBatis --> ( 难度等级: [0.9644, 0.9659) || 挂载数据: 无 ) 
│       │   ├── 认识MyBatis核心组件 --> ( 难度等级: [0.9644, 0.9647) || 挂载数据: 无 ) 
│       │   │   ├── 准备MyBatis环境 --> ( 难度等级: [0.9644, 0.9645) || 挂载数据: qa: 10 ) 
│       │   │   ├── MyBatis的核心组件 --> ( 难度等级: [0.9645, 0.9645) || 挂载数据: 无 ) 
│       │   │   ├── SqlSessionFactory（工厂接口） --> ( 难度等级: [0.9645, 0.9646) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用XML构建SqlSessionFactory --> ( 难度等级: [0.9645, 0.9645) || 挂载数据: 无 ) 
│       │   │   │   └── 使用代码创建SqlSessionFactory --> ( 难度等级: [0.9645, 0.9646) || 挂载数据: 无 ) 
│       │   │   ├── SqlSession --> ( 难度等级: [0.9646, 0.9646) || 挂载数据: 无 ) 
│       │   │   ├── 映射器 --> ( 难度等级: [0.9646, 0.9647) || 挂载数据: 无 ) 
│       │   │   │   ├── 用XML实现映射器 --> ( 难度等级: [0.9646, 0.9646) || 挂载数据: 无 ) 
│       │   │   │   ├── 注解实现映射器 --> ( 难度等级: [0.9646, 0.9646) || 挂载数据: 无 ) 
│       │   │   │   ├── SqlSession发送SQL --> ( 难度等级: [0.9646, 0.9646) || 挂载数据: 无 ) 
│       │   │   │   ├── 用Mapper接口发送SQL --> ( 难度等级: [0.9646, 0.9646) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 对比两种发送SQL方式 --> ( 难度等级: [0.9646, 0.9647) || 挂载数据: 无 ) 
│       │   │   └── 生命周期 --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: 无 ) 
│       │   │       ├── SqlSessionFactoryBuilder --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: 无 ) 
│       │   │       ├── SqlSessionFactory --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: 无 ) 
│       │   │       ├── SqlSession --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: 无 ) 
│       │   │       └── Mapper --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: qa: 4 ) 
│       │   ├── MyBatis配置 --> ( 难度等级: [0.9647, 0.9649) || 挂载数据: 无 ) 
│       │   │   ├── properties属性 --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: 无 ) 
│       │   │   │   ├── property子元素 --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用properties文件 --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 使用程序传递方式传递参数 --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: qa: 2 ) 
│       │   │   ├── settings设置 --> ( 难度等级: [0.9647, 0.9647) || 挂载数据: 无 ) 
│       │   │   ├── typeAliases别名 --> ( 难度等级: [0.9647, 0.9648) || 挂载数据: 无 ) 
│       │   │   │   ├── 系统定义别名 --> ( 难度等级: [0.9647, 0.9648) || 挂载数据: 无 ) 
│       │   │   │   └── 自定义别名 --> ( 难度等级: [0.9648, 0.9648) || 挂载数据: qa: 1 ) 
│       │   │   ├── typeHandler类型转换器 --> ( 难度等级: [0.9648, 0.9648) || 挂载数据: 无 ) 
│       │   │   │   ├── 系统定义的typeHandler --> ( 难度等级: [0.9648, 0.9648) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义typeHandler --> ( 难度等级: [0.9648, 0.9648) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 枚举typeHandler --> ( 难度等级: [0.9648, 0.9648) || 挂载数据: 无 ) 
│       │   │   │   └── 文件操作 --> ( 难度等级: [0.9648, 0.9648) || 挂载数据: 无 ) 
│       │   │   ├── ObjectFactory（对象工厂） --> ( 难度等级: [0.9648, 0.9648) || 挂载数据: 无 ) 
│       │   │   ├── 插件 --> ( 难度等级: [0.9648, 0.9649) || 挂载数据: 无 ) 
│       │   │   ├── environments（运行环境） --> ( 难度等级: [0.9649, 0.9649) || 挂载数据: 无 ) 
│       │   │   │   ├── transactionManager（事务管理器） --> ( 难度等级: [0.9649, 0.9649) || 挂载数据: 无 ) 
│       │   │   │   └── environment数据源环境 --> ( 难度等级: [0.9649, 0.9649) || 挂载数据: qa: 2 ) 
│       │   │   ├── databaseIdProvider数据库厂商标识 --> ( 难度等级: [0.9649, 0.9649) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用系统默认的databaseIdProvider --> ( 难度等级: [0.9649, 0.9649) || 挂载数据: 无 ) 
│       │   │   │   └── 不使用系统规则 --> ( 难度等级: [0.9649, 0.9649) || 挂载数据: 无 ) 
│       │   │   └── 引入映射器的方法 --> ( 难度等级: [0.9649, 0.9649) || 挂载数据: 无 ) 
│       │   ├── 映射器 --> ( 难度等级: [0.9649, 0.9652) || 挂载数据: 无 ) 
│       │   │   ├── select元素——查询语句 --> ( 难度等级: [0.9649, 0.965) || 挂载数据: 无 ) 
│       │   │   │   ├── 简单的select元素的应用 --> ( 难度等级: [0.9649, 0.9649) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 自动映射和驼峰映射 --> ( 难度等级: [0.9649, 0.9649) || 挂载数据: 无 ) 
│       │   │   │   ├── 传递多个参数 --> ( 难度等级: [0.9649, 0.965) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用resultMap映射结果集 --> ( 难度等级: [0.965, 0.965) || 挂载数据: 无 ) 
│       │   │   │   └── 分页参数RowBounds --> ( 难度等级: [0.965, 0.965) || 挂载数据: 无 ) 
│       │   │   ├── insert元素——插入语句 --> ( 难度等级: [0.965, 0.965) || 挂载数据: 无 ) 
│       │   │   │   ├── 简单的insert语句的应用 --> ( 难度等级: [0.965, 0.965) || 挂载数据: qa: 7 ) 
│       │   │   │   ├── 主键回填 --> ( 难度等级: [0.965, 0.965) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 自定义主键 --> ( 难度等级: [0.965, 0.965) || 挂载数据: 无 ) 
│       │   │   ├── update元素和delete元素 --> ( 难度等级: [0.965, 0.965) || 挂载数据: qa: 1 ) 
│       │   │   ├── sql元素 --> ( 难度等级: [0.965, 0.965) || 挂载数据: 无 ) 
│       │   │   ├── 参数 --> ( 难度等级: [0.965, 0.9651) || 挂载数据: 无 ) 
│       │   │   │   ├── 存储过程参数支持 --> ( 难度等级: [0.965, 0.9651) || 挂载数据: qa: 2 ) 
│       │   │   │   └── 特殊字符串的替换和处理（#和$） --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: qa: 1 ) 
│       │   │   ├── resultMap元素 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: 无 ) 
│       │   │   │   ├── resultMap元素的构成 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: qa: 9 ) 
│       │   │   │   ├── 使用map存储结果集 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: 无 ) 
│       │   │   │   └── 使用POJO存储结果集 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: 无 ) 
│       │   │   ├── 级联 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: 无 ) 
│       │   │   │   ├── MyBatis中的级联 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: 无 ) 
│       │   │   │   ├── 建立POJO --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 配置映射文件 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: 无 ) 
│       │   │   │   ├── 延迟加载 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: 无 ) 
│       │   │   │   ├── 另一种级联 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 多对多级联 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: 无 ) 
│       │   │   ├── 缓存 --> ( 难度等级: [0.9651, 0.9652) || 挂载数据: 无 ) 
│       │   │   │   ├── 一级缓存和二级缓存 --> ( 难度等级: [0.9651, 0.9651) || 挂载数据: qa: 4 ) 
│       │   │   │   └── 缓存配置项、自定义和引用 --> ( 难度等级: [0.9651, 0.9652) || 挂载数据: 无 ) 
│       │   │   └── 存储过程 --> ( 难度等级: [0.9652, 0.9652) || 挂载数据: 无 ) 
│       │   │       ├── IN和OUT参数存储过程 --> ( 难度等级: [0.9652, 0.9652) || 挂载数据: qa: 10 ) 
│       │   │       └── 游标的使用 --> ( 难度等级: [0.9652, 0.9652) || 挂载数据: 无 ) 
│       │   ├── 动态SQL --> ( 难度等级: [0.9652, 0.9654) || 挂载数据: qa: 1 ) 
│       │   │   ├── if元素 --> ( 难度等级: [0.9652, 0.9652) || 挂载数据: qa: 1 ) 
│       │   │   ├── choose、when、otherwise元素 --> ( 难度等级: [0.9652, 0.9653) || 挂载数据: 无 ) 
│       │   │   ├── trim、where、set元素 --> ( 难度等级: [0.9653, 0.9653) || 挂载数据: qa: 4 ) 
│       │   │   ├── foreach元素 --> ( 难度等级: [0.9653, 0.9653) || 挂载数据: 无 ) 
│       │   │   ├── 用test的属性判断字符串 --> ( 难度等级: [0.9653, 0.9654) || 挂载数据: qa: 3 ) 
│       │   │   └── bind元素 --> ( 难度等级: [0.9654, 0.9654) || 挂载数据: 无 ) 
│       │   ├── MyBatis的解析和运行原理 --> ( 难度等级: [0.9654, 0.9657) || 挂载数据: 无 ) 
│       │   │   ├── 构建SqlSessionFactory过程 --> ( 难度等级: [0.9654, 0.9656) || 挂载数据: 无 ) 
│       │   │   │   ├── 构建Configuration --> ( 难度等级: [0.9654, 0.9655) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 构建映射器的内部组成 --> ( 难度等级: [0.9655, 0.9655) || 挂载数据: 无 ) 
│       │   │   │   └── 构建SqlSessionFactory --> ( 难度等级: [0.9655, 0.9656) || 挂载数据: qa: 1 ) 
│       │   │   └── SqlSession运行过程 --> ( 难度等级: [0.9656, 0.9657) || 挂载数据: qa: 10 ) 
│       │   │       ├── 映射器（Mapper）的动态代理 --> ( 难度等级: [0.9656, 0.9656) || 挂载数据: 无 ) 
│       │   │       └── SqlSession下的四大对象 --> ( 难度等级: [0.9656, 0.9657) || 挂载数据: 无 ) 
│       │   └── 插件 --> ( 难度等级: [0.9657, 0.9659) || 挂载数据: 无 ) 
│       │       ├── 插件接口 --> ( 难度等级: [0.9657, 0.9657) || 挂载数据: 无 ) 
│       │       ├── 插件的初始化 --> ( 难度等级: [0.9657, 0.9658) || 挂载数据: qa: 8 ) 
│       │       ├── 插件的代理和反射设计 --> ( 难度等级: [0.9658, 0.9659) || 挂载数据: 无 ) 
│       │       └── 常用的工具类——MetaObject --> ( 难度等级: [0.9659, 0.9659) || 挂载数据: 无 ) 
│       ├── Spring基础 --> ( 难度等级: [0.9659, 0.9674) || 挂载数据: 无 ) 
│       │   ├── Spring IoC的概念 --> ( 难度等级: [0.9659, 0.9662) || 挂载数据: 无 ) 
│       │   │   ├── Spring的概述 --> ( 难度等级: [0.9659, 0.966) || 挂载数据: 无 ) 
│       │   │   │   └── Spring的简史 --> ( 难度等级: [0.9659, 0.966) || 挂载数据: qa: 10 ) 
│       │   │   ├── Spring IoC概述 --> ( 难度等级: [0.966, 0.9661) || 挂载数据: 无 ) 
│       │   │   │   ├── 主动创建对象 --> ( 难度等级: [0.966, 0.966) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 被动创建对象 --> ( 难度等级: [0.966, 0.9661) || 挂载数据: 无 ) 
│       │   │   │   └── Spring IoC阐述 --> ( 难度等级: [0.9661, 0.9661) || 挂载数据: 无 ) 
│       │   │   └── Spring IoC容器 --> ( 难度等级: [0.9661, 0.9662) || 挂载数据: 无 ) 
│       │   │       ├── Spring IoC容器的设计 --> ( 难度等级: [0.9661, 0.9661) || 挂载数据: 无 ) 
│       │   │       ├── Spring IoC容器的初始化和依赖注入 --> ( 难度等级: [0.9661, 0.9661) || 挂载数据: 无 ) 
│       │   │       └── Spring Bean的生命周期 --> ( 难度等级: [0.9661, 0.9662) || 挂载数据: 无 ) 
│       │   ├── 装配Spring Bean --> ( 难度等级: [0.9662, 0.9664) || 挂载数据: 无 ) 
│       │   │   ├── 依赖注入的3种方式 --> ( 难度等级: [0.9662, 0.9662) || 挂载数据: 无 ) 
│       │   │   │   ├── 构造器注入 --> ( 难度等级: [0.9662, 0.9662) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用setter注入 --> ( 难度等级: [0.9662, 0.9662) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 接口注入 --> ( 难度等级: [0.9662, 0.9662) || 挂载数据: qa: 1 ) 
│       │   │   ├── 装配Bean概述 --> ( 难度等级: [0.9662, 0.9662) || 挂载数据: 无 ) 
│       │   │   ├── 通过XML配置装配Bean --> ( 难度等级: [0.9662, 0.9662) || 挂载数据: 无 ) 
│       │   │   │   ├── 装配简易值 --> ( 难度等级: [0.9662, 0.9662) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 装配集合 --> ( 难度等级: [0.9662, 0.9662) || 挂载数据: 无 ) 
│       │   │   │   └── 命名空间装配 --> ( 难度等级: [0.9662, 0.9662) || 挂载数据: 无 ) 
│       │   │   ├── 通过注解装配Bean --> ( 难度等级: [0.9662, 0.9663) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用@Component装配Bean --> ( 难度等级: [0.9662, 0.9663) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 自动装配——@Autowired --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: qa: 4 ) 
│       │   │   │   ├── 自动装配的歧义性（@Primary和@Qualifier） --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 装载带有参数的构造方法类 --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 使用@Bean装配Bean --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 注解自定义Bean的初始化和销毁方法 --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   ├── 装配的混合使用 --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   ├── 使用Profile --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用注解@Profile配置 --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用XML定义Profile --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   │   ├── 启动Profile --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   │   ├── 点睛 --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   │   └── 演示 --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   ├── 加载属性（properties）文件 --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用注解方式加载属性文件 --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: 无 ) 
│       │   │   │   └── 使用XML方式加载属性文件 --> ( 难度等级: [0.9663, 0.9663) || 挂载数据: qa: 4 ) 
│       │   │   ├── 条件化装配Bean --> ( 难度等级: [0.9663, 0.9664) || 挂载数据: 无 ) 
│       │   │   ├── Bean的作用域 --> ( 难度等级: [0.9664, 0.9664) || 挂载数据: 无 ) 
│       │   │   └── 使用Spring表达式（Spring EL） --> ( 难度等级: [0.9664, 0.9664) || 挂载数据: 无 ) 
│       │   │       ├── Spring EL相关的类 --> ( 难度等级: [0.9664, 0.9664) || 挂载数据: qa: 2 ) 
│       │   │       └── Spring EL运算 --> ( 难度等级: [0.9664, 0.9664) || 挂载数据: qa: 10 ) 
│       │   ├── 面向切面编程 --> ( 难度等级: [0.9664, 0.9667) || 挂载数据: 无 ) 
│       │   │   ├── 一个简单的约定游戏 --> ( 难度等级: [0.9664, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   ├── 约定规则 --> ( 难度等级: [0.9664, 0.9664) || 挂载数据: 无 ) 
│       │   │   │   ├── 读者的代码 --> ( 难度等级: [0.9664, 0.9664) || 挂载数据: 无 ) 
│       │   │   │   └── 笔者的代码 --> ( 难度等级: [0.9664, 0.9665) || 挂载数据: 无 ) 
│       │   │   ├── Spring AOP的基本概念 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   ├── AOP的概念和使用原因 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 面向切面编程的术语 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   └── Spring对AOP的支持 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   ├── 使用@AspectJ注解开发Spring AOP --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   ├── 选择切点 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   ├── 创建切面 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   ├── 连接点 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   ├── 测试AOP --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   │   ├── 装配AOP --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: qa: 10 ) 
│       │   │   │   │   ├── 使用注解装配AOP --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: qa: 1 ) 
│       │   │   │   │   └── AOP避坑指南 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   ├── 环绕通知 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 织入 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   ├── 给通知传递参数 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: 无 ) 
│       │   │   │   └── 引入 --> ( 难度等级: [0.9665, 0.9665) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用XML配置开发Spring AOP --> ( 难度等级: [0.9665, 0.9666) || 挂载数据: 无 ) 
│       │   │   │   ├── 前置通知、后置通知、返回通知和异常通知 --> ( 难度等级: [0.9665, 0.9666) || 挂载数据: 无 ) 
│       │   │   │   ├── 环绕通知 --> ( 难度等级: [0.9666, 0.9666) || 挂载数据: 无 ) 
│       │   │   │   ├── 给通知传递参数 --> ( 难度等级: [0.9666, 0.9666) || 挂载数据: 无 ) 
│       │   │   │   └── 引入 --> ( 难度等级: [0.9666, 0.9666) || 挂载数据: 无 ) 
│       │   │   ├── 经典Spring AOP应用程序 --> ( 难度等级: [0.9666, 0.9666) || 挂载数据: 无 ) 
│       │   │   └── 多个切面 --> ( 难度等级: [0.9666, 0.9667) || 挂载数据: 无 ) 
│       │   ├── Spring和数据库编程 --> ( 难度等级: [0.9667, 0.9669) || 挂载数据: 无 ) 
│       │   │   ├── 传统的JDBC代码的弊端 --> ( 难度等级: [0.9667, 0.9667) || 挂载数据: 无 ) 
│       │   │   ├── 配置数据库资源 --> ( 难度等级: [0.9667, 0.9668) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用简单数据库配置 --> ( 难度等级: [0.9667, 0.9667) || 挂载数据: qa: 4 ) 
│       │   │   │   ├── 使用第三方数据库连接池 --> ( 难度等级: [0.9667, 0.9668) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 使用JNDI数据库连接池 --> ( 难度等级: [0.9668, 0.9668) || 挂载数据: 无 ) 
│       │   │   ├── JDBC代码失控的解决方案——jdbcTemplate --> ( 难度等级: [0.9668, 0.9669) || 挂载数据: 无 ) 
│       │   │   │   ├── jdbcTemplate的增、删、查、改 --> ( 难度等级: [0.9668, 0.9668) || 挂载数据: qa: 5 ) 
│       │   │   │   ├── 执行多条SQL --> ( 难度等级: [0.9668, 0.9668) || 挂载数据: qa: 1 ) 
│       │   │   │   └── jdbcTemplate的源码分析 --> ( 难度等级: [0.9668, 0.9669) || 挂载数据: qa: 7 ) 
│       │   │   └── Spring的缺点 --> ( 难度等级: [0.9669, 0.9669) || 挂载数据: 无 ) 
│       │   ├── 深入Spring数据库事务管理 --> ( 难度等级: [0.9669, 0.9672) || 挂载数据: 无 ) 
│       │   │   ├── Spring数据库事务管理器的设计 --> ( 难度等级: [0.9669, 0.9669) || 挂载数据: 无 ) 
│       │   │   │   ├── 配置事务管理器 --> ( 难度等级: [0.9669, 0.9669) || 挂载数据: 无 ) 
│       │   │   │   └── 用Java配置方式实现Spring数据库事务 --> ( 难度等级: [0.9669, 0.9669) || 挂载数据: qa: 1 ) 
│       │   │   ├── 编程式事务 --> ( 难度等级: [0.9669, 0.967) || 挂载数据: 无 ) 
│       │   │   ├── 声明式事务 --> ( 难度等级: [0.967, 0.967) || 挂载数据: 无 ) 
│       │   │   │   ├── Transactional的配置项 --> ( 难度等级: [0.967, 0.967) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 使用XML进行配置事务管理器 --> ( 难度等级: [0.967, 0.967) || 挂载数据: 无 ) 
│       │   │   │   ├── 事务定义器 --> ( 难度等级: [0.967, 0.967) || 挂载数据: 无 ) 
│       │   │   │   └── 声明式事务的约定流程 --> ( 难度等级: [0.967, 0.967) || 挂载数据: qa: 1 ) 
│       │   │   ├── 数据库的相关知识 --> ( 难度等级: [0.967, 0.9671) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 数据库事务ACID特性 --> ( 难度等级: [0.967, 0.967) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 丢失更新 --> ( 难度等级: [0.967, 0.967) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 隔离级别 --> ( 难度等级: [0.967, 0.9671) || 挂载数据: 无 ) 
│       │   │   ├── 选择隔离级别和传播行为 --> ( 难度等级: [0.9671, 0.9671) || 挂载数据: 无 ) 
│       │   │   │   ├── 选择隔离级别 --> ( 难度等级: [0.9671, 0.9671) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 传播行为 --> ( 难度等级: [0.9671, 0.9671) || 挂载数据: 无 ) 
│       │   │   ├── 在Spring+MyBatis组合中使用事务 --> ( 难度等级: [0.9671, 0.9671) || 挂载数据: 无 ) 
│       │   │   └── 典型错误用法的剖析 --> ( 难度等级: [0.9671, 0.9672) || 挂载数据: 无 ) 
│       │   │       ├── 错误使用Service --> ( 难度等级: [0.9671, 0.9671) || 挂载数据: qa: 10 ) 
│       │   │       ├── 过长时间占用事务 --> ( 难度等级: [0.9671, 0.9671) || 挂载数据: 无 ) 
│       │   │       └── 错误捕捉异常 --> ( 难度等级: [0.9671, 0.9672) || 挂载数据: qa: 1 ) 
│       │   └── Spring基础配置 --> ( 难度等级: [0.9672, 0.9674) || 挂载数据: qa: 10 ) 
│       │       └── Java配置 --> ( 难度等级: [0.9672, 0.9674) || 挂载数据: 无 ) 
│       ├── Spring MVC框架 --> ( 难度等级: [0.9674, 0.9689) || 挂载数据: 无 ) 
│       │   ├── Spring MVC的初始化和流程 --> ( 难度等级: [0.9674, 0.9679) || 挂载数据: 无 ) 
│       │   │   ├── MVC设计概述 --> ( 难度等级: [0.9674, 0.9676) || 挂载数据: 无 ) 
│       │   │   │   ├── Spring MVC的架构 --> ( 难度等级: [0.9674, 0.9675) || 挂载数据: qa: 10 ) 
│       │   │   │   └── Spring MVC组件与流程 --> ( 难度等级: [0.9675, 0.9676) || 挂载数据: qa: 1 ) 
│       │   │   ├── Spring MVC初始化 --> ( 难度等级: [0.9676, 0.9677) || 挂载数据: 无 ) 
│       │   │   │   ├── 初始化Spring IoC上下文 --> ( 难度等级: [0.9676, 0.9676) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 初始化映射请求上下文 --> ( 难度等级: [0.9676, 0.9677) || 挂载数据: 无 ) 
│       │   │   │   └── 使用注解配置方式初始化 --> ( 难度等级: [0.9677, 0.9677) || 挂载数据: 无 ) 
│       │   │   └── Spring MVC开发流程详解 --> ( 难度等级: [0.9677, 0.9679) || 挂载数据: qa: 1 ) 
│       │   │       ├── 配置@RequestMapping --> ( 难度等级: [0.9677, 0.9678) || 挂载数据: 无 ) 
│       │   │       ├── 控制器的开发 --> ( 难度等级: [0.9678, 0.9678) || 挂载数据: qa: 10 ) 
│       │   │       └── 视图渲染 --> ( 难度等级: [0.9678, 0.9679) || 挂载数据: 无 ) 
│       │   ├── 深入Spring MVC组件开发 --> ( 难度等级: [0.9679, 0.9684) || 挂载数据: 无 ) 
│       │   │   ├── 控制器接收各类请求参数 --> ( 难度等级: [0.9679, 0.968) || 挂载数据: 无 ) 
│       │   │   │   ├── 接收普通请求参数 --> ( 难度等级: [0.9679, 0.9679) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 使用@RequestParam注解获取参数 --> ( 难度等级: [0.9679, 0.9679) || 挂载数据: qa: 4 ) 
│       │   │   │   ├── 使用URL传递参数 --> ( 难度等级: [0.9679, 0.9679) || 挂载数据: 无 ) 
│       │   │   │   ├── 传递JSON参数 --> ( 难度等级: [0.9679, 0.968) || 挂载数据: qa: 8 ) 
│       │   │   │   └── 接收列表数据和表单序列化 --> ( 难度等级: [0.968, 0.968) || 挂载数据: 无 ) 
│       │   │   ├── 重定向 --> ( 难度等级: [0.968, 0.968) || 挂载数据: qa: 2 ) 
│       │   │   ├── 保存并获取属性参数 --> ( 难度等级: [0.968, 0.9681) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 注解@RequestAttribute --> ( 难度等级: [0.968, 0.9681) || 挂载数据: 无 ) 
│       │   │   │   ├── 注解@SessionAttribute和注解@SessionAttributes --> ( 难度等级: [0.9681, 0.9681) || 挂载数据: 无 ) 
│       │   │   │   └── 注解@CookieValue和注解@RequestHeader --> ( 难度等级: [0.9681, 0.9681) || 挂载数据: 无 ) 
│       │   │   ├── 验证表单 --> ( 难度等级: [0.9681, 0.9682) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用JSR 303注解验证输入内容 --> ( 难度等级: [0.9681, 0.9681) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 使用验证器 --> ( 难度等级: [0.9681, 0.9682) || 挂载数据: qa: 10 ) 
│       │   │   ├── 数据模型 --> ( 难度等级: [0.9682, 0.9683) || 挂载数据: 无 ) 
│       │   │   ├── 视图和视图解析器 --> ( 难度等级: [0.9683, 0.9683) || 挂载数据: 无 ) 
│       │   │   │   ├── 视图 --> ( 难度等级: [0.9683, 0.9683) || 挂载数据: qa: 3 ) 
│       │   │   │   └── 视图解析器 --> ( 难度等级: [0.9683, 0.9683) || 挂载数据: 无 ) 
│       │   │   └── 上传文件 --> ( 难度等级: [0.9683, 0.9684) || 挂载数据: qa: 1 ) 
│       │   │       ├── MultipartResolver概述 --> ( 难度等级: [0.9683, 0.9684) || 挂载数据: 无 ) 
│       │   │       └── 提交上传文件表单 --> ( 难度等级: [0.9684, 0.9684) || 挂载数据: qa: 10 ) 
│       │   └── Spring MVC高级应用 --> ( 难度等级: [0.9684, 0.9689) || 挂载数据: 无 ) 
│       │       ├── Spring MVC的数据转换和格式化 --> ( 难度等级: [0.9684, 0.9685) || 挂载数据: 无 ) 
│       │       │   ├── HttpMessageConverter和JSON消息转换器 --> ( 难度等级: [0.9684, 0.9684) || 挂载数据: qa: 6 ) 
│       │       │   ├── 一对一转换器（Converter） --> ( 难度等级: [0.9684, 0.9685) || 挂载数据: qa: 1 ) 
│       │       │   ├── 数组和集合转换器GenericConverter --> ( 难度等级: [0.9685, 0.9685) || 挂载数据: qa: 1 ) 
│       │       │   └── 使用格式化器（Formatter） --> ( 难度等级: [0.9685, 0.9685) || 挂载数据: 无 ) 
│       │       ├── 为控制器添加通知 --> ( 难度等级: [0.9685, 0.9686) || 挂载数据: 无 ) 
│       │       ├── 处理异常 --> ( 难度等级: [0.9686, 0.9688) || 挂载数据: 无 ) 
│       │       └── 国际化 --> ( 难度等级: [0.9688, 0.9689) || 挂载数据: 无 ) 
│       │           ├── MessageSource接口 --> ( 难度等级: [0.9688, 0.9688) || 挂载数据: 无 ) 
│       │           ├── CookieLocaleResolver和SessionLocaleResolver --> ( 难度等级: [0.9688, 0.9688) || 挂载数据: 无 ) 
│       │           ├── 国际化拦截器（LocaleChangeInterceptor） --> ( 难度等级: [0.9688, 0.9689) || 挂载数据: 无 ) 
│       │           └── 开发国际化 --> ( 难度等级: [0.9689, 0.9689) || 挂载数据: 无 ) 
│       ├── SSM框架+Redis实践应用 --> ( 难度等级: [0.9689, 0.9704) || 挂载数据: 无 ) 
│       │   └── 高并发业务 --> ( 难度等级: [0.9689, 0.9704) || 挂载数据: 无 ) 
│       │       ├── 互联系统应用架构基础分析 --> ( 难度等级: [0.9689, 0.9691) || 挂载数据: 无 ) 
│       │       ├── 高并发系统的分析和设计 --> ( 难度等级: [0.9691, 0.9693) || 挂载数据: 无 ) 
│       │       │   ├── 有效请求和无效请求 --> ( 难度等级: [0.9691, 0.9691) || 挂载数据: qa: 6 ) 
│       │       │   ├── 系统设计 --> ( 难度等级: [0.9691, 0.9692) || 挂载数据: qa: 1 ) 
│       │       │   ├── 数据库设计 --> ( 难度等级: [0.9692, 0.9692) || 挂载数据: qa: 10 ) 
│       │       │   ├── 动静分离技术 --> ( 难度等级: [0.9692, 0.9693) || 挂载数据: 无 ) 
│       │       │   └── 锁和高并发 --> ( 难度等级: [0.9693, 0.9693) || 挂载数据: qa: 10 ) 
│       │       ├── 搭建抢红包开发环境和超发现象 --> ( 难度等级: [0.9693, 0.9695) || 挂载数据: 无 ) 
│       │       │   ├── 搭建Service层和DAO层 --> ( 难度等级: [0.9693, 0.9694) || 挂载数据: qa: 6 ) 
│       │       │   └── 使用全注解搭建SSM开发环境 --> ( 难度等级: [0.9694, 0.9695) || 挂载数据: qa: 2 ) 
│       │       ├── 悲观锁 --> ( 难度等级: [0.9695, 0.9697) || 挂载数据: 无 ) 
│       │       ├── 乐观锁 --> ( 难度等级: [0.9697, 0.9699) || 挂载数据: 无 ) 
│       │       │   ├── CAS原理概述 --> ( 难度等级: [0.9697, 0.9698) || 挂载数据: qa: 2 ) 
│       │       │   ├── 乐观锁实现抢红包业务 --> ( 难度等级: [0.9698, 0.9699) || 挂载数据: qa: 3 ) 
│       │       │   └── 乐观锁重入机制 --> ( 难度等级: [0.9699, 0.9699) || 挂载数据: qa: 1 ) 
│       │       ├── 使用Redis实现抢红包 --> ( 难度等级: [0.9699, 0.9702) || 挂载数据: 无 ) 
│       │       │   ├── 使用注解方式配置Redis --> ( 难度等级: [0.9699, 0.97) || 挂载数据: 无 ) 
│       │       │   ├── 数据存储设计 --> ( 难度等级: [0.97, 0.9701) || 挂载数据: qa: 4 ) 
│       │       │   └── 使用Redis实现抢红包 --> ( 难度等级: [0.9701, 0.9702) || 挂载数据: 无 ) 
│       │       └── 各类方式的优缺点 --> ( 难度等级: [0.9702, 0.9704) || 挂载数据: qa: 1 ) 
│       ├── 点睛Spring 4.x --> ( 难度等级: [0.9704, 0.9719) || 挂载数据: qa: 1 ) 
│       │   ├── Spring常用配置 --> ( 难度等级: [0.9704, 0.9711) || 挂载数据: 无 ) 
│       │   │   ├── Bean的Scope --> ( 难度等级: [0.9704, 0.9706) || 挂载数据: 无 ) 
│       │   │   │   └── 示例 --> ( 难度等级: [0.9704, 0.9706) || 挂载数据: 无 ) 
│       │   │   ├── Spring EL和资源调用. --> ( 难度等级: [0.9706, 0.9707) || 挂载数据: 无 ) 
│       │   │   │   └── 示例 --> ( 难度等级: [0.9706, 0.9707) || 挂载数据: 无 ) 
│       │   │   ├── Bean的初始化和销毁 --> ( 难度等级: [0.9707, 0.9709) || 挂载数据: 无 ) 
│       │   │   └── 事件（Application Event） --> ( 难度等级: [0.9709, 0.9711) || 挂载数据: qa: 3 ) 
│       │   │       └── 示例 --> ( 难度等级: [0.9709, 0.9711) || 挂载数据: 无 ) 
│       │   └── Spring高级话题 --> ( 难度等级: [0.9711, 0.9719) || 挂载数据: qa: 1 ) 
│       │       ├── Spring Aware --> ( 难度等级: [0.9711, 0.9712) || 挂载数据: 无 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.9711, 0.9712) || 挂载数据: 无 ) 
│       │       ├── 多线程 --> ( 难度等级: [0.9712, 0.9713) || 挂载数据: 无 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.9712, 0.9713) || 挂载数据: qa: 1 ) 
│       │       ├── 计划任务 --> ( 难度等级: [0.9713, 0.9714) || 挂载数据: qa: 1 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.9713, 0.9714) || 挂载数据: 无 ) 
│       │       ├── 条件注解@Conditional --> ( 难度等级: [0.9714, 0.9715) || 挂载数据: 无 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.9714, 0.9715) || 挂载数据: 无 ) 
│       │       ├── 组合注解与元注解 --> ( 难度等级: [0.9715, 0.9716) || 挂载数据: 无 ) 
│       │       │   └── 示例 --> ( 难度等级: [0.9715, 0.9716) || 挂载数据: 无 ) 
│       │       ├── @Enable*注解的工作原理 --> ( 难度等级: [0.9716, 0.9717) || 挂载数据: qa: 1 ) 
│       │       │   ├── 第一类：直接导入配置类 --> ( 难度等级: [0.9716, 0.9717) || 挂载数据: 无 ) 
│       │       │   ├── 第二类：依据条件选择配置类 --> ( 难度等级: [0.9717, 0.9717) || 挂载数据: 无 ) 
│       │       │   └── 第三类：动态注册Bean --> ( 难度等级: [0.9717, 0.9717) || 挂载数据: 无 ) 
│       │       └── 测试 --> ( 难度等级: [0.9717, 0.9719) || 挂载数据: 无 ) 
│       │           └── 示例 --> ( 难度等级: [0.9717, 0.9719) || 挂载数据: 无 ) 
│       ├── 点睛Spring MVC 4.x --> ( 难度等级: [0.9719, 0.9733) || 挂载数据: 无 ) 
│       │   └── Spring MVC基础 --> ( 难度等级: [0.9719, 0.9733) || 挂载数据: 无 ) 
│       │       ├── Spring MVC概述 --> ( 难度等级: [0.9719, 0.9721) || 挂载数据: 无 ) 
│       │       ├── Spring MVC的常用注解 --> ( 难度等级: [0.9721, 0.9724) || 挂载数据: 无 ) 
│       │       ├── Spring MVC基本配置 --> ( 难度等级: [0.9724, 0.9727) || 挂载数据: 无 ) 
│       │       │   ├── 静态资源映射 --> ( 难度等级: [0.9724, 0.9725) || 挂载数据: qa: 3 ) 
│       │       │   ├── 拦截器配置 --> ( 难度等级: [0.9725, 0.9726) || 挂载数据: 无 ) 
│       │       │   ├── @ControllerAdvice --> ( 难度等级: [0.9726, 0.9727) || 挂载数据: 无 ) 
│       │       │   └── 其他配置 --> ( 难度等级: [0.9727, 0.9727) || 挂载数据: qa: 8 ) 
│       │       ├── Spring MVC的高级配置 --> ( 难度等级: [0.9727, 0.973) || 挂载数据: 无 ) 
│       │       │   ├── 文件上传配置 --> ( 难度等级: [0.9727, 0.9728) || 挂载数据: qa: 1 ) 
│       │       │   ├── 自定义HttpMessageConverter --> ( 难度等级: [0.9728, 0.9729) || 挂载数据: 无 ) 
│       │       │   └── 服务器端推送技术 --> ( 难度等级: [0.9729, 0.973) || 挂载数据: qa: 2 ) 
│       │       └── Spring MVC的测试 --> ( 难度等级: [0.973, 0.9733) || 挂载数据: 无 ) 
│       ├── Java EE简介 --> ( 难度等级: [0.9733, 0.9748) || 挂载数据: 无 ) 
│       │   ├── Java EE --> ( 难度等级: [0.9733, 0.9738) || 挂载数据: 无 ) 
│       │   │   ├── Java EE架构 --> ( 难度等级: [0.9733, 0.9736) || 挂载数据: qa: 4 ) 
│       │   │   └── Java EE的缺点 --> ( 难度等级: [0.9736, 0.9738) || 挂载数据: 无 ) 
│       │   ├── Spring Boot --> ( 难度等级: [0.9738, 0.9743) || 挂载数据: 无 ) 
│       │   └── Hello，Spring Boot --> ( 难度等级: [0.9743, 0.9748) || 挂载数据: 无 ) 
│       │       ├── 创建一个Maven工程 --> ( 难度等级: [0.9743, 0.9744) || 挂载数据: qa: 2 ) 
│       │       ├── 增加Web支持 --> ( 难度等级: [0.9744, 0.9745) || 挂载数据: 无 ) 
│       │       ├── Hello Spring Boot示例 --> ( 难度等级: [0.9745, 0.9746) || 挂载数据: qa: 2 ) 
│       │       ├── 使用热部署 --> ( 难度等级: [0.9746, 0.9747) || 挂载数据: 无 ) 
│       │       └── 添加REST支持 --> ( 难度等级: [0.9747, 0.9748) || 挂载数据: 无 ) 
│       ├── Spring Boot基础 --> ( 难度等级: [0.9748, 0.9763) || 挂载数据: 无 ) 
│       │   ├── 检查Java环境与安装Java --> ( 难度等级: [0.9748, 0.9753) || 挂载数据: 无 ) 
│       │   ├── 安装和配置Maven --> ( 难度等级: [0.9753, 0.9758) || 挂载数据: 无 ) 
│       │   │   ├── Maven介绍 --> ( 难度等级: [0.9753, 0.9754) || 挂载数据: qa: 9 ) 
│       │   │   ├── 安装Maven --> ( 难度等级: [0.9754, 0.9755) || 挂载数据: qa: 2 ) 
│       │   │   ├── 设置Maven --> ( 难度等级: [0.9755, 0.9756) || 挂载数据: 无 ) 
│       │   │   ├── 使用IDE设置Maven --> ( 难度等级: [0.9756, 0.9757) || 挂载数据: 无 ) 
│       │   │   └── Maven的常用命令 --> ( 难度等级: [0.9757, 0.9758) || 挂载数据: 无 ) 
│       │   └── Spring核心技术 --> ( 难度等级: [0.9758, 0.9763) || 挂载数据: 无 ) 
│       │       ├── Spring的历史 --> ( 难度等级: [0.9758, 0.976) || 挂载数据: 无 ) 
│       │       ├── Spring容器介绍 --> ( 难度等级: [0.976, 0.9761) || 挂载数据: 无 ) 
│       │       └── Spring AOP介绍 --> ( 难度等级: [0.9761, 0.9763) || 挂载数据: 无 ) 
│       ├── MVC框架 --> ( 难度等级: [0.9763, 0.9778) || 挂载数据: 无 ) 
│       │   ├── 集成MVC框架 --> ( 难度等级: [0.9763, 0.9765) || 挂载数据: 无 ) 
│       │   │   ├── 引入依赖 --> ( 难度等级: [0.9763, 0.9764) || 挂载数据: 无 ) 
│       │   │   ├── Web应用目录结构 --> ( 难度等级: [0.9764, 0.9764) || 挂载数据: qa: 1 ) 
│       │   │   └── Java包名结构 --> ( 难度等级: [0.9764, 0.9765) || 挂载数据: 无 ) 
│       │   ├── 使用Controller --> ( 难度等级: [0.9765, 0.9766) || 挂载数据: qa: 10 ) 
│       │   ├── URL映射到方法 --> ( 难度等级: [0.9766, 0.9768) || 挂载数据: 无 ) 
│       │   │   ├── @RequestMapping --> ( 难度等级: [0.9766, 0.9767) || 挂载数据: qa: 2 ) 
│       │   │   ├── URL路径匹配 --> ( 难度等级: [0.9767, 0.9767) || 挂载数据: qa: 10 ) 
│       │   │   ├── HTTP method匹配 --> ( 难度等级: [0.9767, 0.9767) || 挂载数据: qa: 2 ) 
│       │   │   ├── consumes和produces --> ( 难度等级: [0.9767, 0.9768) || 挂载数据: 无 ) 
│       │   │   └── params和header匹配 --> ( 难度等级: [0.9768, 0.9768) || 挂载数据: qa: 2 ) 
│       │   ├── 方法参数 --> ( 难度等级: [0.9768, 0.977) || 挂载数据: 无 ) 
│       │   │   ├── PathVariable --> ( 难度等级: [0.9768, 0.9768) || 挂载数据: 无 ) 
│       │   │   ├── Model＆ModelAndView --> ( 难度等级: [0.9768, 0.9768) || 挂载数据: qa: 3 ) 
│       │   │   ├── JavaBean接受HTTP参数 --> ( 难度等级: [0.9768, 0.9769) || 挂载数据: qa: 6 ) 
│       │   │   ├── @RequsetBody接受JSON --> ( 难度等级: [0.9769, 0.9769) || 挂载数据: qa: 1 ) 
│       │   │   ├── MultipartFile --> ( 难度等级: [0.9769, 0.9769) || 挂载数据: qa: 1 ) 
│       │   │   ├── @ModelAttribute --> ( 难度等级: [0.9769, 0.9769) || 挂载数据: 无 ) 
│       │   │   └── @InitBinder --> ( 难度等级: [0.9769, 0.977) || 挂载数据: 无 ) 
│       │   ├── 验证框架 --> ( 难度等级: [0.977, 0.9771) || 挂载数据: 无 ) 
│       │   │   ├── JSR- --> ( 难度等级: [0.977, 0.977) || 挂载数据: 无 ) 
│       │   │   ├── MVC中使用@Validated --> ( 难度等级: [0.977, 0.9771) || 挂载数据: 无 ) 
│       │   │   └── 自定义校验 --> ( 难度等级: [0.9771, 0.9771) || 挂载数据: 无 ) 
│       │   ├── WebMvcConfigurer --> ( 难度等级: [0.9771, 0.9773) || 挂载数据: 无 ) 
│       │   │   ├── 跨域访问 --> ( 难度等级: [0.9771, 0.9772) || 挂载数据: qa: 2 ) 
│       │   │   └── 注册Controller --> ( 难度等级: [0.9772, 0.9773) || 挂载数据: 无 ) 
│       │   ├── 视图技术 --> ( 难度等级: [0.9773, 0.9774) || 挂载数据: 无 ) 
│       │   │   ├── 使用Freemarker --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: qa: 7 ) 
│       │   │   ├── 使用Beetl --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: 无 ) 
│       │   │   ├── 使用Jackson --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: qa: 1 ) 
│       │   │   ├── Redirect和Forward --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: 无 ) 
│       │   │   ├── Beetl模板引擎 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: 无 ) 
│       │   │   │   ├── 安装Beetl --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: 无 ) 
│       │   │   │   ├── 设置定界符号和占位符 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 配置Beetl --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: 无 ) 
│       │   │   │   └── groupTemplate --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: 无 ) 
│       │   │   ├── 使用变量 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: 无 ) 
│       │   │   │   ├── 全局变量 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 局部变量 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: 无 ) 
│       │   │   │   ├── 共享变量 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 模板变量 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: qa: 4 ) 
│       │   │   ├── 表达式 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 计算表达式 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 逻辑表达式 --> ( 难度等级: [0.9773, 0.9773) || 挂载数据: qa: 2 ) 
│       │   │   ├── 控制语句 --> ( 难度等级: [0.9773, 0.9774) || 挂载数据: 无 ) 
│       │   │   │   ├── 循环语句 --> ( 难度等级: [0.9773, 0.9774) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 条件语句 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   │   └── try catch --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 6 ) 
│       │   │   ├── 函数调用 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 1 ) 
│       │   │   ├── 格式化函数 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   ├── 直接调用Java --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   ├── 标签函数 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   ├── HTML标签 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 10 ) 
│       │   │   ├── 安全输出 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 4 ) 
│       │   │   ├── 高级功能 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义函数 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 2 ) 
│       │   │   │   ├── 自定义格式化函数 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义标签函数 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义HTML标签 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 1 ) 
│       │   │   │   └── AJAX局部渲染 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 10 ) 
│       │   │   ├── 脚本引擎 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 1 ) 
│       │   │   ├── JSON技术 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 10 ) 
│       │   │   │   ├── 在Spring Boot中使用Jackson --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   │   ├── 自定义ObjectMapper --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   │   ├── Jackson的三种使用方式 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   │   ├── Jackson树遍历 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 对象绑定 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 9 ) 
│       │   │   │   ├── 流式操作 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── Jackson注解 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │   │   └── 集合的反序列化 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: qa: 2 ) 
│       │   │   └── MVC分离开发 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │       ├── 集成WebSimulate --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │       ├── 模拟JSON响应 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   │       └── 模拟模板渲染 --> ( 难度等级: [0.9774, 0.9774) || 挂载数据: 无 ) 
│       │   ├── 通用错误处理 --> ( 难度等级: [0.9774, 0.9776) || 挂载数据: 无 ) 
│       │   └── curl命令 --> ( 难度等级: [0.9776, 0.9778) || 挂载数据: 无 ) 
│       ├── 数据库访问 --> ( 难度等级: [0.9778, 0.9793) || 挂载数据: 无 ) 
│       │   ├── 配置数据源 --> ( 难度等级: [0.9778, 0.9779) || 挂载数据: 无 ) 
│       │   ├── Spring JDBC Template --> ( 难度等级: [0.9779, 0.978) || 挂载数据: 无 ) 
│       │   │   ├── 查询 --> ( 难度等级: [0.9779, 0.9779) || 挂载数据: qa: 2 ) 
│       │   │   ├── 修改 --> ( 难度等级: [0.9779, 0.978) || 挂载数据: qa: 10 ) 
│       │   │   └── JdbcTemplate增强 --> ( 难度等级: [0.978, 0.978) || 挂载数据: 无 ) 
│       │   ├── BeetlSQL介绍 --> ( 难度等级: [0.978, 0.9781) || 挂载数据: 无 ) 
│       │   │   ├── BeetlSQL功能概览 --> ( 难度等级: [0.978, 0.978) || 挂载数据: 无 ) 
│       │   │   ├── 添加Maven依赖 --> ( 难度等级: [0.978, 0.9781) || 挂载数据: 无 ) 
│       │   │   ├── 配置BeetlSQL --> ( 难度等级: [0.9781, 0.9781) || 挂载数据: 无 ) 
│       │   │   ├── SQLManager --> ( 难度等级: [0.9781, 0.9781) || 挂载数据: 无 ) 
│       │   │   ├── 使用SQL文件 --> ( 难度等级: [0.9781, 0.9781) || 挂载数据: 无 ) 
│       │   │   └── 使用实体 --> ( 难度等级: [0.9781, 0.9781) || 挂载数据: 无 ) 
│       │   ├── SQLManager内置CRUD --> ( 难度等级: [0.9781, 0.9783) || 挂载数据: qa: 1 ) 
│       │   │   ├── 内置的插入API --> ( 难度等级: [0.9781, 0.9782) || 挂载数据: 无 ) 
│       │   │   ├── 内置的更新（删除）API --> ( 难度等级: [0.9782, 0.9782) || 挂载数据: 无 ) 
│       │   │   ├── 内置的查询API --> ( 难度等级: [0.9782, 0.9782) || 挂载数据: 无 ) 
│       │   │   └── 代码生成方法 --> ( 难度等级: [0.9782, 0.9783) || 挂载数据: 无 ) 
│       │   ├── 使用sqlId --> ( 难度等级: [0.9783, 0.9784) || 挂载数据: 无 ) 
│       │   │   ├── md文件命名 --> ( 难度等级: [0.9783, 0.9783) || 挂载数据: 无 ) 
│       │   │   ├── md文件构成 --> ( 难度等级: [0.9783, 0.9783) || 挂载数据: qa: 1 ) 
│       │   │   ├── 调用sqlId --> ( 难度等级: [0.9783, 0.9783) || 挂载数据: 无 ) 
│       │   │   ├── 翻页查询 --> ( 难度等级: [0.9783, 0.9783) || 挂载数据: 无 ) 
│       │   │   ├── TailBean --> ( 难度等级: [0.9783, 0.9783) || 挂载数据: 无 ) 
│       │   │   ├── ORM查询 --> ( 难度等级: [0.9783, 0.9784) || 挂载数据: qa: 1 ) 
│       │   │   ├── 其他API --> ( 难度等级: [0.9784, 0.9784) || 挂载数据: qa: 2 ) 
│       │   │   └── Mapper详解 --> ( 难度等级: [0.9784, 0.9784) || 挂载数据: 无 ) 
│       │   ├── BeetlSQL的其他功能 --> ( 难度等级: [0.9784, 0.9785) || 挂载数据: 无 ) 
│       │   │   ├── 常用函数和标签 --> ( 难度等级: [0.9784, 0.9784) || 挂载数据: 无 ) 
│       │   │   ├── 主键设置 --> ( 难度等级: [0.9784, 0.9785) || 挂载数据: 无 ) 
│       │   │   ├── BeetlSQL注解 --> ( 难度等级: [0.9785, 0.9785) || 挂载数据: 无 ) 
│       │   │   └── NameConversion --> ( 难度等级: [0.9785, 0.9785) || 挂载数据: 无 ) 
│       │   ├── 使用JDBC --> ( 难度等级: [0.9785, 0.9786) || 挂载数据: 无 ) 
│       │   ├── 使用DAO --> ( 难度等级: [0.9786, 0.9788) || 挂载数据: qa: 5 ) 
│       │   ├── 集成Hibernate --> ( 难度等级: [0.9788, 0.9789) || 挂载数据: 无 ) 
│       │   ├── 集成JPA --> ( 难度等级: [0.9789, 0.979) || 挂载数据: 无 ) 
│       │   ├── 集成MyBatis --> ( 难度等级: [0.979, 0.9791) || 挂载数据: 无 ) 
│       │   └── 设计ORM --> ( 难度等级: [0.9791, 0.9793) || 挂载数据: 无 ) 
│       ├── Spring Data JPA --> ( 难度等级: [0.9793, 0.9807) || 挂载数据: 无 ) 
│       │   ├── 集成Spring Data JPA --> ( 难度等级: [0.9793, 0.98) || 挂载数据: 无 ) 
│       │   │   ├── 集成数据源 --> ( 难度等级: [0.9793, 0.9794) || 挂载数据: qa: 1 ) 
│       │   │   ├── 配置JPA支持 --> ( 难度等级: [0.9794, 0.9796) || 挂载数据: qa: 7 ) 
│       │   │   ├── 创建Entity --> ( 难度等级: [0.9796, 0.9798) || 挂载数据: 无 ) 
│       │   │   └── 简化Entity --> ( 难度等级: [0.9798, 0.98) || 挂载数据: 无 ) 
│       │   └── Repository --> ( 难度等级: [0.98, 0.9807) || 挂载数据: 无 ) 
│       │       ├── CrudRepository --> ( 难度等级: [0.98, 0.9801) || 挂载数据: 无 ) 
│       │       ├── PagingAndSortingRepository --> ( 难度等级: [0.9801, 0.9801) || 挂载数据: 无 ) 
│       │       ├── JpaRepository --> ( 难度等级: [0.9801, 0.9802) || 挂载数据: 无 ) 
│       │       ├── 持久化Entity --> ( 难度等级: [0.9802, 0.9803) || 挂载数据: 无 ) 
│       │       ├── Sort --> ( 难度等级: [0.9803, 0.9804) || 挂载数据: qa: 3 ) 
│       │       ├── Pageable和Page --> ( 难度等级: [0.9804, 0.9804) || 挂载数据: qa: 2 ) 
│       │       ├── 基于方法名字查询 --> ( 难度等级: [0.9804, 0.9805) || 挂载数据: 无 ) 
│       │       ├── @Query查询 --> ( 难度等级: [0.9805, 0.9806) || 挂载数据: qa: 2 ) 
│       │       ├── 使用JPA Query --> ( 难度等级: [0.9806, 0.9807) || 挂载数据: 无 ) 
│       │       └── Example查询 --> ( 难度等级: [0.9807, 0.9807) || 挂载数据: 无 ) 
│       ├── Spring Boot配置 --> ( 难度等级: [0.9807, 0.9822) || 挂载数据: 无 ) 
│       │   ├── 配置Spring Boot --> ( 难度等级: [0.9807, 0.9811) || 挂载数据: 无 ) 
│       │   │   ├── 服务器配置 --> ( 难度等级: [0.9807, 0.9808) || 挂载数据: qa: 10 ) 
│       │   │   ├── 使用其他Web服务器 --> ( 难度等级: [0.9808, 0.9809) || 挂载数据: qa: 1 ) 
│       │   │   ├── 配置启动信息 --> ( 难度等级: [0.9809, 0.981) || 挂载数据: qa: 2 ) 
│       │   │   └── 配置浏览器显示ico --> ( 难度等级: [0.981, 0.9811) || 挂载数据: qa: 1 ) 
│       │   ├── 日志配置 --> ( 难度等级: [0.9811, 0.9815) || 挂载数据: 无 ) 
│       │   ├── 读取应用配置 --> ( 难度等级: [0.9815, 0.9819) || 挂载数据: 无 ) 
│       │   │   ├── Environment --> ( 难度等级: [0.9815, 0.9816) || 挂载数据: 无 ) 
│       │   │   ├── @Value --> ( 难度等级: [0.9816, 0.9817) || 挂载数据: qa: 8 ) 
│       │   │   └── @ConfigurationProperties --> ( 难度等级: [0.9817, 0.9819) || 挂载数据: 无 ) 
│       │   └── Spring Boot自动装配 --> ( 难度等级: [0.9819, 0.9822) || 挂载数据: 无 ) 
│       │       ├── @Configuration和@Bean --> ( 难度等级: [0.9819, 0.9819) || 挂载数据: 无 ) 
│       │       ├── Bean条件装配 --> ( 难度等级: [0.9819, 0.9819) || 挂载数据: 无 ) 
│       │       ├── Class条件装配 --> ( 难度等级: [0.9819, 0.982) || 挂载数据: 无 ) 
│       │       ├── Environment装配 --> ( 难度等级: [0.982, 0.982) || 挂载数据: 无 ) 
│       │       ├── 其他条件装配 --> ( 难度等级: [0.982, 0.9821) || 挂载数据: qa: 3 ) 
│       │       ├── 联合多个条件 --> ( 难度等级: [0.9821, 0.9821) || 挂载数据: 无 ) 
│       │       ├── Condition接口 --> ( 难度等级: [0.9821, 0.9822) || 挂载数据: 无 ) 
│       │       └── 制作Starter --> ( 难度等级: [0.9822, 0.9822) || 挂载数据: qa: 7 ) 
│       ├── 部署Spring Boot应用 --> ( 难度等级: [0.9822, 0.9837) || 挂载数据: 无 ) 
│       │   ├── 以jar文件运行 --> ( 难度等级: [0.9822, 0.9826) || 挂载数据: qa: 3 ) 
│       │   ├── 以war方式部署 --> ( 难度等级: [0.9826, 0.983) || 挂载数据: qa: 4 ) 
│       │   ├── 多环境部署 --> ( 难度等级: [0.983, 0.9833) || 挂载数据: qa: 4 ) 
│       │   └── @Profile注解 --> ( 难度等级: [0.9833, 0.9837) || 挂载数据: 无 ) 
│       ├── Testing单元测试 --> ( 难度等级: [0.9837, 0.9852) || 挂载数据: 无 ) 
│       │   ├── JUnit介绍 --> ( 难度等级: [0.9837, 0.9841) || 挂载数据: 无 ) 
│       │   │   ├── JUnit的相关概念 --> ( 难度等级: [0.9837, 0.9838) || 挂载数据: 无 ) 
│       │   │   ├── JUnit测试 --> ( 难度等级: [0.9838, 0.9839) || 挂载数据: qa: 3 ) 
│       │   │   ├── Assert --> ( 难度等级: [0.9839, 0.984) || 挂载数据: 无 ) 
│       │   │   └── Suite --> ( 难度等级: [0.984, 0.9841) || 挂载数据: 无 ) 
│       │   ├── Spring Boot单元测试 --> ( 难度等级: [0.9841, 0.9844) || 挂载数据: 无 ) 
│       │   │   ├── 测试范围依赖 --> ( 难度等级: [0.9841, 0.9841) || 挂载数据: qa: 2 ) 
│       │   │   ├── Spring Boot测试脚手架 --> ( 难度等级: [0.9841, 0.9842) || 挂载数据: qa: 1 ) 
│       │   │   ├── 测试MVC --> ( 难度等级: [0.9842, 0.9843) || 挂载数据: 无 ) 
│       │   │   ├── 完成MVC请求模拟 --> ( 难度等级: [0.9843, 0.9843) || 挂载数据: 无 ) 
│       │   │   ├── 比较MVC的返回结果 --> ( 难度等级: [0.9843, 0.9844) || 挂载数据: 无 ) 
│       │   │   └── JSON比较 --> ( 难度等级: [0.9844, 0.9844) || 挂载数据: qa: 10 ) 
│       │   ├── Mockito --> ( 难度等级: [0.9844, 0.9848) || 挂载数据: 无 ) 
│       │   │   ├── 模拟对象 --> ( 难度等级: [0.9844, 0.9846) || 挂载数据: qa: 3 ) 
│       │   │   ├── 模拟方法参数 --> ( 难度等级: [0.9846, 0.9847) || 挂载数据: 无 ) 
│       │   │   └── 模拟方法返回值 --> ( 难度等级: [0.9847, 0.9848) || 挂载数据: qa: 2 ) 
│       │   └── 面向数据库应用的单元测试 --> ( 难度等级: [0.9848, 0.9852) || 挂载数据: 无 ) 
│       │       ├── @Sql --> ( 难度等级: [0.9848, 0.9849) || 挂载数据: qa: 10 ) 
│       │       ├── XLSUnit --> ( 难度等级: [0.9849, 0.9851) || 挂载数据: 无 ) 
│       │       └── XLSUnit的基本用法 --> ( 难度等级: [0.9851, 0.9852) || 挂载数据: 无 ) 
│       ├── REST --> ( 难度等级: [0.9852, 0.9867) || 挂载数据: 无 ) 
│       │   ├── REST简介 --> ( 难度等级: [0.9852, 0.9856) || 挂载数据: 无 ) 
│       │   │   ├── REST风格的架构 --> ( 难度等级: [0.9852, 0.9852) || 挂载数据: 无 ) 
│       │   │   ├── 使用“api”作为上下文 --> ( 难度等级: [0.9852, 0.9853) || 挂载数据: 无 ) 
│       │   │   ├── 增加一个版本标识 --> ( 难度等级: [0.9853, 0.9853) || 挂载数据: 无 ) 
│       │   │   ├── 标识资源 --> ( 难度等级: [0.9853, 0.9854) || 挂载数据: 无 ) 
│       │   │   ├── 确定HTTP Method --> ( 难度等级: [0.9854, 0.9854) || 挂载数据: qa: 4 ) 
│       │   │   ├── 确定HTTP Status --> ( 难度等级: [0.9854, 0.9855) || 挂载数据: qa: 1 ) 
│       │   │   └── REST VS. WebService --> ( 难度等级: [0.9855, 0.9856) || 挂载数据: qa: 10 ) 
│       │   ├── Spring Boot集成REST --> ( 难度等级: [0.9856, 0.9859) || 挂载数据: 无 ) 
│       │   │   ├── 集成REST --> ( 难度等级: [0.9856, 0.9857) || 挂载数据: 无 ) 
│       │   │   ├── @RestController --> ( 难度等级: [0.9857, 0.9858) || 挂载数据: 无 ) 
│       │   │   └── REST Client --> ( 难度等级: [0.9858, 0.9859) || 挂载数据: qa: 5 ) 
│       │   ├── Swagger UI --> ( 难度等级: [0.9859, 0.9863) || 挂载数据: qa: 4 ) 
│       │   │   ├── 集成Swagger --> ( 难度等级: [0.9859, 0.986) || 挂载数据: 无 ) 
│       │   │   ├── Swagger规范 --> ( 难度等级: [0.986, 0.986) || 挂载数据: qa: 3 ) 
│       │   │   ├── 接口描述 --> ( 难度等级: [0.986, 0.986) || 挂载数据: qa: 1 ) 
│       │   │   ├── 查询参数描述 --> ( 难度等级: [0.986, 0.9861) || 挂载数据: qa: 1 ) 
│       │   │   ├── URI中的参数 --> ( 难度等级: [0.9861, 0.9861) || 挂载数据: 无 ) 
│       │   │   ├── HTTP头参数 --> ( 难度等级: [0.9861, 0.9862) || 挂载数据: 无 ) 
│       │   │   ├── 表单参数 --> ( 难度等级: [0.9862, 0.9862) || 挂载数据: 无 ) 
│       │   │   ├── 文件上传参数 --> ( 难度等级: [0.9862, 0.9863) || 挂载数据: 无 ) 
│       │   │   └── 整个请求体作为参数 --> ( 难度等级: [0.9863, 0.9863) || 挂载数据: 无 ) 
│       │   └── 模拟REST服务 --> ( 难度等级: [0.9863, 0.9867) || 挂载数据: 无 ) 
│       ├── MongoDB --> ( 难度等级: [0.9867, 0.9881) || 挂载数据: 无 ) 
│       │   ├── 安装MongoDB --> ( 难度等级: [0.9867, 0.987) || 挂载数据: qa: 3 ) 
│       │   ├── 使用shell --> ( 难度等级: [0.987, 0.9874) || 挂载数据: qa: 3 ) 
│       │   │   ├── 指定数据库 --> ( 难度等级: [0.987, 0.9871) || 挂载数据: 无 ) 
│       │   │   ├── 插入文档 --> ( 难度等级: [0.9871, 0.9872) || 挂载数据: qa: 1 ) 
│       │   │   ├── 查询文档 --> ( 难度等级: [0.9872, 0.9873) || 挂载数据: 无 ) 
│       │   │   ├── 更新操作 --> ( 难度等级: [0.9873, 0.9873) || 挂载数据: 无 ) 
│       │   │   └── 删除操作 --> ( 难度等级: [0.9873, 0.9874) || 挂载数据: 无 ) 
│       │   ├── Spring Boot集成MongoDB --> ( 难度等级: [0.9874, 0.9878) || 挂载数据: 无 ) 
│       │   └── 增删改查 --> ( 难度等级: [0.9878, 0.9881) || 挂载数据: qa: 2 ) 
│       │       ├── 增加API --> ( 难度等级: [0.9878, 0.9878) || 挂载数据: qa: 1 ) 
│       │       ├── 根据主键查询API --> ( 难度等级: [0.9878, 0.9879) || 挂载数据: 无 ) 
│       │       ├── 查询API --> ( 难度等级: [0.9879, 0.9879) || 挂载数据: 无 ) 
│       │       ├── 修改API --> ( 难度等级: [0.9879, 0.988) || 挂载数据: 无 ) 
│       │       ├── 删除API --> ( 难度等级: [0.988, 0.988) || 挂载数据: 无 ) 
│       │       ├── 使用MongoDatabase --> ( 难度等级: [0.988, 0.9881) || 挂载数据: 无 ) 
│       │       └── 打印日志 --> ( 难度等级: [0.9881, 0.9881) || 挂载数据: qa: 9 ) 
│       ├── Elasticsearch --> ( 难度等级: [0.9881, 0.9896) || 挂载数据: 无 ) 
│       │   ├── Elasticsearch介绍 --> ( 难度等级: [0.9881, 0.9885) || 挂载数据: 无 ) 
│       │   │   ├── 安装Elasticsearch --> ( 难度等级: [0.9881, 0.9883) || 挂载数据: 无 ) 
│       │   │   └── Elasticsearch的基本概念 --> ( 难度等级: [0.9883, 0.9885) || 挂载数据: qa: 2 ) 
│       │   ├── 使用REST访问Elasticsearch --> ( 难度等级: [0.9885, 0.9889) || 挂载数据: 无 ) 
│       │   │   ├── 添加文档 --> ( 难度等级: [0.9885, 0.9886) || 挂载数据: qa: 4 ) 
│       │   │   ├── 根据主键查询 --> ( 难度等级: [0.9886, 0.9886) || 挂载数据: 无 ) 
│       │   │   ├── 根据主键更新 --> ( 难度等级: [0.9886, 0.9887) || 挂载数据: 无 ) 
│       │   │   ├── 根据主键删除 --> ( 难度等级: [0.9887, 0.9888) || 挂载数据: qa: 2 ) 
│       │   │   ├── 搜索文档 --> ( 难度等级: [0.9888, 0.9888) || 挂载数据: qa: 1 ) 
│       │   │   └── 联合多个索引搜索 --> ( 难度等级: [0.9888, 0.9889) || 挂载数据: 无 ) 
│       │   ├── 使用RestTemplate访问ES --> ( 难度等级: [0.9889, 0.9893) || 挂载数据: qa: 1 ) 
│       │   │   ├── 创建Book --> ( 难度等级: [0.9889, 0.9891) || 挂载数据: qa: 2 ) 
│       │   │   └── 使用RestTemplate获取搜索结果 --> ( 难度等级: [0.9891, 0.9893) || 挂载数据: qa: 3 ) 
│       │   └── Spring Data Elastic --> ( 难度等级: [0.9893, 0.9896) || 挂载数据: 无 ) 
│       │       ├── 安装Spring Data --> ( 难度等级: [0.9893, 0.9894) || 挂载数据: qa: 7 ) 
│       │       ├── 编写Entity --> ( 难度等级: [0.9894, 0.9894) || 挂载数据: qa: 2 ) 
│       │       ├── 编写Dao --> ( 难度等级: [0.9894, 0.9895) || 挂载数据: 无 ) 
│       │       └── 编写Controller --> ( 难度等级: [0.9895, 0.9896) || 挂载数据: qa: 1 ) 
│       ├── Cache --> ( 难度等级: [0.9896, 0.9911) || 挂载数据: 无 ) 
│       │   ├── 关于Cache --> ( 难度等级: [0.9896, 0.9899) || 挂载数据: 无 ) 
│       │   │   ├── Cache的组件和概念 --> ( 难度等级: [0.9896, 0.9897) || 挂载数据: 无 ) 
│       │   │   ├── Cache的单体应用 --> ( 难度等级: [0.9897, 0.9898) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用专有的Cache服务器 --> ( 难度等级: [0.9898, 0.9898) || 挂载数据: 无 ) 
│       │   │   └── 使用一二级缓存服务器 --> ( 难度等级: [0.9898, 0.9899) || 挂载数据: 无 ) 
│       │   ├── Spring Boot Cache --> ( 难度等级: [0.9899, 0.9901) || 挂载数据: 无 ) 
│       │   ├── 注释驱动缓存 --> ( 难度等级: [0.9901, 0.9904) || 挂载数据: 无 ) 
│       │   │   ├── @Cacheable --> ( 难度等级: [0.9901, 0.9902) || 挂载数据: qa: 1 ) 
│       │   │   ├── Key生成器 --> ( 难度等级: [0.9902, 0.9902) || 挂载数据: qa: 5 ) 
│       │   │   ├── @CachePut --> ( 难度等级: [0.9902, 0.9902) || 挂载数据: 无 ) 
│       │   │   ├── @CacheEvict --> ( 难度等级: [0.9902, 0.9903) || 挂载数据: 无 ) 
│       │   │   ├── @Caching --> ( 难度等级: [0.9903, 0.9903) || 挂载数据: 无 ) 
│       │   │   └── @CacheConfig --> ( 难度等级: [0.9903, 0.9904) || 挂载数据: 无 ) 
│       │   ├── 使用Redis Cache --> ( 难度等级: [0.9904, 0.9906) || 挂载数据: 无 ) 
│       │   │   ├── 集成Redis缓存 --> ( 难度等级: [0.9904, 0.9905) || 挂载数据: 无 ) 
│       │   │   ├── 禁止缓存 --> ( 难度等级: [0.9905, 0.9905) || 挂载数据: 无 ) 
│       │   │   └── 定制缓存 --> ( 难度等级: [0.9905, 0.9906) || 挂载数据: 无 ) 
│       │   ├── Redis缓存原理 --> ( 难度等级: [0.9906, 0.9909) || 挂载数据: 无 ) 
│       │   └── 实现Redis两级缓存 --> ( 难度等级: [0.9909, 0.9911) || 挂载数据: 无 ) 
│       │       ├── 实现TwoLevelCacheManager --> ( 难度等级: [0.9909, 0.9909) || 挂载数据: 无 ) 
│       │       ├── 创建RedisAndLocalCache --> ( 难度等级: [0.9909, 0.991) || 挂载数据: 无 ) 
│       │       ├── 缓存同步说明 --> ( 难度等级: [0.991, 0.991) || 挂载数据: 无 ) 
│       │       └── 将代码组合在一起 --> ( 难度等级: [0.991, 0.9911) || 挂载数据: 无 ) 
│       ├── Spring Session --> ( 难度等级: [0.9911, 0.9926) || 挂载数据: 无 ) 
│       │   ├── 水平扩展实现 --> ( 难度等级: [0.9911, 0.9919) || 挂载数据: qa: 2 ) 
│       │   └── Spring Session --> ( 难度等级: [0.9919, 0.9926) || 挂载数据: 无 ) 
│       │       ├── Spring Session介绍 --> ( 难度等级: [0.9919, 0.9922) || 挂载数据: qa: 10 ) 
│       │       └── Nginx+Redis --> ( 难度等级: [0.9922, 0.9926) || 挂载数据: qa: 9 ) 
│       ├── 监控Spring Boot应用 --> ( 难度等级: [0.9926, 0.9941) || 挂载数据: 无 ) 
│       │   ├── 安装Acutator --> ( 难度等级: [0.9926, 0.9928) || 挂载数据: 无 ) 
│       │   ├── HTTP跟踪 --> ( 难度等级: [0.9928, 0.9929) || 挂载数据: 无 ) 
│       │   ├── 日志查看 --> ( 难度等级: [0.9929, 0.9931) || 挂载数据: qa: 2 ) 
│       │   ├── 线程栈信息 --> ( 难度等级: [0.9931, 0.9933) || 挂载数据: 无 ) 
│       │   ├── 内存信息 --> ( 难度等级: [0.9933, 0.9934) || 挂载数据: 无 ) 
│       │   ├── 查看URL映射 --> ( 难度等级: [0.9934, 0.9936) || 挂载数据: 无 ) 
│       │   ├── 查看Spring容器管理的Bean --> ( 难度等级: [0.9936, 0.9937) || 挂载数据: 无 ) 
│       │   ├── 其他监控 --> ( 难度等级: [0.9937, 0.9939) || 挂载数据: 无 ) 
│       │   └── 编写自己的监控信息 --> ( 难度等级: [0.9939, 0.9941) || 挂载数据: 无 ) 
│       │       ├── 编写HealthIndicator --> ( 难度等级: [0.9939, 0.994) || 挂载数据: qa: 10 ) 
│       │       └── 自定义监控 --> ( 难度等级: [0.994, 0.9941) || 挂载数据: qa: 2 ) 
│       ├── Web开发 --> ( 难度等级: [0.9941, 0.9956) || 挂载数据: 无 ) 
│       │   ├── Web基础 --> ( 难度等级: [0.9941, 0.9942) || 挂载数据: qa: 10 ) 
│       │   ├── Servlet入门 --> ( 难度等级: [0.9942, 0.9943) || 挂载数据: qa: 6 ) 
│       │   ├── Servlet开发 --> ( 难度等级: [0.9943, 0.9944) || 挂载数据: 无 ) 
│       │   ├── Servlet进阶 --> ( 难度等级: [0.9944, 0.9945) || 挂载数据: qa: 1 ) 
│       │   ├── JSP开发 --> ( 难度等级: [0.9945, 0.9946) || 挂载数据: qa: 10 ) 
│       │   ├── MVC开发 --> ( 难度等级: [0.9946, 0.9947) || 挂载数据: 无 ) 
│       │   ├── MVC高级开发 --> ( 难度等级: [0.9947, 0.9948) || 挂载数据: 无 ) 
│       │   ├── 使用Filter --> ( 难度等级: [0.9948, 0.9949) || 挂载数据: qa: 2 ) 
│       │   │   └── 修改响应 --> ( 难度等级: [0.9948, 0.9949) || 挂载数据: 无 ) 
│       │   ├── 使用Listener --> ( 难度等级: [0.9949, 0.995) || 挂载数据: 无 ) 
│       │   ├── 部署 --> ( 难度等级: [0.995, 0.9951) || 挂载数据: 无 ) 
│       │   ├── 集成Filter --> ( 难度等级: [0.9951, 0.9952) || 挂载数据: 无 ) 
│       │   ├── 使用Interceptor --> ( 难度等级: [0.9952, 0.9953) || 挂载数据: 无 ) 
│       │   ├── 处理CORS --> ( 难度等级: [0.9953, 0.9954) || 挂载数据: 无 ) 
│       │   ├── 异步处理 --> ( 难度等级: [0.9954, 0.9955) || 挂载数据: 无 ) 
│       │   └── 使用WebSocket --> ( 难度等级: [0.9955, 0.9956) || 挂载数据: qa: 3 ) 
│       ├── Spring开发 --> ( 难度等级: [0.9956, 0.997) || 挂载数据: 无 ) 
│       │   ├── IoC容器 --> ( 难度等级: [0.9956, 0.9963) || 挂载数据: 无 ) 
│       │   │   ├── IoC原理 --> ( 难度等级: [0.9956, 0.9957) || 挂载数据: 无 ) 
│       │   │   ├── 使用Annotation配置 --> ( 难度等级: [0.9957, 0.9959) || 挂载数据: 无 ) 
│       │   │   ├── 定制Bean --> ( 难度等级: [0.9959, 0.996) || 挂载数据: 无 ) 
│       │   │   ├── 使用Resource --> ( 难度等级: [0.996, 0.9961) || 挂载数据: qa: 2 ) 
│       │   │   └── 注入配置 --> ( 难度等级: [0.9961, 0.9963) || 挂载数据: 无 ) 
│       │   └── 集成第三方组件 --> ( 难度等级: [0.9963, 0.997) || 挂载数据: 无 ) 
│       │       ├── 集成JavaMail --> ( 难度等级: [0.9963, 0.9964) || 挂载数据: qa: 7 ) 
│       │       ├── 集成JMS --> ( 难度等级: [0.9964, 0.9965) || 挂载数据: 无 ) 
│       │       ├── 使用Scheduler --> ( 难度等级: [0.9965, 0.9965) || 挂载数据: qa: 1 ) 
│       │       ├── 集成JMX --> ( 难度等级: [0.9965, 0.9966) || 挂载数据: 无 ) 
│       │       ├── 集成Open API --> ( 难度等级: [0.9966, 0.9967) || 挂载数据: 无 ) 
│       │       ├── 访问Redis --> ( 难度等级: [0.9967, 0.9968) || 挂载数据: 无 ) 
│       │       ├── 集成Artemis --> ( 难度等级: [0.9968, 0.9969) || 挂载数据: qa: 3 ) 
│       │       ├── 集成RabbitMQ --> ( 难度等级: [0.9969, 0.997) || 挂载数据: qa: 3 ) 
│       │       └── 集成Kafka --> ( 难度等级: [0.997, 0.997) || 挂载数据: 无 ) 
│       ├── Spring Boot开发 --> ( 难度等级: [0.997, 0.9985) || 挂载数据: 无 ) 
│       │   ├── 使用开发者工具 --> ( 难度等级: [0.997, 0.9972) || 挂载数据: qa: 1 ) 
│       │   ├── 打包Spring Boot应用 --> ( 难度等级: [0.9972, 0.9974) || 挂载数据: 无 ) 
│       │   ├── 使用Actuator --> ( 难度等级: [0.9974, 0.9976) || 挂载数据: 无 ) 
│       │   ├── 使用Profiles --> ( 难度等级: [0.9976, 0.9978) || 挂载数据: 无 ) 
│       │   ├── 使用Conditional --> ( 难度等级: [0.9978, 0.998) || 挂载数据: 无 ) 
│       │   ├── 加载配置文件 --> ( 难度等级: [0.998, 0.9981) || 挂载数据: 无 ) 
│       │   ├── 禁用自动配置 --> ( 难度等级: [0.9981, 0.9983) || 挂载数据: 无 ) 
│       │   └── 添加Filter --> ( 难度等级: [0.9983, 0.9985) || 挂载数据: qa: 2 ) 
│       └── Spring Cloud开发 --> ( 难度等级: [0.9985, 1.0) || 挂载数据: qa: 2 ) 
└── 其他 --> ( 难度等级: [0, 0) || 挂载数据: 无 ) 
    ├── 其他类别标签问题 --> ( 难度等级: [0, 0) || 挂载数据: qa: 10 ) 
    ├── 应用类问题 --> ( 难度等级: [0, 0) || 挂载数据: qa: 10 ) 
    └── 第三方包问题 --> ( 难度等级: [0, 0) || 挂载数据: qa: 10 )