D11（java基础）
流
-
概念：内存与存储设备之间传输数据的通道。
流的分类
按方向：
-
输入流：将存储设备中的内容读入到内存中。
-
输出流：将内存中的内容写入到存储设备中。
按单位：
-
字节流：以字节为单位，可以读写所有数据。
-
字符流：以字符为单位，只能读写文本数据。
按功能：
-
节点流：具有实际传输数据的读写功能。
-
过滤流：在节点流的基础之上增强功能。
文件字节输入流
public static void main(String[] args) throws Exception {
//创建FileInputStream，并指定文件路径。
FileInputStream fis=new FileInputStream("d:\\aaa.txt");
int data=0;
while((data=fis.read())!=-1){
System.out.println((char)data);
}
fis.close();
System.out.println("执行完毕");
}
//读取一个文件内的数据。
// 一次读多个字节。
byte[] buf=new byte[3];
int count= fis.read(buf);
System.out.println(new String(buf));
byte[] buf=new byte[1024];
int count=0;
while((count=fis.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
文件字节输出流
public static void main(String[] args) throws Exception{
//创建文件输出字节流对象。
FileOutputStream fos=new FileOutputStream("d:\\bbb.txt");
fos.write(97);
fos.write('b');
fos.write('c');
fos.close();
System.out.println("执行完毕");
}
//向一个文件内写入数据。
String string="helloworld";
fos.write(string.getBytes());
字节流复制文件
public static void main(String[] args) throws Exception{
FileInputStream fis=new FileInputStream("d:\\111.webp");
FileOutputStream fos=new FileOutputStream("d:\\222.webp");
byte[] buf=new byte[1024];
int count=0;
while((count=fis.read(buf))!=-1){
fos.write(buf,0,count);
}
fis.close();
fos.close();
System.out.println("复制完毕");
}
字节缓冲流
-
提高IO效率，减少访问磁盘的次数。
//使用字节缓冲流读取文件。
public static void main(String[] args) throws Exception{
FileInputStream fis=new FileInputStream("d:\\aaa.txt");
BufferedInputStream bis=new BufferedInputStream(fis);
int data=0;
while((data=bis.read())!=-1){
System.out.print((char)data);
}
bis.close();
}
public static void main(String[] args) throws Exception{
FileOutputStream fos=new FileOutputStream("d:\\buffer.txt");
BufferedOutputStream bos=new BufferedOutputStream(fos);
for(int i=0;i<10;i++){
bos.write("helloworld\r\n".getBytes());//写入8K缓冲区。
bos.flush(); //刷新到硬盘。
}
bos.close();//内部调用flush方法。
}
对象流
-
使用流传输对象的过程称为序列化（把对象写入文件），反序列化。
序列化
ObjectOutputStream
-
序列化类必须要实现Serializable接口。
public static void main(String[] args) throws Exception {
FileOutputStream fos=new FileOutputStream("d:\\stu.bin");
ObjectOutputStream oos=new ObjectOutputStream(fos);
Student zhangsan =new Student("张三",20);
oos.writeObject(zhangsan);
oos.close();
System.out.println("序列化完毕");
}
反序列化
public static void main(String[] args) throws Exception{
FileInputStream fis=new FileInputStream("d:\\stu.bin");
ObjectInputStream ois=new ObjectInputStream(fis);
Student s=(Student) ois.readObject();
ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());
}
注意事项
-
序列化类必须要实现Serializable接口。
-
序列化类中对象属性要求实现Serializable接口。
-
序列化版本号ID，保证序列化的类和反序列化的类是同一个类。
-
使用transient（瞬间的）修饰属性，这个属性就不能被序列化了。
-
静态属性不能序列化。
-
序列化多个对象，可以借助集合（ArrayList）实现。
字符流
-
字符流的父类（抽象类）
Reader：字符输入流
Writer：字符输出流
文件字符流
-
使用FileReader读取文件
public static void main(String[] args) throws Exception{
FileReader fr=new FileReader("d:\\hello.txt");
// int data=0;
// while((data=fr.read())!=-1){
// System.out.print((char)data);
// }
char[] buf=new char[1024];
int count=0;
while((count=fr.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
fr.close();
}</pre>
-
使用FileWriter写入文件
public static void main(String[] args) throws Exception{
FileWriter fw=new FileWriter("d:\\write.txt");
for(int i=0;i<10;i++){
fw.write("java能用\r\n");
fw.flush();
}
fw.close();
System.out.println("执行完毕");
}
-
使用FileReader和FileWriter复制文本文件，不能复制图片等二进制文件（因为它们没有字符编码）。
-
使用字节流可以复制任意文件。
public static void main(String[] args) throws Exception{
FileReader fr=new FileReader("d:\\write.txt");
FileWriter fw=new FileWriter("d:\\write2.txt");
int data=0;
while((data=fr.read())!=-1){
fw.write(data);
fw.flush();
}
fr.close();
fw.close();
System.out.println("执行完毕");
}
字符缓冲流
-
使用字符缓冲流读取文件。
public static void main(String[] args) throws Exception{
FileReader fr=new FileReader("d:\\write.txt");
BufferedReader br=new BufferedReader(fr);
// char[] buf=new char[1024];//缓冲区
// int count=0;
// while((count=br.read(buf))!=-1){
// System.out.print(new String(buf,0,count));
// }
//第二种方法：一行一行地读取。
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
br.close();
System.out.println("完毕");
}
-
使用字符缓冲流写入文件。
public static void main(String[] args) throws Exception{
FileWriter fw=new FileWriter("d:\\buffer.txt");
BufferedWriter bw=new BufferedWriter(fw);
for(int i=0;i<10;i++){
bw.write("可以");
bw.newLine();// 写入一个换行符，兼容性更好。
bw.flush();
}
bw.close();
System.out.println("完毕");
}
打印流
-
支持数据原样打印。（如97不会变成'A'）
public static void main(String[] args) throws Exception{
PrintWriter pw=new PrintWriter("d:\\print.txt");
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.println('a');
pw.close();
System.out.println("完毕");
}
转换流
-
InputStreamReader/OutputStreamWriter
-
可将字节流转换为字符流。
-
可设置字符的编码方式。
File类
-
File类的使用
-
分隔符
-
文件操作
-
文件夹操作
/*
File类的使用
1. 分隔符
2. 文件操作
3. 文件夹操作
*/
public class Demo{
psvm(String[] args){
separator();
}
// 1. 分隔符
public static void separator(){
sout("路径分隔符" + File.pathSeparator);
sout("名称分隔符" + File.separator);
}
// 2. 文件操作
public static void fileOpen(){
// 1. 创建文件
if(!file.exists()){ // 是否存在
File file = new File("...");
boolean b = file.creatNewFile();
}
// 2. 删除文件
// 2.1 直接删除
file.delete(); // 成功true
// 2.2 使用jvm退出时删除
file.deleteOnExit();
// 3. 获取文件信息
sout("获取绝对路径" + file.getAbsolutePaht());
sout("获取路径" + file.getPath());
sout("获取文件名称" + file.getName());
sout("获取夫目录" + file.getParent());
sout("获取文件长度" + file.length());
sout("文件创建时间" + new Date(file.lashModified()).toLocalString());
// 4. 判断
sout("是否可写" + file.canWrite());
sout("是否是文件" + file.isFile());
sout("是否隐藏" + file.isHidden());
}
// 文件夹操作
public static void directoryOpe() throws Exception{
// 1. 创建文件夹
File dir = new File("...");
sout(dir.toString());
if(!dir.exists()){
//dir.mkdir(); // 只能创建单级目录
dir.mkdirs(); // 创建多级目录
}
// 2. 删除文件夹
// 2.1 直接删除
dir.delete(); // 只能删除最底层空目录
// 2.2 使用jvm删除
dir.deleteOnExit();
// 3. 获取文件夹信息
sout("获取绝对路径" + dir.getAbsolutePaht());
sout("获取路径" + dir.getPath());
sout("获取文件名称" + dir.getName());
sout("获取夫目录" + dir.getParent());
sout("获取文件长度" + dir.length());
sout("文件夹创建时间" + new Date(dir.lashModified()).toLocalString());
// 4. 判断
sout("是否是文件夹" + dir.isDirectory());
sout("是否隐藏" + dir.isHidden());
// 5. 遍历文件夹
File dir2 = new File("...");
String[] files = dir2.list();
for(String string : files){
sout(string);
}
// FileFilter接口的使用
//过滤文件，只有满足特定条件的文件才会被记录。
File[] files2 = dir2.listFiles(new FileFilter(){
@Override
public boolean accept(File pathname){
if(pathname.getName().endsWith(".jpg")){
return true;
}
return false;
}
});
for(File file : files2){
sout(file.getName());
}
}
}
递归遍历文件夹
psvm(String[] args){
listDir(new File("d:\\myfiles"));
}
public static void listDir(File dir){
File[] files = dir.listFiles();
sout(dir.getAbsolutePath());
if(files != null && files.length > 0){
for(File file : files){
if(file.isDirectory()){
listDir(file); // 递归
}else {
sout(file.getAbsolutePath());
}
}
}
}
递归删除文件夹
public static void deleteDir(File dir){
File[] files = dir.listFiles();
if(files != null && files.length > 0){
for(File file : files){
if(file.idDirectory()){
deleteDir(file); // 递归
}else{
// 删除文件
sout(file.getAbsolutePath() + "删除" + file.delete());
}
}
System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());//删除已被清空的文件夹
}
}
Properties
public class PropertiesStudy {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
properties.setProperty("String_Title", "PropertiesStudy");
properties.setProperty("String_Name", "Properties");
Set<String> strings = properties.stringPropertyNames();
for (String string : strings) {
System.out.println("Key:"+string+";"+properties.getProperty(string));
}
// 输出
PrintWriter printWriter = new PrintWriter("PropertiesStudy.txt");
properties.list(printWriter);
printWriter.close();
// 保存
FileOutputStream fileOutputStream = new FileOutputStream("PropertiesStudyStore.properties");
properties.store(fileOutputStream, "注释");
fileOutputStream.close();
}
}
标签：java,String,基础,sout,file,println,new,public,D11 From： https://www.cnblogs.com/BTB-12138/p/16630008.html