JAVASE--10

最新推荐文章于 2024-05-28 06:15:00 发布
最新推荐文章于 2024-05-28 06:15:00 发布
阅读量495 收藏 1
点赞数
分类专栏： JAVASE--API
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZUIHENderen46/article/details/82949237
版权

XML


XML 可扩展标记语言,EXtensible Markup Language
简化数据的存储和共享
两台计算机传输数据使用,
简化平台的变更==构建复杂数据结构
数据 * * 算法 * * *分离=====配置文件
基本语法
XMl的处理指令----解析引擎看的

<?xml vaerson="1.0" encoding= "UTF-8" ?>


开头标签可以加属性,但是结束标签不能加属性,属性可以用单引号也可以用双引号,一般情况下用双引号,但是当有双引号只能用单引号,保证属性格式统一/

大小写敏感的
只有起始标签是不行的,必须的有结束标签,
开始标签和结束标签之间,要么包含标签要么包含文本.什么都不包含的时候或者
一个XML,必须得有且一个根标签(不被其他标签包含得标签)
XML要求所有元素必须正确嵌套
实体引用===XML的转义字符
    实体引用                        字符                              说明
    &lt;                        <                               小于
    &gt                         >                               大于
    &aops;                      '                               单引号
    &quop;                      "                               双引号
    &amp;                       &                               与


CDATA块


    格式:<![CDATA [文本内容]]>
特殊标签中的实体引用被忽略,所有内容被当成一块文本数据对待

<?xml version="1.0" encoding="UTF-8"?>
<list>
    <emp id="1">
        <name>张三</name>
        <age>23</age>
        <gender>男</gender>
        <salary>3333</salary>
    </emp>
    <emp id="2">
        <name>李四</name>
        <age>24</age>
        <gender>男</gender>
        <salary>5555</salary>
    </emp>
    <emp id="3">
        <name>王五</name>
        <age>25</age>
        <gender>34</gender>
        <salary>4354</salary>
    </emp>
    <emp id="4">
        <name>黄志宏</name>
        <age>24</age>
        <gender>男</gender>
        <salary>10000</salary>
    </emp>
    <emp id="5">
        <name>小六子</name>
        <age>12</age>
        <gender>男</gender>
        <salary>1111</salary>
    </emp>
</list>


SAX解析==逐行扫描,边扫描边解析


优点:解析可以立即开始,速度快,没有内存压力
缺点:不能对节点修改


DOM文档对象模型 === 把文档中的所有元素按照其出现的层次关系,解析成一个个Node节点(推荐)


优点:把XML文件在内存中构造树形结构,可以遍历和修改节点
缺点:如果过文件比较大,内存有压力,解析的时间长
 

使用dom解析XML文档
public class ParseXmlDemo {
    public static void main(String[] args) {
        /*
         * 将emplist.xml文档中所有的员工信息解析出来,存入到List集合. 每个员工信息用一个Emp实例保存
         */
        List<Emp> list = new ArrayList<Emp>();

        /*
         * 使用DOM解析XML的步骤
         * 1:创建SAXReader
         * 2:使用SAXReader读取xml文档,并生成对应的Document对象,该对象保存了该文档的所有数据及结构
         * 这一步也是DOM解析耗时耗资源的地方 
         * 3:通过Document对象获取根元素
         * 4:按照XML文档的结构从根元素开始主机获取子元素以达到遍历XML文档数据的目的
         */
        try {
            // 1:创建SAXReader对象(字符输入流)
            SAXReader reader = new SAXReader();
            // 2:读取xml文档
            Document document = reader.read(new File("emplist.xml"));
            // Document document = reader.read(new
            // FileInputStream("emplist.xml"));都可以
            /*
             * 3:Document提供了获取根元素的方法 Element getRootElement()
             * 
             * Element的每一个实例用于表示XML文档中的一个元素(一对标签), 其提供了用于获取该元素相关信息的一系列方法:
             * 
             * String getName() 获取单签标签的名字
             * 
             * String getText() 获取当前标签中间的文本
             * 
             * Element element(String name) 获取当前标签中指定名字的子标签
             * 
             * List elements() 获取当前标签中的所有子标签
             * 
             * List elements(String name) 获取当前标签下所有指定名字的同名字标签
             * 
             * Attribute attribute(String name)
             * 获取指定名字的属性,Attribute的每一个实例用于表示一个标签中的一个属性,可以通过 它获取该属性的名字与对应的属性值
             * 
             * String attributeValue(String name) 可以直接获取当前标签中指定名字的属性所对应的值
             * 
             */
            Element root = document.getRootElement();// 获取跟标签,就是list标签

            List<Element> empList = root.elements("emp");
            /*
             * 遍历每个<emp>标签,获取员工消息
             */
            for (Element empEle : empList) {
                // int id = Integer.parseInt(empEle.attribute("id").getValue());
                int id = Integer.parseInt(empEle.attributeValue("id"));
                // 获取<name>标签-->获取<name>标签中间的文本
                String name = empEle.element("name").getText();
                // 获取<age>标签-->获取<age>标签中间的文本
                int age = Integer.parseInt(empEle.elementText("age"));
                // 获取<gender>标签-->获取<gender>标签中间的文本
                String gender = empEle.element("gender").getText();
                // 获取<salary>标签-->获取<salary>标签中间的文本
                int salary = Integer.parseInt(empEle.elementText("salary"));
                // System.out.println(id + "," +name + ","+ age + "," + gender +
                // "," + salary);
                list.add(new Emp(id, name, age, gender, salary));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        for (Emp emp : list) {
            System.out.println(emp);
        }

    }
}


dom4j生成xml文档


   

 /**
     * 生成XML的步骤:
     * 1:创建一个Document对象,表示一饿空白文档
     * 2:向Document中添加根元素.
     * 3:向根元素中主机添加子元素,以形成XML文档的结构
     * 4:创建XMLWriter
     * 5:使用XMLWriter将Document对象写出以生成文档
     */
    try{
        //创建一个空白文档
        Document doc = DocumentHelper.createDocument(); 

        /*
         * Document提供了添加根元素的方法:
         * Element addElement(String name)
         * 向当前文档中添加给定名字的根元素,并将其以一个Element实例形式返回,以便继续向根元素中追加操作
         * 注意:该方法只能调用一次,因为一个文档只允许有一个根元素.IllegalAddException
         */
        Element root = doc.addElement("list");

        /*
         * 将集合中每个员工信息以一个<emp>标签形式添加到根标签
         */
        for(Emp emp : list){
            //向根元素root<list>中添加<emp>的子标签
            Element empEle = root.addElement("emp");

            //向<emp>标签中添加子标签<name>
            Element nameEle = empEle.addElement("name");
            //向子标签<name>中添加文本
            nameEle.addText(emp.getName());

            //向<emp>标签中添加子标签<age>
            Element ageEle = empEle.addElement("age");
            ageEle.addText(emp.getAge()+"");

            //向<emp>标签中添加子标签<gender>
            Element genderEle = empEle.addElement("gender");
            genderEle.addText(emp.getGender());

            //向<emp>标签中添加子标签<salary>
            Element salaryEle = empEle.addElement("salary");
            salaryEle.addText(emp.getSalary()+"");

            //添加属性:id
            empEle.addAttribute("id", emp.getId()+"");
        }

        //创建XMLWriter
        XMLWriter writer = new XMLWriter(
                    new FileOutputStream("myemp.xml"),OutputFormat.createPrettyPrint()
                );
        writer.write(doc);
        writer.close();

    }catch(Exception e){
        e.printStackTrace();
    }


线程池:


线程池主要有两个作用:
1:重用线程
线程若频繁的创建销毁会给线程调度带来不小的额外工作量,会降低性能
2:控制线程数量
线程数量过大,会导致系统资源开销大,每个线程都需要内存来得以运行.
还有一个问题是:过多的线程会导致CPU过度切换,导致整体的并发性能降低.
当有以上情况出现时,都应当使用线程池了管理线程


时间\日期操作
java.util.Date


Date的每一个实例用于表示一个确切的时间点,内部维护的一个long值,该值是UTC(1970年1月1日00:00:00)到当前Date表示的时间之间所经过 的毫秒
由于Date存在始去以及千年虫问题,所以大部分的放啊发再JDK1.1版本推出时就被声明为过时的,而这些操作时间的方法都被Calendar的相关方法取代.

//默认创建表示当前系统时间;
Date date = new Date();
System.out.println("当前系统时间:" + date);//Tue Aug 21 09:55:37 GMT+08:00 2018
System.out.println(date.getYear()+1900);

/*
 * long getTime()
 * 获取Date内部维护的long值
 */
long time = date.getTime();
System.out.println("当前的long:" + time);
/*
 * 获取明天这个时间 
 */
time = time + 1000 * 60 * 60 * 24;
/*
 *  void setTime(long time)
 * 设置一个long值,使Date表示该日期
 */
date.setTime(time);
System.out.println("明天的这个时候:" + date);


java.text.SimpleDateFormat
可以按照一个指定的日期格式将Date于String进行相互转换

Date date = new Date();
System.out.println(date);
/*
 * Tue Aug 21 10:34:30 GMT+08:00 2018
 *     MM  dd HH:mm:ss           yyyy 
 */
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//2018-08-21 10:34:30 上午 星期二
/*
 * String format(Date date)
 * 将给定的Date按照当前SDF指定的日期格式转换为字符串
 */
String line = sdf.format(date);
System.out.println(line);
将字符串解析为Date
String line = "2018-08-08 20:43:35";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = sdf.parse(line);
System.out.println(date);


Calendar(抽象类)java.util.Calendar 日历类


Calendar本身是一个抽象类 ,不可实例化,但是提供了一个实现的静态方法:getInstance,可以根据当前系统所在的地区获取一个使用的实现类的实例,
大部分读取获取回来的都是格里高利历GregorianCalendar,即阳历

//获取Calendar默认表示当前系统时间
Calendar calendar = Calendar.getInstance();
//Calendar的toString不能直观反映出具体表示的日期
System.out.println(calendar);
/**
 * Date getTime()
 * Calendar的getTime()方法可以将其表示的时间以一个Date实例形式放回
 */
Date date = calendar.getTime();
System.out.println("当前时间信息:" + date);

//java.util.GregorianCalendar[time=1534832195639,areFieldsSet=true,
areAllFieldsSet=true,lenient=true,zone=sun.util.calenda
r.ZoneInfo[id="GMT+08:00",offset=28800000,dstSavings=0,useDaylight=f
alse,transitions=0,lastRule=null],firstDayOfWeek=1,minima
lDaysInFirstWeek=1,ERA=1,YEAR=2018,MONTH=7,WEEK_OF_YEAR=
34,WEEK_OF_MONTH=4,DAY_OF_MONTH=21,DAY_OF_YEAR=233,DAY_O
F_WEEK=3,DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=2,HOUR_OF_DAY=14,MI
NUTE=16,SECOND=35,MILLISECOND=639,ZONE_OFFSET=28800000,DST_OFFSET=0]
//当前时间信息:Tue Aug 21 14:16:35 GMT+08:00 2018

/**
 * void setTime()
 * 使用当前Calendar表示给定的Date所表示的日期
 * Date->Calendar
 */
calendar.setTime(date);
Calendar可以获取各个时间分量的值
int get(int field)
不同的时间分量用不同的数字表示,这些数字无需记忆,Calendar都提供了对应的常量

Calendar calendar = Calendar.getInstance();
//获取年
int year = calendar.get(Calendar.YEAR);
//获取月(从0开始)
int month = calendar.get(Calendar.MONTH) + 1;
//获取日
/**
 * 和"天"有关的常量
 * DAY_OF_YEAR  年中的天
 * DAY_OF_MONTH  月中的天
 * DAY_OF_WEEK 周中的天
 * DATE  月中的天,于DAY_OF_MONTH一致
 */
int day = calendar.get(Calendar.DAY_OF_MONTH);
//int day = calendar.get(Calendar.DATE);
//获取小时
int hours = calendar.get(Calendar.HOUR_OF_DAY);//24小时制
//int hours = calendar.get(Calendar.HOUR);//12小时制
//分钟
int mimute = calendar.get(Calendar.MINUTE);
//秒
int second = calendar.get(Calendar.SECOND);
System.out.println(year + "-" + month + "-" + day + " " + hours + ":" + mimute + ":" + second);


//周几?
int dow = calendar.get(Calendar.DAY_OF_WEEK);
String[] data = {"日","一","二","三","四","五","六"};
System.out.println("周" + data[dow-1]);

//今年的第几天?
int doy = calendar.get(Calendar.DAY_OF_YEAR);
System.out.println("今天是今年的第" + doy + "天");

//指定时间分量能够获取的最大值
int days = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);
System.out.println("今年总共有"  + days + "天");
Calendar提供了;
void set(int field ,int value)
对给定的时间分量设置给定的值

Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());//Tue Aug 21 15:27:33 GMT+08:00 2018
calendar.set(Calendar.YEAR, 2008);
calendar.set(Calendar.MONTH , 7);//从0开始
calendar.set(Calendar.DAY_OF_MONTH,22);
calendar.set(Calendar.HOUR_OF_DAY, 8);
calendar.set(Calendar.MINUTE, 25);
calendar.set(Calendar.SECOND, 20);
System.out.println(calendar.getTime());//Mon Sep 22 08:25:20 GMT+08:00 2008
void add(int field , int amount)
对给定的时间分量加上给定的值,若给定的值为负数,则是减去对应的值

Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());
/*
 * 3年2个月零25天以后是哪天?
 */
calendar.add(Calendar.YEAR, 3);
calendar.add(Calendar.MONTH, 2);
calendar.add(Calendar.DAY_OF_YEAR, 25);
System.out.println(calendar.getTime());
//3年2个月零25天以后的周三是几月几号
calendar.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
System.out.println(calendar.getTime());


Lambda


lambda表达式是jdk1.8之后推出的一个新特性,可以更加简洁的创建匿名内部类,
使用lambda创建匿名内部类时要求该接口必须有且只有一个抽象方法时才可以使用.
lambda语法:

(参数列表)->{
方法体
}


使用lambda无需指定实现的接口,以及重写方法,编译器回结合当前源码分析并自动判别.注意,lambda也是编译器认可了最终会被编译器改为传统方式创建
 

   //匿名内部类
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("hello");
        }
    };
    //lambda形式创建
    Runnable r2 = ()->{
        System.out.println("hello");
    };
    //{}中间只有一句表达式,可以省略
    Runnable r3 = ()->System.out.println("hello");
    List<String> list = new ArrayList<String>();
    list.add("小仓");
    list.add("玛利亚");
    list.add("齐天大圣");
    /*
     * 匿名内部类实现比较器
     */
    /*Comparator<String> com = new Comparator<String>() {

        @Override
        public int compare(String o1, String o2) {
            return o1.length() - o2.length();
        }
    };*/
    ==========================================
    /*Collections.sort(list, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.length() - o2.length();
        }
    });*/


    /*
     * lambda形式
     */

    /*Comparator<String> com = (String o1 ,String o2)->{
        return o1.length() - o2.length();
    };*/

    /*Collections.sort(list, (Comparator<String>) (String o1 ,String o2)->{
        return o1.length() - o2.length();
    });*/

    ===========================================
    /*
     * 方法中参数的类型可以不指定,忽略{}的同时,若方法中有return,则return关键字也要忽略
     */
    /*Comparator<String> com = (o1,o2)-> o1.length() - o2.length();*/

    Collections.sort(list, (Comparator<String>) (o1 , o2)->o1.length() - o2.length());

    //Collections.sort(list, com);

    System.out.println(list);


JDK8之后,集合和Map都提供了一个方法,使用lambda方式遍历元素,
并且若该集合或Map是线程安全的,那么这种遍历方式于元素增删也是并发安全的.
曾经使用迭代器遍历时我们介绍过,迭代器遍历集合不与集合自身增删元素互斥,
并发操作需要自行维护同步,而新的这种遍历方式无需这样做

List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");

list.forEach((e)->{System.out.println(e);});

Map<String,Integer> map = new HashMap<String,Integer>();
map.put("语文", 98);
map.put("数学", 100);
map.put("英语", 88);

map.forEach((k,v)->{System.out.println(k+ ":" +v);});

 

Aaron.Huang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javase-2.0.jar
04-21
使用java在服务端进行aes的加密解密，前端使用该js进行aes加密解密；
javase-3.3.0.zip
08-29
1. 引入库：首先需要在项目中引入javase-3.3.0.jar作为依赖，这通常通过构建工具如Maven或Gradle来完成，或者手动将jar文件添加到项目的类路径中。 2. 导入类：在代码中，需要导入`MatrixToImageWriter`类以及可能...
javaSE（完整版）
热门推荐
qq_56047419的博客
05-11 1万+
1.java语言的特点： 1.简单性：java语言是纯面向对象语言，语法简单，单继承，没有指针，还会自动收集内存垃圾 2.面向对象性：所有元素都要通过类和对象来访问，万物皆对象 3.平台无关性：跨平台，只需要开发一次就可以在不同平台（也可以说操作系统）上运行 4.分布式：支持网络，可多个客户端相互调用 5.健壮性：java编写的程序很多方面具有可靠性，java编译器编译期间就能检测出其他语言仅在运行中才能检测出的问题（java会检查程序在编码和运行时的错误，并消除错误） 5.安全性:删除了指..
JavaSE概述
weixin_45661469的博客
08-09 9816
JavaSE
【JavaSE】JavaSE概述
最新发布
wosixiaokeai的博客
05-28 1121
Java SE最显著的特点之一是它的“一次编写，到处运行”（Write Once, Run Anywhere）的能力。这是通过Java虚拟机（JVM）实现的，JVM可以在任何支持它的操作系统上运行Java程序。因此，Java程序可以在Windows、Linux、Mac OS X等不同的操作系统上无缝运行。Java SE是基于面向对象编程（OOP）的。它支持类、对象、继承、封装、多态等面向对象编程的核心概念。这使得Java代码更易于组织、管理和重用。
JavaSE简介
coder_jh的博客
06-13 2376
Java SE（Java Standard Edition）是Java平台的标准版，也是企业应用中最常用的一种Java平台版本。JavaSE包含了支持基本Java开发的所有常规API，提供了许多用于创建桌面应用、网络应用和Web服务的工具和技术。
初始Java
m0_66483195的博客
08-02 219
Java的概述 和 第一个Java 的代码 一些笔记
JavaSE 基础知识
weixin_53850894的博客
09-29 752
本文将对Java的三大特性：封装、继承、多态进行简单的说明，涉及abstract、final、static、implements、extends……等关键字，主要对父类和子类的继承、方法的重载和重写进行详细的叙述。
javase-2.2-API文档-中文版.zip
07-13
赠送jar包：javase-2.2.jar； 赠送原API文档：javase-2.2-javadoc.jar； 赠送源代码：javase-2.2-sources.jar； 赠送Maven依赖信息文件：javase-2.2.pom； 包含翻译后的API文档：javase-2.2-javadoc-API文档-中文...
javase-3.3.3-API文档-中英对照版.zip
06-12
赠送jar包：javase-3.3.3.jar； 赠送原API文档：javase-3.3.3-javadoc.jar； 赠送源代码：javase-3.3.3-sources.jar； 赠送Maven依赖信息文件：javase-3.3.3.pom； 包含翻译后的API文档：javase-3.3.3-javadoc-API...
core-3.3.3 + javase-3.3.3+ zxing-1.7-core + zxing-j2se-1.7
06-18
本文将深入探讨在给定的压缩包中涉及的几个关键组件：`core-3.3.3`, `javase-3.3.3`, `zxing-1.7-core` 和 `zxing-j2se-1.7`，以及与之相关的JDK版本，包括JDK1.7和JDK1.8。这些组件主要用于二维码生成和处理，对于...
Java虚拟机规范_JavaSE 10
04-15
《The Java ® Virtual Machine Specification Java SE 10 Edition》Oracle官方原版。
JavaSE详细教程.1
m0_67503918的博客
06-07 3972
JavaSE基础知识系列：JDK安装、环境变量配置、第一个程序
JavaSE基础 (全网最全知识点)
不吃紫菜的博客
02-27 654
背景介绍 java运行机理(即使编译型语言，又是解释型语言) 编译型语言(如：c语言) 源代码需要通过预编译形成可执行文件，再由系统执行该文件形成可识别的二进制文件 解释型语言 边执行边转换。源代码先翻译成中间代码，解释器(类似于JVM)再对中间代码进行解释运行，每执行一次都要翻译一次。 标识符规则： 标识符只能由大小写字母、数字、下划线(_)和美元符号($)组成，但是不能...
【JavaSE---10】常用类
渐渐的忘记，赶不上明天（读研ing，2024年毕业）
05-30 109
1. 异常 2. 异常处理（2种处理方式） 2.1 try-catch-finally 2.2 throws抛出异常 2.2.1 throws 2.2.2 throw 2.2.3 throws vs throw 2.3 细节 2.4 练习 3. 自定义异常
JavaSE 10
cystart的博客
01-31 182
面向对象的特征一：封装与隐藏 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).此时，针对于属性就体现了封装性。 封装性的体现：我们将类的属性xxx私有化(pr
java-SE-10
konstantin的博客
06-09 382
集合，迭代器这些都和c++差不多；List，LinkList，Arrays，ArrayList,Queue，Stack，Iterator; 具体实现在c语言中和数据结构课程中有； 映射表 map，是key/value结构，也就是键值对，如果提供了键，就可以找到值；java提供了两个通用的实现HashMap和TreeMap，散列表没有排序，对键进行散列，树映射表用键对元素进行排列，形成搜索树；
JavaSE-10之JVM
lingdu6633的博客
04-07 1066
是可运行Java代码的虚拟计算机，包括一套字节码指令集，一组寄存器（是 CPU 内部的数量较少但是速度很快的内存（与之对应的是 CPU 外部相对较慢的 RAM 主内 存）。寄存器通过对常用值（通常是运算的中间值）的快速访问来提高计算机程序运行的速 度）。，一个栈，一个垃圾回收，堆，和一个存储方法区域， 运行过程： 源文件经过编译器编译成字节码文件，字节码文件经过Java虚拟机中的解释器编译成特定机器上的机器码， 当一个程序开始运行的时候，虚拟机就开始实例化了，多个程序启动，就会有多个虚拟机实例化，程序
Java SE(10)
qq_64054746的博客
02-02 143
Java 聊天室实现客户端之间的信息流通及服务端向客户端群发送消息
那javaSE -17可不可以用
06-12
JavaSE-17是Java的最新版本，如果您使用JavaSE-17，则可以使用Java 14中引入的记录（Record）特性而无需担心保留字问题。JavaSE-17中包含了Java 14及更早版本中的所有功能，同时还引入了新的功能和改进。 因此，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值