Javase基础部分知识点总结
标识符
- 就是用来给包、类、方法、变量等起名字的符号
- 组成规则：
-
unicode字符- 数字字符，英文大小写字母，汉字（不建议使用汉字）
- 下划线 _
- 美元符 $
-
- 注意事项：
- 不能以数字开头
- 不能是JAVA中的关键字
- 常见命名规则：
- 基本要求
- 见名知意
- 常见的命名
- 包（其实就是文件夹，用于对类的管理）
- 全部小写，多级包用 .隔开
- 举例：
com.qgp
- 类的命名规则
- 一个单词首字母大写举例 ：
Student Car - 多个单词每个单词首字母大写
HelloWorld - 方法和变量
- 一个单词首字母小写 ：举例：age， name
- 多个单词组成 从第二个瘦子开始每个单词的首字母大写 ：
maxAge getAge
- 一个单词首字母大写举例 ：
- 包（其实就是文件夹，用于对类的管理）
- 基本要求
变量的定义和使用（variable）
-
变量的定义格式：
数据类型 变量名 = 初始化值；
int a = 10；
变量定义的注意事项： 1.变量未赋值，不能直接使用
2.变量只在它所属的范围内有效果
（便改良属于它所在的那对大括号）
3.一行上可以定义的多个变量，但是不建议这样使用
-
数据类型：
byte short int long float double char boolean -
注意：
- 定义long类型变量的时候，最好直接加上L
- 定义float类型变量的时候，最好直接加上F
类型转换
-
类型转换：
-
隐式转换：
byte，short，char——>int——>long——>float——>double -
强制转换：目标类型 变量名 = （目标类型）（被转换的数据）；
举例： byte d = （byte）（a+b）
建议：数据做运算时，结果应该是什么类型，就用什么类型接受，不要随意转换类型，否则会有精度的损失。
-
-
+这是一个运算符，用于做加法运算的。
我们在左运算的时候，一般要求参与运算的数据类型必须一致。
-
我们要求参与运算的数据的类型一致，而现在不一致，我们应该用什么类型接收呢？
运算符：
运算符：就是用于对常量和变量进行操作的符号
运算符分类：
-
算术运算符
+ - * / % ++ --整数相除只能得到整数，要想得到小数，必须有浮点数参与运算
%：用于获取两个数据相除时候的余数
/ ：用于获取两个数据相除时候的商
字符参与加法运算，其实就是拿字符在计算机中存储的数据值来参与运算的
字符串参与加法运算，其实做的不是加法运算，而是字符串的拼接。
++ – :自增自减，用于对变量加1或者减1
单独使用时候，++ – 放在变量的前面或者后面，结果一样。
参与其他操作的时候：
++在后面，先拿变量做操作，然后变量再++
++在前面，先变量++，然后再拿变量做操作
-
赋值运算符
基本的赋值运算符： =
扩展的赋值运算符：+=，-=，*=，/=，……
注意：扩展的数据运算符，隐含了强制类型转换
int a = 10； 解释： 把10赋值给int类型的变量a
+= ：拿+=的左边和右边的数据做+,然后把结果赋值给左边，其他同理。
-
关系运算符
== ！= >= <= < > 关系运算符的结果是boolean类型。
-
逻辑运算符
解释：用于连接关系表达式
& | ^ ! && || & ：有false则false
| ：有true则true
^ ：相同为false，不同为true
! : true则false，false则true
&& : &&与 &的结果一样
|| : || 与 |的结果一样
&& 和&的区别：
&&有短路效果，左边为false，右边不执行。
&
无论左边是什么，右边都会执行。 -
三元运算符(可以用于获取两个数据的最大值)
关系表达式？表达式1：表达式2
int a =10； int b = 20；
int c = （a>b)?a:b; 如果是true，表达式1就是结果
如果是false，表达式2就是结果
表达式：
-
表达式：用元素安抚连接起来的符合
java语句的式子。不同的运算符连接的表达式是不同类型的表达式 举例：a,b a+b 就是表达式
键盘录入（Scanner）
使用步骤：
- 导包
import java.util.Scanner; 快捷键：Ctrl+Shift+O - 创建键盘录入对象
Scanner sc = new Scanner(System.in); - 接受数据
int i = sc.nextInt();
循环
顺序结构：从上往下，依次执行
if语句：
格式:
if (条件1) {
语句块1;
}else if (条件2) {
语句块2;
}else{
语句块3;
}
条件案例:输入月份，输出对应的季节：
1~3–春季
4~6–夏季
7~9–秋季
10~12–冬季
ppublic class Season {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner scan=new Scanner(System.in);
System.out.println("输入数字：");
int a=scan.nextInt();
if(a>=1 && a<=3) {
System.out.println("春季");
}
else if (a>=4 && a<=6) {
System.out.println("夏季");
}
else if (a>=7 && a<=9) {
System.out.println("秋季");
}
else if (a>=10 && a<=12) {
System.out.println("冬季");
}else {
System.out.println("你疯了");
}
}
switch语句：
格式:
switch(表达式){
case 常量表达式1:
语句块1;
break;
case 常量表达式2:
语句块2;
break;
case 常量表达式3:
语句块3;
break;
default:
其他;
}
格式解释：
表达式：byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是字符串
case后面的值：就是用来和表达式的值进行匹配的内容
break:表示中断的意思
default：所有的值都不匹配的时候，就执行default
- 需求：键盘录入星期数，显示今天的减肥活动
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿
- 示例代码：
public class Sport{
public static void main(String[] args){
// 1. 键盘录入星期数据，使用变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入");
int week = sc.nextInt();
// 2. 多情况判断，采用switch语句实现
switch(week){
// 3. 在不同的case中，输出对应的减肥计划
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("慢走");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("拳击");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("好好吃一顿");
break;
default:
System.out.println("您的输入有误");
break;
}
}
}
switch语句case穿透
- 概述 : 如果switch语句中,case省略了break语句, 就会开始case穿透
- 需求 : 键盘录入星期数，输出工作日、休息日 (1-5)工作日，(6-7)休息日
- 示例代码：
/*
case穿透是如何产生的?
如果switch语句中,case省略了break语句, 就会开始case穿透.
现象：
当开始case穿透，后续的case就不会具有匹配效果，内部的语句都会执行
直到看见break，或者将整体switch语句执行完毕，才会结束。
*/
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期数:");
int week = sc.nextInt();
switch(week){
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("工作日");
break;
case 6:
case 7:
System.out.println("休息日");
break;
default:
System.out.println("您的输入有误");
break;
}
}
}
for循环
格式:
for(初识条件;判断条件;变化条件){
循环体;
}
//1.初识条件->判断条件->循环体->变化条件->判断条件->循环体
案例:输入一个整数,然后打印0到这个整数,最后打印0到这个整数之和
import java.util.Scanner;
public class Sum{
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner scan=new Scanner(System.in);
System.out.println("请输入数字：");
int n=scan.nextInt();
int a=0;
for(int i=0;i<=n;i++) {
a+=i;
}
System.out.println("和为："+a);
}
初始化语句;
while(条件表达式){
循环体;
循环变量控制语句;
}
初始化语句;
do{
循环体;
循环变量控制语句;
}while(条件表达式);
虽然三种循环可以做相同的事情，但是它们还是有区别的：
A：do……while 至少执行一次循环体
B：for和while循环必须先判断条件才可以执行循环体
for循环和while循环有没有区别呢？
for循环结束后初始化的变量就不能被使用了，而while循环结束后，初始化的变量还可以继续使用
推荐使用循环的顺序是：for ----- while ------ do …while
跳转控制语句
break：中断的意思
使用场景： A、switch语句中
B、循环中（离开场景使用没有意义)
continue：继续的意思
使用场景：循环中
注意：
离开场景使用没有意义的
continue 的作用，结束一次循环，继续下一次的循环.
Random :用于产生随机数
使用步骤： A：导包 import java.util.Random;
B：创建对象 r = new Random()；
C：获取随机数 int number = r.nextInt(10);
获取数据的范围：[0,10) 包括0，不包括10
案例：猜数字小游戏：
分析：A：系统随机产生一个1 --100之间的随机数
import java.util.Random;
r = new Random()；
int number = r.nextInt(10);
B：键盘录入我们猜的数据：`
C:比较两个数据：用if语句
如果大了，提示猜大了
如果小了，提示猜小了
猜中了：提示恭喜你，猜中了
多次才数据，而我们不知道猜多少次 while循环
数组
数组定义：
存储同一种数据类型的多个元素的容器。
定义格式：
A：数据类型 [] 数组名；
举例： int [] arr；定义了一个int类型的数组，数组名是arr
B：数据类型 数组名 []；
举例： int arr []定义了一个int类型的变量，变量名是arr数组
数组初始化：
A：所谓的初始化，就是为数组开辟没存空间，并为数组中的每个元素赋予初始值。
B：我们有两种方式可以实现数组的初始化
a：动态初始化 只给出长度，由系统给出初始化值
b：静态初始化 给出初始化值，由系统决定长度
动态初始化：
数据类型 [] 数组名 = new 数据类型 [数组长度]
int [] arr = new int [3];
JAVA中的内存分配：
栈（存储的是局部变量）
堆（存储的是new出来的东西）
方法区（面向对象的进阶讲）
本地方法区（和系统相关）
寄存器（给CPU使用）
静态初始化：
数据类型 [] 数组名 = new 数据类型 []{元素1，元素2，元素3，…}
int [] arr = {1,2,3}
两个常见小问题：
ArrayIndexOutOfBoundsException:数组索引异常越界
产生原因：我们访问了不存在的索引
nullPointerException：空指针异常
产生原因：数组已经不在指向堆内存的数据了，你还使用数组名去访问元素
访问数组元素
引用类型：类，接口，数组
常量：空常量，null，是可以赋值给引用类型的
arr = null;
二维数组定义的格式：
数据类型[][] [] [] 数组名；(推荐格式）
B数据类型 数组名 [] []；
数据类型 [] 数组名 []；
二维数组的初始化：
动态初始化
数据类型 [] [] 数组名 = new 数据类型 [m] [n]；
m 表示的是二维数组中的一维数组的个数
n 表示的是一维数组中的元素个数
静态初始化
数据类型 [] [] 数组名 = new 数据类型 {元素1，元素二，元素3，等等}
方法
方法：其实就是完成特定功能的代码块
定义格式：
修饰符 返回值类型 方法名 （参数类型 参数名1， 参数类型 参数名2……）{
方法体
return 返回值；
}
格式解释：
A：修饰符 目前记住 public static
B：返回值类型 用于限定返回值的数据类型
C：方法名 为了方便我们调用方法的名字
D：参数类型 用于限定调用方法时传入的数据的类型
E：参数名 用于接受调用方法时传入的数据变量
F：方法体 完成功能的代码
G：return 结束方法，并把返回值带给调用者
写一个方法有两个明确：
A：返回值类型 明确功能结果的数据类型
B：参数列表 明确有几个参数，以及参数的数据类型
方法的调用：
（有明确返回值的方法调用）
A：单独调用，没有意义。 sum（10，20）
B：输出调用，有意义，但是不够好，因为我可能拿结果进一步操作 System.out.println(sum(10,20));
C：赋值调用 （推荐使用）
int result = sum（10，20）；
在这可以对result 进行操作
案例：写一个方法用于求和
两个明确： 返回值：int
参数列表 ：int a int b
package myMethod;
public class MethodDemo {
public static void main(String[] args) {
//单独调用，没有意义。
sum (10,20);`
int result = sum(10,20);
System.out.println(result);
}
public static int sum(int a ,int b ) {
int c = a + b;
return c;
}
}
void修饰的方法单独调用
printHelloWorld();
方法重载
方法重载：
在同一个类中，出现了方法名相同的情况。
方法重载的特点：
方法名相同，参数列表不同。与返回值无关。
参数列表不同：
参数个数不同
参数对应的类型不同
不能出现方法名相同，并且参数列表也相同的情况。
注意：
在调用方法的时候，JAVA虚拟机会通过参数列表的不同来区分同名的方法。
方法的参数如果是基本数据类型：形式参数的改变不影响实际参数。
形式参数：用于接受时间参数的变量
实际参数：用于参与运算的变量
面向对象：
面向对象的思想：
面向对象是基于面向过程的编程思想
对象去调用功能
面向对象的思想特点：
A：是一种更符合我们思考习惯的思想
B：可以将复杂的事情简单化
C：将我们从执行者变成了指挥者
举例：买电脑：
面向过程：我要买电脑 – 明确电脑的意义 – 上网查参数 – 去中关村买电 – 讨价还价
面向对象：我要买电脑 – 班长去给我买电脑 – 买回电脑
成员变量和局部变量的区别：
A：在类中的位置不同
成员变量：类中，方法外
局部变量：方法中或者方法声明上（形式参数）
B：在内存中的位置不同
成员变量：堆内存
局部变量：栈内存
C:生命期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值的问题
成员变量有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用
如果有成员变量名和局部变量名相同，在局部使用的时候，采用的是就近原则。
举例：
public class Variable {
int x ; //成员变量
public void show() {
int y; //局部变量
}
}
通过对象直接 访问成员变量，会存在数据安全问题
这个时候，我们就能不能不让外界的对象直接访问成员变量？
Private关键字
private是一个修饰符，可以修饰成员变量，也可以修饰成员方法
被private修饰的成员变量只能在本类中访问
针对private修饰的成员变量，我们会提供相应的getXxx()``和setXxx() 用于获取和设置成员变量的值，方法用public修饰
封装：
this关键字
用this关键字实现把局部变量赋值给成员变量。
this代表所在类的对象引用
方法被哪个对象调用，this就代表哪个对象。
使用场景：
局部变量隐藏成员变量。
构造方法：
给对象的数据进行初始化
格式：
方法名和类名相同
没有返回值类型，连void都不饿能写
没有具体的返回值
调用构造方法：用new关键字
格式：类名 对象名 = new 构造方法(……);
构造方法的注意事项：
如果我们没有给出构造方法，系统会提供一个默认的无参构造方法供我们使用
如果我们给出了构造方法，系统将不会给我们体统无参构造供我们使用
这个时候如果我们想使用无参构造方法，就必须自己提供
构造方法也可以重载
推荐：自己给无参构造
成员变量赋值：
setXxx();
getXxx();
类名作为形式参数，其实这里需要的是该类的对象。
如果方法的和返回值是类名：其实返回的就是该类的对象
Random类
Java.lang包下的类在使用的时候需要导包的；
Random();无参构造方法
Random r = new Random();
看成员方法
public int nextInt （int n ） ：产生的就是一个[0,n)范围内的随机数
调用方法：
看返回值类型：人家返回什么类型，你就用什么类型接收
看方法名：名字不要写错了
看形式参数：人家要几个参数，你就给几个参数，人家要什么数据类型的，你就给什么数据类型的
String类
构造方法：
String （String original）：把字符串数据封装成字符串对象
举例: String s1 = new String ("hello");
String （char [] value ）: 把字符数组的数据封装成字符串对象
举例： char [] chs = {'h','e','l','l','o'};
String s2 = new String (chs);
String （char [] value, int index , int count ）:把字符数组中的一部分数据 封装成字符串对象
举例： String s3 = new String(chs,0,chs.length);
数组名，开始索引，长度
System.out.println(s3);
String s4 = "String"
注意：字符串是一种比较特殊的引用数据类型，直接输出字串对象输出的是该对象的数据。
通过构造方法创建的字符串对象和直接赋值方式从创建的对象有什么区别呢？
通过构造方法创建字符串对象是在堆内存
直接赋值方法创建的对象实在方法去的常量池。
== 的作用：基本数据类型：比较的是基本数据类型的值是否相同
引用数据类型：比较的是引用数据类型的地址值是否相同
字符串的内容是存储在方法区常量池里面的，是为了方便字符串的重复使用。
String类的判断功能
Object:是类层次结构中的根类，所有的类都直接或者简洁的继承自该类。
如果一个方法的形式参数是Object，那么这里我们就可以传递他的任意的子类对象、
boolean equlas(Object obj)：比较字符串的内容是否相同
举例： System.out.println(s1.equals(s3));
boolean equlasIgnoreCase (String str):比较字符串的内容是否相同，忽略大小写
举例： System.out.println(s1.equalsIgnoreCase(s3));
boolean startWith（String str） ：判断字符串对象是否以指定的str开头
举例： System.out.println(s1.startwith("字符"))
boolean endWith （String str）：判断字符串对象是否以指定的 str结尾
String类的获取功能
举例： String s = "helloworld";
System.out.println(s.length());
char charAt(int index):获取指定索引处的字符
举例： System.out.println(s.charAt(0));
int indexOf(String str):获取str在字符串对象中第一次出现的索引
举例： System.out.println(s.indexOf("l"));
查询不到返回-1
String substring(int start):从start开始截取字符串
举例： System.out.println(s.substring(0));
String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
举例： System.out.println(s.substring(0, s.length()));
包括Start 不包括end
遍历数组可以用 length() 方法获取字符串的长度
练习获取字符中大写字母，小写字母，和数字；
分析：
A:键盘录入一个字符串数据
B:定义三个统计变量，初始化值都是0
C:遍历字符串，得到每一个字符
D:拿字符进行判断
假如ch是一个字符。
大写：ch>='A' && ch<='Z'
小写：ch>='a' && ch<='z'
数字：ch>='0' && ch<='9'
E:输出结果
public class StringTest2 {
public static void main(String[] args) {
//键盘录入一个字符串数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串数据：");
String s = sc.nextLine();
//定义三个统计变量，初始化值都是0
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//遍历字符串，得到每一个字符
for(int x=0; x<s.length(); x++) {
char ch = s.charAt(x);
//拿字符进行判断
if(ch>='A' && ch<='Z') {
bigCount++;
}else if(ch>='a' && ch<='z') {
smallCount++;
}else if(ch>='0' && ch<='9') {
numberCount++;
}else {
System.out.println("该字符"+ch+"非法");
}
}
//输出结果
System.out.println("大写字符："+bigCount+"个");
System.out.println("小写字符："+smallCount+"个");
System.out.println("数字字符："+numberCount+"个");
}
}
string类的转换功能
char[] toCharArray():把字符串转换为字符数组
举例：char[] chs = s.toCharArray();
String toLowerCase():把字符串转换为小写字符串
举例：System.out.println("HelloWorld".toLowerCase());
String toUpperCase():把字符串转换为大写字符串
举例：System.out.println("HelloWorld".toUpperCase());
String s1 = s.substring(开始索引,截取个数) 截取字符串
String类的其他功能
String trim()去除字符串两端空格
举例：s1.trim();
String[] split(String str) 按照指定符号分割字符串
String s1 = "aa,bb,ccc"
举例： String [] 数组名 = s1.split(",") 按逗号分隔
StringBuilder类
StringBulider：是一个可变的字符串。字符串缓冲区类
string和StringBuilder的区别：
String的内容是固定的。
StringBuilder的内容是可变的
构造方法
StringBuilder()
成员方法：
public int capacity(); 返回当前容量
System.out.println(sb.capacity());
public int length() 返回长度
System.out.println(sb.length());
StringBuilder类的常用方法
public StringBuilder append (任意类型)添加功能
punlic StringBuilder reveser() 反转功能
String和StringBuilder的相互转换
StringBuilder -- String Stringbuilder sb = new StringBuilder(s);
String -- StringBuildre sb.toString();
学集合类的原因：
我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通对象来体现的。
为了行方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要相对的多个对象惊醒存储，就不能是一个基本的变量，而应该是一个容器类型的变量。
到目前位置，学习到了那些容器类型的数据呢 StringBuilder ，数组
StringBuilderd的结果只能是一个字符串类型，不一定满足我们的需求。
所以我们只能选择数组了，也就是我们前面学习过的对象数组。
但是，数组的长度是固定的，适应不了变化的需求，那么，我们该如何选择呢》
这个时候java提供了集合类给我们使用、
集合类的特点：
长度可变。
ArrayLIst：是一种特殊的数据类型，泛型
使用：在出现E的地方我们使用引用数据类型替换即可
举例：ArrayList>,ArrayList
构造方法：ArrayList()
public boolean add(E e):添加元素
举例 ：array.add("hello")
public void add (int index,E element):在指定的索引处添加一个元素
举例： array.add(1,"anroid")
获取元素
public E get(int index):返回指定索引的元素
举例: array.get(0);
集合长度
public int size(); 返回集合中的元素的个数
举例：array.size();
删除元素
public boolean remover(Object o):删除指定的元素，返回删除是否成功
举例：array.remove("hello"); 成功返回true
public E remove (int index):删除指定索引处的元素，返回被删除的元素
举例：array.remove(0);
修改元素
public E set (int index , E element): 修改指定索引处的元素，返回被修改的元素
举例: array.set(1,"android");
集合的遍历：通过size方法和get方法配合使用
IO流可以把数据存储到文件
也可以从文件中读取数据
输出流写数据的步骤：
A：创建输出流对象
FileWriter fw = new FileWriter("d:\\a.txt")
B：调用输出流对象的写数据方法，并刷新缓冲区
fw.writer("helloworld");
//fw.fulsh
C：释放资源
fw.close
相对路径：相对当前项目而言的，在项目的根目录下
绝对路径：以盼复开始的路径(d"\\a.txt)
close()和flush()方法的区别
flush()：刷新缓冲区
close()：先刷新缓冲区，然后通知系统释放资源，流对象不可以再被使用
常见的应用
文件赋值（u盘拷贝内容）
上传文件（微信图片）
下载文件（迅雷）
IO流： 输入流 把三国演义文档导入到java程序
输出流 FileWriter 向计算机txt文档中写数据
构造方法
FileWriter(String fileName):传递一个文件名称
输出流写数据的对象
A：创建输出流对象
B：调用输出流对象的写数据的方法
C：释放资源
创建输出流对象做了哪些事情：
A：调用系统资源创建了一个文件
B：创建输出流对象
C: 把输出流对象指向文件
void writer (String strt) :写一个字符串数据
举例：fw.fwrite("abcde");
void writer (String str, int index , int l len) ：写 一个字符串中的一部分数据
举例： fw.fwriter("abcde",1,3); 结果：bcd
void writer (int ch) ： 写一个在i付出数据，这里写int类型的好处是既可以写char类型的数据，也可以写查对应的int类型的数据 举例 ‘a’ 97
举例：fw.fwrite(97);
void writer (char [] chs) ：写一个字符串数组数据
char [] chs = {'a','b',}
举例：fw.fwrite(chs);
void writer (char [] chs, int index , int len) ：写一个字符数组的一部分数据
举例：fw.fwrite(chs,2,3);
如何实现数据的换行？
\n可以事项换行，但是windows系统自带的记事本打开 并没有换行，这是为什么呢？因为windows识别的不是\n，而是\r\n。
windows：\r\n
linux ：\n
mac :\r
如何实现数据的追加写入？
FileWritere fw = new FileWriter(“c.txt”，true)表示追加写入，默认是false
FileReader读数据
构造方法：
FileReader（String fileName)"传递文件名称
输入流写读文件的步骤
A：创建输入流对象
B：调用输入流对象的写数据的方法
C：释放资源
java.io.FileNotFoundeException: fr.txt(fr指文件名)
int read(): 一次读取一个字符
int ch = fr.read(chs);
文件赋值也是有规律可循的，也就是说有套路。
数据源：FileWriterDemo.java -- 读数据 -- FileReader
目的地：Copy.java -- 写数据 -- FileWriter
字符缓冲流
BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
BufferedReader：将字符输入流中读取我那本，缓冲各个自付费，从而实现字符、数组和行的高效写入。
缓冲流的特殊功能
缓冲流的特殊功能：
void newline()：写一个换行符，这个换行符由系统决定
br.newline;
String readLine()：一次读取一行数据，但是不读取换行符
String line = br.readLine();
上一篇： Python知识点总结大全(一)
下一篇： Spring AMQP