File使用操作和Java中的IO流
File使用操作和Java中的IO流
File (文件类)
图片演示
操作一 文件方法使用
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.File;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) throws IOException {
// 文件对象创建操作 Java中的file对象，并不是和硬盘绑定的
// 1、如何构建文件对象
File file = new File("D:\\Files\\0729");// 通过文件的绝对路径【常用】
System.out.println("访问的绝对路径:" + file); // D:\Files\0729
// 2、通过父目录
String parent = "D:\\Files\\0728";
File file1 = new File(parent, "qwq.wmv");
System.out.println("访问父目录的文件路径:" + file1);// 访问父目录的文件路径:D:\Files\0728\qwq.wmv
// 3、使用父文件对象构建文件
File file2 = new File(file, "data.txt");
File file3 = new File(file, "hello.java");
System.out.println("构建新文件的路径:" + file2);// 构建新文件的路径:D:\Files\0729\data.txt
System.out.println("构建新文件的路径:" + file3);// 构建新文件的路径:D:\Files\0729\hello.java
// 文件对象的信息获取
System.out.println("文件的绝对路径:" + file.getAbsolutePath());
System.out.println("文件的构建路径:" + file.getPath());
System.out.println("文件的名称:" + file.getName());
System.out.println("文件的长度:" + file.length());
System.out.println("返回此文件名或者路径名:" + file.getName());// 返回此文件名或者路径名:0729
System.out.println("返回此File对象所对应的路径名:"+ file.getPath());// 返回此File对象所对应的路径名:D:\Files\0729
System.out.println("返回此File对象的绝对路径:"+ file.getAbsoluteFile());// 返回此File对象的绝对路径:D:\Files\0729
System.out.println("返回此File对象的所对应的绝对路径名:"+ file.getAbsolutePath());// 返回此File对象的所对应的绝对路径名:D:\Files\0729
System.out.println("返回此File对象所对应目录(最后一级子目录)的父目录名:"+file.getParent()); // 返回此File对象所对应目录(最后一级子目录)的父目录名:D:\Files
// 文件属性判断
System.out.println("文件是否存在:" + file1.exists());
System.out.println("文件和目录是否可写:" + file1.canWrite());
System.out.println("文件和目录是否可读:" + file1.canRead());
System.out.println("文件的目录是否为绝对路径:"+ file1.isAbsolute());
System.out.println("文件是否为文件夹:" + file1.isDirectory());
System.out.println("文件是否为普通文件:" + file1.isFile());
// 常规文件信息
System.out.println("返回文件的最后修改时间:"+file1.lastModified());
System.out.println("返回文件内容的长度:"+file1.length());
// 文件的操作 【创建、删除】
// boolean success = file1.createNewFile();// 文件创建 抛出异常IOException
// System.out.println(success);// true为创建成功 false为创建失败或者原文件夹中有该文件
// boolean success1 = file1.delete();// 文件删除
// System.out.println(success1);// true为删除成功 false为删除失败
//
File file4 = new File("D:\\Files\\0729\\item");
boolean success2 = file4.mkdir(); // 只能创建一个子文件夹，不能创建多个文件夹【单层】 mkdir
System.out.println(success2);
boolean success3 = file4.mkdirs(); // 能创建多个文件夹【多层】 mkdirs
System.out.println(success3);
boolean success4 = file4.renameTo(new File("D:\\Files\\0729\\demo"));
System.out.println(success4);// true 已经重新修改命名为demo
}
}
操作二 搜索一个文件夹下的名字、过滤器
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
public class FileDemo2 {
public static void main(String[] args) {
// 文件过滤 list得到是文件名
// FilenameFilter遍历文件的名称及调用者的对象
// FileFilter遍历文件对象
// list方法入参的是FilenameFilter
// listFiles方法入参的是FilenameFilter和FileFilter
// 练习:遍历一个文件夹下的所以文件
File file = new File("D:\\Files\\0729\\word\\share");
// FileFilter的用法:
File[] files = file.listFiles(new FileFilter() {
@Override // pathname是当前遍历到的文件对象
public boolean accept(File pathname) {
// System.out.println("pathname="+ pathname);
// return true;
// System.out.println(pathname.isFile());
// return pathname.isFile(); // 返回文件的名字
return pathname.length() >= 0;// 过滤文件的大小
}
});
// 遍历结果
for (File file2 : files) {
System.out.println(file2);
}
// D:\Files\0729\word\share\date.txt
// D:\Files\0729\word\share\hello.java
// D:\Files\0729\word\share\新建文本文档 - 副本 (2).txt
// D:\Files\0729\word\share\新建文本文档 - 副本 (3).txt
// D:\Files\0729\word\share\新建文本文档 - 副本 (4).txt
// D:\Files\0729\word\share\新建文本文档 - 副本 (5).txt
// D:\Files\0729\word\share\新建文本文档 - 副本.txt
// D:\Files\0729\word\share\新建文本文档.txt
// 相当于一个拦截器
// String[] files = file.list(new FilenameFilter() {
//
// @Override
// public boolean accept(File dir, String name) {
// // System.out.println("dir=" + dir);
// // System.out.println("name=" + name);
// // 过滤的规则【文件名中包含"java"】
// return name.contains("java");// 这里输入的是要过滤的名字
// }
// });
// 输出结果
// for (String file1 : files) {
// System.out.println(file1);
// }
// hello.java
}
}
操作三 遍历一个文件夹下的所有文件
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.File;
//练习： 遍历一个文件夹下的所有文件
public class FileDemo03 {
public static void main(String[] args) {
// 1、先构建文件对象
File file = new File("D:\\Files");
printFile(file);
}
// 定义一个递归打印文件的方法
public static void printFile(File file) {
// 1、出口 当当前文件是一个普通文件时退出
if (file.isFile()) { // 搜索文件名
System.out.println("---文件名-->"+file.getName());
return;
}
// 2、递归规律
if (file.isDirectory()) {// 搜索文件夹
System.out.println("--文件夹--->" + file.getName() );
}
// 遍历当前文件的所有内容
for (File item : file.listFiles()) {
printFile(item);
}
}
}
注意:要是if文件名不加入return;会出现空指针异常
※IO流的理解
JAVA的IO流是实现数据输入/输出的基础，在Java中把不同的输入、输出源（键盘、文件、网络连接等）抽象地表述为流，使用流来访问数据
–流的分类
按照流向：
–输入流、InputStream\Reader
–输出流、OutputStream\Writer
按照类型：
–字节流、数据单元为8位的字节
–字符流、数据单元为16位的字节
按照角色：
–节点流、针对某个特定的IO设备、比如磁盘、网络（低级流）
–处理流、针对已存在的流进行封装，进行高级的操作（高级流）
注意:转义字符
注意在操作一中:因为这个是在String里面输入的绝对路径本来是为D:\Files\0729\data.txt 后来输入到String里面或者new FileInputStream自动转义为"D:\Files\0729\data.txt"
操作一:读取文件其中的字符个数和字符串的类型
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Arrays;
// 现在"D:\\Files\\0729\\data.txt"有这么一个文件 内容有sfgsgsopawiempad
public class FileInputStreamDemo {
// 读取文件的输入信息
public static void main(String[] args) throws IOException {
// 1、读取 InputStream是字节流输入流 【字节作为单位】
// 从文件中读取数据到程序【输入流】
// InputStream input = new InputStream();// 因为InputStream它是一个抽象类 ，所以只能调用它的实现类
InputStream input = new FileInputStream("D:\\Files\\0729\\data.txt");// 注意:转义符 因为这个是在String里面绝对路径 需要抛出异常FileNotFoundException 也要导包
// 读取字节 当流中的数据读完时会返回-1
// int res = input.read();// 读取一个字节 //抛出异常IOException 这里只需要抛出IOException也抛出了FileNotFoundException 也要导包
// IOException 的源码 如下:
// public class FileNotFoundException extends IOException {
// System.out.println(res);// -1
// res = input.read();
// System.out.println(res);// -1
// 读取多个字节的操作 当流中的数据读完时会返回-1
byte[] buff = new byte[10];// 从流中读取数据，读到数组中进行存储，返回读取的个数
// 一次性读取10个 【设定缓冲数组】 要是太小会出现乱码
// byte[] buff1 = new byte[1024];// 一次性读取10个 【设定缓冲数组】
int res = input.read(buff);// 从流中读取数据，读到数组中进行存储，返回读取的个数
// int res = input.read(buff, 2, 4);// 存储的数组 偏移量 【存储时的编译】 限制读取的个数 这里是从第2个字节然后截取到第4个字节
// 使用String构造器将字节数组转换为字符串
String str = new String(buff);
System.out.println("字符个数:" + res);// 10
System.out.println("ASCII转换成String类型:" + Arrays.toString(buff));// ASCII转换成String类型:[115, 102, 103, 115, 103,
// 115, 111, 112, 97, 119]
System.out.println("把字节转换为字符串(String类型):" + str);// 把字节转换为字符串(String类型):sfgsgsopaw
}
}
操作二:实现整个文件的内容打印输出
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
// 现我在"D:\\Files\\0729\\data.txt"有这么一个文件 内容有However mean your
public class FileInputStreamDemo2 {
// 读取文件的输入信息
public static void main(String[] args) throws IOException {
// 字符流
InputStream input = new FileInputStream("D:\\Files\\0729\\data.txt");// 需要抛出异常FileNotFoundExceptio
// 如何实现整个文件的内容打印输出
// 读取
/* int res = input.read();// 读取一个字节
System.out.println(res);
res = input.read();
System.out.println(res); */
// int res = 0; // 一个一个字节地读取 效率很慢
// while (res!=-1) {
// res = input.read();
// System.out.println((char)(res));
// }
// 为了提高效率 应该使用数组定义
// 要是没加偏移量就会出现读取过长的长度
// 1、定义一个数组
// byte[] buff = new byte[15];
// int len = 0;// 读取的个数
// // OPEN1:
// while ((len = input.read(buff)) != -1) { // 当流中的数据就没有读取完就继续进行读取(要是没读取完就会返回读取的个数) 当流中的数据读完时会返回-1
// String str = new String(buff);
// // 要是不设置偏移量会出现误差
// // 为什么会出现这样呢？
// // 因为我设置了数组为10个字符
// // 但是内容里面有一共17个字符
// // 第一次 读取了是However me10个字符
// // 第二次 读取了是an your7个字符
// // 然后又因为数组中还有位置 所以继续读取 就多加了进了 me3个字符
// System.out.print(str);// However mean your me
// }
// 为了提高效率 应该使用数组定义
// 解决办法:
// OPEN2:
byte[] buff = new byte[10];
int len = 0;// 读取的个数
while ((len = input.read(buff)) != -1) { // 当流中的数据就没有读取完就继续进行读取(要是没读取完就会返回读取的个数) 当流中的数据读完时会返回-1
// 读取了多少就转换多少len
String str = new String(buff, 0, len);// 字节数组、偏移量【读取时的偏移】、len个数
// System.out.println(str);// However me
// an your
System.out.print(str);// However mean your
}
}
}
操作三:在文件中输出内容
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class FileOutputStreamDemo {
// 实现文件的拷贝、输出
public static void main(String[] args) throws IOException {
// 1、构建输出流 【字节输出流】【默认会覆盖原来的内容】 设置true为追加模式
OutputStream output = new FileOutputStream(new File("D:\\Files\\0729\\data.txt"), true);
//
// // 2、写出信息【字节】
output.write("c");// 写出单个字节数据
output.write("helloworld".getBytes());// 写出多个字节数据 文件中输出了helloworld
output.write("helloworld".getBytes(), 2, 4);// 写出多个字节数据 【有偏移量】 文件中输出了llow
// 释放资源
output.close();
}
}
操作三、1:在此加上try catch异常
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public static void main(String[] args) throws IOException {
// 1、构建输出流 【字节输出流】【默认会覆盖原来的内容】 设置true为追加模式
OutputStream output = null;
try {
output = new FileOutputStream(new File("D:\\Files\\0729\\data.txt"), true);
// output.write("helloworld".getBytes());
output.write("helloworld".getBytes(), 2, 4);// 写出多个字节数据 【有偏移量】 文件中输出了llow
} catch (Exception e) {
e.printStackTrace();
} finally {
// 释放资源
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
操作四 文件复制到另一个路径中 【多字节 效率快】
内容是直接把数组存储进一个数组中然后进行输入、输出读写操作
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class FileCopyDemo {
// 多个字节比单个字节访问的效率要快 因为它是减少了IO交互的次数
public static void main(String[] args) {
// 1、构建流 【输入流、输出流】
InputStream input = null;
OutputStream out = null;
try {
input = new FileInputStream("D:\\Files\\0729\\data.txt");
out = new FileOutputStream("D:\\Files\\0729\\item\\data.txt");
// 2、循环进行读写操作【多个字节、数组、长度】
// 定义数组buff及长度len
byte[] buff = new byte[100];
int len = 0;//
while ((len = input.read(buff)) != -1) { // 条件 及 读取
// 写出数据
out.write(buff, 0, len);// 读多少就写多少len
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3、释放资源
try {
input.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
操作五 文件复制到另一个路径中 【单字节 效率慢 】
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class FileCopyDemo02 {
//
public static void main(String[] args) {
// 1、构建流 【输入流、输出流】
InputStream input = null;
OutputStream out = null;
try {
input = new FileInputStream("D:\\Files\\0729\\data.txt");
out = new FileOutputStream("D:\\Files\\0729\\item\\data.txt");
// 2、循环进行读写操作【单个字节、数组、长度】
// 定义数组buff及长度len
int len = 0;//
while ((len = input.read()) != -1) { // 条件 及 读取
// 写出数据
out.write(len);// 读多少就写多少len
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3、释放资源
try {
input.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
内容是直接把数组存储进一个数组中然后进行输入、输出读写操作
操作六、使用Reader读取文件里面的内容 【单个字符读取】 【多个字符读取】【循环读取】
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.Closeable;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Arrays;
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
// 字符的输入流 【单位:字符】
// Reader是一个抽象类 public abstract class Reader implements Readable, Closeable {
// new一个FileReader
Reader reader = new FileReader("D:\\Files\\0729\\data.txt");
// 读取数据操作 流的数据读完返回-1 文本内容有He的内容
// char item = (char) reader.read();
// System.out.println(item);// H
// item = (char) reader.read();
// System.out.println(item);// e
// int res = reader.read();
// System.out.println(res);// -1
// 读取多个字符的操作
char[] item = new char[10];
reader.read(item);
System.out.println(new String(item));//He
// 出现空格的原因是因为设置了char为[10]的操作
// 循环读取所有内容操作类似字节流的
char[] buff = new char[10];
int len = 0;// 读取的个数
while((len=reader.read(buff))!=-1) {
String str = new String(buff,0,len);
System.out.println(Arrays.toString(str.toCharArray()));
}
// 释放资源
reader.close();
}
}
操作七、使用Writer写出字符串
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
package com.day0729;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
// 在文件中写出字符串
Writer writer = new FileWriter("D:\\Files\\0729\\data.txt");
// writer 和append都可以直接写出字符串
writer.write("hello girl!!");
writer.append("test");
// 释放资源
writer.close();
}
}
练习代码:
练习1:键盘录入一个文件夹路径,统计该文件夹(包含子文件夹)中文件个数和文件夹个数。
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
import java.io.File;
import java.util.Iterator;
import java.util.Scanner;
public class HomeWork1 {
// 3、数量文件统计
static int dirs = 0;
static int files = 0;
// 定义一个递归打印文件的方法
public static void main(String[] args) {
countNum();
}
// 统计计数的单位
public static void countNum() {
// 1、创建Scanner
Scanner sc = new Scanner(System.in);
// 2、读取文件路径
System.out.println("请输入文件路径:");
String path = sc.next();
File file = new File(path);
// 3、统计
iter(file);
// 4、打印输出
System.out.printf("文件夹个数:%d ,文件个数为:%d", dirs, files);
// 5、关闭
sc.close();
}
// 封装迭代操作
public static void iter(File file) {
// 获取所有的子文件
File[] filees = file.listFiles();
for (File fileItem : filees) {
// --判断是否为文件
if (fileItem.isDirectory()) {
dirs++;
// 继续遍历子文件
iter(fileItem);
} else {
// --判断是否为文件夹
files++;
}
}
}
}
练习2:键盘录入一个文件夹路径和一个文件名,当前目录（包含子目录）下是否有该文件，有则返回该文件的绝对路径，没有则返回null。
一:只能查看该文件下的文件类型
/**
* @author Lantzrung
* @date 2022年7月30日
* @Description
*/
import java.awt.event.ItemEvent;
import java.io.File;
import java.util.Iterator;
import java.util.Scanner;
//作业2：
//键盘录入一个文件夹路径和一个文件名,当前目录（包含子目录）下是否有该文件，有则返回该文件的绝对路径，没有则返回null。
public class HomeWork02 {
static String name;
static String files;
public static void main(String[] args) {
// 键盘录入
System.out.println("输入一个文件夹路径:");
Scanner sc = new Scanner(System.in);
String directoryName = sc.next();
File file = new File(directoryName);
// System.out.println("查看绝对路径:" + file);
System.out.println("输入一个文件名:");
name = sc.next();
// System.out.println("查看文件名:" + name);
Query(file);
System.out.println(files);
// 释放资源
sc.close();
}
// 定义一个查询的方法
public static void Query(File file) {
// 判断该文件夹是否存在 当前目录（包含子目录）下是否有该文件，有则返回该文件的绝对路径，没有则返回null。
if (file.isDirectory()) {
for (File item : file.listFiles()) {
if (item.isDirectory()) {
Query(item);
}
if (item.isFile() && name.equals(item.getName())) {
// System.out.println("查找的文件夹绝对路径为:"+item.getAbsoluteFile());
files = "查找的文件夹绝对路径为:" + item.getAbsoluteFile();
}
}
} else {
files = null;
}
}
}
一、1
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
import java.io.File;
import java.util.Iterator;
import java.util.Scanner;
// 这里只能查看一个文件夹下的data.txt的类型
public class HomeWork2 {
// 定义默认的FileName;
static String absolutePath = null;
public static void main(String[] args) {
countNum();
}
// 定义一个递归打印文件的方法
public static void countNum() {
// 1、创建Scanner
Scanner sc = new Scanner(System.in);
// 2、读取文件路径
System.out.println("请输入文件路径:");
String path = sc.next();
File file = new File(path);
System.out.println("请输入文件名:");
String name = sc.next();
// 3、去迭代获取，有则设置绝对路径，没有则默认为null
iter(file, name);
// 4、打印输出
if (absolutePath != null) {
System.out.printf("文件夹中存在该文件" + absolutePath);
} else {
System.out.printf("文件夹中不存在该文件");
}
// 5、关闭
sc.close();
}
// 封装迭代操作
public static void iter(File file, String name) {
// 获取所有的子文件
File[] filees = file.listFiles();
// 遍历及判断
for (File fileItem : filees) {
// --判断是否为文件
if (fileItem.isDirectory()) {
// 继续遍历子文件
iter(fileItem, name);
} else {
// --判断是否为文件夹 [出口]
if (fileItem.getName().equals(name)) {
// System.out.println("文件夹中存在该文件:" + fileItem.getAbsolutePath());
absolutePath = fileItem.getAbsolutePath();
}
}
}
}
}
实例二:能遍历该文件夹下的子文件的类型
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
import java.io.File;
import java.util.Iterator;
import java.util.Scanner;
public class HomeWork2_2 {
public static void main(String[] args) {
countNum();
}
// 定义一个递归打印文件的方法
public static void countNum() {
// 1、创建Scanner
Scanner sc = new Scanner(System.in);
// 2、读取文件路径
System.out.println("请输入文件路径:");
String path = sc.next();
File file = new File(path);
System.out.println("请输入文件名:");
String name = sc.next();
// 3、去迭代获取，有则设置绝对路径，没有则默认为空操作
iter(file, name);
// 4、关闭
sc.close();
}
// 封装迭代操作
public static void iter(File file, String name) {
// 获取所有的子文件
File[] filees = file.listFiles();
// 遍历及判断
for (File fileItem : filees) {
// --判断是否为文件
if (fileItem.isDirectory()) {
// 继续遍历子文件
iter(fileItem, name);
} else {
// --判断是否为文件夹 [出口]
if (fileItem.getName().equals(name)) {
System.out.println("文件夹中存在该文件:" + fileItem.getAbsolutePath()); // absolutePath =
// fileItem.getAbsolutePath(); }
}
}
}
}
}
练习3:通过键盘输入模拟用户交流，然后把交流的信息记录在log.txt中。
【提示：换行输出加个\n即可】
通过键盘输入模拟用户交流，然后把交流的信息记录在log.txt中。
–格式：【用户1】【时间yyyy-MM-dd HH:mm:ss】【内容】
–当其中用户一个输入exit时，聊天结束
实现一: 可实现三个用户 但有输入完一次后有延迟
/**
* @author Lantzrung
* @date 2022年7月30日
* @Description
*/
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
//作业3：【提示：换行输出加个\n即可】
public class HomeWork03 {
public static void main(String[] args) throws IOException {
// 通过键盘输入模拟用户交流，然后把交流的信息记录在log.txt中。
OutputStream w1 = new FileOutputStream(new File("D:\\files\\log.txt"), true);
Scanner sc = new Scanner(System.in);
System.out.println("-------聊天界面-------");
int user = 0;
String input;
while (true) {
user++;
if (user == 1) {
// --格式：【用户1】【时间yyyy-MM-dd HH:mm:ss】【内容】
SimpleDateFormat date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("用户1:");
input = sc.next();
String str = "用户1:[" + date.format(new Date()) + "]+ 聊天内容 :" + input + "\n";
if (input.equals("exit")) {
System.out.println("退出聊天界面");
break;
}
w1.write(str.getBytes());
}
if (user == 2) {
// --格式：【用户1】【时间yyyy-MM-dd HH:mm:ss】【内容】
SimpleDateFormat date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("用户2:");
input = sc.next();
String str = "用户2:[" + date.format(new Date()) + "]+ 聊天内容 :" + input + "\n";
if (input.equals("exit")) {
// --当其中用户一个输入exit时，聊天结束
System.out.println("退出聊天界面");
break;
}
w1.write(str.getBytes());
}
if (user == 3) {
// --格式：【用户1】【时间yyyy-MM-dd HH:mm:ss】【内容】
SimpleDateFormat date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("用户3:");
input = sc.next();
String str = "用户3:[" + date.format(new Date()) + "]+ 聊天内容 :" + input + "\n";
if (input.equals("exit")) {
System.out.println("退出聊天界面");
break;
}
w1.write(str.getBytes());
}
}
}
}
实现二: 可实现二个用户
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class HomeWork3 {
// 通过键盘输入模拟用户交流。然后把交流的信息记录在log.txt中。
public static void main(String[] args) throws IOException {
// 1、创建Scanner
Scanner sc = new Scanner(System.in);
// 构建输出流 字符流 使用追加模式
Writer writer = new FileWriter("D:\\Files\\0729\\data01.txt", true);// 追加模式就是不会覆盖
// 定义一个变量
boolean oneTurn = true;// 是否第一个用户的回合
// 2、实现用户的交流
while (true) {
int man = oneTurn ? 1 : 2;// 那个用户
System.out.println("用户" + man + "请输入发送的信息:");
String msg = sc.next();
// --格式:【用户1】【时间yyyy-MM-dd HH:mm:ss】【内容】
String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
// System.out.printf("【用户%d】【时间:%s】【内容:%s】", man);
String line = "【用户" + man + "】【时间:" + time + "】【内容:" + msg + "】\n";// 格式语句
// 输出日志
writer.write(line);
// 刷新
writer.flush();
// 切换用户[取反]
oneTurn = !oneTurn;
// 退出
if (msg.equals("exit")) {
break;
}
}
// 3、关闭
sc.close();
writer.close();
}
}
练习四:
测试文件拷贝时，缓冲数组长度对于复制速率的影响
//定义一个缓存数组
byte[] buff = new byte[1024];
1024--1014ms
1024*2--526ms
1024*8--170ms
1024*1024--122ms
1024*1024*1024--726ms
//答案：并不是缓冲数组长度越大复制速率就越高，不是越大时间就越少
//而是在合适的范围内是速率最优，一般为1024*8
//返回的越大可能返回的速率会越慢
/**
* @author Lantzrung
* @date 2022年7月29日
* @Description
*/
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class HomeWork4 {
public static void main(String[] args) {
// 1、构建流【输入流、输出流】
InputStream input = null;
OutputStream out = null;
try {
input = new FileInputStream("这里写入要输入的文件的绝对路径");
out = new FileOutputStream("这里写入要输出的文件的绝对路径");
// 2、循环进行读写操作【多个字节、数组、长度】
// 定义缓冲数组buff及长度len
byte[] buff = new byte[1024*8];
int len = 0;
//开始
long start = System.currentTimeMillis();
while ((len = input.read(buff)) != -1) {// 条件 及 读取
// 写出数据
out.write(buff, 0, len);// 读多少就写出多少len
}
//结束
long end = System.currentTimeMillis();
//输出时间
System.out.println("使用时间为："+(end-start));
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3、释放资源
try {
input.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
