文章目录
File类
概述
- File类是文件和目录路径名的抽象表示
- 文件和目录是可以通过File封装成对象的
- File封装的不是一个真实存在的文件，只是一个路径名；它可以存在，也可以不存在；将来要通过具体的操作把这个路径的内容转换为具体存在。
构造方法
public class FileDemo01 {
public static void main(String[] args) {
//File(String pathname)：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File f1 = new File("D:\\data\\java.txt");
System.out.println(f1);
//File(String parent, String child)：从父路径名字符串和子路径名字符串创建新的 File实例。
File f2 = new File("D:\\data","java.txt");
System.out.println(f2);
//File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例。
File f3 = new File("D:\\data");
File f4 = new File(f3,"java.txt");
System.out.println(f4);
}
}
创建功能
判断功能
获取功能
删除功能
绝对路径和相对路径的区别
绝对路径：完整的路径名，不需要任何其他信息九口人定位它所表示的文件。
例： D:\demo\java,txt
相对路径：必须使用取自其他路径名的信息进行解释
递归
概述
- 从编程来看，递归是指方法定义中调用方法本身的现象。
- 递归可以把一个复杂问题层层转化为一个相较于原问题规模较小的问题来求解。
- 只需少量程序就可描述出解题过程中的多次重复计算。
注意事项
递归一定要有出口，否则内存溢出。但是递归次数不宜过多。否则也会溢出。
递归求阶乘
//核心代码
public static int jc(int n) {
//在方法内部判断该变量的值是否是1
if(n == 1) {
//是：返回1
return 1;
} else {
//不是：返回n*(n-1)!
return n*jc(n-1);//调用本身
}
}
IO流
IO流概述
逐个分析
IO：输入或者输出， Input/Output；
流：一种抽象概念，对数据传输的总称；数据在设备间的传输称为流，流的本质是数据传输。
所以IO流的本质就是用来处理设备间数据传输问题的，比如文件复制、文件上传、文件下载.
那么IO流就是用来处理设备间数据传输问题的。
IO流分类
那么根据数据的流向，我们可以将IO流分为哦两种，分别是输入流(读数据)和输出流(写数据)，
按照数据类型，我们一般分为字节流和字符流，再细分为字节输入输出流和字符输入输出流。
如果是纯文本文件，优先使用字符流。图片视频等二进制文件，优先使用字节流。
如果不确定文件类型，优先使用字节流，而字节流是万能的流。
字节流
字节流抽象基类
InputStream：表示字节输入流的所有类的超类；
OutputStream：表示字节输出流的所有类的超类；
它们的子类名都是以其递父类名作为子类名的后缀。
注意写入的字节导致底层系统的调用。
字节输出流
FileOutputStream(String name)：创建文件输出流以指定的名称写入文件。
那么使用字节输出流写数据的步骤一共有三步：
1）创建字节输出流对象；
2）调用字节输出流对象的写数据方法；
3）释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
注意一定要释放资源！！！
写数据的方法分类一般有如下几个
在实际运用过程中，我们会遇到两个小问题
1）字节流写数据如何实现换行呢？
在不同操作系统下的换行符有所区别
- windows:\r\n
- linux:\n
- mac:\r
2）字节流写数据如何实现追加写入呢？
public FileOutputStream(String name,boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头
在编写代码时，我们除了将IOException抛出，还可以用try…catch…finally解决异常问题。
在最后的finall块进行释放资源的操作。同时也要注意创建文件是否成功，需要考虑代码的健壮性。
字节输入流
字节流读数据有两种思路
1）一次读一个字节数据
FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream ，该文件由文件系统中的路径名name命名。
读取数据的步骤与写数据的步骤思路基本一致。
2）一次读一个字节数组数据
- public int read(byte[] b)：从输入流读取最多b.length个字节的数据
- 返回的是读入缓冲区的总字节数,也就是实际的读取字节个数
代码例如如下
实际运用
字节流复制文本文件——其实就是把文本文件的内容读取出来，写入到另一个文件中。
字节缓冲流
BufferedOutputStream——该类实现缓冲输出流，通过设置这样的输出流，应用程序可以向底层输出流写入字节，写入字节不必导致底层系统的调用；
BufferedInputStream——创建后将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节；
其实字节缓冲流构造方法时，需要的还是字节流，而不是具体的文件或路径。因为字节缓冲流·仅仅提供缓冲区，而读写数据还是依靠基本的字节流对象进行操作。其内部封装了一个大小为8192的字节数据，这就是它的缓冲区。
字节缓冲流读取、写入数据的耗时会比较少，会更快响应。一般情况可以多考虑缓冲流。
字符流
介绍
用字节流操作带有中文的文本文件时，发现会出现乱码。为了操作中文方便，提供了字符流。
所以字符流=字节流+编码表。
那么什么是编码表呢？
我们知道计算机中的信息都是二进制，它们按照规则将字符存储到计算机中，称为编码；反之解析出来称为解码。注意编码解码用的方式要统一，否则会乱码。
一套字符至少有一套字符编码，比如ASCII字符集、GBXXX字符集、Unicode字符集等。具体就不详细介绍了。
以上的字符集遵从一个编码规则：
1）128个US-ASCII字符，只需一个字节编码；
2）拉丁文等字符，需要二个字节编码；
3） 大部分常用字（含中文），使用三个字节编码；
4） 其他极少使用的Unicode辅助字符，使用四字节编码；
字符流抽象基类
Reader——字符输入流的抽象类；
Writer——字符输出流的抽象类；
字符串中的解码编码问题
一些相关方法
转换流
InputStreamReader——字节流到字符流的桥梁，读取字节，并使用指定的编码将其解码为字符，使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集；
OutputStreamWriter——是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节；它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集；
构造方法
字符流写数据的5种方式
读数据两种方式
刷新和关闭
字符流同样也有字符缓冲流
字符缓冲流
BufferedWriter——将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途；
BufferedReader——从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可指定可默认，默认足够大，可用于大多用途；
字符缓冲流有它的特有功能
1）BufferedWriter
2）BufferedReader
特殊操作流
标准输入流
public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源。
标准输出流
public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标；
输出语句的本质：是一个标准的输出流；
PrintStream类有的方法，System.out都可以使用；
打印流
1）字节打印流——PrintStream；
PrintStream(String fileName)：使用指定的文件名创建新的打印流；
使用继承父类的方法写数据，查看的时候会转码，使用自己特有的方法写数据，查看的数据原样输出。
2）字符打印流——PrintWriter
打印流的特点：
1）只负责输出数据，不负责读取数据；
2）永远不会抛出IOException；
3）有自己特有的方法；
对象序列化流
1）对象序列化——将对象保存到磁盘中，或者在网络中传输对象；
2）这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息；
3）字节序列写到文件之后，相当于文件中持久保存了一个对象的信息；
反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化；
ObjectOutputStream
将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取（重构）对象。 可以通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象
序列化对象方法
注意：
1）一个对象要想被序列化，该对象所属的类必须实现Serializable 接口；
2）Serializable是一个标记接口，实现该接口，不需要重写任何方法；
对象反序列化流
ObjectInputStream
ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象；
反序列化对象的方法：
serialVersionUID
1）用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？
会出问题，会抛出InvalidClassException异常；
2）如果出问题了，如何解决呢？
重新序列化；
给对象所属的类加一个serialVersionUID
- private static final long serialVersionUID = 42L;
transient
如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程；
注意：在序列化过程中，要考虑对象所属的类文件是否存在以及文件内容是否为空
Properties集合
介绍
1）是一个Map体系的集合类；
2）Properties可以保存到流中或从流中加载；
3）属性列表中的每个键及其对应的值都是一个字符串
特有方法
和IO流结合的方法
总结
IO流小结
练习
public class Test {
public static void main(String[] args) throws IOException {
/* 1. 利用File构造器，new 一个文件目录file
1)在其中创建多个文件和目录，测试自己学过的File类的方法
2)手动编写方法，实现删除file中指定文件的操作*/
File f1 = new File("F:\\Test");
System.out.println(f1.mkdir());
PrintStream ss = System.out;
File f2 = new File("F:\\Test\\Demo");
System.out.println(f2.mkdirs());
File f3 = new File("F:\\Test\\java.txt");
System.out.println(f3.createNewFile());
File f4 = new File("F:\\Test\\Demo\\java.txt");
System.out.println(f4.createNewFile());
//判断
System.out.println("------------------------------");
System.out.println(f1.isDirectory());
System.out.println(f2.isFile());
System.out.println(f3.exists());
//获取
System.out.println(f4.getAbsolutePath());
System.out.println(f1.getPath());
System.out.println(f2.getName());
//返回数组
String[] s = f3.list();
if(s != null){
for(int i = 0; i < s.length; i++){
System.out.println(s[i]);
}
}else{
System.out.println("数组为空！");
}
File[] f = f2.listFiles();
if(f != null){
for(int i = 0; i < f.length; i++){
System.out.println(f[i]);
}
}else{
System.out.println("数组为空！");
}
//手动编写方法，实现删除file中指定文件的操作
System.out.println("------------------------------");
File f5 = new File("F:\\Home");
System.out.println(f5.mkdir());
File f6 = new File("F:\\Home\\java.txt");
System.out.println(f6.createNewFile());
removeDirectory(f5);
//3. 遍历指定目录所有文件名称，包括子文件目录中的文件（注意这句话，经典递归方法，不知道思路的直接问）。
System.out.println("------------------------------");
File f7 = new File("F:\\Test\\Demo\\Work");
f7.mkdirs();
File f8 = new File("F:\\Test\\Demo\\Work\\dir.txt");
f8.createNewFile();
showDir(f1);
}
//删除
public static void removeDirectory(File f){
File[] arr = f.listFiles();
if(arr != null){//数组是否为空
for(File dir : arr){
if(dir.isDirectory()){//是目录就递归
removeDirectory(dir);
}else{//否则是文件就删除
dir.delete();
System.out.println("删除成功！");
}
}
}
}
//遍历目录下所有文件的名称包括子目录中的子文件
public static void showDir(File f){
File[] dir = f.listFiles();
if(dir != null){//数组不为空
for(File ff : dir) {
if(ff.isDirectory()){//是否为目录
System.out.println(ff.getName());
showDir(ff);
}else{
System.out.println(ff.getName());
}
}
}
}
}
public class Test02 {
public static void main(String[] args) throws IOException {
//创建文件目录
File f1 = new File("F:\\Test02\\Work");
System.out.println(f1.mkdirs());
File f2 = new File("F:\\Test02\\Work\\java.jpg");
System.out.println(f2.createNewFile());
//获取后缀
String[] ff = f1.list();
if(ff != null){
for(String fileName : ff){
if(fileName.contains(".")){
int index = fileName.lastIndexOf(".");
String sub = fileName.substring(index);
if(sub.equals(".jpg")){//是否包含该类型文件
System.out.println(fileName);
}
}
}
}else{//为空
System.out.println("数组为空！");
}
}
}
//4. 创建一个与a.txt文件同目录下的另外一个文件b.txt f3 F:\Test\Demo\java.txt
public class Test03 {
public static void main(String[] args) throws IOException {
File f1 = new File("F:\\Test03\\Demo\\");
f1.mkdirs();
File f2 = new File("F:\\Test03\\Demo\\a.txt");
f2.createNewFile();
File f3 = new File("F:\\Test03\\Demo\\b.txt");
f3.createNewFile();
}
}
/*5.操作D盘下的my.txt文件
1) 判断my.txt文件是否存在
2) 若存在则删除;若不存在则创建*/
public class Test04 {
public static void main(String[] args) throws IOException {
File f1 = new File("D:\\my.txt");
if(f1.exists()){//文件是否存在
System.out.println("删除结果："+f1.delete());
}else{
System.out.println("创建结果："+f1.createNewFile());
}
}
}
/* 7.使用File类删除某个文件夹（例如D盘下的temp文件夹）下的所有文件和文件夹:
1） 判断temp文件夹下的文件类型，如果是文件则直接删除
2） 如果是文件夹则获取该文件夹下的子文件和文件夹
3） 使用递归的方式删除所有temp文件夹下的文件和文件夹（可参考3题）*/
public class Test05 {
public static void main(String[] args) throws IOException {
//创建目录和文件
File f1 = new File("D:\\temp");
System.out.println(f1.mkdir());
File f2 = new File("D:\\temp\\Test");
System.out.println(f2.mkdirs());
File f3 = new File("D:\\temp\\java.txt");
System.out.println(f3.createNewFile());
File f4 = new File("D:\\temp\\Test\\web.txt");
System.out.println(f4.createNewFile());
File f5 = new File("D:\\temp\\Test\\Demo");
System.out.println(f5.mkdirs());
deleteAll(f1);
}
public static void deleteAll(File f){
File[] file = f.listFiles();
for(File f2 : file){
if(f2.isFile()){
f2.delete();
System.out.println("删除了"+f2.getName());
}else{
deleteAll(f2);
}
}
f.delete();
System.out.println("删除了"+f.getName());
}
}
//3.使用缓冲流实现a.jpg文件复制为b.jpg文件的操作
public class Test {
public static void main(String[] args) throws IOException {
//创建对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\Test03\\b.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("F:\\Test03\\a.jpg"));
//复制
byte[] bys = new byte[1024];
int len;
while((len= bis.read(bys)) != -1){
bos.write(bys,0,len);
}
//释放资源
bos.close();
bis.close();
}
}
//分别使用字节流和字节缓冲流，实现文本文件/图片/视频文件的复制。并比较二者在数据复制方面的效率（提示：日期类）
public class Test02 {
public static void main(String[] args) throws IOException {
long startTime = System.currentTimeMillis();//开始时间
// method1();
method2();
long endTime = System.currentTimeMillis();//结束时间
System.out.println("共耗时"+(endTime-startTime)+"毫秒");
}
//字节流实现文本文件/图片/视频文件
public static void method1() throws IOException {
// FileInputStream fis = new FileInputStream("F:\\Test03\\a.jpg");
// FileInputStream fis = new FileInputStream("F:\\Test03\\a.txt");
FileInputStream fis = new FileInputStream("F:\\Test03\\a.avi");
// FileOutputStream fos = new FileOutputStream("D:\\Test0303\\b.jpg");
// FileOutputStream fos = new FileOutputStream("D:\\Test0303\\b.txt");
FileOutputStream fos = new FileOutputStream("D:\\Test0303\\b.avi");
byte[] bys = new byte[1024];
int len;
while((len = fis.read(bys)) != -1){
fos.write(bys,0,len);
}
fis.close();
fos.close();
}
//字节缓冲流实现文本文件/图片/视频文件的复制
public static void method2() throws IOException {
/*BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\Test03\\a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\Test0303\\b.txt"));*/
/*BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\Test03\\a.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\Test0303\\b.avi"));*/
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\Test03\\a.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\Test0303\\b.jpg"));
byte[] bys = new byte[1024];
int len;
while((len = bis.read(bys)) != -1){
bos.write(bys,0,len);
}
bis.close();
bos.close();
}
}
/*2. 获取自定义文本上每个字符出现的次数
提示：遍历文本的每一个字符；字符及出现的次数保存在Map中；将Map中数据写入文件
列入：aabbccddwab ----->a3b3c2d2w1*/
public class Test03 {
public static void main(String[] args) throws IOException {
//创建Map集合
Map<Character,Integer> map = new HashMap<>();
//遍历每一个字符，每个字符出现的次数放到map中
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\Test03\\hello.txt"));
int c = 0;
while ((c = bis.read())!=-1){
char ch = (char) c;
//判断字符及出现次数
if(map.get(ch)==null){
map.put(ch,1);
}else{
map.put(ch,map.get(ch)+1);
}
}
//把map中数据存入文件count.txt
// BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("F:\\Test03\\count.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\Test03\\count.txt"));
//遍历map，再写入数据
Set<Map.Entry<Character,Integer>> entrySet = map.entrySet();
for (Map.Entry<Character,Integer> entry :entrySet) {
char key = entry.getKey();
int value = entry.getValue();
bw.write(key);
bw.write(""+value);
// bos.write(key+ "=" + value);
}
bis.close();
// bos.close();
bw.close();
}
}
//3.编写一个应用程序，将用户从键盘输入的10个整数存入文件，再顺序读出。
public class Test04 {
public static void main(String[] args) throws IOException {
//获取10个String 整数
System.out.println("请输入10个整数:");
Scanner sc = new Scanner(System.in);
String str = sc.next();
File file = new File("F:\\Test03\\s.txt");
//存入文件
FileOutputStream fos =null;
try{
fos = new FileOutputStream(file);
fos.write(str.getBytes());
System.out.println("存入文件成功！");
}catch (IOException i){
i.printStackTrace();
}
finally {
if(fos != null){
try{
fos.close();
}catch(IOException i){
i.printStackTrace();
}
}
}
//顺序读出
FileInputStream fis = null;
try{
fis = new FileInputStream(file);
int data;
System.out.println("顺序读取的内容为：");
while((data = fis.read()) != -1){
System.out.print((char) data);
}
}catch (IOException i){
i.printStackTrace();
}finally {
if(fis != null){
try{
fis.close();
}catch (IOException i){
i.printStackTrace();
}
}
}
}
}
/*4.编写程序向文本文件中写入自己的信息，
格式为：姓名：XXX 性别：X 年龄：XX 班级：XXX，
将该信息读出后显示的屏幕上后把文件删除。
（思考，读取中文会出现乱码？应该用什么流来读取最好？？可以先不用纠结，继续往后面的知识学了 再来解决）*/
public class Test05 {
public static void main(String[] args) throws IOException {
System.out.println("填写自己的信息：");
System.out.println("格式为：姓名：XXX 性别：X 年龄：XX 班级：XXX");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
FileOutputStream file = null;
try {
file = new FileOutputStream("F:\\hello.txt");
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
}
DataOutputStream fos = null;
try {
fos = new DataOutputStream(file);
fos.write(str.getBytes());
fos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
sc.close();
File file1 = new File("F:\\hello.txt");
seek(file1);
System.out.println("\n");
delete(file1);
}
public static void seek(File file1) {
FileReader fr = null;
try {
fr = new FileReader(file1);
int data = fr.read();
System.out.print("信息读出:");
while (data != -1) {
System.out.print((char)data);
data = fr.read();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fr != null) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void delete(File file1) {
System.out.println("已删除");
file1.delete();
}
}
/*
1.在指定的路径下新建一个 .txt 文件 "test.txt"，利用程序在文件中写入如下内容：
"Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，
是由Sun Microsystems公司于 1995年5月推出的Java程序设计语言和Java平台
（即JavaSE, JavaEE, JavaME）的总称。Java 技术具有 卓越的通用性、高效性、平台移植性和安全性，
广泛应用于个人PC、数据中心、游戏控制台、科 学超级计算机、移动电话和互联网，
同时拥有全球最大的开发者专业社群。在全球云计算和移动互 联网的产业环境下，Java更具备了显著优势和广阔前景。"
并且成功读出在控制台打印，而且利用程序复制 test.txt 给 test1.txt
*/
public class Test {
public static void main(String[] args) {
//创建字符流对象 写入文本
BufferedWriter bw = null;
String s = "Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由Sun Microsystems公司于 1995年5月推出的Java程序设计语言和Java平台（即JavaSE, JavaEE, JavaME）的总称。Java 技术具有 卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科 学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。在全球云计算和移动互 联网的产业环境下，Java更具备了显著优势和广阔前景。";
try{
bw = new BufferedWriter(new FileWriter("F:\\Test03\\test.txt"));
bw.write(s);
}catch (IOException i){
i.printStackTrace();
}finally {
if(bw != null){
try{
bw.flush();
bw.close();
}catch (IOException i){
i.printStackTrace();
}
}
}
//读取文本并打印
BufferedReader br = null;
try {
//输入流对象
br = new BufferedReader(new FileReader("F:\\Test03\\test.txt"));
String str;
while((str=br.readLine())!=null)
{
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
}finally
{
if(br!=null)
{
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//复制test.txt 给 test1.txt
//数据源输入 目的地输出
BufferedWriter bw2 = null;
BufferedReader br2 = null;
try{
bw2 = new BufferedWriter(new FileWriter("F:\\Test03\\test1.txt"));
br2 = new BufferedReader(new FileReader("F:\\Test03\\test.txt"));
String str;
while((str=br2.readLine()) != null){
bw2.write(s);
System.out.println(str);
}
}catch (IOException i){
i.printStackTrace();
}finally {
try{//释放资源
if(bw2 != null){
bw2.close();
br2.close();
}
}catch (IOException i){
i.printStackTrace();
}
}
}
}
//（字符流）读取一个文本文件，每行都追加一个“好”，在文件结尾再追加“完毕”。
public class Test02 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("F:\\Test03\\earth.txt"));
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\Test03\\earth2.txt"));
//读取一个文本文件，每行都追加一个“好”，在文件结尾再追加“完毕”。
String line;
while((line=br.readLine())!=null){
//每行都追加一个“好”
line=line+"好";
bw.write(line);
bw.newLine();
bw.flush();
}
//在文件结尾再追加“完毕”
bw.write("完毕");
bw.flush();
//释放资源
bw.close();
br.close();
}
}
/*使用Java的输入、输出流将一个文本文件的内容按行读出，
每读出一行就顺序添加行号，并写入到另一个文件中。*/
public class Test03 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("F:\\Test03\\app.txt"));
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\Test03\\app2.txt"));
//读取一个文本文件，每行都追加一个“好”，在文件结尾再追加“完毕”。
String line;
int count = 1;
while((line=br.readLine())!=null){
//每行都追加一个“好”
line = (count++) + line;
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
br.close();
}
}
/*4.（实践题）使用输入流读取试题文件，每次显示试题文件中的一道题目。
读取到字符“*”时暂停读取，等待用户从键盘输入答案。用户做完全部题目后。
程序给出用户的得分(10分一道题)。
1） 试题内容如下：
(1)英雄联盟S9全球总决赛是什么时间开幕的？
A.2018-08-08 B. 2018-08-01
C.2019-10-01 D. 2019-10-02 D
********************
(2)下列哪个英雄不属于《英雄联盟》？
A.卡特 B.盲僧 C.剑豪 D.后羿 D
********************
(3).以下哪一句不是疾风剑豪亚索的台词?
A.死亡如风，常伴吾身。B.面对疾风吧!C.真正的大师，永远都怀着一颗学徒的心。D.哈塞给！ C
********************
(4).英雄联盟世界S赛被OMG基地50血翻盘的战队是? C
A.SKT B.Najin C.FNC D.G2
********************
（5）英雄联盟中，戏称最争气的英雄是? B
A迅捷斥候 B蒸汽机器人 C德玛西亚之力 D疾风剑豪
********************
-------》程序运行如下：
(1)英雄联盟S9全球总决赛是什么时间开幕的？
A.2018-08-08 B. 2018-08-01
C.2019-10-01 D. 2019-10-02
输入选择的答案（A、B、C、D）：D
(2)下列哪个英雄不属于《英雄联盟》？
A.卡特 B.盲僧 C.剑豪 D.后羿
输入选择的答案（A、B、C、D）：D
...
...
完成试题，恭喜你 你最后的得分为：20 分。*/
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class Test04 {
public static void main(String[] args) throws IOException {
//创建输入流对象
BufferedReader br = new BufferedReader(new FileReader("F:\\Test03\\exam.txt"));
//显示试题题目 *暂停读取 用户输入答案
String str;//读取到的字符串
StringBuilder yourAns = new StringBuilder();//拼接自己的答案
Scanner sc = new Scanner(System.in);
while((str = br.readLine()) != null){
if(!str.startsWith("*")){
System.out.println(str);
}else{
System.out.println("输入选择的答案(A、B、C、D)：");
yourAns.append(sc.next());
}
}
//释放资源
br.close();
String ans = "DDCCB";
//分数
int score = 0;
for(int i = 0; i < ans.length(); i++){
if(yourAns.charAt(i) == ans.charAt(i)){
score +=10;
}
}
//输出最后得分
System.out.println("完成试题，恭喜你 你最后的得分为："+score+"分");
}
}
/*1.用代码实现以下需求：
(1)已知配置文件config.txt中有三个键值对
name=zhangsan
score=80
address=beijing
(2)使用IO字节流对象和Properties类结合使用,将配置文件中的score键的值修改为100*/
import java.io.*;
import java.util.Properties;
import java.util.Set;
public class Test {
public static void main(String[] args) throws IOException {
//创建对象
File file = new File("F:\\Test03\\config.txt");
Properties pro = new Properties();
//键值对输入
pro.setProperty("name", "zhangsan");
pro.setProperty("score", "80");
pro.setProperty("address", "beijing");
//properties修改score为100
Set<String> set = pro.stringPropertyNames();
for(String key : set){
pro.setProperty("score","100");
String value = pro.getProperty(key);
System.out.println(key +"="+ value);
}
FileOutputStream fos = new FileOutputStream(file);
pro.store(fos, null);
fos.close();
}
}
/*2.编写一个小程序，记录程序运行的次数，满足5次后，给出提示，试用次数已到，请注册！
分析：
1.将配置文件封装成File对象，判断文件是否存在，不存在则自己创建
2.需要计数器；
3.计数器的值，生命周期要比应用程序的生命周期要长，需要对计数器的值进行持久化。count = 1，
里面存储的应该是键值方式，Map集合，要和设备上的数据关联，需要IO技术。集合 + IO = Properties。*/
public class Test02 {
public static void main(String[] args) throws IOException {
//创建对象
File file = new File("F:\\Test04\\game.txt");
Properties pro = new Properties();
//判断文件是否存在
if(!file.exists()){
file.createNewFile();
}
//读取数据到集合
FileReader fr = new FileReader(file);
pro.load(fr);
fr.close();
//获取运行次数
String count = pro.getProperty("count");
int number = Integer.parseInt(count);
//判断是否满足5次
if(number >=5){
System.out.println("试用次数已到，请注册！");
}else{
//程序运行
calculate();
//次数加一
number++;
pro.setProperty("count", String.valueOf(number));
FileWriter fw = new FileWriter("F:\\Test04\\game.txt");
pro.store(fw, null);
fw.close();
}
}
public static void calculate(){
Scanner sc =new Scanner(System.in);
System.out.println("两个数的计算");
System.out.println("请输入第一个整数：");
int a = sc.nextInt();
System.out.println("请输入第二个整数：");
int b = sc.nextInt();
System.out.println("和为"+ (a+b));
System.out.println("差为"+ Math.abs(a-b));
System.out.println("乘积为"+ (a*b));
}
}
public class Test {
public static void main(String[] args) throws IOException {
//输入学员信息
/*
张三，男，23
李四，女，34
王五，男，27
李六，女，33
王二，男，26
王五，男，27
}*/
Scanner sc = new Scanner(System.in);
ArrayList<Student> arr = new ArrayList<>();
System.out.println("录入格式：张三,男,25");
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\StudentInfo.txt"));
for (int i = 1; i <= 6; i++){
System.out.println("请输入第"+i+"个学员的信息：");
String s = sc.next();
input(s, arr);
}
//将集合对象写入到D:\\StudentInfo.txt
bw.write(arr.toString());
bw.newLine();
bw.close();
//读取文件中的对象
BufferedReader br = new BufferedReader(new FileReader("D:\\StudentInfo.txt"));
char[] ch = new char[1024];
int len;
while((len = br.read(ch)) != -1){
System.out.println(new String(ch, 0 ,len));
}
br.close();
//去重并按照年龄从小到大的顺序排序
deduplicate(arr);
arr.sort((s1, s2) -> {
int num = s1.getAge() - s2.getAge();
return num;
});
//PrintWriter流写入到 E:\\StudentInfo.txt文件中(写入格式：张三-男-25)
PrintWriter pw = new PrintWriter("E:\\StudentInfo.txt");
for(Student s : arr){
StringBuilder sb = new StringBuilder();
sb.append(s.getName()).append("-").append(s.getGender()).append("-").append(s.getAge());
String ss = sb.toString();
pw.println(ss);
}
pw.close();
}
//录入到集合中
public static void input (String s, ArrayList<Student> arr){
String[] data = s.split("，");
Student stu = new Student();
stu.setName(data[0]);
stu.setGender(data[1]);
stu.setAge(Integer.parseInt(data[2]));
arr.add(stu);
}
//去重
public static void deduplicate(ArrayList<Student> arr){
for(int i = 0; i < arr.size(); i++){
for(int j=i+1; j < arr.size()-i; j++){
if( arr.get(i).getName().equals(arr.get(j).getName())
&& arr.get(i).getGender().equals(arr.get(j).getGender())
&& (arr.get(i).getAge() == arr.get(j).getAge()) ){
arr.remove(j);
}
}
}
}
}
5349
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
