Android的五大存储方式：SharedPreferences、内部存储、外部存储、SQLite和网络存储

最新推荐文章于 2021-11-07 22:35:57 发布
最新推荐文章于 2021-11-07 22:35:57 发布
阅读量1.3k 收藏
点赞数
分类专栏： android 文章标签： android SQLlte sdcard cache preference
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NiZhuanXingHeIT/article/details/48270385
版权

概述

1、SharedPreferences：
用getPreferences(“文件名”,MODE_XXX),有四种MODE,最常用的是MODE_PRIVATE,用sharedPreferences.edit的到editor，用putXXX(“key”,”data”)来写入数据，读取数据用preferences.getXXX(“key”,”默认文本”),XXX可以是String、Integer等引用数据类型;创建后的文件在shared_prefs里面（文件后缀为.xml）。
2、内部存储：
分为cache缓存和cache Dir两种存储方式。
cahe的存储需要用到文件输入输出流，通过openOutputStream(“文件名”，MODE_XXX)得到文件输出流，openInputStream(“文件名”)得到文件输入流。创建完后的文件在files文件夹下。
cache Dir和的输入输出方式和cache类似，创建方式有所不同，需要用 new File(getCacheDir(),”文件名”)类创建，创建后的文件在cache目录下。
3、外部存储sdcard：
外部存储需要用到Environment.XXX得到sdcard下的指定目录来存储，也是用到new File(父路径，文件名)。创建完的文件在mnt的sdcard路径下，位置不确定。
4、SQLite数据库：
SQLite没有数据类型。
首先要建一个继承于SQLiteOpenHelper的类，实现其中的至少一个构造方法和两个方法onCreate()、onUpdate()。在onCreate()中用execSQL()方法创建数据库，创建完的数据库在data/data/项目名称/databases路径下，往SQLite的增删改查分别需要用到insert()、delete()、update()、query()方法。
网络存储：
略。

知识

SharedPreferences、外部存储与内部存储

public class MainActivity extends Activity implements View.OnClickListener {
    private TextView mTextRead;
    private EditText mEditWrite;
    private Button mButtonWrite;
    private Button mButtonRead;
    private Button mButtonReadCache;
    private Button mButtonWriteCache;
    private Button mButtonWriteCacheDir;
    private Button mButtonReadCacheDir;
    private Button mButtonWriteSdcard;
    private Button mButtonReadSdcard;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mTextRead = (TextView) findViewById(R.id.text_read);
        mEditWrite = (EditText) findViewById(R.id.edit_write);
        mButtonWrite = (Button) findViewById(R.id.button_write);
        mButtonRead = (Button) findViewById(R.id.button_read);
        mButtonReadCache = (Button) findViewById(R.id.button_read_cache);
        mButtonWriteCache = (Button) findViewById(R.id.button_write_cache);
        mButtonWriteCacheDir = (Button) findViewById(R.id.button_write_cache_dir);
        mButtonReadCacheDir = (Button) findViewById(R.id.button_read_cache_dir);
        mButtonWriteSdcard = (Button) findViewById(R.id.button_write_sdcard);
        mButtonReadSdcard = (Button) findViewById(R.id.button_read_sdcard);

        mButtonRead.setOnClickListener(this);
        mButtonWrite.setOnClickListener(this);
        mButtonReadCache.setOnClickListener(this);
        mButtonWriteCache.setOnClickListener(this);
        mButtonWriteCacheDir.setOnClickListener(this);
        mButtonReadCacheDir.setOnClickListener(this);
        mButtonWriteSdcard.setOnClickListener(this);
        mButtonReadSdcard.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.button_write:
                writeToPreferences();
                break;
            case R.id.button_read:
                readFromPreferences();
                break;
            case R.id.button_write_cache:
                writeToCache();
                break;
            case R.id.button_read_cache:
                readFromCache();
                break;
            case R.id.button_write_cache_dir:
                writeToCacheDir();
                break;
            case R.id.button_read_cache_dir:
                readToCacheDir();
                break;
            case R.id.button_write_sdcard:
                writeToSdcard();
                break;
            case R.id.button_read_sdcard:
                readFromSdcard();
                break;
            default:
                break;
        }
    }

    private void readFromSdcard() {
        try {
            File file = new File(Environment.getExternalStorageDirectory(),"hello.txt");
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
            String line = br.readLine();
            while(line!=null){
                mTextRead.setText(line);
                line = br.readLine();
            }
            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 外部存储
     * 将数据输出到sdcard里
     */
    private void writeToSdcard() {
        File file = new File(Environment.getExternalStorageDirectory(),"hello.txt");
        if(!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            FileOutputStream fos = new FileOutputStream(file);
            PrintWriter pw = new PrintWriter(fos);
            pw.write(mEditWrite.getText().toString());
            pw.flush();
            pw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     *内部存储dir
     * 读缓存
     */
    private void readToCacheDir() {
        File file = new File(getCacheDir(),"cache_dir");
        if(!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
            String line = br.readLine();
            while(line!=null){
                mTextRead.setText(line);
                line = br.readLine();
            }
            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     *内部存储dir
     * 写缓存
     */
    private void writeToCacheDir() {
        File file = new File(getCacheDir(),"cache_dir");
        if(!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            PrintWriter pw = new PrintWriter(new FileOutputStream(file));
            pw.write(mEditWrite.getText()+"");
            pw.flush();
            pw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 内部存储
     *写缓存
     */
    private void readFromCache() {
        try {
            FileInputStream is = openFileInput("cache_test");
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String line = br.readLine();
            while(line!=null){
                mTextRead.setText(mTextRead.getText()+line);
                line = br.readLine();
            }
            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 内部存储
     * 读缓存
     */
    private void writeToCache() {
        try {
            FileOutputStream os = openFileOutput("cache_test", MODE_PRIVATE);
            PrintWriter pw = new PrintWriter(os);
            pw.write("你好缓存");
            pw.flush();
            pw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * SharedPreferences存储方式的输入，会自动找到shared_prefs文件夹，里面存放
     * SharedPreferences的存储数据的文件，通过Key Word得到数据
     * 去除数据不需要用到editor
     */
    private void readFromPreferences() {
        SharedPreferences preferences = getSharedPreferences("preferences_test", MODE_PRIVATE);
        String content = preferences.getString("edit_input","默认值");
        mTextRead.setText(content);
    }

    /**
     * SharedPreferences存储方式的输出，会自动生成shared_prefs文件夹，里面存放
     * SharedPreferences的存储数据的文件，这里是preferences_test.xml文件，edit_input是Key Word
     * 利用editor存储数据
     */
    private void writeToPreferences() {
        SharedPreferences preferences = getSharedPreferences("preferences_test",MODE_PRIVATE);
        SharedPreferences.Editor editor = preferences.edit();
        editor.putString("edit_input",mEditWrite.getText().toString());
        editor.commit();
    }
}

布局:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              xmlns:tools="http://schemas.android.com/tools"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical">

    <TextView
        android:id="@+id/text_read"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>


    <EditText
        android:id="@+id/edit_write"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

    <Button
        android:id="@+id/button_write"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Write To Preferences"/>
    <Button
        android:id="@+id/button_read"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Read From Preferences"/>
    <Button
        android:id="@+id/button_write_cache"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Write To Cache"/>
    <Button
        android:id="@+id/button_read_cache"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Read From Cache"/>
    <Button
        android:id="@+id/button_write_cache_dir"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Write To Cache Dir"/>
    <Button
        android:id="@+id/button_read_cache_dir"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Read From Cache Dir"/>
    <Button
        android:id="@+id/button_write_sdcard"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Write To Sdcard"/>
    <Button
        android:id="@+id/button_read_sdcard"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Read From Sdcard"/>
</LinearLayout>

结果演示：
这里写图片描述

SQLide数据库

建立一个集成于SQLiteOpenHelper类的类，实现至少一个构造方法和两个方法onCreate()和onUpdate():

public class MySQliteOpenHelper extends SQLiteOpenHelper {

    public MySQliteOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
        super(context, name, factory, version);
    }

    public MySQliteOpenHelper(Context context,String name){
        this(context,name,null,1);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        //创建一个SQLite数据库，路径在活动路径的databases里。
        db.execSQL("create table if not exists user(id integer primary key autoincrement,userName varchar(18),password varchar(18))");
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }
}

主活动:

public class TestSQLiteActivity extends Activity implements View.OnClickListener {
    private Button mButtonCreateSQLite;
    private Button mButtonInsertData;
    private Button mButtonDeleteData;
    private Button mButtonUpdateData;
    private Button mButtonQueryData;
    private SQLiteDatabase mDb;

    private EditText mUserNameEdit;
    private EditText mPasswordEdit;
    private TextView mUserText;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.layout_sqlite);

        mButtonCreateSQLite = (Button) findViewById(R.id.button_create_sqlite);
        mButtonInsertData = (Button) findViewById(R.id.button_insert_data);
        mButtonDeleteData = (Button) findViewById(R.id.button_delete_data);
        mButtonUpdateData = (Button) findViewById(R.id.button_update_data);
        mButtonQueryData = (Button) findViewById(R.id.button_query_data);

        mUserNameEdit = (EditText) findViewById(R.id.edit_user_name);
        mPasswordEdit = (EditText) findViewById(R.id.edit_password);
        mUserText = (TextView) findViewById(R.id.text_user);

        MySQliteOpenHelper mySQliteOpenHelper = new MySQliteOpenHelper(getApplicationContext(),"SQLite_DB.db");
        //必须要得到一个database
        mDb = mySQliteOpenHelper.getWritableDatabase();//必须这样才能创建数据库

        mButtonCreateSQLite.setOnClickListener(this);
        mButtonInsertData.setOnClickListener(this);
        mButtonDeleteData.setOnClickListener(this);
        mButtonUpdateData.setOnClickListener(this);
        mButtonQueryData.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.button_create_sqlite:
                Toast.makeText(getApplicationContext(),"创建SQLite数据库成功",Toast.LENGTH_SHORT).show();
                break;
            case R.id.button_insert_data:
                insertData();
                break;
            case R.id.button_delete_data:
                deleteData();
                break;
            case R.id.button_update_data:
                updateData();
                break;
            case R.id.button_query_data:

                Cursor cursor = mDb.query("user",null,null,null,null,null,"id DESC","2,3");//limit语句：偏移量，查询的数据
                        //mDb.rawQuery("select * from user",null);
                cursor.moveToFirst();
                mUserText.setText("数据：\n");
                int n=1;
                while (!cursor.isAfterLast()){
                    int id = cursor.getInt(cursor.getColumnIndex("id"));
                    String userName = cursor.getString(cursor.getColumnIndex("userName"));
                    String password = cursor.getString(cursor.getColumnIndex("password"));
                    mUserText.setText(mUserText.getText().toString()+n+":id:"+id+"\t userName:"+userName+"\t password:"+password+"\n");
                    cursor.moveToNext();
                    n++;
                }
                break;
            default:
                break;
        }
    }

    private void updateData() {
        ContentValues values = new ContentValues();
        values.put("password", "789456");
        mDb.update("user", values, "userName=?", new String[]{"zhangsan"});
        Toast.makeText(getApplicationContext(), "修改用户名为张三的用户成功！", Toast.LENGTH_SHORT).show();
    }

    private void deleteData() {
        mDb.delete("user","userName=?",new String[]{"zhangsan"});
        Toast.makeText(getApplicationContext(), "删除用户名为zhangsan的用户成功", Toast.LENGTH_SHORT).show();
    }

    private void insertData() {
        //contentValue用于加载要存储的数据
        ContentValues value = new ContentValues();
        String userName = mUserNameEdit.getText().toString();
        String password = mPasswordEdit.getText().toString();
        //put("属性名","value")
        value.put("userName",userName);
        value.put("password",password);
        mDb.insert("user", null, value);
        Toast.makeText(getApplicationContext(), "插入用户名为"+userName+"的用户成功", Toast.LENGTH_SHORT).show();
        return;
    }
}

布局：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent">

    <EditText
        android:id="@+id/edit_user_name"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="userName"/>

    <EditText
        android:id="@+id/edit_password"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="password"/>

    <TextView
        android:id="@+id/text_user"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

    <Button
        android:id="@+id/button_create_sqlite"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Create SQlite"/>
    <Button
        android:id="@+id/button_insert_data"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Insert Data"/>
    <Button
        android:id="@+id/button_delete_data"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Delete Data"/>
    <Button
        android:id="@+id/button_update_data"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Update Data"/>
    <Button
        android:id="@+id/button_query_data"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Query Data"/>
</LinearLayout>

结果演示：
这里写图片描述

逆转星河
关注
专栏目录
数据存储(SharedPreferences)(内部存储及外部存储)
The_king_of_Asia的博客
02-03 1036
作用 :处理将数据存储到本地的操作 注意：本地指的不是d盘，f盘，而是手机的机身内存和外部存储卡 控制数据存储，取出的方式： SharedPreferences 内部存储 外部存储 (内部存储和外部存储合起来也可称为文件存储) 网络（即数据存储服务端中，客户端想要读取数据需连网） SQLite数据库 (1)SharedPreferences 轻量级存储特点：1.生成的本地存储文件的类型固定为xm
数据存储（sharedPreferences,内部存储，外部存储，SQLite数据库，网络存储）
Mr_haimeng的博客
09-07 778
1、SharedPreferences xml存储xml布局文件<TextView android:id="@+id/textview" android:layout_width="match_parent" android:layout_height="wrap_content" /> <EditText android:id
Android第六讲——数据存储（五种）SharedPreferences、内部存储(缓存cache)、外部存储(Sdcrad)、SQLite数据库、网络存储
Went_Gone的博客
09-08 1965
目录SharedPreferences 内部存储 外部存储 SQLite数据库存储 网络存储 SharedPreferences通过键值对的形式保存简单的、私有的数据建一个SharedPreferences对象；初始化有两种方式： preferences=getSharedPreferences(“preferences_test”,MODE_PRIVATE); 会在data—>data—
请介绍下android的数据存储方式.,5种常用Android数据存储方法
weixin_39548805的博客
05-26 686
Android中提供的存储方式包括：SharedPreferences、文件存储、SQLite数据库存储方式、内容提供器方式Content Provider以及网络方式 5种，具体介绍如下：1．SharedPreferences作为Android提供的一种配置文件读/写方式，默认保存在应用的目录data//shared_prefs下，通过方法getSharedPreferences(xx, 0);...
Android的数据存储方式之一——SharedPreferences
xiangruyimo122的博客
06-20 360
Android存储方式有使用SharedPreferences存储数据；文件存储数据；SQLite数据库存储数据；使用ContentProvider存储数据；网络存储数据。 首先说明SharedPreferences存储方式，它是 Android提供的用来存储一些简单配置信息的一种机制，例如：登录用户的用户名与密码。其采用了Map数据结构来存储数据，以键值的方式存储，可以简单的读取与写入。
android的五种存储方式SharedPreferences、文件存储、SQLite数据库、ContentProvider、网络存储
小葩葩的专栏
03-22 4966
第一种： 使用SharedPreferences存储数据     适用范围：保存少量的数据，且这些数据的格式非常简单：字符串型、基本类型的值。比如应用程序的各种配置信息（如是否打开音效、是否使用震动效果、小游戏的玩家积分等），解锁口令密码等    核心原理：保存基于XML文件存储的key-value键值对数据，通常用来存储一些简单的配置信息。通过DDMS的File Explorer面板，展
Android开发笔记之: 数据存储方式详解
09-05
本文将详细解析Android中的五种主要数据存储方式：SharedPreferences、Internal Storage、External Storage、SQLite Database和Internet。 1. SharedPreferences SharedPreferences主要用于存储键值对的基本数据...
Android五种存储方式
09-26
Shared Preferences适合轻量级数据，内部存储用于私有小文件，外部存储适用于大文件，SQLite处理结构化数据，而Content Provider则为跨应用数据共享提供了可能。在实际项目中，合理运用这些存储方式，能有效提升应用...
AndRoid五种存储方式
11-20
在Android开发中，数据存储是不可或缺的一部分，它涵盖了多种方式，包括文件存储、SharedPreferences、SQLite数据库、网络存储以及ContentProvider。下面将详细讲解这五种Android数据存储方式。 1. 文件存储： ...
Android四种存储方式 sharedpreference,file,SQlite,contentprovider
12-25
Android四种存储方式 sharedpreference,file,SQlite,contentprovider 实现创建数据库和表及增删改查
Android详细教程（基础篇）：二十五、android SharedPreferences数据存储详解
二总的猫
04-10 788
对于数据的存储操作而言，Android之中一共提供了五种方式，SharedPreferences方式、文件存储方式、 SQLite数据库存储、Content Provider方式、网络存储 8.1. SharedPreferences存储数据： 多用于配置文件存储 public interface SharedPreferences SharedPrefe...
Android数据存储内置存储的使用
CSDN_OF_ZHAO的博客
08-05 402
实现往内置存储中写入文件,读取文件,删除文件:       核心代码示例如下:              1)内部存储的写入:                  方法一:FileOutputStream  fileOutputStream = openFileOutput(String name,int mode);                  方法二:File file = new
SharedPreferences sd卡存储
weixin_41956752的博客
06-21 235
1 SharedPreferences login = getSharedPreferences("login", MODE_PRIVATE); boolean aBoolean = login.getBoolean("boolean", false);判断用if (aBoolean) 2SharedPreferences login = getSharedPreferences("login",...
Android数据存储（内部，外部，SharedPreferences，SQlite）
qq_44408913的博客
09-07 491
数据的存储位置 内部存储：data/data/对应包名/files/文件名 外部存储：/storage/emulated/0/对应包名/文件 内部存储的读写 写 String file="data.text"; String setText = this.et_setText.getText().toString().trim(); FileOutputStream fos=null; try { fos=openFileOutput(file,*MODE_APPEND*); fos.wr
Android中缓存、文件、SharedPreference和数据库的清除
awodefengduanwu的博客
01-10 685
一、前言 现如今，大部分应用都提供了各自的缓存清理方式。在这里把我在做缓存清理的过程中学到的一些知识记录下来，以便以后温故知新。 二、正文 首先，是关于Android的一些存储路径的介绍。 我们的应用程序一般会产生以下几种类型的数据： file-普通的文件存储 database-数据库文件（.db文件） sharedPreference-配置数据(.xml文件） cache-图片缓存文件 应用内数...
Android SharedPreferences
weixin_33777877的博客
07-25 95
一，SharedPreferences简介 SharedPreferences是轻量级存储类，只能存放基本数据类型，且只能在本程序中使用,一般用于存放软件的配置参数（字体，颜色，位置，默认参数等），整体效率俩看不是特别的高，但是对于常规的轻量级而言，比SQLite要好不少。 SharedPreferences是以键值对来存储应用程序的配置信息的一种方式，基本上和J2SE(...
Android数据存储和访问之SharedPreferences存储方式_用户登录记住密码案例
change__x的博客
04-08 613
这次实验我们来做一个用户登录记住密码案例，当用户选中了记住密码复选框，并成功登录一次之后，这个时候如果再重新启动登录界面，之前输入的用户名和密码就会显示在文本框中。 本次实验所用到的是SharedPreferences存储方式，首先我们来讲一下SharedPreferences存储方式。SharedPreferences是Android平台上一个轻量级的存储类，主要用于存储一些应用程序的配置参数
Android数据存储、文件存储、SQLite数据库简单使用、 sharedPreferences存储（五）
www？的博客
11-07 6409
文章目录5 数据存储5.1 数据的存储方式5.2 文件存储5.2.1 将数据存入文件中5.2.2 从文件中读取数据5.2.3 实战演练-保存QQ账号和密码5.3 sharedPreferences存储5.3.1 将数据存入SharedPreferences中5.3.2 读取和删除数据5.3.3 实战演练—保存QQ账号和密码5.4 SQlite数据库存储5.4.1 SQLite数据库的创建5.4.2 SQLite数据库的基本操作5.4.3 使用sql语句进行数据操作5.4.4 SQLite数据库中的事务5.4
Android数据存储详解：SharedPreferences、文件、SQLite、ContentProvider与网络存储
"Android开发中提供了五种不同的数据存储方式，包括SharedPreferences、文件存储、SQLite数据库、ContentProvider和网络存储。这些方法各有特点，适用于不同的数据存储需求。" 在Android应用开发中，数据存储是非常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值