UFL12-4——大数据数值转字符串方法

大数据数值转字符串 的方法

我们在游戏开发时，为了避免在界面中显示过长的数值，往往需要把过长数值进行转换

比如：1198678978​ 转换为 11亿9千万​、5328987​ 转换为 532万8千​
因为如果直接在界面上显示过长的数值可能会影响UI布局，而过大的数也可以直接粗略显示可以直接省略后面的内容，显示一个大概数值

因此我们可以将其封装为一个常用方法

需求：以 亿 和 万 作为转换临界点，超过亿，则显示为 n亿n千万​，超过万，则显示为 n万n千​ 这种形式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/// <summary>
/// 把大数值转换为精简了位数的字符串，大于一亿的转换为n亿n千万，大于一万的转换为n万n千
/// </summary>
/// <param name="num">要转换的数值</param>
/// <returns>转换出来的字符串</returns>
public static string GetBigDataToString(int num)
{
    //如果大于一亿，就显示为n亿n千万
    if (num >= 100000000)
    {
        return BigDataChange(num, 100000000, "亿", "千万");
    }
    //如果大于一万，就显示为n万n千
    else if (num >= 10000)
    {
        return BigDataChange(num, 10000, "万", "千");
    }
    //都不满足，直接显示数值本身
    else
    {
        return num.ToString();
    }
}

/// <summary>
/// 把大数值转换为精简了位数的字符串，可以自定义分割位数，如n亿n千万，n万n千
/// </summary>
/// <param name="num">要转换的数值</param>
/// <param name="company">分割单位，可填100000000（亿），10000（万）等等</param>
/// <param name="bigCompany">大单位 亿、万 等等</param>
/// <param name="littleCompany">小单位 千万、千 等等</param>
/// <returns>转换出来的数值</returns>
private static string BigDataChange(int num, int company, string bigCompany, string littleCompany)
{
    resultStr.Clear();
    resultStr.Append(num / company);
    resultStr.Append(bigCompany);
    int tmpNum = num % company;
    tmpNum /= (company / 10);
    //算出来不为0
    if (tmpNum != 0)
    {
        resultStr.Append(tmpNum);
        resultStr.Append(littleCompany);
    }
    return resultStr.ToString();
}

使用示例

1
2
3
4
5
6
7
void Start()
{
    print(TextUtil.GetBigDataToString(1245000000));
    print(TextUtil.GetBigDataToString(5689523));
    print(TextUtil.GetBigDataToString(5869));
    print(TextUtil.GetBigDataToString(1));
}

输出：image​

具体代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using UnityEngine.Events;

/// <summary>
/// 用于处理字符串的一些公共功能
/// </summary>
public class TextUtil
{
    private static StringBuilder resultStr = new StringBuilder("");

    #region 字符串拆分相关
    /// <summary>
    /// 拆分字符串，返回字符串数组
    /// </summary>
    /// <param name="str">想要被拆分的字符串</param>
    /// <param name="type">拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <returns>拆分出来的数组</returns>
    public static string[] SplitStr(string str, int type = 1)
    {
        if (str == "")
            return new string[0];
        string newStr = str;
        if (type == 1)
        {
            //为了避免英文符号填成中文符号，我们先进行一个替换
            while (newStr.IndexOf("；") != -1)
            {
                newStr = newStr.Replace("；", ";");
            }
            return newStr.Split(';');
        }
        else if (type == 2)
        {
            //为了避免英文符号填成中文符号，我们先进行一个替换
            while (newStr.IndexOf("，") != -1)
            {
                newStr = newStr.Replace("，", ",");
            }
            return newStr.Split(',');
        }
        else if (type == 3)
        {
            return newStr.Split('%');
        }
        else if (type == 4)
        {
            //为了避免英文符号填成中文符号，我们先进行一个替换
            while (newStr.IndexOf("：") != -1)
            {
                newStr = newStr.Replace("：", ":");
            }
            return newStr.Split(':');
        }
        else if (type == 5)
        {
            return newStr.Split(' ');
        }
        else if (type == 6)
        {
            return newStr.Split('|');
        }
        else if (type == 7)
        {
            return newStr.Split('_');
        }
        return new string[0];
    }

    /// <summary>
    /// 拆分字符串 返回整形数组
    /// </summary>
    /// <param name="str">想要被拆分的字符串</param>
    /// <param name="type">拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <returns>拆分出来的数组</returns>
    public static int[] SplitStrToIntArr(string str, int type = 1)
    {
        string[] strs = SplitStr(str, type);
        if (str.Length == 0)
            return new int[0];
        //将字符串数组转换为整形数组
        return Array.ConvertAll<string, int>(strs, (str) =>
        {
            return int.Parse(str);
        });
    }

    /// <summary>
    /// 专门用来处理拆分类似于"1,10;2,20;3,30"这样的数值对信息，并将其转换为整形数
    /// </summary>
    /// <param name="str">待拆分的字符串</param>
    /// <param name="typeOne">数值对的分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <param name="typeTwo">数值对内部的分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <param name="callBack">传递数值对的回调函数</param>
    public static void SplitStrToIntArrTwice(string str, int typeOne, int typeTwo, UnityAction<int, int> callBack)
    {
        string[] strs = SplitStr(str, typeOne);
        if (strs.Length == 0)
            return;
        int[] ints;
        for (int i = 0; i < strs.Length; i++)
        {
            ints = SplitStrToIntArr(strs[i], typeTwo);
            if (ints.Length == 0)
                continue;
            callBack.Invoke(ints[0], ints[1]);
        }
    }

    /// <summary>
    /// 专门用来处理拆分类似于"1,10;2,20;3,30"这样的键值对信息，拆分为字符串
    /// </summary>
    /// <param name="str">待拆分的字符串</param>
    /// <param name="typeOne">键值对分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <param name="typeTwo">键值对内部的分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <param name="callBack">传递字符串对的回调函数</param>
    public static void SplitStrwice(string str, int typeOne, int typeTwo, UnityAction<string, string> callBack)
    {
        string[] strs1 = SplitStr(str, typeOne);
        if (strs1.Length == 0)
            return;
        string[] strs2;
        for (int i = 0; i < strs1.Length; i++)
        {
            strs2 = SplitStr(strs1[i], typeTwo);
            if (strs2.Length == 0)
                continue;
            callBack.Invoke(strs2[0], strs2[1]);
        }
    }
    #endregion

    #region 数值转字符串相关
    /// <summary>
    /// 将数值转换为字符串，可以指定长度，长度不足时自动在前面补充0
    /// </summary>
    /// <param name="value">要转换的数值</param>
    /// <param name="len">最短长度，传入的数值长度不足时会补充0</param>
    /// <returns>转换出来的字符串</returns>
    public static string GetNumStr(int value, int len)
    {
        //int.ToString如果传入一个"Dn"（n是数值）的字符串，
        //代表想要将数值转换为长度为n的字符串，如果长度不够，会在前面补充0
        return value.ToString($"D{len}");
    }

    /// <summary>
    /// 让指定的浮点数保留小数点后n位
    /// </summary>
    /// <param name="value">要转换的浮点数</param>
    /// <param name="len">保留小数位数</param>
    /// <returns>转换出来的字符串</returns>
    public static string GetDecimalStr(float value, int len)
    {
        //float.ToString如果传入一个"Fn"（n是数值）的字符串，
        //代表想要保留小数点后几位小数
        return value.ToString($"F{len}");
    }

    /// <summary>
    /// 把大数值转换为精简了位数的字符串，大于一亿的转换为n亿n千万，大于一万的转换为n万n千
    /// </summary>
    /// <param name="num">要转换的数值</param>
    /// <returns>转换出来的字符串</returns>
    public static string GetBigDataToString(int num)
    {
        //如果大于一亿，就显示为n亿n千万
        if (num >= 100000000)
        {
            return BigDataChange(num, 100000000, "亿", "千万");
        }
        //如果大于一万，就显示为n万n千
        else if (num >= 10000)
        {
            return BigDataChange(num, 10000, "万", "千");
        }
        //都不满足，直接显示数值本身
        else
        {
            return num.ToString();
        }
    }

    /// <summary>
    /// 把大数值转换为精简了位数的字符串，可以自定义分割位数，如n亿n千万，n万n千
    /// </summary>
    /// <param name="num">要转换的数值</param>
    /// <param name="company">分割单位，可填100000000（亿），10000（万）等等</param>
    /// <param name="bigCompany">大单位 亿、万 等等</param>
    /// <param name="littleCompany">小单位 千万、千 等等</param>
    /// <returns>转换出来的数值</returns>
    private static string BigDataChange(int num, int company, string bigCompany, string littleCompany)
    {
        resultStr.Clear();
        resultStr.Append(num / company);
        resultStr.Append(bigCompany);
        int tmpNum = num % company;
        tmpNum /= (company / 10);
        //算出来不为0
        if (tmpNum != 0)
        {
            resultStr.Append(tmpNum);
            resultStr.Append(littleCompany);
        }
        return resultStr.ToString();
    }
    #endregion

    #region 时间转化相关
    /// <summary>
    /// 将秒数转换为时分秒字符串
    /// </summary>
    /// <param name="timeSec">秒数</param>
    /// <param name="egZero">是否忽略0</param>
    /// <param name="isKeepLength">是否保留最短两位长度，即存在类似与这样的格式"01:05:35"</param>
    /// <param name="hourStr">小时的拼接字符</param>
    /// <param name="minuteStr">分钟的拼接字符</param>
    /// <param name="secondStr">秒数的拼接字符</param>
    /// <returns>转换好的时间字符串</returns>
    public static string SecondToHMS(int timeSec, bool egZero = false, bool isKeepLength = false, string hourStr = "时", string minuteStr = "分", string secondStr = "秒")
    {
        //时间不会有负数，如果发现了负数，就直接归0
        if (timeSec < 0)
            timeSec = 0;

        //计算小时
        int hour = timeSec / 3600;
        //计算分钟
        //除去小时后的剩余秒
        int second = timeSec % 3600;
        //剩余秒转分钟数
        int minute = second / 60;
        //计算秒
        second = timeSec % 60;
        //拼接
        resultStr.Clear();
        //如果小时不为0，或者不忽略0
        if (hour != 0 || !egZero)
        {
            //具体几个小时
            resultStr.Append(isKeepLength ? GetNumStr(hour, 2) : hour);
            resultStr.Append(hourStr);
        }
        //如果分钟不为0，或者不忽略0，或者小时不为0
        if (minute != 0 || !egZero || hour != 0)
        {
            //具体几分钟
            resultStr.Append(isKeepLength ? GetNumStr(minute, 2) : minute);
            resultStr.Append(minuteStr);
        }
        //如果秒不为0 或者 不忽略0 或者 小时和分钟都不为0
        if (second != 0 || !egZero || hour != 0 || minute != 0)
        {
            //具体多少秒
            resultStr.Append(isKeepLength ? GetNumStr(second, 2) : second);
            resultStr.Append(secondStr);
        }

        //如果传入的是0秒，则需要特别输出一个0秒
        if (resultStr.Length == 0)
        {
            resultStr.Append(0);
            resultStr.Append(secondStr);
        }

        return resultStr.ToString();
    }

    /// <summary>
    /// 返回类似于00:00:00这样格式的时间字符串
    /// </summary>
    /// <param name="s">要转换的字符串</param>
    /// <param name="egZero">是否忽略0</param>
    /// <returns>转换出来的字符串</returns>
    public static string SecondToColonStr(int s, bool egZero = false)
    {
        return SecondToHMS(s, egZero, true, ":", ":", "");
    }
    #endregion
}