Java 复习
2024.05.07 by zetazero
1.关键字
abstruct assert boolean break byte case catch char classconst continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while
2.不是关键字
System true false null
3.标识符
- 标识符由字母 下划线 美元符号 和数字组成 长度没限制
- 标识符的第一个字符不能是数字字符
- 标识符不能是关键字
- 标识符不能是true false null
4. 方法重写 (覆盖)
- 这个子类方法的函数名 参数个数 参数类型和返回值类型必须和父类的方法完全相同
- 重写方法既可操作继承的成员变量 调用继承的方法 也可以操作子类新声明的成员变量 调用新定义的其他方法 但是无法操作被子类隐藏的成员变量和方法 （如果子类想使用被隐藏的成员变量和方法 必须使用关键词super）
- static静态方法不可重写 但可被继承
- 实例方法不可被类方法重写
- 只有非private方法可重写
- 在重写父类方法的时候 不允许降低方法的访问权限 但可以提高访问权限(访问修饰符按访问权限从高到低的排序是public->protecetd->友好的->private)
5.方法重载
- 重载也可以发生在子类与父类(子类中定义一个与父类方法名相同但参数列表不同的方法)
- 在一个类中 可以有多个方法具有相同的名字 但是这些方法的参数必须不同 (返回值不做规定 可以相同也可以不同) 参数不同是指满足下列条件之一：
- 参数的个数不同
- 参数的个数相同 但是参数列表中对应的某个参数的类型不同
- 如果两个方法名字相同 即使返回类型不同 也必须保证参数不同
6.算术混合运算的精度
- 表达式有double 则按double进行运算
- 表达式的最高精度是float 则按float进行运算
- 表达式的最高精度是long 则按long进行运算
- 表达式的最高精度低于int 则按int进行运算
- Java允许把不超过byte short char 的取值范围的常量算术表达式的值 赋给byte short char 型变量
7.数据类型转换
- 精度由低到高:byte->short->char->int->long->float->double
- 级别低的值赋给级别高的变量 自动进行类型转换
- 高级别的变量->低级别的变量 需要强制转换
8.基本数据类型
- byte
- 变量 1字节内存 占8位
- 一个汉字是3个字节
- 范围是**-128~127**
- short
- 分配2字节内存 占16位
- 范围是-215 ~ 215 -1
- char
- 分配2字节内存 占16位
- 范围是0~65535
- int
- 常量:123(十进制) 077(八进制 用0做前缀) 0x3ABC(十六进制 0x和0X做前缀) 二进制(0b 0B)
- int变量分配4字节内存 取值是-231 ~ 231 -1
- long
- 常量用后缀L
- 分配8字节内存 占64位 1字节占8位
- float
- 常量后缀是f或F
- float变量在存储float型数据时 保留8位有效数字
- 分配4字节 32位
- double
- 后缀是d或D
- 分配8字节 占64位
- 浮点数 后缀什么都不加 默认double
9.Java 的平台
- JavaSE 标准版
- JavaEE 企业版
- JavaME 精简版
10.实例变量和类变量
-
区别：
-
1.类变量也叫静态变量，也就是在变量前加了static的变量;
-
2.实例变量也叫对象变量,即没加static的变量;
-
3.类变量和实例变量的区别在于:类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果;而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象;类变量又叫静态成员变量，它不需要创建对象就可以已经在内存中存在了。类就像一份说明书，说明这种类的实例对象的规格。而在创建实例对象的时候，内存中会为每一个实例对象的每一个非静态成员变量开辟一段内存空间，用来存储这个对象所有的非静态成员变量值。即使两个不同的实例对象是属于同一个 class类，但是它们的同名非静态成员变量在内存中占用的空间是不同的。而静态成员变量也就是类变量不同。所有的实例对象都共用一个类变量,内存中只有一处空间是放这个类变量值的。因此，如果一个对象把类变量值改了，另外一个对象再取类变量值就是改过之后的了。
-
4.类变量可以通过类名直接访问
-
-
不能用static修饰局部变量 以及原因：
- 生命周期：局部变量的生命周期与其所在的方法或代码块的执行期间相对应，而静态变量的生命周期与整个应用程序的执行期间相对应。因此，将
static用于局部变量会违反局部变量的生命周期规则。 - 访问权限：在方法内部声明的局部变量只能在该方法内部访问，而静态变量可以在类的任何地方访问，包括类的其他方法。因此，将局部变量声明为静态变量会破坏Java语言中的访问控制机制。
- 线程安全性：与其他语言类似，在多线程环境中，将局部变量声明为静态变量可能导致线程安全性问题。
- 生命周期：局部变量的生命周期与其所在的方法或代码块的执行期间相对应，而静态变量的生命周期与整个应用程序的执行期间相对应。因此，将
11.访问权限
-
private protected public在类外部
-
private成员：私有成员只能在声明它们的类内部访问，外部类无法直接访问。即使是同一个包中的其他类也无法访问私有成员。
-
protected成员：受保护成员可以在声明它们的类的内部访问，以及在同一包内的其他类和任何子类中访问。但是，如果受保护成员的类和访问它的类不在同一包中，而且访问它的类不是受保护成员的子类，则无法直接访问该成员。
-
public成员：公共成员可以在声明它们的类的内部访问，以及在任何其他类中的任何地方访问，无论这些类是否在同一包中。
-
友好成员：当在另外一个类中用Tom创建一个对象后 如果这个类与Tom类在同一个包中 那么该对象能访问自己的友好变量和友好方法 在任何一个与Tom同包的类中 也可以通过Tom类名访问Tom类的友好变量和友好方法
- 如果用import引用另一个包中的类 并创建对象 那么该对象不能访问自己的友好变量和友好方法
class Tom{ float weight; //友好变量 float f(float a,float b){ //友好方法 return a+b; } } -
-
不可以修饰局部变量 可以修饰构造方法
-
类中的实例方法总是可以操作该类的实例变量和类变量 类方法总是可以操作该类的类变量 与访问限制符没关系
-
不能用protected private修饰类
- 因为如果使用private修饰外部类，其它类就不能访问的这个类，那么这个类就不能创建实例，这个类的属性和方法就不能被外界访问，所以没有意义。
-
高->低：public --> protected --> 友好 -->private
12.String 常见方法
- str.substring(int x,int y) 裁剪出来索引[x,y)的字符串 str.substring(int x) 裁剪出来索引x到末尾的字符串
- str+3.0+4 就是直接加上去就行
- str.repeat(int x) 重复str字符串x次
- str.charAt(int x) 输出索引为x的字符
- str.replace(char x,char y)/(String x,String y) 把x替换成y
- str.startWith(String x) 判断str前缀是否为x
- str.endsWith(String x) 判断str后缀是否为x
- str.equals(String x) 判断str是否与x相等
- str.equalsIgnoreCase(String x) 不区分大小写判断str是否与x相等
- str.toLowerCase() 转化成小写
- str.toUpperCase() 转化成大写
13.控制台运行Java程序
- 创建一个Hello.java 文件 并在该文件里编写程序
- 在控制台使用javac Hello.java命令将其编译成Hello.class文件
- 最后直接运行java Hello命令 即可运行该java程序
14.Java的数组
- 不允许在声明数组中的方括号内指定数组元素个数
- int b[][]=new int [3] [6] b.length=3
- 定义二维数组的时候 可以只定义行数 不必定义列数的准确数量
- 例如：int b=new int [3] [ ] 是可以的
- char类型的数组 用sout输出的时候 直接输出该数组的所有元素值
15. 运算符
-
运算符运算后的结果的精度与运算前各数中精度最高的相同
-
^ 异或运算符：如果a b两个数据对应的位相同 则c的该位是0 否则是1
- 相同—0
- 不同—1
-
instanceof运算符
- 运算符左面是一个对象 右面是一个类 当左面的对象是右面的类或子类创建的对象时 该运算符的结果是true 否则是false
- 对象 instanceof 类
16.语句
-
空语句
- 一个分号也是一个语句 称作空语句
-
控制语句
- 条件分支语句 开关语句 循环语句
- switch开关语句
- 表达式可以是byte short int char String类型
- 表达式 不可以是浮点型(double float) 也不可以是long 可能会导致损失
-
do-while
- do-while和while的区别是do-while至少被执行一次
-
break和continue
- break
- 整个循环结束
- continue
- 结束本次循环
- break
17.成员变量和局部变量
- 成员变量有默认值 局部变量没有默认值
- this.x 指的是成员变量x
- 在使用局部变量的时候 由于局部变量没有默认值 所以必须要在使用前 给局部变量赋值
- 对变量的操作(赋值)只能放在方法体中
class DemoTest{
int a;
float b=12.57f; //合法
a=12; //非法 这是赋值语句 语句不是变量的声明 只能出现在方法体
b=12.56f; //非法
}
18.参数的传值
- 对于基本类型的参数 向该参数传递的值的级别 不可以高于该参数的级别 例如：可以向double型参数传递一个float值(可以直接进行转换)
- 可变参数
- 这些参数类型必须相同
- 称x是参数列表中的可变参数的参数代表 参数代表必须是参数列表的最后一个
public void f(int ...x)
public void method(int ...x,int y) //非法 因为参数代表必须是参数列表的最后一个
19.实例方法和类方法
- 不能用static修饰构造方法
- 区别：
- 在实例方法中 不仅可以操作实例变量 也可以操作类变量 实例方法可以调用类中的实例方法和类方法(不包括构造方法)
- 实例方法不可用类名调用 只可用对象调用
- 类方法不可以操作实例变量 不可以调用类中的实例方法 只可以调用类中的类方法
- 类方法不可操作实例变量的原因：在类创建对象之前实例对象变量还没有分配内存
- 对于static方法 不必创建对象就可以用类名直接调用 如果一个方法不需要操作类中的任何实例变量或调用类中的实例方法就可以满足程序需求 则可以把这个方法设计成static方法
20.this
- this不能出现在类方法
- 因为类方法可以通过类名直接调用 这时可能还没有任何对象产生
21.import
- 无包名且在同一个文件夹下的类 可以互相使用
- 无包名类也可以通过import语句使用有包名的类
- 有包名的类无论如何也不能使用无包名的类
22.继承
- 子类继承的方法只能操作子类继承的成员变量或 未继承的成员变量(隐藏的成员变量) 不可能操作子类新声明的变量
- 子类新定义的方法可以操作子类继承和子类新声明的成员变量 但无法操作子类隐藏的成员变量(可以用super操作子类隐藏的成员变量)
- 使用子类的构造方法创建一个子类对象的时候 不仅子类中声明的成员变量被分配了内存空间 而且父类的成员变量也都分配的内存空间
- 当子类与父类在同一包内
- 子类继承父类的非private成员变量和成员方法
- 父类的构造方法不继承 但是可使用
- 当子类与父类不在同一包内
- 子类继承父类的非private和友好成员变量和成员方法
23.super
- 当用super调用被隐藏的方法时 该方法中出现的成员变量是被子类隐藏的成员变量或继承的成员变量
- 如果子类在其构造方法中需要使用super调用父类的构造方法 而且super必须是子类构造方法的第一个语句 如果不显式的在子类构造方法写出super关键词来调用父类的某个构造方法 那么默认就有 super();
24.final
- final定义类不许有子类
- final修饰父类方法 该方法不许子类重写
- final修饰变量 则是常量
- final修饰方法中的参数 则参数的值只能使用不可改变
- final不可以修饰构造方法
25. 对象的上转型对象
- Animal类是Tiger类的父类 当用子类创建一个对象 并把这个对象的引用放到父类的对象中
Tiger b=new Tiger();
Animal a=b; //a是b的上转型对象 (老虎是动物)
- 上转型对象相当于子类对象的一个"简化"对象
- 上转型对象不能访问子类新增的成员变量 不能调用子类新增的方法
- 上转型对象可以访问子类继承或隐藏的成员变量 也可以调用子类继承的方法或子类重写的实例方法
- 上转型对象优先调用子类重写的实例方法 而不是调用子类继承的方法
- 可以将对象的上转型对象再强制转换成一个子类对象 这时该子类对象又具有了子类所有的属性和功能
- 如果子类重写了父类的静态方法 那么子类对象的上转型对象不能调用子类重写的静态方法 只能调用父类的静态方法
26.abstract
- 抽象方法只允许声明 不允许实现(没有方法体) 而且不允许使用final和abstract 同时修饰一个方法或类 也不允许使用static和private修饰abstract方法 即abstract方法必须是非private的实例方法(访问权限必须高于private)
- abstract类中可以有abstract方法也可以有非abstract方法 但是非abstract类不可以有abstract方法
- abstract类不能用new标识符创建对象
- 如果一个非抽象类是一个抽象类的子类 那么它必须重写父类的抽象方法(给出方法体)
- 如果一个抽象类是一个抽象类的子类 那么它可以重写父类的abstract方法 也可以继承父类的abstract方法
- 可以使用abstract类声明对象 尽管不能使用new标识符创建该对象 但该对象可以成为其子类对象的上转型对象 那么该对象就可以调用子类重写的方法
27.接口
- 接口体的所有抽象方法的访问权限一定是public(允许省略抽象方法的public和abstract)
- 接口体中所有static常量的访问权限一定都是public (而且允许省略public final static) 所以接口体只有常量没有变量(必须指定初值)
- 接口体实例方法必须用default修饰(不可省略) 访问权限一定是public(可以省略public)
- 接口体的static方法 可以用public和private修饰
- 如果一个类实现了某接口 那么这个类就拥有接口中的常量 default方法(去掉default关键字) 但该类不拥有接口的static和private方法
- 接口中除了private方法以外 其他方法的访问权限默认都是public 重写不可忽略public(否则就降低了访问权限)
- 可以用接口名访问接口的常量和static方法
- 父类实现某接口 子类自然实现该接口 不必显示声明
- 接口也可以继承
- import不仅引入了包中的类 也可以引入包中的接口
- 接口回调
- 可以把实现某接口的类创建的对象的引用赋值各该接口声明的接口变量 那么该接口变量就可以调用被类实现的接口方法 以及接口提供的default方法或类重写的default方法
28.内部类
-
内部类的外嵌类的成员变量在内部类中仍然有效 内部类的方法也可以调用外嵌类中的方法
-
外嵌类的类体中可以用内部类声明对象 作为外嵌类的成员
-
内部类仅供它的外嵌类使用 其他类不可以用其个类的内部类声明对象 可以用protected和private修饰内部类(不可以修饰非内部类)
-
内部类的外嵌类的成员变量在内部类有效
-
内部类可以被修饰为static内部类 static内部类不能操作外嵌类中的实例成员变量 非内部类不可以是static类
-
内部类的类体可以声明类变量和类方法
-
匿名类
- Java允许用户直接使用一个类的子类的类体创建一个子类对象 也就是说在创建子类对象时 除了使用父类的构造方法外 还有类体 此类体被认为是一个子类去掉类声明后的类体 称为匿名类 匿名类就是一个子类 可以直接用匿名类创建一个对象
- 匿名类可以继承父类的方法 也可以重写父类的方法
- 在使用匿名类时 必然是在某个类中 直接用匿名类创建对象 因此匿名类一定是内部类
- 匿名类可以访问外嵌类中的成员变量和方法 在匿名类的类体中不可以声明static成员变量和static方法
- 用匿名类创建对象时 虽然有构造方法 但是不能显式定义其构造方式 要直接使用父类的构造方法
- 匿名类一定是final类
- 编译器会给匿名类一个名字
29.异常类
- throw抛出异常对象
- throws在方法声明中指定可能会抛出的异常类型
30.String
- String类是final类 在java.lang包里 String类不能有子类
- String常量放在常量池里
- new构造的对象 不在常量池
- you+hi 相当于new String(“你好”) 不在常量池 在堆中
- “你”+“好"相当于常量池中的"你好” 也就是String x=“你好”
String you="你";
String hi="好";
String testOne,testTwo;
testOne=you+hi;
testTwo="你"+"好"
- 转义字符 也算在String的长度里
String x="\t\nABC";
System.out.println(x.length()); //输出5
31.正则表达式
| 带限定修饰符的模式 | 意义 | 带限定修饰符的模式 | 意义 |
|---|---|---|---|
| X? | X出现0次或1次 | X{n,} | X至少出现n次 |
| X* | X出现0次或多次 | X{n,m} | X出现n次至m次 |
| X+ | X出现1次或多次 | XY | X的后缀是Y |
| X{n} | X恰好出现n次 | X|Y | X或Y |
32.BigInteger
- 构造方法：参数是String类型
BigInteger bigInteger = new BigInteger("1232312212554855"); //参数是String
BigInteger b=BigInteger.valueOf(4); //参数是long类型
33.Math
- sqrt参数类型和返回值类型 都是double
public static double sqrt(double a) {
return StrictMath.sqrt(a);
}
34.Class类与反射
- Class是java.lang包中的类
- 任何类都默认有一个public的静态的Class对象 该对象的名字是class
- Class对象调用如下方法可以获取当前类的有关信息 例如类的名字 类中的方法名称 成员变量的名称 这一机制是Java反射
- String getName():返回类的名字
- …
35.组件及事件处理
- JFrame常用方法
- JFrame():创建一个无标题窗口
- JFrame(String s):创建标题为s的窗口
- public void setBounds(int a,int b,int width,int height):设置窗口的初始位置是(a,b),即距屏幕左面a个像素,距屏幕上方b个像素,窗口的宽是width,高是 height。
- public void setSize(int width,int height):设置窗口的大小。
- public void setlocation(int x,int y):设置窗口的位置,默认位置是(0,0)
- public void setVisible(boolean b):设置窗口是否可见,窗口默认是不可见的。
- public void setResizable(boolean b):设置窗口是否可调整大小,默认可调整大小。
- public void dispose():撤销当前窗口,并释放当前窗口所使用的资源。
- public void setExtendedState(int state):设置窗口的扩展状态,其中参数 state 取JFrame类中的类常量MAXIMIZEDHORIZ(水平方向最大化)、MAXIMIZEDVERT(垂直方向最大化)或MAXIMIZEDBOTH(水平、垂直方向都最大化)。
- public void setDefaultCloseOperation(int operation):该方法用来设置单击窗体右上角的关闭图标后程序会做出怎样的处理,其中的参数operation取JFrame类中的int型 stati常量DO NOTHING ON CLOSE(什么也不做)、HIDE ON CLOSE(隐藏当前窗口)DISPOSEONCLOSE(隐藏当前窗口,并释放窗体占有的其他资源)或EXITONCLOSE(结束窗口所在的应用程序),程序根据参数operation的取值做出不同的处理。
- 常用组件
- 都是JComponent子类
- JTextField 文本框
- JTextArea 文本区
- JButton 按钮
- JLabel 标签
- JCheckBox 复选框
- JRadioButton 单选框
- JComboBox 下拉列表
- JPasswordField 密码框
- 常用容器
- JPanel 面板
- JTabbedPane 选项卡窗格
- JScrollPane 滚动窗格
- JSplitPane 拆分窗格
- JLayeredPane 分层窗格
- 常用布局
- FlowLayout 布局
- BorderLayout 布局
- CardLayout 布局
- GridLayout 布局
- null 布局
- BoxLayout 布局
Java IO流
1.流的分类
- 按操作数据单位不分为：字节流(8 bit)二进制文件 字符流(按字符)文本文件
- 按数据流的流向不同分为：输入流(读取) 输出流(写入)
- 按流的角色的不同分为：节点流 处理流/包装流
| 抽象基类 | 字节流 | 字符流 |
|---|---|---|
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
-
Java的IO流的类 都是从以上4个抽象基类派生的
-
由着4个类派生出来的子类名称都是以其父类名作为子类名后缀
2.常用的类
- InputStream：字节输入流
- InputStream抽象类是所有类字节输入流的超类
FileInputStream：文件输入流
package hspedu.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStream_ {
public static void main(String[] args) {
readFile01();
readFile02();
}
/*演示FileInputStream (字节输入流 文件-->程序)
* 单个字节的读取 效率比较低
* ->使用read(byte[] b) */
static public void readFile01(){
String filePath="D:\\Java\\hspedu\\hello.txt";
int readData=0;
FileInputStream fileInputStream = null;
try {
/*创建FileInputStream对象 用于读取文件*/
fileInputStream = new FileInputStream(filePath);
/*从该输入流读取一个字节的数据 如果没有输入可用 此方法将阻止
* 如果返回-1 表示读取完毕*/
while ((readData=fileInputStream.read())!=-1){
System.out.print((char)readData);//转成char显示
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//一定要关闭文件流 释放资源
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
/*使用read(byte[] b) 读取文件 提高效率
* */
static public void readFile02(){
String filePath="D:\\Java\\hspedu\\hello.txt";
/*字节数组*/
byte[] buf=new byte[8];//一次读取8个字节
int readLen=0;
FileInputStream fileInputStream = null;
try {
/*创建FileInputStream对象 用于读取文件*/
fileInputStream = new FileInputStream(filePath);
/*从该输入流读取最多b.length字节的数据到字节数组 如果没有输入可用 此方法将阻止
* 如果返回-1 表示读取完毕
* 如果读取正常 返回实际读取的字节数*/
while ((readLen=fileInputStream.read(buf))!=-1){
System.out.print(new String(buf,0,readLen));//转成char显示
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//一定要关闭文件流 释放资源
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
- BufferedInputStream：缓冲字节输入流
- ObjectInputStream：对象字节输入流
- OutputStream：字节输出流
FileOutputStream
package hspedu.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStream01 {
public static void main(String[] args) {
writeFile();
}
/*演示使用FileOutputStream 将数据写入文件
* 如果文件不存在 则创建该文件*/
static public void writeFile(){
/*创建FileOutputStream对象*/
String filePath="D:\\Java\\hspedu\\a.txt";
FileOutputStream fileOutputStream=null;
try {
/*1.new FileOutputStream(filePath) 创建方式 当写入内容时 会覆盖原来的内容
* 2.new FileOutputStream(filePath,true) 创建方式 当写入内容时 会追加到文件后面*/
fileOutputStream=new FileOutputStream(filePath,true);
/*1.写入一个字节*/
// fileOutputStream.write('H');
/*2.写入多个字符串*/
/* String str="hello,world";
*//*str.getBytes() 可以把 字符串->字节数组*//*
fileOutputStream.write(str.getBytes());*/
/*3.写入字符串指定范围的数据
* write(byte[] b,int off,int len) 将len字节从位于off 指定字节数组*/
String str="hello,world";
fileOutputStream.write(str.getBytes(),0,str.length());
System.out.println("写入成功");
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
try {
fileOutputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
- 使用FileInputStream和FileOutputStream完成文件拷贝
package hspedu.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopy {
public static void main(String[] args) {
/*完成 文件拷贝 将""D:\GoogleDownload\1.jpg"" 拷贝到D:\Java\hspedu */
/*1.创建文件的输入流 将文件读入到程序
* 2.创建文件的输出流 将读取到的文件数据 写入到指定的文件*/
String srcFilePath = "D:\\GoogleDownload\\1.jpg";
String destFilePath="D:\\Java\\hspedu\\2.jpg";
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream(srcFilePath);
fileOutputStream=new FileOutputStream(destFilePath);
/*定义一个字节数组 提高读取效果*/
byte[] buf=new byte[1024];
int readLen;
while ((readLen=fileInputStream.read(buf))!=-1){
/*读取到后就写入文件 通过fileOutputStream 边读边写*/
fileOutputStream.write(buf,0,readLen);
}
System.out.println("拷贝成功");
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
/*关流 释放资源*/
try {
if (fileInputStream != null) {
fileInputStream.close();
}
if (fileOutputStream != null) {
fileOutputStream.close();
}
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
}
FileReader
- 相关方法
- new FileReader(File/String)
- read:每次获取单个字符 返回该字符 如果到文件末尾 返回-1
- read(char[ ]):批量读取多个字符到数组 返回读取到的字符数 如果到文件末尾 返回-1
- new String(char[]):将char[]转换成String
- new String(char[],off,len):将char[]的指定部分转化成String
- 样例代码：
package hspedu.File;
import java.io.FileReader;
import java.io.IOException;
public class FileReader01_ {
public static void main(String[] args) {
// readFile01();
readFile02();
}
/*单个字符读取*/
static public void readFile01() {
String FilePath = "D:\\Java\\hspedu\\story.txt";
FileReader fileReader = null;
int data;
/*1.创建fileReader对象*/
try {
fileReader = new FileReader(FilePath);
/*循环读取 使用read 单个字符读取*/
while ((data = fileReader.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
try {
if (fileReader != null) {
fileReader.close();
}
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
/*字符数组读取*/
static public void readFile02() {
String FilePath = "D:\\Java\\hspedu\\story.txt";
FileReader fileReader = null;
int readLen=0;
char[] buf=new char[8];
/*1.创建fileReader对象*/
try {
fileReader = new FileReader(FilePath);
/*循环读取 使用read(buf) 返回的是实际读取到的字符数
* 返回-1 说明文件结束*/
while ((readLen = fileReader.read(buf)) != -1) {
System.out.print(new String(buf,0,readLen));
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
try {
if (fileReader != null) {
fileReader.close();
}
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
}
FileWriter 继承于Writer
- 相关方法
- new FileWriter(File/String):覆盖模式 相当于流的指针在首端
FileWriter类的构造函数会在打开文件时自动创建文件。当你使用new FileWriter(FilePath)创建FileWriter对象时，如果指定的文件不存在，Java会尝试创建该文件。因此，即使在代码中没有显式地创建文件的操作，执行程序后文件也会被创建。
- new FileWriter(File/String,true):追加模式 相当于流的指针在尾端
- write(int):写入单个字符
- write(char[]):写入指定数组
- write(char[],off,len):写入指定数组的指定部分
- write(string):写入整个字符串
- write(string,off,len):写入字符串的指定部分
- String类：toCharArray:将String转换成char[]
- new FileWriter(File/String):覆盖模式 相当于流的指针在首端
FileWriter使用后 必须要关闭(close)或刷新(flush) 否则写入不到指定的文件
- 样例代码：
package hspedu.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriter_ {
public static void main(String[] args) {
String FilePath = "D:\\Java\\hspedu\\note.txt";
/*创建FileWriter对象*/
FileWriter fileWriter = null;
char[] chars={'a','b','c'};
try {
fileWriter = new FileWriter(FilePath);//覆盖模式
//1.write(int):写入单个字符
fileWriter.write('H');
//2.write(char[]):写入指定数组
fileWriter.write(chars);
//3.write(char[],off,len):写入指定数组的指定部分(指定部分的len表示5个字符)
fileWriter.write("双刀流天下第一".toCharArray(),0,5);
//4.write(string):写入整个字符串
fileWriter.write("你好双刀流!!!");
//5.write(string,off,len):写入字符串的指定部分*/
fileWriter.write("双刀流天下第一",0,2);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
/*==FileWriter使用后 必须要关闭(close)或刷新(flush) 否则写入不到指定的文件==*/
try {
if(fileWriter!=null){
fileWriter.close();
}
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
System.out.println("程序结束!");
}
}
3.节点流和处理流
-
处理流BufferedReader和BufferedWriter
-
BufferedReader和BufferedWriter属于字符流 是按照字符来读取数据得到
-
关闭时处理流 只需要关闭外层流
-
BufferedReader 字符流
package hspedu.File;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*更高效*/
public class BufferedReader_ {
public static void main(String[] args) throws IOException {
String FilePath="D:\\Java\\hspedu\\story.txt";
/*创建bufferedReader*/
/*因为 FileReader 是 Reader 的子类，可以直接传递给 BufferedReader 的构造方法作为参数*/
BufferedReader bufferedReader = new BufferedReader(new FileReader(FilePath));
/*读取*/
String line;//按行读取
while ((line=bufferedReader.readLine())!=null){
System.out.println(line);
}
/*关流 关外层流(BufferedReader) 底层会自动关闭节点流*/
bufferedReader.close();
}
}
- **BufferedWriter **字符流
package hspedu.File;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriter_ {
public static void main(String[] args) throws IOException {
String FilePath="D:\\Java\\hspedu\\ok.txt";
/*创建BufferedWriter对象*/
/*覆盖方式写入*/
// BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(FilePath));
/*追加方式写入*/
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(FilePath,true));
bufferedWriter.write("Hello syhsyh");
/*插入换行*/
bufferedWriter.newLine();
// bufferedWriter.write("\n");
bufferedWriter.write("Hello syhsyh");
/*关闭外层流即可 底层自动关闭new FileWriter(FilePath)*/
bufferedWriter.close();
}
}
- BufferedReader和BufferedWriter 进行文本/字符文件的拷贝
package hspedu.File;
import java.io.*;
public class BufferedCopy_ {
public static void main(String[] args) {
/*BufferedReader和BufferedWriter 操作的是字符文件
* 不可操作 二进制文件(声音 视频 word) 可能会导致文件损坏*/
String srcFilePath="D:\\Java\\hspedu\\story.txt";
String destFilePath="D:\\Java\\hspedu\\b.txt";
BufferedReader br=null;
BufferedWriter bw=null;
String line;
try {
br=new BufferedReader(new FileReader(srcFilePath));
bw=new BufferedWriter(new FileWriter(destFilePath));
while ((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
}
System.out.println("完成");
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
try {
assert br != null;
br.close();
assert bw != null;
bw.close();
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
}
- BufferedInputStream 字节流
- BufferedOutputStream 字节流
- 使用BufferedInputStream和BufferedOutputStream进行二进制文件的拷贝
package hspedu.File;
import java.io.*;
/*使用BufferedInputStream和BufferedOutputStream进行二进制文件的拷贝*/
public class BufferedCopy02_ {
public static void main(String[] args) {
/*BufferedInputStream和BufferedOutputStream既可以操作文本文件 也可以操作二进制文件*/
String srcFilePath="D:\\Java\\hspedu\\2.jpg";
String destFilePath="D:\\Java\\hspedu\\3.jpg";
/*创建对象*/
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
try {
/*因为FileInputStream继承了InputStream*/
bis=new BufferedInputStream(new FileInputStream(srcFilePath));
bos=new BufferedOutputStream(new FileOutputStream(destFilePath));
/*循环读取文件 写入destFilePath*/
byte[] buff=new byte[1024];
int readLen;
while((readLen= bis.read(buff))!=-1){
bos.write(buff,0,readLen);
}
System.out.println("完成");
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
/*关流*/
try {
if(bis!=null) {
bis.close();
}
if(bos!=null) {
bos.close();
}
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
}
- 对象处理流
- 推荐实现Serializable(中文:可序列化的)接口
- ObjectOutputStream
- 提供序列化功能
- ObjectInPutStram
- 提供反序列化功能
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
