文本转换工具类

最新推荐文章于 2023-10-13 17:16:26 发布
最新推荐文章于 2023-10-13 17:16:26 发布
阅读量311 收藏 1
点赞数
分类专栏： C# 文章标签： 文本操作工具类 class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27462223/article/details/77189712
版权 
using System;
using System.Collections.Generic;
using System.Text;

namespace InterfaceCommon.Common
{
    /// <summary>
    /// 文本操作工具类
    /// </summary>
    public static class StringUtil
    {

        /// <summary>
        /// 判断字符串是否为空
        /// </summary>
        /// <param name="value">要判断的字符串</param>
        /// <returns>true 为空; false 不为空</returns>
        public static bool Empty(string value)
        {
            return value == null || value.Trim().Length == 0;
        }

        /// <summary>
        /// 判断字符串是否不为空
        /// </summary>
        /// <param name="value">要判断的字符串</param>
        /// <returns>true 不为空; false 为空</returns>
        public static bool NotEmpty(string value)
        {
            return !Empty(value);
        }

        /// <summary>
        /// 将null的字符串转换为空字符串
        /// </summary>
        /// <param name="value">要转换的字符串</param>
        /// <returns>转换后的字符串</returns>
        public static string NullToSpace(string value)
        {
            return value == null ? "" : value;
        }

        /// <summary>
        /// 将字符串中的匹配项替换为指定的字符串
        /// </summary>
        /// <param name="value">要替换的字符串</param>
        /// <param name="find">匹配项</param>
        /// <param name="replace">替换字符串</param>
        /// <returns>替换后的字符串</returns>
        public static string Replace(string value, string find, string replace)
        {
            if (value == null)
            {
                return null;
            }
            return value.Replace(find, replace);
        }

        /// <summary>
        /// 以指定的字符串为分隔符分割字符串
        /// </summary>
        /// <param name="value">要分割的字符串</param>
        /// <param name="split">分隔符字符串</param>
        /// <returns>分割后的字符串数组</returns>
        public static string[] Split(string value, string split)
        {
            if (value == null)
            {
                return null;
            }
            return value.Split(split.ToCharArray());
        }

        /// <summary>
        /// 将字符串转换为整型数据
        /// </summary>
        /// <param name="value">要转换的字符串</param>
        /// <returns>转换后的整形数据</returns>
        public static int ToInt(string value)
        {
            if (Empty(value))
            {
                return 0;
            }
            try
            {
                return Int32.Parse(value);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0;
            }
        }

        /// <summary>
        /// 将对象转换为整型数据
        /// </summary>
        /// <param name="value">要转换的对象</param>
        /// <returns>转换后的整形数据</returns>
        public static int ToInt(object value)
        {
            string valueString = value.ToString();
            if (Empty(valueString))
            {
                return 0;
            }
            try
            {
                return Int32.Parse(valueString);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0;
            }
        }

        /// <summary>
        /// 将字符串转换为长整型数据
        /// </summary>
        /// <param name="value">要转换的字符串</param>
        /// <returns>转换后的整形数据</returns>
        public static long ToLong(string value)
        {
            if (Empty(value))
            {
                return 0L;
            }
            try
            {
                return Int64.Parse(value);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0L;
            }
        }

        /// <summary>
        /// 将对象转换为长整型数据
        /// </summary>
        /// <param name="value">要转换的对象</param>
        /// <returns>转换后的整形数据</returns>
        public static long ToLong(object value)
        {
            string valueString = value.ToString();
            if (Empty(valueString))
            {
                return 0L;
            }
            try
            {
                return Int64.Parse(valueString);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0L;
            }
        }

        /// <summary>
        /// 将字符串转换为单精度数据
        /// </summary>
        /// <param name="value">要转换的字符串</param>
        /// <returns>转换后的整形数据</returns>
        public static float ToFloat(string value)
        {
            if (Empty(value))
            {
                return 0.0F;
            }
            try
            {
                return Single.Parse(value);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0.0F;
            }
        }

        /// <summary>
        /// 将对象转换为单精度数据
        /// </summary>
        /// <param name="value">要转换的对象</param>
        /// <returns>转换后的整形数据</returns>
        public static float ToFloat(object value)
        {
            string valueString = value.ToString();
            if (Empty(valueString))
            {
                return 0.0F;
            }
            try
            {
                return Single.Parse(valueString);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0.0F;
            }
        }

        /// <summary>
        /// 将字符串转换为双精度数据
        /// </summary>
        /// <param name="value">要转换的字符串</param>
        /// <returns>转换后的整形数据</returns>
        public static double ToDouble(string value)
        {
            if (Empty(value))
            {
                return 0.0D;
            }
            try
            {
                return Double.Parse(value);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0.0D;
            }
        }

        /// <summary>
        /// 将对象转换为双精度数据
        /// </summary>
        /// <param name="value">要转换的对象</param>
        /// <returns>转换后的整形数据</returns>
        public static double ToDouble(object value)
        {
            string valueString = value.ToString();
            if (Empty(valueString))
            {
                return 0.0D;
            }
            try
            {
                return Double.Parse(valueString);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0.0D;
            }
        }

        /// <summary>
        /// 将字符串转换为十进制数
        /// </summary>
        /// <param name="value">要转换的字符串</param>
        /// <returns>转换后的十进制数</returns>
        public static decimal ToDecimal(string value)
        {
            if (Empty(value))
            {
                return 0M;
            }
            try
            {
                return Decimal.Parse(value);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0M;
            }
        }

        /// <summary>
        /// 将对象转换为十进制数
        /// </summary>
        /// <param name="value">要转换的对象</param>
        /// <returns>转换后的十进制数</returns>
        public static decimal ToDecimal(object value)
        {
            string valueString = value.ToString();
            if (Empty(valueString))
            {
                return 0M;
            }
            try
            {
                return Decimal.Parse(valueString);
            }
            catch (Exception ex)
            {
                Log.warn(ex.Message);
                return 0M;
            }
        }



        public static string getFormat0CmdtyOrderCode(string oldCmdtyOrderCode)
        {

            string newCmdtyOrderCode = "";

            if (oldCmdtyOrderCode.Length == 7)
            {
                oldCmdtyOrderCode = "0" + oldCmdtyOrderCode;
            }
            else if (oldCmdtyOrderCode.Length == 6)
            {
                oldCmdtyOrderCode = "00" + oldCmdtyOrderCode;
            }
            else if (oldCmdtyOrderCode.Length == 5)
            {
                oldCmdtyOrderCode = "000" + oldCmdtyOrderCode;
            }

            newCmdtyOrderCode = oldCmdtyOrderCode;

            return newCmdtyOrderCode;

        }



        public static string getFormat0CmdtyOrderCodeNew(string oldCmdtyOrderCode)
        {

            string newCmdtyOrderCode = "";

            if (oldCmdtyOrderCode.Length == 12)
            {
                oldCmdtyOrderCode = "0" + oldCmdtyOrderCode;
            }
            else if (oldCmdtyOrderCode.Length == 11)
            {
                oldCmdtyOrderCode = "00" + oldCmdtyOrderCode;
            }
            else if (oldCmdtyOrderCode.Length == 10)
            {
                oldCmdtyOrderCode = "000" + oldCmdtyOrderCode;
            }

            newCmdtyOrderCode = oldCmdtyOrderCode;

            return newCmdtyOrderCode;

        }




        public static string getFormatCmdtyOrderCode(string oldCmdtyOrderCode)
        {

            string newCmdtyOrderCode = "";

            if (oldCmdtyOrderCode.Length == 7)
            {
                oldCmdtyOrderCode = "0" + oldCmdtyOrderCode;
            }
            else if (oldCmdtyOrderCode.Length == 6)
            {
                oldCmdtyOrderCode = "00" + oldCmdtyOrderCode;
            }
            else if (oldCmdtyOrderCode.Length == 5)
            {
                oldCmdtyOrderCode = "000" + oldCmdtyOrderCode;
            }

            if (oldCmdtyOrderCode.Length == 8)
            {
                newCmdtyOrderCode = oldCmdtyOrderCode.Substring(0, 3) + "-" + oldCmdtyOrderCode.Substring(3, 5);
            }
            else
            {
                newCmdtyOrderCode = oldCmdtyOrderCode;
            }

            return newCmdtyOrderCode;

        }


        public static string getWMSCmdtyOrderCode(string oldCmdtyOrderCode)
        {

            string tempCode = "";
            int tempString = 0;
            int tempString1 = 0;
            int tempString2 = 0;
            string newCmdtyOrderCode = "";

            if (oldCmdtyOrderCode.Length == 7)
            {
                oldCmdtyOrderCode = "0" + oldCmdtyOrderCode;
            }
            else if (oldCmdtyOrderCode.Length == 6)
            {
                oldCmdtyOrderCode = "00" + oldCmdtyOrderCode;
            }
            else if (oldCmdtyOrderCode.Length == 5)
            {
                oldCmdtyOrderCode = "000" + oldCmdtyOrderCode;
            }

            if (oldCmdtyOrderCode.Length == 8)
            {
                tempCode = oldCmdtyOrderCode + "00000";

                tempString1 = Int32.Parse((tempCode.Substring(0, 1)))
                            + Int32.Parse((tempCode.Substring(2, 1)))
                            + Int32.Parse((tempCode.Substring(4, 1)))
                            + Int32.Parse((tempCode.Substring(6, 1)))
                            + Int32.Parse((tempCode.Substring(8, 1)))
                            + Int32.Parse((tempCode.Substring(10, 1)))
                            + Int32.Parse((tempCode.Substring(12, 1)));

                tempString2 = Int32.Parse((tempCode.Substring(1, 1)))
                            + Int32.Parse((tempCode.Substring(3, 1)))
                            + Int32.Parse((tempCode.Substring(5, 1)))
                            + Int32.Parse((tempCode.Substring(7, 1)))
                            + Int32.Parse((tempCode.Substring(9, 1)))
                            + Int32.Parse((tempCode.Substring(11, 1)));

                tempString2 = tempString2 * 3;
                tempString = tempString1 + tempString2;

                if (tempString.ToString().Length == 3)
                {
                    tempString = (Int32.Parse(tempString.ToString().Substring(0, 2)) + 1) * 10 - tempString;
                }
                else if (tempString.ToString().Length == 1)
                {
                    tempString = 10 - Int32.Parse(tempString.ToString());
                }
                else
                {
                    tempString = (Int32.Parse(tempString.ToString().Substring(0, 1)) + 1) * 10 - tempString;
                }



                if (tempString == 10)
                {
                    tempString = 0;
                }

                newCmdtyOrderCode = oldCmdtyOrderCode + "0000" + tempString.ToString();
            }
            else
            {
                newCmdtyOrderCode = oldCmdtyOrderCode;
            }

            return newCmdtyOrderCode;

        }



        /// <summary>
        /// 转全角的函数(SBC case)
        /// </summary>
        /// <param name="input">任意字符串</param>
        /// <returns>全角字符串</returns>
        ///<remarks>
        ///全角空格为12288，半角空格为32
        ///其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248
        ///</remarks>        
        public static string ToSBC(string input)
        {
            //半角转全角：
            char[] c = input.ToCharArray();
            for (int i = 0; i < c.Length; i++)
            {
                if (c[i] == 32 || c[i] == 13 || c[i] == 10)
                {
                    c[i] = (char)12288;
                    continue;
                }


                if (c[i] < 127)
                    c[i] = (char)(c[i] + 65248);
            }
            return new string(c);
        }


        /// <summary>
        /// 判断日期型函数
        /// </summary>
        /// <param name="input">任意字符串</param>
        /// <returns>true;false</returns>
        ///<remarks>
        ///</remarks> 
        public static bool isDate(string strDate)
        {
            bool checkFlg = false;
            try
            {
                Convert.ToDateTime(strDate);
                checkFlg = true;
            }
            catch
            {
                checkFlg = false;
            }

            return checkFlg;

        }


        /// <summary>
        /// 判断数字型函数
        /// </summary>
        /// <param name="input">任意字符串</param>
        /// <returns>true;false</returns>
        ///<remarks>
        public static bool isNumberic(string oText)
        {
            try
            {
                int var1 = Convert.ToInt32(oText);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 判断数字型函数（可小数）
        /// </summary>
        /// <param name="input">任意字符串</param>
        /// <returns>true;false</returns>
        ///<remarks>
        public static bool isDecimal(string oText)
        {
            try
            {
                double var1 = Convert.ToDouble(oText);
                if (var1 < 0)
                {
                    Log.error(oText);
                    return false;
                }
                return true;
            }
            catch
            {
                return false;
            }
        }


        /// <summary>
        /// 字段拆分
        /// </summary>
        /// <param name="input">任意字符串</param>
        /// <returns>true;false</returns>
        ///<remarks>
        public static string[] split38byte(string address)
        {
            string[] splitAddress = { "", "", "" };
            int length = address.Length;
            for (int i = 0; i < 3; i++)
            {
                if (length > 38 * (i + 1))
                {
                    splitAddress[i] = address.Substring(38 * i, 38);
                }
                else
                {
                    splitAddress[i] = address.Substring(38 * i, length - (38 * i));
                    break;
                }
            }
            return splitAddress;
        }

        /// <summary>
        /// 将空字符串转换为null的字符串
        /// </summary>
        /// <param name="value">要转换的字符串</param>
        /// <returns>转换后的字符串</returns>
        public static string SpaceToNull(string value)
        {
            if (value.Equals("''"))
            {
                value = "null";
            }
            return value;
        }


        //日期格式转成YYYYMMDD
        public static string forMatDate(string value)
        {
            string lastDate = value.Substring(0, 4) + value.Substring(5, 2) + value.Substring(8, 2);
            return lastDate;
        }

        //日期格式转成YYYYYYMMDDhhmmss
        public static string forMatDateYYYYMMDDhhmmss(string value)
        {
           // string crrent = "2016/9/6 0:00:00.000";
            char[] arrChar = { '/', ':', '-', ' ', '.' };
            string[] list = value.Split(arrChar);
            //[2016,9,6,0,00,00,000]
            if(list[1].Length!=2){
                list[1] = "0" + list[1];
            }
            if (list[2].Length != 2)
            {
                list[2] = "0" + list[2];
            }
            if (list[3].Length != 2)
            {
                list[3] = "0" + list[3];
            }
            value = list[0] + list[1] + list[2] + list[3] + list[4] + list[5];
           /* string[] ms = value.Split(new[] { "." }, StringSplitOptions.None); //将毫秒去掉

            string[] ArrayList = ms[0].Split(new[] { " " }, StringSplitOptions.None); //将年月日和时分秒 分隔开

            string[] year = ArrayList[0].Split(new[] { "/" }, StringSplitOptions.None);//年月日

            if (year[1].Length == 1)
            {
                year[1] = "0" + year[1];
            }
            if (year[2].Length == 1)
            {
                year[2] = "0" + year[2];
            }

            string[] min = ArrayList[1].Split(new[] { ":" }, StringSplitOptions.None);//时分秒

            if (min[0].Length == 1)
            {
                min[0] = "0" + min[0];
            }
            value = year[0] + year[1] + year[2] + min[0] + min[1] + min[2];*/
            //string lastDate = value.Substring(0, 4) + value.Substring(5, 2) + value.Substring(8, 2) + value.Substring(11, 2) + value.Substring(14, 2) + value.Substring(17, 2);
            return value;
        }
        //地址切割
        public static string formatAddress(string address1, string address2, string address3, string address4)
        {
            string address = address1 + address2 + address3 + address4;
            if ((address1.Length + address2.Length + address3.Length + address4.Length) > 114)
            {
                address = address.Substring(0, 114);
            }

            return address;

        }
        //2014/05/15 K0048 LCS ADD START
        /// <summary>
        /// 获取json字段的值
        /// </summary>
        /// <param name="jsonProperty">json字段</param>
        /// <param name="type">值类型</param>
        /// <returns>json字段的值</returns>
        public static string getJsonValue(JsonProperty jsonProperty, string type)
        {
            if (jsonProperty == null)
            {
                switch (type)
                {
                    case "string":
                        return "";
                    case "number":
                        return "0";
                    default:
                        return "";
                }
            }
            else
            {
                switch (type)
                {
                    case "date":
                        if (jsonProperty.Value.Equals("0001-01-0100:00:00"))
                        {
                            return "1970-01-01 00:00:00";
                        }
                        return jsonProperty.Value.Insert(10, " ");
                    default:
                        return jsonProperty.Value;
                }
            }
        }

        /// <summary>
        /// 验证返回信息
        /// </summary>
        /// <param name="responseJObject">json内容</param>
        /// <returns>出错信息</returns>
        public static string validate_Send_Result(JsonObject responseJObject)
        {
            string errorMsg = "";
            if (responseJObject["error_response"] != null)
            {
                errorMsg = responseJObject["error_response"]["zh_desc"].ToString();
            }
            return errorMsg;
        }
        //2014/05/15 K0048 LCS ADD END

    }
}

CurtainMy
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
十六进制转换中文、文本、字符串工具，抓包分析工具。
03-19
可以把十六进制转换成中文、文本、字符串，也可以把中文、文本、字符串转换成十六进制，同时生成十六进制与字符的对照表，主要用于对抓包的十六进制数据进行分析，也适用网络通信程序的开发和调试。 注意，如果十六进制数据是压缩或加密了的，生成的结果会是乱码，这不是程序的问题。
文本转换工具
柴三少_
01-02 377
自己写了一个字符转换工具,可以试试. 下载地址: http://download.csdn.net/detail/w451062810/9727213
转义和反转义工具类
Dzooooone_的博客
03-23 258
【代码】转义和反转义工具类。
BIN文件转C数组工具
02-26
BIN文件转C数组工具 ， 可以将生产固件，素材图片，等原始文件转换成C语言数组，用于代码中定义静态数组
不同类型文件读取工具类
qiu4160240的博客
05-12 159
一个可读取：Excel,html,pdf,txt,word工具类：    package com.topsoft.info.services; /** * Created by IntelliJ IDEA. * User: * Date: 2009-10-9 * Time: 10:40:12 * To change this template use File | S...
文本大写小写转换工具类
最新发布
04-10
1.1、文本大写小写转换工具适合对：“大写字母转为小写，小写字母转为大写；非字母字符保持不变” 需求的人员，解决了指定大写转小写问题。 1.2、代码有完整注释说明。旨在帮助读者通过案例学习，快速掌握存储...
文本与unicode码转换小工具
12-09
例如，如果你在一个使用GBK编码的系统中接收到一个UTF-8编码的文本文件，可能会出现乱码，这时就需要用转换工具将UTF-8转换为GBK。反之，如果你想在支持Unicode的平台上分享包含非ASCII字符的文件，可能需要将GBK或...
批量文本格式转换工具
03-20
批量文本格式转换工具正是为了解决这个问题而设计的，它可以高效地将多种格式的文本文件统一转换成目标格式，例如从GBK、ISO-8859-1等编码转换成UTF-8或Unicode编码。这样的工具极大地提高了工作效率，避免了手动...
文本大写小写双向转换工具
01-02
"文本大写小写双向转换工具"正如其名，它是一个专门设计用于将文本在大写和小写之间相互转换的实用工具。在编程、数据分析、文本处理等场景下，这种工具具有很高的实用性。 首先，我们要理解什么是大小写。在英文...
Java的HTML转义工具
Roc的博客
10-13 861
在开发web应用程序时，我们经常需要处理用户输入的数据并将其显示在网页上。然而，用户输入的数据可能包含HTML标签或特殊字符，如果直接在网页上显示这些数据，会导致XSS攻击或显示错误的结果。为了解决这个问题，我们需要对输入的HTML进行转义，即将特殊字符转换为HTML实体，以确保安全显示。
在线字符串转义工具
AI的博客
03-01 3279
在线字符串转义工具可以将字符串中的双引号、单引号、换行符转义或去转义。
java 数据库的定义_Java 之 数据库
weixin_32371243的博客
02-25 332
1.SQL——结构化查询语言a.分类：①DDL——数据定义语言②DQL——数据查询语言③DML——数据操作语言④DCL——数据控制语言b.DDL：包括对数据库的创建、使用、删除，对表的创建、删除、修改c.DML：包括对表里的数据 增、删、改d.DQL：对表里的数据进行各种各样的查询2.标识符规范：a.第一个字符必须是：字母、下划线(_)、at符号(@)、数字符号(#)b.后续字符可以是：字母、数字...
文本转语音（TTS）工具Balabolka
li_huaqingfeng的博客
08-06 1650
1 说明 Balabolka是一款轻量好玩的文语转换工具，运行在Windows环境。如果想寻找开源的Linux下的相关工具，推荐Ekho。这些工具可以用来生成公交车自动报站的语音文件，省去了录音等繁琐的过程。有些时候为了做到实时的方言版的TTS，可能会和科大讯飞等公司进行业务合作。以下图片来自官网，一览Balabolka的风采。 ...
在线Html转义/反转义工具
WP8HUB
01-25 6631
这个在线工具可以实现HTML字符的转义(Escape)与反转义(Unescape)功能。 工具链接：http://www.atoolbox.net/Tool.php?Id=758 在线HTML转义/反转义工具标题
根据指定的文字生成图片（自适应大小） 工具类
天才小站
08-17 4897
package utils;import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.font.FontRenderContext; import java.awt.geom.AffineTransform; import java.awt.geom.Rectangle2D; impo
各种字符转换工具类
xiao雷博客
03-07 714
package com.isoftstone.common.utils; import java.io.UnsupportedEncodingException; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.math.BigDecimal; imp...
工具类：Base64与图片相互转换
weixin_42401291的博客
10-17 1308
优点：实现图片的数字化 缺点：图片存在失真 程序文件：https://download.csdn.net/download/weixin_42401291/10726838 主程序： using System; using System.Collections.Generic; using System.Drawing; using System.IO; using System.Linq...
C语言实现：十六进制文本与数据转换工具
- 该程序提供的功能包括将十六进制文本转换成相应的字节数据，以及将字节数据转换回十六进制文本。这在处理二进制数据的输入输出、数据存储或网络通信中非常有用。 2. **字符串处理**： - 在C语言中，字符串是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值