javase进阶之IO

目标

1. 能通过FIle类，对文件熟练操作 - 熟练
2. 理解相对路径和绝对路径的区别 - 了解
3. 掌握常见的字节输入输出和字符输入输出流 - 熟练
4. 了解序列化和反序列化 - 熟悉

File类 

Java中的 文件/文件夹的 抽象表示形式 。一个File类的对象, 在JAVA中, 表示一个文件或文件夹。

 1 File类常用的构造方法

注意: 我们使用File类 描述文件时 ,这个File对象描述的文件 可以是不存在的 !

1. File(String pathName)

参数1: 文件的路径, 例如: c://x.txt

2. File(String parentName,String fileName) 

参数1: 文件夹的路径

参数2: 文件的名称

例如: 描述c盘中a文件夹中的x.txt

new File("c://a","x.txt");

3. File(File parent,String fileName) 

参数1: 父文件夹的 File对象

参数2: 文件的名称

例如: 描述c盘中a文件夹中的x.txt

new File(new File("c://a"),"x.txt");

小测试 ：删除文件 

 

三种方法删除a文件夹 

package com.kkb;

import java.io.File;

public class Demo01 {
    public static void main(String[] args) {
        //File file = new File("D:\\a");//构造方法1
        //File file = new File("D:\\","a");//构造方法2
        File dir = new File("D:\\");
        File file = new File(dir,"a");
        file.delete();
        System.out.println("代码执行完毕");
    }
}

测试结果 

 注意：删除文件夹的时候，必须将里面的内容全部清空，否则无法删除

2 File类常用的方法 

-boolean createNewFile(); 

当此File对象表示的文件不存在时 , 此方法用于创建文件 , 创建成功返回true

当此File对象表示的文件已存在时, 此方法不执行任何的操作, 直接返回false

注意: 此方法不能用于创建文件夹

package com.kkb;

import java.io.File;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\a\\1.txt");
        boolean flag = file.createNewFile();
        System.out.println(flag?"文件创建成功":"文件创建失败");
    }
}

- boolean mkdir()

当此File对象表示的文件夹不存在时, 用于创建文件夹, 创建成功返回true

注意: 此方法只能用于创建一层目录, 也就是此File对象表示的父文件夹必须存在.

例如: File a = new File("c://a/b/c");

当我们操作a.mkdir();

//只有b文件夹已经存在时, 才会创建成功.

- boolean mkdirs() 

当此File对象表示的文件夹不存在时, 用于创建文件夹, 创建成功返回true

注意: 此方法可用于创建多层目录

例如: File a = new File("c://a/b/c");

当我们操作a.mkdirs();

会在C盘创建a文件夹, 在a文件夹中创建b文件夹,在b文件夹中创建c文件夹

package com.kkb;

import java.io.File;

public class Demo03 {
    public static void main(String[] args) {
        //File file=new File("D:\\a\\heihei");
        //file.mkdir();//只能创建单层目录
        File file=new File("D:\\a\\heihei2\\haha");
        file.mkdirs();//可以创建多层，也可以创建单层
    }
}

- boolean exists() *

判断此File对象所表示的文件 或 文件夹是否存在.

存在则返回true, 不存在则返回false;

package com.kkb;

import java.io.File;
import java.io.IOException;

public class Demo04 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\a\\heihei2\\1.hahaha");
        if (file.exists()){
            //过往程序创建出来的，则表示程序运行过至少一次
        }else {
            //文件不存在，应该弹出提示，并将文件创建出来
            System.out.println("感谢您安装此软件！");
            file.createNewFile();
        }
    }
}

 

再次运行

- boolean delete(); *

删除此File对象 所表示的文件/文件夹 , 删除成功返回true

注意: 当用于删除文件夹时, 文件夹中的内容必须是空的.

- boolean deleteOnExit() 熟悉

当JVM退出时 , 删除此文件.

- boolean renameTo(File newFile);

更改文件的名称, 并将文件剪切到 参数位置

package com.kkb;

import java.io.File;

public class Demo05 {
    public static void main(String[] args) {
        File oldFile =new File("D:\\a\\1.txt");
        File newFile =new File("D:\\a\\heihei\\2.txt");
        oldFile.renameTo(newFile);
    }
}

 3 File类获取文件信息的方法

- String getAbsolutePath(); 

获取文件的绝对路径, 例如: c://x.txt

- String getName(); 

获取文件的名称 , 名称带有后缀名

- String getPath();

获取文件的路径

- long length(); 

返回文件的字节数

- long lastModified()

获取文件最后一次修改的时间

- boolean isFile() 

获取file对象 是否为文件, 文件则返回true , 文件夹则返回false

- boolean isDirctory()

获取file对象 是否为文件夹, 文件夹则返回true , 文件则返回false

- boolean isHidden()

获取此文件是否为隐藏文件 . 隐藏文件返回true

- String getParent();

通过一个file对象 获取其父文件夹的路径.

- File getParentFile() *

通过一个File对象, 获取其父文件夹的file对象

- String[ ] list() *

只有file对象为文件夹时 才可用, 用于获取子文件 /子文件夹的 路径数组

- File[ ] listFiles() 

只有file对象为文件夹时 才可用, 用于获取子文件 /子文件夹的 文件数组 , 如果不存在子文件 则返回null

4.练习：做一个垃圾处理程序（清楚指定文件夹下的所有avi文件）

简易代码 

package com.kkb;

import java.io.File;

public class Demo06 {
    public static void main(String[] args) {
        File file = new File("D:\\avi");
        deleteAVI(file);
    }

    public static void deleteAVI(File dir) {
        System.out.println("正在扫描："+dir.getAbsolutePath());
        //1.获取文件夹中的所有文件
        File[] files = dir.listFiles();
        //2.循环遍历所有文件
        for (int i = 0; i < files.length; i++) {
            //3.判断每一个文件是否是文件夹 File[]数组
            if (files[i].isDirectory()) {
                //4.1如果是文件夹，则递归此方法
                deleteAVI(files[i]);
            }else {
                //4.2如果是文件，则判断文件的名称是否以AVI结尾
                  if (files[i].getName().endsWith(".avi")||files[i].getName().endsWith(".AVI")) {
                      //5.如果是avi结尾，则删除此文件，并提示文件被删除
                      files[i].delete();
                      System.out.println(files[i].getAbsolutePath()+"- 已删除");
                  }
            }
        }
    }
}

优化代码 

package com.kkb;

import java.io.File;
import java.util.ArrayList;
import java.util.Scanner;

public class Demo07 {
    static ArrayList<File> fileList = new ArrayList<>();
    static long size =0;
    static Scanner input = new Scanner(System.in);
    public static void main(String[] args) {
        File file = new File("D:\\avi");
        scanAVI(file);
        System.out.println("发现垃圾文件"+fileList.size()+"个，共"+size+"个字节");
        System.out.println("列表如下：");
        for (int i = 0; i < fileList.size(); i++) {
            System.out.println(fileList.get(i).getAbsolutePath());
        }
        System.out.println("确认删除吗？Y/N");
        String s =input.nextLine();
        if ("Y".equals(s)||"y".equals(s)){
            //删除
            for (int i = 0; i < fileList.size(); i++) {
                System.out.println(fileList.get(i).getAbsolutePath()+"正在删除");
                fileList.get(i).delete();
            }
        }else {
            //不删除
            System.out.println("欢迎下次再来");
        }
    }

    public static void scanAVI(File dir){
        System.out.println("正在扫描："+dir.getAbsolutePath());
        //1.获取文件夹中的所有文件
        File[] files = dir.listFiles();
        //2.循环遍历所有文件
        for (int i = 0; i < files.length; i++) {
            //3.判断每一个文件是否是文件夹 File[]数组
            if (files[i].isDirectory()) {
                //4.1如果是文件夹，则递归此方法
                scanAVI(files[i]);
            }else {
                //4.2如果是文件，则判断文件的名称是否以AVI结尾
                if (files[i].getName().endsWith(".avi")||files[i].getName().endsWith(".AVI")) {
                    //5.如果是avi结尾，则删除此文件，并提示文件被删除
                    fileList.add(files[i]);
                    size += files[i].length();
                }
            }
        }
    }
}

  

  5.绝对路径与相对路径

绝对路径:

绝对路径是指目录下的绝对位置,直接到达目标位置,通常是从盘符开始的路径。 完整的描述文件位置的路径就是绝对路径。

相对路径

相对路径就是指由这个文件所在的路径引起的跟其它文件（或文件夹）的路径关系。

关于路径生活中的例子

绝对地址:

地址a：中国-北京-海淀区-xx中心C座-503室

相对地址:

地址b：地址a所在楼的 408 室

"D://X/Y/Z.TXT"

"a.txt"

电脑中相对路径与绝对路径

绝对路径:

c://a/b/c.txt

相对路径:

在c://a/b文件夹中的a.Java文件中 描述 heihei.txt

这个heihei.txt 就是相对路径, 相对于c://a/b存在的路径。

它的绝对路径解析为：c://a/b/heihei.txt

 6.FileFilter接口（文件过滤器）

 在之前的代码中增加过滤器，筛选avi文件

package com.kkb;

import java.io.File;
import java.io.FileFilter;

public class Demo08 {
    public static void main(String[] args) {
        File file = new File("D:\\avi");
        deleteAVI(file);
    }

    public static void deleteAVI(File dir) {
        System.out.println("正在扫描："+dir.getAbsolutePath());
        //1.获取文件夹中的所有文件
        File[] files = dir.listFiles(
                new FileFilter() {
                    @Override
                    public boolean accept(File pathname) {
                        if (pathname.isFile()&&!pathname.getName().endsWith(".avi") && !pathname.getName().endsWith(".AVI"))
                             return false;
                        return true;
                    }
                }
        );
        //2.循环遍历所有文件
        for (int i = 0; i < files.length; i++) {
            //3.判断每一个文件是否是文件夹 File[]数组
            if (files[i].isDirectory()) {
                //4.1如果是文件夹，则递归此方法
                deleteAVI(files[i]);
            }else {
                //4.2如果是文件，则判断文件的名称是否以AVI结尾
                  if (files[i].getName().endsWith(".avi")||files[i].getName().endsWith(".AVI")) {
                      //5.如果是avi结尾，则删除此文件，并提示文件被删除
                      files[i].delete();
                      System.out.println(files[i].getAbsolutePath()+"- 已删除");
                  }
            }
        }
    }
}

2.io流 

1.概念 

1. input 输入

2. output 输出

输入与输出:

在我们程序中是一种相对的概念 .

例如:

我们的程序, 从硬盘中读取一个文件 !

这种操作 相对于我们的程序而言, 是在进行输入操作 .

这种操作 相对于我们的硬盘而言, 是在进行输出操作 .

例如:

我们的程序, 在硬盘中创建一个文件 !

这种操作 相对于我们的程序而言, 是在进行输出操作 .

这种操作 相对与我们的硬盘而言, 是在进行输入操作 .

2 Java中流的分类

从操作上来说, 分为两种流:

1. 输入流

2. 输出流

但是通常情况, 我们指的流的分类是:

1. 字节byte流

- 输出流顶级父 : OutputStream

- 输入流顶级父 : InputStream

2. 字符char流

- 输出流顶级父 : Writer

- 输入流顶级父 : Reader

整个Java的io体系, 使用了大量的装饰者设计模式.

字符的组成，依赖编码表：UTF-8,GBK

 3 字节输出流 OutputStream

常用方法:

- void write(int b);

向输出流指向的位置 , 输出一个字节.

- void write(byte[] bytes); *

向输出流指向的位置 , 输出一个字节数组 .

- void write(byte[] bytes,int offset,int len); ***

向输出流指向的位置 , 输出一个字节数组的一部分 (从offset开始, 输出len个字节)

- void close() ***

关闭流, 释放占用的硬件资源.

 FileOutputStream 文件字节输出流 

FileOutputStream 是 OuputStream 的实现类 , 是用于将字节 输出到文件中的 类.

文件输出流 输出时, 指向的文件可以不存在, 会创建文件并输出 .



构造方法:

- FileOutputStream(String filePath); ***

通过文件的绝对路径 , 创建一个指向文件的输出流.



- FileOutputStream(String filePath,boolean append); ***

参数1. filePath: 创建的流 , 指向的文件路径

参数2. append : 设置流是否为追加模式 .

(当值为false时, 会将之前的数据清空)

(当值为true时, 会接着之前的文件 继续存储)



- FileOutputStream(File file); ***

通过文件的file对象 , 创建一个指向文件的输出流.



- FileOutputStream(File file,boolean append); ***

参数1. file : 创建的流 , 指向的文件

参数2. append : 设置流是否为追加模式 .

(当值为false时, 会将之前的数据清空)

(当值为true时, 会接着之前的文件 继续存储)

一次输出一个字节:

public static void main(String[] args) throws Exception {

//创建一个指向d盘 heihei.txt的流

FileOutputStream fos = new FileOutputStream("d://heihei.txt");

fos.write(97);//a

fos.write(98);//b

fos.write(99);//c

fos.write(100);//d

fos.close();

System.out.println("执行完毕");

}



一次输出一个字节数组:

public static void main(String[] args) throws Exception {

byte[] bytes = "从前有座山 , 山上有座嘿嘿嘿".getBytes();

FileOutputStream fos = new FileOutputStream("d://heihei.txt",true);

fos.write(bytes);

fos.close();

System.out.println("执行完毕");

}



一次输出一个字节数组的一部分:

public static void main(String[] args) throws Exception {

byte[] bytes = "从前有座山 , 山上有座嘿嘿嘿".getBytes();

FileOutputStream fos = new FileOutputStream("d://heihei.txt");

fos.write(bytes,0,10);

fos.close();

System.out.println("执行完毕");

}

测试代码1

package com.kkb;

import java.io.FileOutputStream;

public class Demo09 {
    public static void main(String[] args) throws Exception {
        //D:\a\heihei\2.txt
        FileOutputStream fos = new FileOutputStream("D:\\a\\heihei\\2.txt");
        //一次输出一个字节
        //fos.write(65);
        //fos.close();
        //一次输出一个字节数组
//        byte[] bytes = "一二三四五，上山撸老虎！".getBytes();
//        fos.write(bytes);
//        fos.close();
        //一次输出一个字节数组，从指定位置开始，输出指定数量
        byte[] bytes = "一二三四五，上山撸老虎！".getBytes();
        fos.write(bytes,0,10);
        fos.close();
    }
}

 测试代码2

package com.kkb;

import java.io.FileOutputStream;

public class Demo10 {
    public static void main(String[] args) throws Exception {
        //D:\a\heihei\2.txt   第二个参数true(追加模式)
        FileOutputStream fos = new FileOutputStream("D:\\a\\heihei\\2.txt",true);
        //一次输出一个字节数组
        byte[] bytes = "一二三四五，上山撸老虎！".getBytes();
        fos.write(bytes);
        fos.close();

    }
}

4.InputStream 字节输入流 

常用方法:

- int read()

一次读取一个字节,(这个字节 使用0-255的int值来表示) 并返回 , 如果读取到流的尾部则返回-1


- int read(byte[] bytes); ***

一次读取一个字节数组 , 并将读取的内容存储到bytes中 , 返回的是读取的字节个数 , 当读取到流尾部时返回-1


- int read(byte[] bytes,int offIndex,int length)

bytes: 读取的字节数组, 存储的位置

offIndex: 读取的一组字节, 存储在bytes中的起始位置

length: 读取的一组字节的长度

这个方法读取完毕后, 新的数据存储在 bytes数组的 offIndex下标 到 offIndex+length下标


- void close();

关闭流, 释放资源.

FileInputStream 文件输入流

构造方法:

- FileInputStream(String filePath);

根据一个文件的路径, 创建一个指向此文件的输入流

- FileInputStream(File file);

根据一个file对象, 创建一个指向file表示文件的输入流.

一次读取一个字节:

public static void main(String[] args) throws Exception {

StringBuilder sb = new StringBuilder();

FileInputStream fis = new FileInputStream("d://heihei.txt");

int b = -1;

while((b = fis.read())!=-1) {

char c = (char)b;

sb.append(c);

}

fis.close();

System.out.println(sb.toString());

}



一次读取一个字节数组

public static void main(String[] args) throws Exception {

//创建一个指向d盘 heihei.txt文件的输入流

FileInputStream fis = new FileInputStream("d://heihei.txt");

//创建一个长度为1024的字节数组, 用于存储每次读取的数据

byte[] bytes = new byte[1024];

//开始读取, 并记录读取的字节数量

int len = fis.read(bytes);

//将读取的内容 转换为字符串

String text = new String(bytes,0,len);

//打印读取的内容

System.out.println(text);

}



一次读取一个字节数组的一部分

public static void main(String[] args) throws Exception {

FileInputStream fis = new FileInputStream("d://heihei.txt");

byte[] bytes = new byte[1024];

int len = fis.read(bytes,0,20);

String text = new String(bytes,0,20);

System.out.println(text);

}

 测试代码

package com.kkb;

import java.io.FileInputStream;

public class Demo11 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("D:\\a\\heihei\\2.txt");
        //一次读取一个字节
//        int b = fis.read();
//        System.out.println((char)b);
//        fis.close();

        //一次读取一个字节数组
//        byte[] bytes = new byte[1000];
//        int len = fis.read(bytes);
//        System.out.println("读取了"+len+"个字节");
//        String text = new String(bytes,0,len);
//        System.out.println(text);
//        fis.close();

        //一次读取一个字节数组,存储在指定位置
        byte[] bytes = new byte[1000];
        int len = fis.read(bytes,10,400);
        System.out.println("读取了"+len+"个字节");
        String text = new String(bytes,10,400);
        System.out.println(text);
        fis.close();

    }
}

案例：文件的边读边写

package com.kkb;

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

public class Demo12 {
    public static void main(String[] args) throws Exception {
        //1.文件的位置D:\avi\Demo06
        //2.目标文件夹的位置:D:\avi\idea.avi
        //3.创建一个文件对象，指向文件位置
        File file = new File("D:\\avi\\Demo06.java");
        //4.再创建一个文件对象，指向目标位置
        File file2 = new File("D:\\avi\\idea.txt");
        //5.1：创建一个输入流
        FileInputStream fis = new FileInputStream(file);
        //5.2：创建一个输出流
        FileOutputStream fos = new FileOutputStream(file2);
        //6.创建一个字节数组
        byte[] bytes = new byte[1024];
        //7.创建一个变量，用于记录每次读取的字节个数
        int len =0;
        //8.循环读取
//        while (true){
//            len = fis.read(bytes);
//            if (len == -1){
//                break;
//            }
//        }
        while ((len = fis.read(bytes)) ==-1){
            //如果这里执行，则表示读取到了一组字节（bytes），读取的字节数量是len
            //数据的写出
            fos.write(bytes,0,len);
        }
        fos.close();
        fis.close();
    }
}

两个文件一起边读边写

package com.kkb;

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

public class Demo14 {
    public static void main(String[] args) throws Exception {
        //1.文件的位置D:\avi\Demo06
        //2.目标文件夹的位置:D:\avi\idea.avi
        //3.创建一个文件对象，指向文件位置
        File file = new File("D:\\avi\\idea.jpg.JPG");
        //4.再创建一个文件对象，指向目标位置
        File file2 = new File("D:\\avi\\a");
        //5.1：创建一个输入流
        FileInputStream fis = new FileInputStream(file);
        //5.2：创建一个输出流
        FileOutputStream fos = new FileOutputStream(file2);
        //6.创建一个字节数组
        byte[] bytes = new byte[1024];
        //7.创建一个变量，用于记录每次读取的字节个数
        int len =0;
        long count = 0;
        //8.循环读取

        while ((len = fis.read(bytes)) ==-1){
            //如果这里执行，则表示读取到了一组字节（bytes），读取的字节数量是len
            //数据的写出
            fos.write(bytes,0,len);
            count+=len;
            System.out.println("正在处理第一个文件："+count/(file.length()/100)+"%");
        }
        fis.close();
        //开始读取第二个文件
        File file1 = new File("D:\\avi\\idea.jpg.JPG");
        fis = new FileInputStream(file1);
        count = 0;
        while ((len = fis.read(bytes)) ==-1){
            //如果这里执行，则表示读取到了一组字节（bytes），读取的字节数量是len
            //数据的写出
            fos.write(bytes,0,len);
            count+=len;
            System.out.println("正在处理第二个文件："+count/(file1.length()/100)+"%");
        }
        fis.close();
        fos.close();
    }
}

5.字符流

字符输出流 

package com.kkb;

import java.io.File;
import java.io.FileWriter;

public class Demo15 {
    public static void main(String[] args) throws Exception{
        File file = new File("D:\\avi\\吟诗三百首.txt");
        FileWriter fw = new FileWriter(file,true);
        fw.write("哥翁喊上来，池横不敢过\n");
        fw.write("闯前门越广，疑尸地上爽\n");
        //fw.flush();
        fw.close();
    }
}

测试结果 

 

特殊的输出流---打印流

package com.kkb;

import java.io.PrintStream;
import java.io.PrintWriter;

public class Demo16 {
    public static void main(String[] args) throws Exception{
        PrintStream ps = new PrintStream("D:\\avi\\吟诗三百首2.txt");
        PrintWriter ps2 = new PrintWriter("D:\\avi\\吟诗三百首3.txt");
        ps.println("嘿嘿嘿嘿嘿");
        ps2.println("哈哈哈哈哈");
        ps.close();
        ps2.close();
    }
}

  

字符输入流

package com.kkb;

import java.io.File;
import java.io.FileReader;

public class Demo17 {
    public static void main(String[] args) throws Exception{
        File file = new File("D:\\avi\\吟诗三百首4.txt");
        FileReader fr = new FileReader(file);
        while (true){
            int c = fr.read();
            if (c==-1){
                break;
            }
            System.out.print((char)c);
        }
        fr.close();
    }
}

特殊的字符输入流---带有缓冲的字符输入流（逐行读取的流）

package com.kkb;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

public class Demo18 {

    public static void main(String[] args) throws Exception{
        File file = new File("D:\\avi\\吟诗三百首4.txt");
        FileReader fr = new FileReader(file);
        BufferedReader br = new BufferedReader(fr);
        //一次读一行
//        String s = br.readLine();
//        System.out.println(s);
        String text = null;
        while ((text = br.readLine())!=null){
            System.out.println(text);
        }
        br.close();
    }
}

转换流 

字节流与字符流的相互转换

字节输出转换字符流

package com.kkb;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class Demo19 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos = new FileOutputStream("D:\\avi\\吟诗三百首5.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        osw.write("哈哈哈哈啊");
        osw.close();
    }
}

 字节输入转换字符流

package com.kkb;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Demo20 {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("D:\\avi\\吟诗三百首.txt");
        InputStreamReader isr = new InputStreamReader(fis);
        BufferedReader br = new BufferedReader(isr);
        String s = br.readLine();
        System.out.println(s);
    }
}

序列化综合案例

实体类Users 

package com.kkb;

import java.io.Serializable;
import java.util.Objects;
public class User implements Serializable {
    private String username;
    private String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return username.equals(user.username);
    }

    @Override
    public int hashCode() {
        return Objects.hash(username);
    }
}

 登录注册功能

package com.kkb;

import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;


public class Demo21 {
    static Scanner input =new Scanner(System.in);
    public static void main(String[] args) {
        //调用初始化方法
        init();
        //菜单的提示
        System.out.println("欢迎来到xx登录器");
        while (true){
            System.out.println("1.登录\t\t2.注册");
            String s = input.nextLine();
            if ("1".equals(s)){
                login();
            }else if ("2".equals(s)){
                reg();
            }else {
                System.out.println("您的输入有误");
            }
        }
    }
    static File file =new File("D:\\avi\\User.u");
    /**
     * 初始化方法
     * 判断users文件是否存在，存在则读取它，将内容转化为集合。
     */
    private static void init(){
        if (!file.exists())
            return;
        ObjectInputStream ois =null;
        try {
            ois =new ObjectInputStream(new FileInputStream(file));
            users = (ArrayList<User>) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (users == null){
                users =new ArrayList<>();
            }
        }
    }
    static ArrayList<User> users = new ArrayList<>();
    //注册
    private static void reg() {
        System.out.println("开始注册");
        System.out.println("请输入账号");
        String username = input.nextLine();
        System.out.println("请输入密码");
        String password = input.nextLine();
        User user = new User(username,password);
        if (!users.contains(user)) {
            users.add(user);
        }else{
            System.out.println("很遗憾，用户名重复，注册流程结束");
        }
        // 将新增了注册用户的集合，序列化到文件中
        ObjectOutputStream oos = null;
        try {
            oos =new ObjectOutputStream(new FileOutputStream("D:\\avi\\User.u"));
            oos.writeObject(users);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (oos !=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //登录方法
    private static void login() {
        System.out.println("开始登录");
        System.out.println("请输入账号");
        String username = input.nextLine();
        System.out.println("请输入密码");
        String password = input.nextLine();
        User user = new User(username,password);
        int i = users.indexOf(user);
        if (i==-1){
            System.out.println("账号错误，登录失败");
        }else if (password.equals(users.get(i).getPassword())){
            System.out.println("登录成功，由于软件没有任何的功能，流程结束");
        }else {
            System.out.println("密码错误，登录失败");
        }

    }
}

测试结果