java简要实现优先级的分组排序

最新推荐文章于 2023-08-08 23:15:10 发布
最新推荐文章于 2023-08-08 23:15:10 发布
阅读量916 收藏 2
点赞数
分类专栏： 笔记 文章标签： java sort
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w172087242/article/details/101055595
版权

写在前面

本排序适用于内存排序，并且有强制的优先级;比如 有秒杀活动的 > 加入购物车 > 运营元素 > 店铺评分 > 历史购买 > 普通活动;本功能用户实际项目中搜索的展现以及推荐(当然优先级没有上面列的那么简单);该版本性能还可以继续提供，因为时间有限，所以先出一个版本

原文章链接

代码示例

  • 排序元素准备:
    bean包下：
    OrderData(主要放置待排序的id和排序因子所对应的值)
package littlehow.sort.group.bean;


import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * OrderData
 *
 * @author littlehow
 * @time 2017-08-14 11:23
 */
public class OrderData<T> {
    private T id;

    /**
     *  得分
     */
    private Map<String, Comparable> orderScoreMap;

    /**
     * 属性
     */
    private Map<String, Object> attribute;

    public void add(String key, Comparable value) {
        if (orderScoreMap == null) orderScoreMap = new HashMap<>();
        orderScoreMap.put(key, value);
    }

    public Comparable get(String key) {
        if (orderScoreMap == null) return null;
        return orderScoreMap.get(key);
    }

    public Map<String, Comparable> getOrderScoreMap() {
        return orderScoreMap;
    }

    public void setAttribute(String key, Object value) {
        if (attribute == null) attribute = new HashMap<>();
        attribute.put(key, value);
    }

    public Object getAttribute(String key) {
        if (attribute == null) return null;
        return attribute.get(key);
    }

    /**
     * 兼容前期已经调用的版本
     * @param map
     */
    @Deprecated
    public void setOrderScoreMap(Map<String, Double> map) {
        Set<Map.Entry<String, Double>> entrySet = map.entrySet();
        for (Map.Entry<String, Double> entry : entrySet) {
            add(entry.getKey(), entry.getValue());
        }
    }

    public T getId() {
        return id;
    }

    public void setId(T id) {
        this.id = id;
    }

    public boolean equalsProperty(OrderData<T> other, String key) {
        if (other == null) return false;
        return this.get(key).equals(other.get(key));
    }
}
  • OrderDirect 主要指明排序方向
package littlehow.sort.group.bean;

/**
 * OrderDirect 排序方向
 *
 * @author littlehow
 * @time 2017-08-14 11:10
 */
public enum OrderDirect {
    DESC(-1),//倒序
    ASC(1)//正序
    ;
    public final int v;
    OrderDirect(int v) {
        this.v = v;
    }
}

package littlehow.sort.group.bean;  
/**  
 * OrderProperty 排序要素    
 * @author littlehow  
 * @time 2017-08-14 11:11  
 */ 

public class OrderProperty implements Comparable<OrderProperty> { 
    /**  * 要素标识  */  
    private String id;   
    /**  * 要素序号  */  
    private int ordinal;   
    /**  * 要素排序方向  */  
    private OrderDirect orderDirect;   
    /**  * 是否为是非因子  */  
    private boolean trueOrFalse;   
    /**  * 为null的时候的默认值  */  
    private Comparable defaultNullValue = 0.0;   
    public OrderProperty() { } 
    public OrderProperty(String id, int ordinal) { 
        this(id, ordinal, OrderDirect.DESC);
    } 
    public OrderProperty(String id, Integer ordinal, OrderDirect orderDirect) {
        this.id = id;  
        this.ordinal = ordinal;  
        this.orderDirect = orderDirect;  
   } 

    public OrderProperty(String id, int ordinal, OrderDirect orderDirect, boolean trueOrFalse) { 
        this(id, ordinal, orderDirect);  
        this.trueOrFalse = trueOrFalse;  
    } 

    public OrderProperty(String id, int ordinal, OrderDirect orderDirect, boolean trueOrFalse, Comparable defaultNullValue) { 
        this(id, ordinal, orderDirect, trueOrFalse);  
        this.defaultNullValue = defaultNullValue;  
    } 

    public String getId() { 
        return id;  
    } 
   
    public void setId(String id) { 
        this.id = id;  
    } 

    public int getOrdinal() { 
        return ordinal;  
    } 

   public void setOrdinal(int ordinal) { 
       this.ordinal = ordinal;  
   } 

   public OrderDirect getOrderDirect() { 
       return orderDirect;  
   } 
   public void setOrderDirect(OrderDirect orderDirect) { 
       this.orderDirect = orderDirect;  
   } 
   public boolean isTrueOrFalse() { 
       return trueOrFalse;  
   } 

   public void setTrueOrFalse(boolean trueOrFalse) { 
       this.trueOrFalse = trueOrFalse;  
   } 
  
   public Comparable getDefaultNullValue() { 
       return defaultNullValue;  
   } 
   
   public void setDefaultNullValue(Comparable defaultNullValue) {
       this.defaultNullValue = defaultNullValue;  
   } 
   
   /**  
    * 正序排列 ASC  
    * @param other  
    * @return  
    */  
    public int compareTo(OrderProperty other) { 
        return this.ordinal > other.ordinal ? 1 : this.ordinal == other.ordinal ? 0 : -1;  
    } 

  @Override  
  public String toString() { 
      return "{id=" + id + ", ordinal=" + ordinal + ", orderDirect=" + orderDirect + "}";  
  }
} 


package littlehow.sort.group.bean;

import java.util.Comparator;
import java.util.List;

/**
 * OrderDataComparator
 *
 * @author littlehow
 * @time 2017-08-15 15:50
 */
public class OrderDataComparator implements Comparator<OrderData> {
    private List<OrderProperty> orderProperties;
    public OrderDataCompara

tor(List<OrderProperty> orderProperties) {
        this.orderProperties = orderProperties;
    }

    /**
     * 进行排序
     * @param o1
     * @param o2
     * @return
     */
    public int compare(OrderData o1, OrderData o2) {
        for (OrderProperty orderProperty : orderProperties) {
            //排序key
            String key = orderProperty.getId();
            //排序默认值
            Comparable dv = orderProperty.getDefaultNullValue();
            //排序方向
            OrderDirect orderDirect = orderProperty.getOrderDirect();
            //元素一对应排序因子
            Comparable c1 = o1.get(key);
            if (c1 == null) c1 = dv;
            //元素二对应排序因子
            Comparable c2 = o2.get(key);
            if (c2 == null) c2 = dv;

            if (c1.compareTo(c2) == 0) {
                continue;//如果是一样的，则进行下一排序因子的比较
            }
            return c1.compareTo(c2) * orderDirect.v;
        }
        //如果抵达这一步，证明前面要素比较全部一致，不需要进行元素交换
        return 0;
    }
}
  • 工具包
package littlehow.sort.group.utils;   
import littlehow.sort.group.bean.OrderData; 
import littlehow.sort.group.bean.OrderDataComparator; 
import littlehow.sort.group.bean.OrderProperty;  
import java.util.Collections; 
import java.util.Comparator; 
import java.util.List;  
/**  
* SortUtil  *  
* @author littlehow  
* @time 2017-08-14 11:42  
*/ 
public abstract class SortUtils { 
	/**  
	* 进行实际排序  
	* @param orderDatas  
	* @param orderProperties  
	* @param max  
	*/  
	public static <T> void order(List<OrderData<T>> orderDatas, List<OrderProperty> orderProperties, int max) { 
	//将要素要优先级排序, 优先级高的排在前面  
	Collections.sort(orderProperties);  
	sort(orderDatas, new OrderDataComparator(orderProperties), max);  
} 

/**  
 *  
 * @param list  
 * @param comparator  
 * @param maxSize  
 */  
 public static <T> void sort(List<OrderData<T>> list, Comparator<OrderData> comparator, int maxSize) { 
     int length = list.size();  
     if (maxSize > length) maxSize = length;  
     bubble(list, (Comparator) comparator, maxSize);  
 } 

 /**  
  * 支持局部排序  
  * @param targets  
  * @param comparator  
  * @param maxSize -- 想要排序的数量  
  */  
  private static <T> void bubble(List<OrderData<T>> targets, Comparator comparator, int maxSize) { 
      int length = targets.size();  
      for (int i = 0; i < maxSize; i++) { 
          for (int j = i + 1; j < length; j++) { 
             if (comparator.compare(targets.get(i), targets.get(j)) > 0) {
                 //进行元素置换  
                 swap(targets, i, j);  
             } 
         } 
     } 
 } 

 /**  
  * 元素交换  
  * @param targets  
  * @param i  
  * @param j  
  * @param <T>  
  */  
  private static <T> void swap(List<OrderData<T>> targets, int i, int j) { 
      OrderData<T> tmp = targets.get(i);  
      targets.set(i, targets.get(j));  
      targets.set(j, tmp);  
  } 
}
  • 其他类
package com.kom.base.sort.utils;


import java.lang.reflect.Field;
import java.util.*;

/**
 * CollectionUtils
 *
 * @author littlehow
 * @time 2017-06-09 10:07
 */
public class CollectionUtils {

    private static final List EMPTY_LIST = new ArrayList();
    //私有构造，也可把类提取成抽象类
    private CollectionUtils(){}

    /**
     * 判断集合是否为空
     * @param collection
     * @return
     */
    public static boolean isEmpty(Collection collection) {
        return collection == null || collection.isEmpty();
    }

    /**
     * 判断集合非空
     * @param collection
     * @return
     */
    public static boolean isNotEmpty(Collection collection) {
        return !isEmpty(collection);
    }


    /**
     * 截取list
     * @param orig
     * @param startIndex
     * @param <T>
     * @return
     */
    public static <T> List<T> subList(List<T> orig, int startIndex) {
        if (isEmpty(orig) || startIndex >= orig.size()) {
            return EMPTY_LIST;
        }
        if (startIndex == 0) return orig;
        return subList(orig, startIndex, orig.size());
    }

    /**
     * 截取list集合 前闭后开区间, 如果起始位置为0，终止位置和集合总条数一致，则直接返回原有集合
     * @param orig        -- 要截取的集合
     * @param startIndex  -- 起始下标
     * @param endIndex    -- 终止下标但不包含该值
     * @param <T>
     * @return
     */
    public static <T> List<T> subList(List<T> orig, int startIndex, int endIndex) {
        if (isEmpty(orig) || startIndex >= endIndex || startIndex >= orig.size() || endIndex > orig.size()) {
            return EMPTY_LIST;
        }
        //如果起始位置为0，终止位置和集合总条数一致，则直接返回原有集合
        if (orig.size() == endIndex && startIndex == 0) return orig;
        List<T> desc = new ArrayList<T>(endIndex - startIndex);
        for (int i = startIndex; i < endIndex; i++) {
            desc.add(orig.get(i));
        }
        return desc;
    }
}

package littlehow.sort.group.service;


import littlehow.sort.group.bean.OrderData;
import littlehow.sort.group.bean.OrderProperty;

import java.util.ArrayList;
import java.util.List;

/**
 * SortService
 *
 * @author littlehow
 * @time 2017-08-16 13:58
 */
public abstract class SortService {
    /**
     * 全体排序
     * @param orderDatas
     * @param orderProperties
     * @param <T>
     * @return
     */
    public abstract  <T> List<T> sort(List<OrderData<T>> orderDatas, List<OrderProperty> orderProperties);

    /**
     * 按照top max 排序
     * @param orderDatas
     * @param orderProperties
     * @param maxSize
     * @param <T>
     * @return
     */
    public abstract  <T> List<T> sortMax(List<OrderData<T>> orderDatas, List<OrderProperty> orderProperties, int maxSize);

    /**
     * 分页排序
     * @param orderDatas
     * @param orderProperties
     * @param pageNo
     * @param pageSize
     * @param <T>
     * @return
     */
    public abstract <T> List<T> sortPaging(List<OrderData<T>> orderDatas, List<OrderProperty> orderProperties, int pageNo, int pageSize);

    /**
     * 获取id
     * @param orderDatas
     * @param start
     * @param end
     * @return
     */
    public final <T> List<T> getIds(List<OrderData<T>> orderDatas, int start, int end) {
        List<T> ids = new ArrayList<>(orderDatas.size());
        for (int i = start; i < end; i++) {
            ids.add(orderDatas.get(i).getId());
        }
        return ids;
    }
}

package littlehow.sort.group.service;


import littlehow.sort.group.bean.OrderData;
import littlehow.sort.group.bean.OrderProperty;
import littlehow.sort.group.utils.CollectionUtils;
import littlehow.sort.group.utils.SortUtils;

import java.util.List;

/**
 * SortService
 *
 * @author littlehow
 * @time 2017-08-16 12:24
 */
public class GroupSortService extends SortService{
    @Override
    public <T> List<T> sort(List<OrderData<T>> orderDatas, List<OrderProperty> orderProperties) {
        if (CollectionUtils.isEmpty(orderDatas)) return null;
        return sortMax(orderDatas, orderProperties, orderDatas.size());
    }


    @Override
    public <T> List<T> sortMax(List<OrderData<T>> orderDatas, List<OrderProperty> orderProperties, int maxSize) {
        if (CollectionUtils.isEmpty(orderDatas) || CollectionUtils.isEmpty(orderProperties)) return null;
        if (orderDatas.size() == 1) {//只有一个元素就没有排序的必要
            return getIds(orderDatas, 0, 1);
        }
        if (maxSize > orderDatas.size()) {
            maxSize = orderDatas.size();
        }
        //进行排序
        SortUtils.order(orderDatas, orderProperties, maxSize);
        return getIds(orderDatas, 0, maxSize);
    }

    @Override
    public <T> List<T> sortPaging(List<OrderData<T>> orderDatas, List<OrderProperty> orderProperties, int pageNo, int pageSize) {
        if (CollectionUtils.isEmpty(orderDatas) || CollectionUtils.isEmpty(orderProperties)) return null;
        int start = (pageNo - 1) * pageSize;
        int end = start + pageSize;
        //分页已经超出范围
        if (start >= orderDatas.size()) return null;
        if (end > orderDatas.size()) {
            end = orderDatas.size();
        }
        //进行排序
        SortUtils.order(orderDatas, orderProperties, end);
        return getIds(orderDatas, start, end);
    }
}
  • 简单测试用例TestSort
package littlehow.sort.group.test;

import littlehow.sort.group.bean.OrderData;
import littlehow.sort.group.bean.OrderDirect;
import littlehow.sort.group.bean.OrderProperty;
import littlehow.sort.group.service.GroupSortService;
import littlehow.sort.group.service.SortService;

import java.util.*;

/**
 * TestSort
 *
 * @author littlehow
 * @time 2017-08-14 17:08
 */
public class TestSort {

    static double[] orderScore = {1.5, 1.8, 2.9, 3.3, 1.5, 1.6, 3.1, 2.9,0,1,2,1.6,0,1.5, 0.7, 0,7, 1.5, 1.5, 3.3, 1.6, 4.2,1,1,1.5, 4.1,1.5,1.6};
    static double[] trueFalse = {0.0, 1.0};
    static Random random = new Random();
    static int length = orderScore.length;
    static SortService sortService = new GroupSortService();

    private static List<OrderProperty> orderProperties = new ArrayList<OrderProperty>();
    static {
        orderProperties.add(new OrderProperty("seckill", 1, OrderDirect.DESC, true));
        orderProperties.add(new OrderProperty("cart", 2, OrderDirect.ASC, true));
        orderProperties.add(new OrderProperty("marketingText", 3, OrderDirect.ASC));
        orderProperties.add(new OrderProperty("shopScore", 4, OrderDirect.DESC));
        orderProperties.add(new OrderProperty("historyPurchase", 5, OrderDirect.ASC));
        orderProperties.add(new OrderProperty("activity", 6, OrderDirect.ASC));
    }
    public static void main(String[] args) {
        test();
    }

    static void test() {
        List<OrderData<Integer>> orderDatas = new ArrayList<>();
        for (int i=1; i<11; i++) {
            orderDatas.add(getOrderData(i));
        }
        for (OrderData orderData : orderDatas) {
            System.out.println(orderData.getId() + ":" + orderData.getOrderScoreMap());
        }
//        System.out.println("========================分割===============================");
        long start = System.currentTimeMillis();
        for (int i=0;i<1;i++) {
           
            Collections.shuffle(orderDatas); 
            for (OrderData orderData : orderDatas) { 
               System.out.print(orderIntData.getId()+"-"); 
            }
      List<Integer> result = sortService.sortPaging(orderDatas, orderProperties, 1, 10); 
      System.out.println(result); 
   } 
   System.out.println("-------------------->耗时:" + (System.currentTimeMillis() - start) + "毫秒"); 
} 
static OrderData getOrderData(int id) { 
    OrderData orderData = new OrderData(); 
    orderData.setId(id); 
    orderData.setOrderScoreMap(getOrderScore()); 
    return orderData; 
} 
 static Map<String, Double> getOrderScore() { 
     Map<String, Double> map = new HashMap<String, Double>(); 
     for (OrderProperty orderProperty : orderProperties) { 
         if (random.nextInt(10) < 4) continue; 
         if (orderProperty.isTrueOrFalse()) { 
             map.put(orderProperty.getId(), trueFalse[random.nextInt(2)]); 
         } else { 
             map.put(orderProperty.getId(), orderScore[random.nextInt(length)]); 
         } 
     } 
     return map; 
 }
}
little_how
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java集合分组和排序
HY
05-23 137
java集合分组和排序
java实现优先级队列以及堆排序
wuqindeyunque的博客
02-20 1105
1.优先级队列 1.1优先级队列定义 优先级队列顾名思义首先是一种队列，但是和普通队列每次出队都是出队首元素不同，优先级队列每次出队出优先级最高的元素. 首先想到使用数组或者链表来实现优先级队列。 如果使用有序数组，数组按优先级队列排序，出队和队列类似，区别在于入队时要找出新元素的位置，还要移动新元素位置后面的元素；如果使用无序数组，入队与队列类似，只要将队尾...
HQL。。。
又小雨的博客
07-12 250
一、基础语法 1.执行顺序 from——where——group by———having——select———order by——limit 2.基础语法 0. 查询各个数据类型的字段的语法(array、map、struct) select name,salary,hobbies[1],cards['123456'],addr.city from t_person; 1. 条件查询：= != >= <= select * from t_person where addr.city='郑州'; 2
Java的分组和排序
dou_ge_ge的博客
07-25 2095
一、排序 数组排序： Array.sort(int[] a)：直接对数组a进行升序排序 Array.sort(int[] a , int fromIndex, int toIndex)：直接对数组a中第fromIndex到toIndex-1个（自然语言描述）元素进行排序。 集合排序： Collections.sort指定一个Comparator接口 List对象的sort...
Hibernate查询语言-HQL
lhtzbj12的专栏
01-19 712
Hibernate配备了一种非常强大的查询语言，这种语言看上去很像SQL。但是不要被语法结构 上的相似所迷惑，HQL是非常有意识的被设计为完全面向对象的查询，它可以理解如继承、多态 和关联之类的概念。第 15 章 HQL: Hibernate查询语言Hibernate配备了一种非常强大的查询语言，这种语言看上去很像SQL。但是不要被语法结构 上的相似所迷惑，HQL是非常有意识的被设计为完全面向对象的
如何使用HQL语句进行排序
大道至简，知易行难
06-06 1689
文章转载自：https://blog.csdn.net/laijunpeng/article/details/12280917
MySQL数据高阶处理技巧：掌握先排序后分组的智慧
修己xj的博客
08-08 1991
在MySQL数据库的数据探索旅程中，排序和分组是不可或缺的工具。然而，当你面对大量数据、重复值等情况时，常规的处理方法可能显得不够灵活。本文将为你揭示一个精妙的技巧：如何在MySQL中先排序，后分组，从而获取每个类型的最新数据，助你轻松驾驭复杂的数据处理任务。
java数百种算法实现
06-03
以下是一些可能包含在"java算法大全源码包"中的关键算法类别及其简要介绍： 1. 排序算法： - 冒泡排序：基础排序算法，通过不断交换相邻的不正确顺序元素进行排序。 - 选择排序：每次找到未排序部分的最小元素并...
浅析java 归并排序算法
09-03
Java 归并排序算法是一种基于分治思想的高效排序算法，它的主要特点是稳定且具有较高的时间复杂度效率。归并排序的基本操作包括将大问题分解为小问题，然后逐个解决小问题，最后将解决好的小问题合并为解决大的问题...
Java面试题及其简要答案
最新发布
07-05
Java面试题及其简要答案
Java实现遍历、排序、查找算法及简要说明.docx
10-18
在本文档中，我们主要探讨了Java中关于遍历、排序和查找算法的实现和简要说明。首先，我们详细介绍了二叉树的遍历算法，包括四种主要的遍历方式：先序遍历、中序遍历、后序遍历和层次遍历。 1. **遍历算法**： - *...
用java实现快速排序
01-05
根据给定文件的信息，本文将围绕“用Java实现快速排序”的主题进行展开，不仅解析标题与描述中的核心知识点，还会对部分代码示例进行解读，最后结合这些信息给出一个完整的快速排序算法实现。 ### 快速排序算法简介...
hibernate--HQL查询语句-----分组、排序--多条件排序
热门推荐
liyanhui1001的专栏
08-25 4万+
1.实体的更新和删除： 　　在继续讲解HQL其他更为强大的查询功能前，我们先来讲解以下利用HQL进行实体更新和删除的技术。这项技术功能是Hibernate3的新加入的功能，在Hibernate2中是不具备的。      比如在Hibernate2中，如果我们想将数据库中
【大数据之Hive】十二、Hive-HQL查询之分组、join、排序
阿宁的博客
06-15 1667
group by 通常和聚合函数一起使用，按照一个或多个列的结果进行分组，任何对每个租执行聚合操作。用group by时，select中只能用在group by中的字段和聚合函数。
分别使用Criteria与HQL进行分组、时间排序查询
qq_42341160的博客
10-17 805
分别使用Criteria与HQL进行分组、时间排序查询Criteriahqluser.hbm.xml实体类 Criteria public static void main(String[] args) { //实例化对象 UserEntity userEntity = new UserEntity(); //配置 Configu...
delete select语句_软件测试常用的增删改查SQL语句
weixin_39824834的博客
11-22 350
目录：1、DDL:数据定义语言（data definition language）2、DML:数据操作语言（Data Manipulation Language）3、DCL:数据控制语言（Data Control Language）1、DDL:数据定义语言（data definition language）2、DML:数据操作语言（Data Manipulation Language）查询记录语句...
java实现分组排序
ડUN的博客
09-09 2100
方案1 使用单个Comparator实现 /** * 使用单个比较器进行多字段排序 * @param medalList * @return */ public static List<String> rankBySingleComparator(List<Medal> medalList){ Collections.sort(medalList,(medal1,medal2)->{ //第一排序字段 if(medal1.get
java顺序排序_十大经典排序——java实现
weixin_35035699的博客
02-21 788
排序算法排序算法算是我们学习算法的入门篇，在正式介绍各种排序算法前，先介绍一下要用到的一些术语：稳定排序：如果a本来在b的前面，且a==b，排序以后a依旧在b的前面，那就是稳定排序，否在是非稳定排序原地排序：就是在排序过程中不申请多于的存储空间，只利用原来存储待排数据的存储空间进行比较和交换的数据排序。而非原地排序就是需要利用额外的数组来辅助排序。总览：选择排序代码思路首先找到数组中最小的元素，其...
对象数组的排序问题，设置对象某一属性的优先级最高
YANGYYID的博客
10-17 1381
在实习期间的一个项目中，经理叫我将查询结果（是一个对象数组，项目中是租约信息的列表）按照地理位置的远近排序，并且当结果含有自己时显示在第一个。其实这样的功能是很常见的，网上很多解决方法，大多都是要写一个实现一个comparator的接口的比较器，然后调用Collections类的排序方法。但并不能解决我这里的要求，就是让某个属性有最高级。我想了很久，逐步调试，发现解决问题的方法就在比较器的实现上，
Java实现的八大排序算法详解
以下是几种常见的排序算法及其Java实现的简要说明： 1. **插入排序**（Insertion Sort）： 插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值