Java编程学习六

标签：Java 编程 System 学习 File println new public out

java IO操作： Java中，Io操作主要是指使用Java进行输入和输出操作。

Java中所有的IO机制都是基于数据流进行输入输出的。这些数据流表示了字符或者字节数据的流动序列。

在Java中进行io操作，通常需要用到Java.io包中的类。比如说fiel类，用于表示文件和目录路径名的抽象表示形式。。。可以用来创建，删除，重命名文件和目录以及获取文件属性等信息。

1.File类

File封装的一个文件操作类，我们之前在window操作文件或文件夹都是通过图形化界面操作。我们可以通过File这个类完成对文件的操作

public class File
extends Object
implements Serializable, Comparable<File>
--------------------------如果想使用File必须创建File对象--------------

File 文件的各种操作：

package aaa1125;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

/**
 * @className: Test01
 * @author: Zyl
 * @date: 2024/11/24 17:19
 * @Version: 1.0
 * @description:
 */

public class Test01 {
    public static void main(String[] args) throws IOException {
/*        //两种写法\\和/都可以
          //而我们在Linux或macOS下，路径是/，而不是\,而Java语言跨平台，所以，在Windows下也可以使用/
          //创建对象使用的是绝对路径，\:windows中使用，\表示转义符;
        File file1 = new File("D:\\aaa666\\123.txt");
        System.out.println(file1.exists());//true;
        File file2 =new File("D:/aaa666/123.txt");
        System.out.println(file2.exists());//true;
        File file3 =new File("123.txt");//相对路径，创建在当前项目下，所以是相对路径，如果当前项目下没有，就会报错，所以，在项目下创建文件，一定要使用绝对路径，否则会报错。
        file3.createNewFile();//创建文件

 */
/*
        File file =new File("D:/aaa666/456.txt");
        //创建新文件
        file.createNewFile();
        File file1 =new File("D:/aaa666/haha");
        //创建文件夹 但是mkdir 不能创建中间目录，只能创建一层，所以要使用mkdirs
        file1.mkdir();
        //创建多级文件夹
        File file2 =new File("D:/aaa666/123/456/789");
        file2.mkdirs();
        //注意创建的是文件还是文件夹和调用的方法有关和后缀无关
*/
/*
        File file1 =new File("D:/aaa666/456.txt");
        //设置文件只能读
        file1.setReadOnly();
        //设定最后修改时间
        file1.setLastModified(1000000000000L);
        //重命名
        file1.renameTo(new File("D:/aaa666/haha.txt"));
        //在不同的文件夹下，重名名可以当作剪切
        File file2 =new File("D:/aaa666/haha.txt");
        file2.renameTo(new File("D:/456.txt"));
        //删除文件
        File file3 =new File("D:/456.txt");
        file3.delete();
        //删除可以删除文件也可以删除文件夹，注意要是空文件夹才能删除；
*/
/*
        File file1=new File("D:/aaa666/haha");
        //判断这个是不是一个文件
        boolean f = file1.isFile();
        System.out.println(f);//false,这是一个文件夹;
        //判断这个是不是一个文件夹
        boolean d = file1.isDirectory();
        System.out.println(d);//true;
        */
/*判断是否是隐藏文件*//*

        boolean h = file1.isHidden();
        System.out.println(h);//false;
        */
/*得到名字和相对路径和绝对路径和父亲路径*/
/*
        String name = file1.getName();
        System.out.println(name);
        String path = file1.getPath();//相对路径
        System.out.println(path);
        String absolutePath = file1.getAbsolutePath();//绝对路径，一般用这个
        System.out.println(absolutePath);
        String parent = file1.getParent();//父路径
        System.out.println(parent);
        // canonicePath也是绝对路径,absolutePath，是不带盘符，带盘符叫canonicalPath;
        String canonicalPath = file1.getCanonicalPath();
        System.out.println(canonicalPath);
        //是否是可读
        boolean canRead = file1.canRead();
        System.out.println(canRead);//true;
        //是否可写
        boolean canWrite = file1.canWrite();
        System.out.println(canWrite);//true;
        //是否是可执行
        boolean canExecute = file1.canExecute();
        System.out.println(canExecute);//true;
        //file1.list()//列出当前文件夹下所有的子文件和文件
 */

/*

        File file2 =new File("D:/aaa666/123");
        String[] list = file2.list();//列出当前文件夹下所有的子文件和文件
        File [] files = file2.listFiles();//列出当前文件夹下的子文件或子目录的对象
        //遍历
        for (String s : list) {
            System.out.println(s);
        }
        //遍历子文件或子目录的对象
        for (File file : files) {
            System.out.println(file);
        }
        for (File file : files) {
            System.out.println(file.getParent());
        }
        for (File file : files) {
            System.out.println(file.exists());//true
        }
        System.out.println(Arrays.toString(list));//打印数组
        System.out.println(Arrays.toString(files));
*/






    }
}

File递归查找题：表示方法本身调用本身。而且方法中必须有出口。

package aaa1125;

import java.io.File;
import java.io.OutputStream;

/**
 * @className: Test03
 * @author: Zyl
 * @date: 2024/11/25 10:10
 * @Version: 1.0
 * @description:递归遍历文件夹
 */

public class Test03 {
    public static void main(String[] args) {
        File file = new File("src/aaa1114");
        print(file);


    }
    public static void print(File file){
        //判断是不是文件
        if(file.isFile()){
            String name = file.getName();
            if (name.endsWith(".java")) {
                System.out.println(name);
            }
        }else {
            //否则是文件，然后判断是不是空的
            //获取文件数组
            File[] files = file.listFiles();
            if (files.length> 0) {
                //遍历文件
                for (File f : files) {
                    print(f);//递归
                }
            }
        }
    }
}

二、IO流

上面讲解的File对象只是对文件的增删改查操作，但是无法通过代码往文件中添加内容。如果想添加内容需要使用IO流对象。生活: 水流，电流，人流等。

IO操作：

I:InputStream;

O:OutputStream;

1.按流向分。

输入流:程序可以从中读取数据的流

输出流:程序向其中写入数据的流。

2.按数据传输单位分。

字节流:以字节为单位传输数据的流。

字符流：以字符为单位传输数据的流。

3.按功能分。（了解）

节点流：用于直接操作目标设备的流。

过滤流：是对一个已存在的流的链接和封装，通过对数据进行处理，为程序提供功能强大灵活的读写功能。（处理流）

四大基流：IO流的四大基类

字节输入流：input Stream。

字节输出流：output Stream

字符输入流：Reader

字符输出流:Writer

1 .字节输出流：inputStream

public abstract class OutputStream
extends Object
implements Closeable, Flushable
这个抽象类是表示字节输出流的所有类的超类

2.字节输入流：：output Stream

public abstract class InputStream
extends Object
implements Closeable这个抽象类是表示输入字节流的所有类的超类

字节输出流和字节输入流的各种操作

package aaa1125;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.Arrays;

/**
 * @className: Test02
 * @author: Zyl
 * @date: 2024/11/24 18:38
 * @Version: 1.0
 * @description:
 */

public class Test02 {
    public static void main(String[] args) throws Exception{
/*
//输出流
        //1. 创建一个输出流对象,如果没有文件，会自动生成//true表示追加数据
        FileOutputStream out=new FileOutputStream("D:/aaa666/zhao.txt",true);
        //2. 写入数据两种写法
       // out.write(100);//100 是字符，会转成ASCII码，写入到文件中是d;
        byte[] bytes = "helloworld".getBytes();
        out.write(bytes);
        out.write(100);
        out.write(100);
        out.write(100);//写入helloworld追加 ddd
        out.write(120);
        out.write(130);
        //指定写入内容的个数
        //out.write(bytes,0,5);//0表示从第几个字节开始读取，5表示读取5个字节
        //3. 关闭流
        out.close();
 */

//输入流
    /*        //1. 创建一个输入流对象
            FileInputStream in=new FileInputStream("D:/aaa666/zhao.txt");
            //2.读取数据，一个一个读和批量读  -1表示读取完毕
            int read1 = in.read();
            System.out.println(read1);//返回结果是字符的ASCII码，是内容
            int read2 = in.read();
            System.out.println((char)read2);//int类型强转字符
            byte[] bytes = new byte[100];
            int len=in.read(bytes);//依次读取100个内容放入数组中，返回读取的字节数长度
            System.out.println(len);//读取的字节数长度
            System.out.println(Arrays.toString(bytes));
            //将byte数组转换为字符串形式
            String s = new String(bytes,0,len);//0表示从第几个字节开始读取，len表示读取的字节数
            System.out.println(s);
            //3.关闭流
            in.close();
    */


/*        //循环读取——————————————————————————
        //1. 创建一个输入流对象
        FileInputStream in=new FileInputStream("D:/aaa666/zhao.txt");

        byte[] bytes = new byte[10];
        int len=0;
        StringBuilder sb=new StringBuilder();
        while ((len=in.read(bytes))>0){
            //将byte数组转换为字符串形式
            String s = new String(bytes,0,len);
            sb.append(s);
        }
        System.out.println(sb);
        //3.关闭流
        in.close();
*/


/*
//文件的复制操作：：：：图片复制
        FileInputStream in=new FileInputStream("D:/aaa666/zhao.txt");
        FileOutputStream out=new FileOutputStream("D:/aaa666/zhao1.txt");
        byte[] bytes = new   byte[10];
        int len=0;
        while ((len=in.read(bytes))>0){
            out.write(bytes,0,len);
        }
        out.close();
        in.close();
        System.out.println("复制成功");
*/





    }
}

文件复制操作：输入流和输出流结合；；；

package aaa1125;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @className: Demo01
 * @author: Zyl
 * @date: 2024/11/25 8:56
 * @Version: 1.0
 * @description: 复制操作
 */

public class Demo01 {
    public static void main(String[] args) throws Exception{
//      FileInputStream in=new FileInputStream("C:/Users/zyluse/Desktop/01.jpg");
//      FileOutputStream out=new FileOutputStream("D:/aaa666/03.jpg");
        FileInputStream in=new FileInputStream("picture/01.jpg");
        FileOutputStream out=new FileOutputStream("src/aaa1125/04.jpg");
      byte [] bytes=new byte[2048];
      int i=-1;
      while((i=in.read(bytes))!=-1){
          out.write(bytes,0,i);
      }
      in.close();
      out.close();






    }
}

3.字符输出流

上面的字节流，适合读取的单位为字节类型。适合读取音频，视频，压缩等。而字符流适合读取文本类。一定不适合音频和视频操作。

public abstract class Writer
extends Object
implements Appendable, Closeable, Flushable、
用于写入字符流的抽象类。子类必须实现的唯一方法是write（char []，int，int），flush（）和close（）。然而，大多数子类将覆盖这里定义的一些方法，以便提供更高的效率，附加的功能或两者。

public class Test09 {
public static void main(String[] args) throws IOException {
Writer w=new FileWriter("demo02/f.txt");
w.write("你好世界",0,3);
w.close();
}
}

4.字符输入流

public abstract class Reader
extends Object
implements Readable, Closeable用于读取字符流的抽象类。子类必须实现的唯一方法是read（char []，int，int）和close（）。然而，大多数子类将覆盖这里定义的一些方法，以便提供更高的效率，附加的功能或两者。

ublic class Test10 {
public static void main(String[] args) throws Exception {
//字符输入流 Reader
Reader r=new FileReader("demo02/f.txt");

/*
//一次读取一个字符
int read=-1;
while ( (read=r.read())!=-1 ){
System.out.print((char)read);
}*/

/*一次读取多个字符*/
char[] cs=new char[50];
int size=-1;
while ( (size=r.read(cs))!=-1 ) {
System.out.println(new String(cs, 0, size));
}
r.close();
}
}

字符输入流和字符输出流的各种操作：

package aaa1125;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @className: Test04
 * @author: Zyl
 * @date: 2024/11/25 15:27
 * @Version: 1.0
 * @description:复制加重命名，，写一篇小说，复制
 */

public class Test04 {
    public static void main(String[] args) throws IOException {
        FileReader fr=new FileReader("D:/aaa666/123.txt");
        FileWriter fw=new FileWriter("D:/AAAAAAAAAAAA/669.txt");
        char [] bs=new char[2048];
        int len=-1;
        while((len=fr.read(bs))!=-1){
            fw.write(bs,0,len);
        }
        fr.close();
        fw.close();
    }
}

5.过滤流之缓冲输入流，缓冲输出流

BufferInputStream：

InputStream is=new FileInputStream("a.txt");
BufferedInputStream bis=new BufferedInputStream(is);

int a=-1;
while ( (a=bis.read())!=-1 ){
System.out.print((char) a);
}

bis.close();
is.close();

BufferOutputStream:

OutputStream os=new FileOutputStream("a.txt"); //基础流直接作用在文件上
BufferedOutputStream bos=new BufferedOutputStream(os);//缓存流作用在基础流上,默认缓存区是8k

String str="hello world java ai开发";
bos.write(str.getBytes());

bos.close();
os.close();

还有Buffer write和Bufferread

验证缓存流的效率：

package aaa1125;

import java.io.*;

/**
 * @className: Test05
 * @author: Zyl
 * @date: 2024/11/25 16:43
 * @Version: 1.0
 * @description:
 */

public class Test05 {
    public static void main(String[] args) throws Exception{
/*        long start=System.currentTimeMillis();
        InputStream is=new FileInputStream("D:/AAAAAAAAAAAA/vido/8.1.mp4");
        BufferedInputStream bis=new BufferedInputStream(is);
        OutputStream os=new FileOutputStream("D:/AAAAAAAAAAAA/vido/8.11.mp4");
        BufferedOutputStream bos=new BufferedOutputStream(os);

        int a=-1;
        while(   (a=bis.read())!=-1   ){
            bos.write(a);
        }
        bis.close();
        bos.close();
        is.close();
        os.close();
        long end=System.currentTimeMillis();
        System.out.println("耗时："+(end-start));
       */
        long start=System.currentTimeMillis();
        InputStream is=new FileInputStream("D:/AAAAAAAAAAAA/vido/8.1.mp4");
        BufferedInputStream bis=new BufferedInputStream(is);
        OutputStream os=new FileOutputStream("D:/AAAAAAAAAAAA/vido/8.11.mp4");
        BufferedOutputStream bos=new BufferedOutputStream(os);
        byte [] ch=new byte[4028];
        int a=-1;
        while(   (a=is.read(ch))!=-1   ){
            os.write(ch);
        }
        bis.close();
        bos.close();
        is.close();
        os.close();
        long end=System.currentTimeMillis();
        System.out.println("耗时："+(end-start));
    }
}

6.过滤流之对象输出流和对象序列化

对象流就是将我们的java对象来进行文件的存取操作。也就是说将我们的java对象存储到文件中。,

：为什么我们需要将java对款存储到文件中？,我们玩游戏的时候存档其实就是将游戏运行时候的内存中的对象信息存储到本地文件中，将来再去读取存档的时候就可以读取到当时存的信息了。

存档。----序列化.

public class Test {
public static void main(String[] args) throws Exception{
Game game=new Game("李白",16,100,60);
OutputStream os=new FileOutputStream("wzry/info/p1.txt");
ObjectOutputStream oos=new ObjectOutputStream(os);
//存档方法 java.io.NotSerializableException: 没有序列化。---
oos.writeObject(game);
oos.close();
os.close();
}
}

读档 ---反序列化上一个对象输入流不是打游戏存档吗？这个对象输出流就相当于取档读游戏。

public class Test02 {
public static void main(String[] args) throws Exception{
InputStream is=new FileInputStream("wzry/info/p1.txt");
ObjectInputStream ois=new ObjectInputStream(is);
//读档
Object o = ois.readObject();
System.out.println(o);
ois.close();
is.close();
}
}

7.序列化版本ID

定义：serialVersionUID 是 Java 序列化机制中的一个版本标识符，用于验证序列化的对象和反序列化的对象是否属于同一个版本。

作用：

版本控制：当类的字段或方法发生变化时，serialVersionUID 也会发生变化。这有助于确保反序列化的对象与原始序列化的对象版本一致。

import java.io.*;

class Person implements Serializable {
private static final long serialVersionUID = 1L; // 显式定义 serialVersionUID
private String name;
private int age;

// 构造方法、getter 和 setter 方法等
public Person(String name, int age) {
this.name = name;
this.age = age;
}

@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + '}';
}
}

public class SerializationDemo {
public static void main(String[] args) {
Person person = new Person("Alice", 30);

// 序列化对象到文件
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
oos.writeObject(person);
} catch (IOException e) {
e.printStackTrace();
}

// 从文件中反序列化对象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
Person deserializedPerson = (Person) ois.readObject();
System.out.println(deserializedPerson);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}

标签：Java,编程,System,学习,File,println,new,public,out
From： https://blog.csdn.net/weixin_64574904/article/details/144038196