Java程序设计（高级及专题）- IO流与序列化

最新推荐文章于 2022-03-23 09:28:53 发布
最新推荐文章于 2022-03-23 09:28:53 发布
阅读量285 收藏 1
点赞数 1
分类专栏： Java 文章标签： java高级
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37651267/article/details/90048289
版权

在这里插入图片描述

  • 今天我们讲讲I/O流与序列化的问题？
    个人理解：在我们在编程开发的时候，往往会涉及到文件的读取与写入，而java为我们提供的I/O流就是用来解决这个问题的。我们在读取和写入文件的时候，都会涉及到序列化的东西，谈到序列化就离不开编码格式，我们的windows是用GBK来编码的而我们的Java通常是用UTF-8来编码的，所以我们有时候开发会遇到乱码的问题，此时我们不要慌，问题总是会能解决的，大不了从新来吗；哪么我们回过头来看看I/O,它有五类一接口一关键字，分别是InputStream字节输入流（文件写入）、OutputStream字节输出流（文件读取）、Reader字符输入流（文件写入）、Writer字符输出流（文件读取）、File文件类（文件路径）和Serializable标识接口（序列化的标准）以及transient（反序列化关键字）;一个字符等于两个字节，字符流能处理的字节流都能处理，字符流不一定能够处理字节流的事物。

File类

/*
File读取文件的三种方式（第三种常用）
	File.separator  可以看成  //
	从盘符开始写，是绝对路径 如：e:\\work\\workspace\\ioDemo\\txt\\aaa.txt
	直接写是相对路径，相对工程下的.classpath文件
	f1.createNewFile();只能新建一个文件,不能新建文件夹
	file.list();//该方法只能得到该目录下子目录的文件名的String集合
*/
       File f=new File("D:"+File.separator+"aaa"+File.separator+"aaa.txt");
		/*
		File f1=new File("D:"+File.separator+"aaa","aaa.txt");
		
		File parent=new File("D:"+File.separator+"aaa");
		File child=new File(parent,"aaa.txt");*/

下面是它的一些方法：

序号方法介绍
1public String getName()返回由此抽象路径名表示的文件或目录的名称。
2public String getParent()返回此抽象路径名的父路径名的路径名字符串，如果此路径名没有指定父目录，则返回 null。
3public File getParentFile()返回此抽象路径名的父路径名的抽象路径名，如果此路径名没有指定父目录，则返回 null。
4public String getPath()将此抽象路径名转换为一个路径名字符串。
5public boolean isAbsolute()测试此抽象路径名是否为绝对路径名。
6public String getAbsolutePath()返回抽象路径名的绝对路径名字符串。
7public boolean canRead()测试应用程序是否可以读取此抽象路径名表示的文件。
8public boolean canWrite()测试应用程序是否可以修改此抽象路径名表示的文件。
9public boolean exists()测试此抽象路径名表示的文件或目录是否存在。
10public boolean isDirectory()测试此抽象路径名表示的文件是否是一个目录。
11public boolean isFile()测试此抽象路径名表示的文件是否是一个标准文件。
12public long lastModified()返回此抽象路径名表示的文件最后一次被修改的时间。
13public long length()返回由此抽象路径名表示的文件的长度。
14public boolean createNewFile() throws IOException当且仅当不存在具有此抽象路径名指定的名称的文件时，原子地创建由此抽象路径名指定的一个新的空文件。
15public boolean delete()删除此抽象路径名表示的文件或目录。
16public void deleteOnExit()在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
17public String[] list()返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组。
18public String[] list(FilenameFilter filter)返回由包含在目录中的文件和目录的名称所组成的字符串数组，这一目录是通过满足指定过滤器的抽象路径名来表示的。
19public File[] listFiles()返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件。
20public File[] listFiles(FileFilter filter)返回表示此抽象路径名所表示目录中的文件和目录的抽象路径名数组，这些路径名满足特定过滤器。
21public boolean mkdir()创建此抽象路径名指定的目录。
22public boolean mkdirs()创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。
23public boolean renameTo(File dest)重新命名此抽象路径名表示的文件。
24public boolean setLastModified(long time)设置由此抽象路径名所指定的文件或目录的最后一次修改时间。
25public boolean setReadOnly()标记此抽象路径名指定的文件或目录，以便只可对其进行读操作。
26public static File createTempFile(String prefix, String suffix, File directory) throws IOException在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
27public static File createTempFile(String prefix, String suffix) throws IOException在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
28public int compareTo(File pathname)按字母顺序比较两个抽象路径名。
29public int compareTo(Object o)按字母顺序比较抽象路径名与给定对象。
30public boolean equals(Object obj)测试此抽象路径名与给定对象是否相等。
31public String toString()返回此抽象路径名的路径名字符串。

InputStream 字节输入流

package com.gaoji.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
//输入字节流
public class IOdome_03 {
    //读取字节流InputStream
    public static void main(String[] args) throws IOException   {
        File f1 = new File("D://");//目标文件夹
        File f2 = new File(f1, "aaa.txt");//目标文件
        
        InputStream in =null;
        try {
            in = new FileInputStream(f2);//对该流进行实例化赋值
            int a = 0;//用于介绍流中独处的内容
//            in.skip(1);//跳过n个字节不读
//            第一种方法
//            while ((a=in.read())!=-1) {
//                System.out.print((char)a);
//            }
//          第二种方法(比较耗内存，速度会变快)
            byte[] bs = new byte[in.available()];
            while ((a=in.read())!=-1) {
                for(int i=0;i<bs.length;i++){
                    if(bs[i]==0){
                        break;
                    }
                }
                System.out.print((char)a);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            in.close();
        }
    }
}

OutputStream 字节输出流

package com.gaoji.io;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
//输出字节流
public class IOdome_04 {
    //写入字节流OutputStream
    public static void main(String[] args) throws IOException {
        File f1 = new File("D://");//目标文件夹
        File f2 = new File(f1, "aaa.txt");//目标文件
        OutputStream out=null;
        try {
            out=new FileOutputStream(f2,true);//true是续写，false是重写
            String a="holle wrold1";
//           一个字节一个字节的写
//            byte[] bs=a.getBytes();
//            for (int i = 0; i < bs.length; i++) {
//                out.write(bs[i]);
//            }
//            一个数组的写
            out.write(a.getBytes());
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            out.flush();//刷新(字节流是自动刷新的，不过不写不规范)
            out.close();//关闭
        } 
    }
}

Reader 字符输入流

//读
    public static void reader() {
        try {
            InputStreamReader fr=new InputStreamReader(new FileInputStream(new File("D:\\aaa.txt")),"utf-8");
            char[] cs=new char[6];
            fr.read(cs);
            System.out.println(new String(cs));
            System.out.println(fr.getEncoding());
            fr.close();
    } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
    }
        
    }

Writer 字符输出流

在使用字节输出流可以不刷新文件流，系统会自动刷新，而字符输出流不一样，如果不刷新再关闭的话，文件不会有任何操作的。

//写
    public static void writer() {
        OutputStreamWriter ows = null;
        try {
            ows = new OutputStreamWriter(new FileOutputStream(new File("D://aaa.txt")), "gbk");
            String a = "今天天气不错";
            ows.write(a);
            System.out.println(ows.getEncoding());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                ows.flush();
                ows.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

序列化与反序列化

  • User.java User实体类
package com.gaoji.io;

import java.io.Serializable;
//IO流里面的接口 Serializable
public class User implements Serializable {

    /**
     * 序列化编译id
     * transient //被他修饰的字段不会被序列化
     */
    private static final long serialVersionUID = 4950216177746797393L;
    private int id;
    private String name;
    private char sex;
    private transient String phone;
    public User(int id, String name, char sex, String phone) {
        super();
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.phone = phone;
    }
    public User() {
        super();
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", sex=" + sex + ", phone=" + phone + "]";
    }
}
  • Run.java 序列化运行类
package com.gaoji.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
//对象的序列化与反序列化
public class IOdome_07 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        xlh();
        fxlh();

    }
    //对象序列化
    public static void xlh() throws FileNotFoundException, IOException {
        User u = new User(1, "张三", '男', "15665620000");
        ObjectOutputStream out = null;
        try {
            out = new ObjectOutputStream(new FileOutputStream(new File("d:\\user.dat")));
            out.writeObject(u);
            System.out.println(u);
        } finally {
            out.flush();//刷新
            out.close();//关闭
        }
    }
    //对象反序列化
    public static void fxlh() throws IOException, ClassNotFoundException {
        ObjectInputStream in = null;
        try {
            in = new ObjectInputStream(new FileInputStream(new File("d:\\user.dat")));
            User u = (User) in.readObject();
            System.out.println(u.toString());
        } finally {
            in.close();
        }
    }

}

文件流实现复制

  • 字节流实现
//字节流 FileInputStream和FileOutputStream实现
    public static void InputOutputStream() throws IOException {
        File f1 = new File("D://");
        File f2 = new File(f1, "qqq.jpg");

        File f3 = new File("C://");
        File f4 = new File(f3, "qqq.jpg");

        FileInputStream fis = new FileInputStream(f2);//输入类(读取)
        FileOutputStream fos = new FileOutputStream(f4);//输出类(写入)
        int len = 0;
        while ((len = fis.read()) != -1) {
            fos.write(len);
        }
        fos.flush();
        fos.close();
        fis.close();
    }
  • 字符流实现
//缓存字节流 BufferedInputStream和BufferedOutputStream实现
    public static void BufferedInputOutputStream() throws IOException {
        // TODO Auto-generated method stub
        File f1 = new File("D://");
        File f2 = new File(f1, "qqq.jpg");
        File f3 = new File("C://");
        File f4 = new File(f3, "qqq.jpg");
        BufferedInputStream bin = null;
        BufferedOutputStream out = null;
        try {
            byte[] bs = new byte[1024];
            bin = new BufferedInputStream(new FileInputStream(f2));
            out = new BufferedOutputStream(new FileOutputStream(f4));
            while (bin.read(bs) != -1) {
                out.write(bs);
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            bin.close();
            out.flush();
            out.close();
        }
    }

IO流用递归实现查找系统盘里面的所有文件

package com.gaoji.io;

import java.io.File;

public class IOdomemy_01 {
   public static void main(String[] args) {
    //File f = new File("D://");
    File f = new File("D:\\");
    //getFile(f);
}
    //用递归实现查找系统盘里面的所有文件
    public static void getFile(File f) {
        File[] fs = f.listFiles();
        if(fs != null && fs.length !=0){
            for(File f1:fs){
                if(f1.isDirectory()){
                    getFile(f1);
                }else{
                    System.out.println(f1.getName());
                }
            }
        }
    }
}

试题巩固

1.在d盘根目录新建一个a.txt的文件，在文件中输入任意内容

package com.gaoji.io;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
//1.在d盘根目录新建一个a.txt的文件，在文件中输入任意内容
public class IOword_01 {
    public static void main(String[] args) {
        dome0111();
    }
    //用createTempFile创建文件
    public static void dome01(){
        File parent=new File("d:"+File.separator); 
        try {
            File file = parent.createTempFile("hjbqq",".txt",parent);
            System.out.println(file);
            //d:\hjbqq1465893390880583617.txt
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    用createNewFile创建文件
    public static void dome011(){
        File f1=new File("d:"+File.separator);
        File f2=new File(f1,"txt.txt");
        try {
            //有txt.txt则不创建，否，则相反
            f2.createNewFile();
            System.out.println("是否存在："+f2.exists());
            System.out.println(f2);
            //d:\txt.txt
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //写入字符流
    public static void dome0111(){
        File f1=new File("d:"+File.separator);
        File f2=new File(f1,"txt.txt");
        try {
            FileWriter fw = new FileWriter(f2);
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write("啊啊啊啊");
            bw.flush();//清除缓冲区
            
            bw.close();
            fw.close();
            System.out.println("写入完毕");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
}

2.读取txt.txt文件大小，最近访问时间，是否是一个目录。并删除此文件

package com.gaoji.io;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

//读取txt.txt文件大小，最近访问时间，是否是一个目录。并删除此文件
public class IOword_02 {
    public static void main(String[] args) {
        dome1();
    }

    public static void dome1() {
        File f1 = new File("D:"+File.separator);
        File f2 = new File(f1,"txt.txt");
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        
        System.out.println(f2);
        System.out.println(f2+"的文件大小是"+f2.length());
        System.out.println(f2+"最后一次被修改的时间是"+sdf.format(new Date(f2.lastModified())));
        System.out.println(f2+"是否是一个目录:"+f2.isDirectory());
        if(f2.delete()){
            System.out.println("删除成功！！");
        }else{
            System.out.println("删除失败");
        }
    }
}

3.编写一个程序，删除这个文件夹中的所有文件（用递归算法来实现）

package com.gaoji.io;

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

public class IOword_03 {

    //创建一个多层的文件夹，每个文件中有不同数目的文件，
    //编写一个程序，删除这个文件夹中的所有文件（用递归算法来实现）
    public static void main(String[] args) throws IOException {
        File f1=new File("d:"+File.separator);
        File f2 = new File(f1,"txt");
        
        getFile(f2);

    }
    //删除指定目录下的文件
    public static void getFile(File f) {
        File[] fs = f.listFiles();
        if(fs != null && fs.length !=0){
            for(File f1:fs){
                if(f1.isDirectory()){
                    getFile(f1);
                }else{
                   f1.delete();
                }
            }
        }
    }
}

资源下载

晓宇码匠
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA基础知识之InputStreamReader流
咕噜是个胖子
07-20 11万+
一、InputStreamReader类     API文档说明：InputStreamReader类是从字节流到字符流的桥接器：它使用指定的字符集读取字节并将它们解码为字符。 它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。每次调用一个InputStreamReader的read（）方法都可能导致从底层字节输入流中读取一个或多个字节。 为了实现字节到字符的有效转换...
用JavaIO流中的字节流将一个图片从一个盘复制到另一个盘
码说芯语的博客
02-11 861
用JavaIO流中的字节流将一个图片从一个盘复制到另一个盘 1、具体思路：IO流中字节流的应用 2、注意事项：异常处理，使用完IO流之后一定要关闭，可以使用funally类 3、代码实现： package ioStream_prctise;//包名而已 import java.io.File; import java.io.FileInputStream; import java.io.FileN...
IO流（序列化）
qq_42647047的博客
04-05 354
File类的使用 概述 IO流的引出和File类的作用 3 :IO流的引出 4 : File类的作用 常用构造器 输出 路径分隔符 常用方法 File类的获取功能 list()和listFiles()的区别 list()：返回的是String，输出的是文件和目录的名称，不包含路径； listFiles()：返回的是File类，输出的是文件和目录的名称，包含路径；输出File类默认调用重写的toString()方法。 例如： list()的输出 listFiles()的输出 File
java 序列化是干什么的？
ffeeng的博客
09-05 739
什么是序列化？ 序列化是将对象转换IO流，进行存储，或者在网络中传输。 与之相反的是反序列化，它是将IO流转换成对象。 package learn; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; impor
IO流及序列化
qq_53329270的博客
03-23 622
文件创建：Filefile=newfile(路径)； file.mkdir();创建目录file.createNewFile();创建Txt文档等 mkdir()上层目录不存在，则不创建mkdirs()上目录不存在，一并创建 为什么IO流或者序列化的定义(InputStreamin=null；)需要写在外面？ 1.方便关闭流，或者序列化流，2.方便统一进行调用。 IO流(可能抛出IO异常) 流的关闭顺序：先开的后关，后开的先关(close()) 字节流：输入(InputStream接口...
java高级特性 - io流笔记
最新发布
05-30
Java的IO流是其高级特性中的重要组成部分，它在处理数据输入与输出方面扮演着核心角色。Java的IO系统设计得相当灵活，可以处理各种类型的数据，包括字符、字节，甚至对象。以下是对Java IO流的详细解读。 1. **IO流...
Java面向对象程序设计第08章_Java-IO流.ppt
09-30
Java面向对象程序设计第08章_Java-IO流 Java 中的输入输出流（IO）是计算机输出 / 输入的接口。Java 的核心库 java.io 提供了全面的 IO 接口，包括文件读写、标准设备输出等等。Java 中的 IO 是以流为基础进行输入...
Java高级程序设计实战教程第五章-Java序列化机制.pptx
05-30
实现序列化的关键在于类实现`java.io.Serializable`接口，无须实现任何方法。 5.2.2 序列化应用：除了基础的文件存储和网络传输，序列化也常用于缓存、日志记录、状态备份等场景。 5.2.3 序列化方式：Java中常见的...
Java高级程序设计期末复习题_Java高级程序设计期末复习题_
10-03
Java高级程序设计是Java编程学习中的重要阶段，涵盖了多线程、网络编程、I/O流、集合框架、反射、异常处理、设计模式等核心概念。本篇将针对这些关键知识点进行详细阐述，以帮助学生更好地准备期末复习。 一、多...
Introduction-to-Java-IO.rar_Java IO Tutorial
09-19
此外，Java IO还提供了对象序列化和反序列化的功能，通过ObjectOutputStream和ObjectInputStream可以将Java对象转化为字节流进行存储或网络传输。File类是操作文件的基本工具，可以进行创建、删除、重命名等操作。 ...
Python读取指定路径所有.txt文件，将文件内容写入.txt
热门推荐
小小鹿luby的博客
05-30 3万+
要处理的.txt如下，举例：文件夹lululu下面包含两个子文件夹，每个子文件夹里包含若干个.txt，每个.txt里有几个特征，我要做的是批量读取这些文本文档，并将这些txt写入到一个新的txt里，并且在每类特征后加入类标签，以便后续处理。 代码如下： import glob import os import tensorflow as tf import numpy as np...
java对象的序列化和反序列化
al55550的博客
06-01 90
1.概念 对象转化为字节序列的过程为对象序列化； 字节序列恢复为对象的过程为反序列化； 2.实例 序列化 1 ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(new File("文件路径"))); 2 oo.writeObject(对象); 3 oo.close(); 反...
3、IO流和序列化与反序列化
-简简单单就好♥ﻬ‥
07-14 345
Java I/O(input/output)文件 | 内存 | 键盘 —&gt; 程序的过程叫做读程序 —&gt; 文件 | 内存 | 控制台的过程叫做写文件（File类）相关记录或放在一起的数据的集合叫做文件通过Java.io.File类访问文件属性1234567/**创建文件对象语法*参数内(path name(路径名称))为文件的目录*如"c:\\test.txt"或"c:/test.txt...
IO流以及序列化和反序列化
qq_55137734的博客
11-08 453
什么是流？ 内存与存储设备之间传输数据的通道。 流的分类： 按数据传输的方向来分（以内存为参照）： 1.输入流：硬盘 ---> 内存 2. 输出流：内存 ---> 硬盘 按单位来分： 1.字节流：以字节为单位，啥数据都可以传 2.字符流：以字符为单位，只能传文本数据 按功能来分： ...
Java基础——IO流（三）
12345~
08-02 510
File类 用来将文件或者文件夹封装成对象 方便对文件与文件夹的属性信息进行操作 File对象可以作为参数传递给流的构造函数 了解File类的常用方法 创建文件对象 //创建一个文件对象的几种方法 import java.io.*; public class FileDemo { public static
java编写一个程序,从键盘输入一串字符,从屏幕输出并将其存入a.txt文件中。
weixin_34262482的博客
03-02 5448
import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class OutputA { public static void main(String [] args){ ...
Java缓冲字节流BufferedOutputStream(输出),BufferedInputStream(输入),对文件的复制操作
I want to fly higher
02-13 1673
public static void main(String[] args) throws IOException { //bufferedOutput(); //bufferedInput(); //copyFile(); } /** * 文件复制操作(操作文件最快) * @throws IOException */ private static void co...
字节流,将一段话写入文件内容：b.txt 是在项目的根目录下
gfh
03-07 1681
import java.io.FileOutputStream; import java.io.IOException; /** 字节流,将一段话写入文件内容：b.txt 是在项目的根目录下 */ public class OutputFile { public static void main(String[] args) { try { FileOutputSt...
java IO序列化—纯个人见解
weisian的博客
07-25 358
引入序列化： 计算机对于数据的传输是以字节进行传输的，但是在java中对于基本类型可以直接通过getBytes（）方法进行转码传输，但是对于对象却不可以直接转为字节，所以需要引入序列化的接口，可以将对象进行传输操作。 序列化概念： 序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。 序列化与反
Java流技术详解：序列化与IO操作深入理解
本章节深入探讨了Java流技术，特别是关于对象的序列化与Java流类的使用。序列化（Serialization）是Java中一种将对象的状态信息持久化的过程，主要用于对象的保存和传输。它仅能序列化对象的数据，而非transient和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值