精华内容
下载资源
问答
  • Split()
    千次阅读
    2021-10-28 15:54:12

    1.对单个字符进行分解  分割的是字符,不是字符串,只能用单引号 split('xxxx')

                string s = string.Empty;
                string str = "aascaacbbcssc";
                string[] arr = str.Split('c');
                foreach (var i in arr)
                {
                    s += i + " ";
                } 
    // s:aas aa bb ss  

    2.对多个字符进行分割

                string s = string.Empty;
                string str = "abcdeabcdeabcde";
                string[] arr = str.Split( new char[3] { 'c', 'd', 'e' });
                foreach (var i in arr)
                {
                    s += i + " ";
                } 
    //s:ab   ab   ab 

    3.正则表达式进行分割

                string s = string.Empty;
                string str = "aaajsbbbjsccc";
                string[] brr = Regex.Split(str, "js", RegexOptions.IgnoreCase);
                //string[] arr = str.Split( new char[3] { 'c', 'd', 'e' });
                foreach (var i in brr)
                {
                    s += i + " ";
                } 
    //s:aaa bbb ccc 

    split重载方法

    方法说明
    String.Split (Char[])返回包含此实例中的子字符串(由指定 Char 数组的元素分隔)的 String 数组。
    String.Split (Char[], Int32)返回包含此实例中的子字符串(由指定 Char 数组的元素分隔)的 String 数组。参数指定返回的子字符串的最大数量。
    String.Split (Char[], StringSplitOptions)返回包含此字符串中的子字符串(由指定的 Char 数组的元素分隔)的 String 数组。参数指定是否返回空数组元素。
    String.Split (String[], StringSplitOptions)返回包含此字符串中的子字符串(由指定的 String 数组的元素分隔)的 String 数组。参数指定是否返回空数组元素。
    String.Split (Char[], Int32, StringSplitOptions)返回包含此字符串中的子字符串(由指定的 Char 数组的元素分隔)的 String 数组。参数指定要返回子字符串的最大数量,以及是否要返回空数组元素。
    String.Split (String[], Int32, StringSplitOptions)返回包含此字符串中的子字符串(由指定的 String 数组的元素分隔)的 String 数组。参数指定要返回子字符串的最大数量,以及是否要返回空数组元素。

    方法调用

    
    方法二: String.Split(Char[],Int32)
    
    string str = "aaatbbscctdd";
    
    string []strArray = str.Split(new char[]{'t',2});
    //只切割成2份(result :"aaa" "bbscctdd")
    
    方法三:String.Split(Char[],StringSplitOptions)
    
    string str = "aaatbbscctddt";
    
    string []strArray = str.Split(new char[]{'t',
    StringSplitOptions.RemoveEmptyEntries});
    //去除空元素(result :"aaa" "bbscc" "dd")
    
    string []strArray = str.Split(new char[]{'t',
    StringSplitOptions.None});
    //保留空元素(result :"aaa" "bbscc" "dd" “”) 
    
    方法四:String.Split(String[],StringSplitOptions)
    
    string str = "aaatbbscctddt";
    
    string []strArray = str.Split(new String[]{"t",
    StringSplitOptions.RemoveEmptyEntries});
    //去除空元素(result :"aaa" "bbscc" "dd")
    
    string []strArray = str.Split(new String[]{"t",
    StringSplitOptions.None});
    //保留空元素(result :"aaa" "bbscc" "dd" “”) 
    
    方法五:String.Split(Char[],Int32,StringSplitOptions)
    
    string str = "aaatbbscctddt";
    
    string []strArray = str.Split(new char[]{'t',2,
    StringSplitOptions.RemoveEmptyEntries});
    //切割成2份且去除空元素(result :"aaa" "bbscctddt")
    
    string []strArray = str.Split(new char[]{'t',2,
    StringSplitOptions.None});
    //切割成2份且保留空元素(result :"aaa" "bbscctddt" “”)
    
    方法六:.String.Split(String[],Int32,StringSplitOptions)
    
    string str = "aaatbbscctddt";
    
    string []strArray = str.Split(new String[]{"t",2,
    StringSplitOptions.RemoveEmptyEntries});
    //切割成2份且去除空元素(result :"aaa" "bbscctddt")
    
    string []strArray = str.Split(new String[]{"t",2,
    StringSplitOptions.None});//
    切割成2份且保留空元素(result :"aaa" "bbscctddt" “”)
    
    

    更多相关内容
  • C# Split 用法

    2018-11-22 22:51:54
    C# Split 用法
  • c语言实现字符串分割split(), 实现C语言实现按分隔符来截取字符串
  • important physics split step methood
  • fft radix-4, split radix
  • Split step fourier method
  • Java split方法详细讲解

    万次阅读 多人点赞 2020-12-25 18:37:03
    方法1:split(String regex) split()方法:分割字符串,参数regex称为分割符,可以使用正则表达式来表示 public String[] split(String regex) { return split(regex, 0); } 入门案例1 分割符可以是任意字母,...

    今天是圣诞节,我是中国人,无视圣诞节。
    文章可能有点长,看下来必定有所收获。
    没有学过正则表达式的去b站看,一个半小时应该可以看完,要看请点这里
    这是必备的前置技能,不懂得话没法真正明白split用法

    方法1:split(String regex)

    split()方法:分割字符串,参数regex称为分割符,可以使用正则表达式来表示

    public String[] split(String regex) {
        return split(regex, 0);
    }
    

    入门案例1

    分割符可以是任意字母,符号,数字,字符串等等,这个基本都会

        @Test
        public void splitDemo1(){
            String str= "1a2";
            String[] split = str.split("a");
            //split:{"1","2"}
            for (int i = 0; i < split.length; i++) {
                System.out.println(split[i]);
            }
        }
    

    运行结果

    1
    2
    

    注意:String类型是不可变的!分隔符会把字符串拆成若干个子字符串,然后生成一个String数组

    入门案例2

    分割符可以用正则表达式来表示

    @Test
    public void splitDemo2(){
        String str= "a33b444c555d";
        //正则表达式中\d+表示一个或多个数字,java中\\表示一个普通\
        //String[] split = str.split(Pattern.compile("\\d+").toString());
        //两种写法都是一样的,下面写法简洁
        String[] split = str.split("\\d+");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
    }
    

    运行结果

    a
    b
    c
    d
    

    入门案例3

    正则表达式篇中讲过,正则表达式中有一些特殊的字符,这些字符本身有特殊含义,加了\后表示仅匹配字符本身
    在这里插入图片描述
    java中两个反斜杠才表示一个\

    @Test
    public void splitDemo3(){
        String str= "aaa|bbb|ccc";
        //使用|作为分隔符,其余特殊字符同理
        String[] split = str.split("\\|");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
    }
    

    运行结果

    aaa
    bbb
    ccc
    

    入门案例4

    分隔符可以有多个,用|隔开,|分支结构:左右两边表达式之间"或"关系,匹配左边或者右边
    这是属于上篇的内容,这里复习一下。正则的语法规则可以在这里灵活运用

    @Test
    public void splitDemo4(){
        String str= "aaa,bbb#ccc";
        //使用,和#分割字符串
        String[] split = str.split(",|#");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
    }
    

    运行结果

    aaa
    bbb
    ccc
    

    分隔符三个特殊位置

    入门案例的分隔符都是在字符串中间,非常好切割,但是如果出现以下任意其一,该怎么分割?

    1.字符串开头有分隔符
    2.分隔符相互紧挨着
    3.字符串最尾部有分割符

    总结:
    字符串开头出现的分隔符将分隔出一个空字符串以及其余部分的正常分隔
    字符串最尾部出现的分隔符,末尾会分割出一个空字符串
    分隔符紧挨着,分隔符之间也会分割出一个空字符串

    特殊案例1

    分隔符紧挨着,分隔符之间也会分割出一个空字符串

    @Test
    public void demo(){
        String str= "19997";
        String[] split = str.split("9");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
    }
    

    两个9之间会分割出一个空字符串,所以会出现两个空字符串,前面的1和7正常分割
    在这里插入图片描述

    特殊案例2

    字符串开头出现的分隔符将分隔出一个空字符串以及其余部分的正常分隔
    字符串最尾部出现的分隔符,其余部分正常分隔,末尾会分割出一个空字符串

        @Test
        public void demo(){
            String str= "yky";
            String[] split = str.split("y");
            System.out.println(split.length);
            System.out.println(Arrays.toString(split));
        }
    

    运行结果:

    2
    [, k]
    //按照我们的结论,返回的数组应该是["",k,""]才对
    

    其实不是结论错了,而是参数limit的问题,接下来
    点进去split方法查看,发现调用的是另一个重载方法split(String regex, int limit)
    分割时末尾的字符串被丢弃了

    public String[] split(String regex) {
        return split(regex, 0);		
        //3.如果 n = 0,匹配到多少次就切割多少次,数组可以是任何长度,并且结尾空字符串将被丢弃。
    }
    

    方法2:split(String regex,int limit)

    public String[] split(String regex) {
        return split(regex, 0);
    }
    

    可以看出只填一个正则表达式的话,limit默认是0,regex表示正则表达式,limit参数控制分割的次数

    limit用法:

    1.如果 limit > 0,(从左到右)最多分割 n - 1 次,数组的长度将不会大于 n,结尾的空字符串不会丢弃

    2.如果 limit < 0,匹配到多少次就分割多少次,而且数组可以是任何长度。结尾的空字符串不会丢弃

    3.如果 limit = 0,匹配到多少次就分割多少次,数组可以是任何长度,并且结尾空字符串将被丢弃

    也就是说,使用split方法时,如果只填一个正则表达式,结尾空字符串将被丢弃

    看看源码大概怎么说的

           ArrayList<String> matchList = new ArrayList<>();
           //......
            int resultSize = matchList.size();
            if (limit == 0)
                while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
                    resultSize--;
    			String[] result = new String[resultSize];
    		//...
    

    先从ArrayList的长度开始遍历,如果发现是空字符串,则长度-1,该长度也等于字符串数组的长度

    进阶案例:

    limit>0限制分割次数

    1.如果 limit > 0,(从左到右)最多分割 limit - 1 次,数组的长度将不会大于limit,结尾的空字符串不会丢弃

    limit=1,分割0次,即不分割,将原字符串装进数组并返回

    limit如果太大超出了匹配次数,匹配到多少次就分割多少次

    String[] split = "abc".split("b",999);	//limit=999,但是b只匹配到一次,所以只能分割一次
    //split:{"a","c"}
    
    String[] split2 = "abc".split("b",1);	//不切割
    //split2:{"abc"}
    

    结尾的空字符串不会丢弃

        @Test
        public void demo1(){
            //limit=3,切割2次,末尾会分割出一个""空字符串
            String[] split = "abcb".split("b",3);
                System.out.println(split.length);	//数组长度是3
            //split:{"a","c",""}
        }
    

    limit<0不限制分割次数

    2.如果 limit < 0,匹配到多少次就分割多少次,而且数组可以是任何长度。结尾的空字符串不会丢弃
    在这里插入图片描述

    limit=0不限制分割次数

    这个是最常用的,要注意结尾的空字符串将会丢弃

    使用o取切割"boo:and:foo",分割后得到数组的长度是3,两个空字符串被丢弃
    在这里插入图片描述

    特殊案例3(字符串不包含分隔符)

    当字符串不包含分隔符时,返回数组只包含一个元素(该字符串本身)

    @Test
    public void demo2(){
        String str= "abcde";
        String[] split = str.split("f",-1);
        //split:{"abcde"}
        System.out.println(split.length);	//1
    }
    

    特殊案例4(字符串只含有分隔符本身)

    字符串只含有分隔符本身,这种切割没啥意义,但还是测试下吧

    切割出三个空字符串,开头结尾,相连的地方各一个空字符串
    在这里插入图片描述

    limit=0时,空字符会被丢弃,返回空数组,长度为0
    在这里插入图片描述

    无聊案例1(切割空字符串)

    经过测试,分隔符是空字符串""还是任意正则表达式,都会返回带空字符串的数组(空字符串也是字符串)
    在这里插入图片描述

    无聊案例2(分隔符是空字符串)

    这种切法非常奇怪,字符串的最末尾会分割出一个"",要去掉的话limit=0即可

    @Test
    public void demo2(){
        String str= "abc";
        String[] split = str.split("",-1);
        System.out.println(split.length);
    }
    

    练习

    截取自jdk源码,Regex分隔符,limit取值,Result截取后的数组

    字符串 “boo:and:foo”
    在这里插入图片描述
    能看懂说明split已经理解了

    知识补充:

    零宽断言(预搜索)

    split里还可以使用零宽断言(预搜索)

    @Test
    public void splitDemo(){
        //分割符是#,但是只要#后面跟123的那个#,其余#不要
        String str= "22222#123#2234";
        String[] split = str.split("#(?=123)");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
    }
    

    运行结果:

    22222
    123#2234
    

    字符边界^$

    split里还可以使用字符边界^$

    ^匹配行首,$匹配行尾,字符边界匹配时是零宽的,匹配的是位置

    @Test
    public void demo1(){
        //\r\n在window时回车+换行的意思
        String str = "#第一章\r\n#第二章";
        Pattern pattern =Pattern.compile("^#",Pattern.MULTILINE);
        String[] split = str.split(pattern.toString(),-1);
        //String[] split = str.split("^#",-1);
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
    }
    

    返回的字符串数组是{"",“第一章\r\n#第二章”}
    分隔符在行首会分割出一个空串"",其余部分正常分割。但是第二个#没有分割,这个出乎意料。

    Pattern pattern =Pattern.compile("^#",Pattern.MULTILINE);
    这个上篇正则表达式讲过,pattern 是正则表达式的编译形式,同时开启多行模式
    pattern.toString() 是正则表达式的字符串形式

    我猜想:问题一定出在pattern.toString(),既然是字符串形式

    Pattern pattern =Pattern.compile("^#",Pattern.MULTILINE);
    String[] split = str.split(pattern.toString(),-1);

    这两行代码我直接写成一行就行了String[] split = str.split("^#",-1);

    开启多行模式似乎不是用在这里的。我只想切割每行行首的#,其余的#不想切割,那怎么开启多行模式?

    我仔细想了一下,我上面用的都是String类的split方法,跟Pattern类的多行模式扯不上边啊。
    这么一想,有道理,去Pattern类看看有没有类似的方法
    在这里插入图片描述
    不光有,还有两。用法肯定是类似的,但是CharSequence是啥?没见过

    public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence {
    

    idea通过快捷键crtl + alt + B看接口的实现关系在这里插入图片描述
    我发现String类实现了这个CharSequence接口,那参数的意思是输入一个String字符串,而匹配规则已经写在Pattern类里了。

        @Test
        public void demo1(){
            Pattern pattern =Pattern.compile("^#",Pattern.MULTILINE);
            //\r\n在window时回车+换行的意思
            String str = "#第一章\r\n#第二章\r\n#第三章";
            String[] split = pattern.split(str, -1);
            System.out.println("数组的长度是:"+split.length);
            //split:{"","第一章","第二章","第三章"}
            for (int i = 0; i < split.length; i++) {
                System.out.print(split[i]);
            }
        }
    

    运行结果:

    数组的长度是:4
    第一章
    第二章
    第三章
    

    开启多行模式的确有效,数组第一个位置是空字符串,打印时不会打出来,那么是怎么判断行首行尾的位置?
    是按照空格,制表符,换行,回车判断的?所以我做了个实验
    字符串分别加了以\r,\n,\r\n,空格,\t
    再根据数组的长度,就知道分隔了多少次,从而知道判断行首的标准是什么。
    如果是4,意味着该字符用来判断行首行尾
    如果是2,说明只分隔了一次,字符串最前面分隔了一次

    @Test
    public void demo2(){
        Pattern pattern =Pattern.compile("^#",Pattern.MULTILINE);
        String str = "#第一章\r#第二章\r#第三章";
        String str2 = "#第一章\n#第二章\n#第三章";
        String str3 = "#第一章\r\n#第二章\r\n#第三章";
        String str4 = "#第一章 #第二章 #第三章";
        String str5 = "#第一章\t#第二章\t#第三章";
        String[] split = pattern.split(str, -1);
        String[] split2 = pattern.split(str2, -1);
        String[] split3 = pattern.split(str3, -1);
        String[] split4 = pattern.split(str4, -1);
        String[] split5 = pattern.split(str5, -1);
        System.out.println("str数组的长度是:"+split.length);
        System.out.println("str2数组的长度是:"+split2.length);
        System.out.println("str3数组的长度是:"+split2.length);
        System.out.println("str4数组的长度是:"+split4.length);
        System.out.println("str5数组的长度是:"+split5.length);
    
    }
    

    运行结果

    str数组的长度是:4
    str2数组的长度是:4
    str3数组的长度是:4
    str4数组的长度是:2
    str5数组的长度是:2
    

    结论:除了字符串开头是行首,\r,\n,\r\n后面都可以当成行首

    $表示匹配字符串结束的地方,开启多行模式后,每一行都相当于一个字符串

    \r,\n,\r\n前面,和字符串最末尾都可以当成行尾被匹配到

    @Test
    public void demo3(){
        Pattern pattern =Pattern.compile("章$",Pattern.MULTILINE);
        String str = "#第一章\r\n#第二章\r\n#第三章";
        String[] split = pattern.split(str, -1);
        System.out.println("数组的长度是:"+split.length);
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i]);
        }
    }
    

    运行结果

    数组的长度是:4
    #第一
    #第二
    #第三
    

    学以致用

    写这么多不是白写的,真正使用的地方到了,也是我研究正则表达式一天的目的:整理md文档

    读写文件用到io流,这里推荐hutool工具包,方便快捷,先导入依赖

    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.5.4</version>
    </dependency>
    

    代码:

        /**
         *
         * @param src  文件的来源
         * @param dest  文件目的地
         */
        public void mdTitleClean(String src,String dest){
            //默认UTF-8编码,可以在构造中传入第二个参数做为编码
            //输入流:将md文档一次性读进内存,返回一个String
            FileReader fileReader = new FileReader(src);
            String result = fileReader.readString();
    
            StringBuilder sb=new StringBuilder();
            //输出流,将字符串打印到文件中,该流使用完会自动关闭
            FileWriter writer = new FileWriter(dest);
    
            //md标题一共有6级,#空格后面写标题,我们想匹配到这个位置,所以是(?=(^#{1,6}\s+))
            Pattern p =Pattern.compile("^\\r?\\n(?=(^#{1,6}\\s+))",Pattern.MULTILINE);
            String[] split = p.split(result);
            for (int i = 0; i <split.length ; i++) {
                if (split[i].equals("")){
                    continue;
                }
                //先清除字符串前后的所有空格,空行,再加4个\r\n,相当于每个标题之间空三行
                sb.append(split[i].trim()).append("\r\n\r\n\r\n\r\n");
            }
            writer.write(sb.toString());
            System.out.println(sb.toString());
        }
    

    代码不难,只需要解释两行

    Pattern p =Pattern.compile("\r?\n(?=(#{1,6}\s+))",Pattern.MULTILINE);

    用到了前面讲的零宽断言字符边界
    在这里插入图片描述
    ^\r?\n表示字符串开头是换行符
    (?=(^#{1,6}\s+)) 表示匹配开头是# ,## ,### 的位置,即一级标题-六级标题
    最终的效果是以一级标题-六级标题前面的\r\n作为分隔符,把整个文档按照标题进行隔开。在这里插入图片描述
    sb.append(split[i].trim()).append("\r\n\r\n\r\n\r\n");

    隔开之后先清除前后空格,再拼接4个\r\n(统一格式),表示每个标题之间空三行

    最终效果图在这里插入图片描述
    以后写md文档就不用太关注格式了,写完用代码整理一下即可,注意在文档中使用#时,不要放在开头就行了。

    补充一点中文标点符号替换成英文的,要使用io流,记得导hutool工具包依赖

    /**
     * 英文标点符号替换成中文的
     *
     * @param str
     * @return
     */
    public String punctuationMarksAlter(String str) {
        str = str.replaceAll("(", "(")
                .replaceAll(")", ")")
                .replaceAll(";", ";")
                .replaceAll("'", "'")
                .replaceAll("'", "'")
                .replaceAll(""", "\"")
                .replaceAll(""", "\"")
                .replaceAll(":", ":")
                .replaceAll("?", "?")
                .replaceAll("[", "[")
                .replaceAll("]", "]")
                .replaceAll("!", "!")
                .replaceAll(".", ".")
                .replaceAll(",", ",");
        return str;
    }
    
    /**
     *
     * @param src  文件的来源
     * @param dest  文件目的地
     */
    public void mdClean(String src,String dest){
        //默认UTF-8编码,可以在构造中传入第二个参数做为编码
        FileReader fileReader = new FileReader(src);
        String result = fileReader.readString();
    
        StringBuilder sb=new StringBuilder();
        FileWriter writer = new FileWriter(dest);
    
        //md标题一共有6级,#空格后面写标题内容,我们想匹配到这个位置,所以是(?=(^#{1,6}\s+))
        Pattern p =Pattern.compile("^\\r?\\n(?=(^#{1,6}\\s+))",Pattern.MULTILINE);
        String[] split = p.split(result);
        for (int i = 0; i <split.length ; i++) {
            if (split[i].equals("")){
                continue;
            }
            //先清除字符串前后的所有空格,空行,再加4个\r\n,相当于每个标题之间空三行
            sb.append(split[i].trim()).append("\r\n\r\n\r\n\r\n");
        }
        //中文标点换成英文的
        String string = this.punctuationMarksAlter(sb.toString());
        writer.write(string);
    }
    

    逻辑可以自行完善
    如果把文档看成一个String字符串,那么就可以写java代码来自动整理md文档的格式了,而不用手动调格式,节约时间精力,更多的时间就可以花在学习上。

    split讲解到此为此,希望有所收获~
    上篇正则表达式的笔记我已经写好了,但是md图片粘贴在csdn上太麻烦,有时间再弄了。没有学过正则表达式的去b站看,一个半小时应该可以看完,要看请点这里

    从圣诞中午12点研究现在的时间是:2020年12月26日01:34:52,虽累也值得


    2020年12月28日19:34:21 开始学习jvm中篇[来自b站尚硅谷免费视频]
    自从学了正则表达式之后,可以很快速地替换文本
    比如下面是笔记的标题

    第十八章:Class文件结构
    
    01-JVM中篇内容概述
    
    02-字节码文件的跨平台性
    03-了解Java的前端编译器
    04-透过亨节码看代码执行细节举例1
    05-话过字节码看代码执行细节举例2
    06-透过字节码看代码执行细节举例3
    07-解读Class文件的三种方式
    08-Class文件本质和内部数据类型
    09-Class文件内部结构概述
    10-字节码数据保存到excel中的操作
    11-Class文件的标识:魔数
    12-Class文件版本号
    
    13-常量池概述
    14-常量池计数器
    15-常量池表中的字面量和符号引用
    16-解析得到常量池中所有的常量
    17-常量池表数据的解读1
    18-常量池表数据的解读2
    19-常量池表项数据的总结
    20-访问标识
    21-类索引、父类索引、接口索引集合
    22-字段表集合的整体理解
    23-字段表数据的解读
    24-方法表集合的整体理解
    25-方法表数据的解读
    26-屈性表集合的整理理解
    27-方法中Code属性的解读
    28-LineNumberTable和LocalVariableTable属性的解读
    29-SourceFile属性的解读
    30-Class文件结构的小结
    31-javac -g操作的说明
    32-javap主要参数的使用
    33-javap解析得到的文件结构的解读
    34-javap使用小结
    
    第十九章:字节码指令集与解析举例
    
    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-类模型与Class实例的位置
    66-链接之验证环节
    67-链接之准备环节
    68-链接之解析环节
    69-初始化过程与类初始化方法
    70-初始化阶段赋值与准备阶段赋值的对比
    71-类初始化方法clinit(的线程安全性
    72-何为类的主动使用和被动使用
    73-类的主动使用1
    74-类的主动使用2
    
    75-类的主动使用3
    76-类的主动使用4
    77-类的被动使用
    78-类的使用介绍
    79-类的卸载相关问题
    
    第二十一章:再谈类的加载器
    
    80-类加载器的概述
    81-命名空间与类的唯一性
    82-类的加载器的分类
    83-引导类加载器的说明
    84-扩展类加载器的说明
    85-系统类加载器的说明
    86-用户自定义类加载器的说明
    87-测试不同类使用的类加载器
    88-ClassLoader与Launcher的初步剖析
    89-ClassLoader的源码解析1
    90-ClassLoader的源码解析2
    91-ClassLoader子类的结构剖析
    
    91-ClassLoader子类的结构剖析
    92-双亲委派机制的优势与劣势
    93-三次双亲委派机制的破坏
    94-热替换的代码实现
    95-沙箱安全机制
    96-自定义类加载器的好处和应用场景
    97-自定义类加载器的代码实现
    98-Java9的新特性
    

    我们想要在每一行的前面加个#,意思是一级标题,就不用自己手动加了,使用正则表达式轻而易举的事
    在这里插入图片描述
    效果图
    在这里插入图片描述
    代码:用之前的代码随便改了下
    主要是正则表达式的匹配规则
    分隔符是(\r?\n)(?=[\d第])
    使用hutool工具包只是为了省几行代码,其实可以用传统io流,就不用导包了

    import cn.hutool.core.io.file.FileReader;
    import cn.hutool.core.io.file.FileWriter;
    import org.junit.Test;
    
    import java.util.Arrays;
    import java.util.Scanner;
    import java.util.regex.Pattern;
    
    public class Test2 {
        public static void main(String[] args) {
    //        String src ="D:\\太阳路\\正则表达式\\正则表达式.md";
            //String dest ="D:\\workspace\\jvm\\chapter05\\src\\main\\java\\c.md";
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入文件的全路径:");
            String src = scanner.next();
            System.out.println("请输入文件的保存路径:");
            String dest = scanner.next();
            new Test2().mdClean(src,dest);
        }
        /**
         * 英文标点符号替换成中文的
         *
         * @param str
         * @return
         */
        public String punctuationMarksAlter(String str) {
            str = str.replaceAll("(", "(")
                    .replaceAll(")", ")")
                    .replaceAll(";", ";")
                    .replaceAll("‘", "'")
                    .replaceAll("’", "'")
                    .replaceAll("“", "\"")
                    .replaceAll("”", "\"")
                    .replaceAll(":", ":")
                    .replaceAll("?", "?")
                    .replaceAll("【", "[")
                    .replaceAll("】", "]")
                    .replaceAll("!", "!")
                    .replaceAll(".", ".")
                    .replaceAll(",", ",");
            System.out.println("标点符号替换完毕");
            return str;
        }
    
        /**
         *
         * @param src  文件的来源
         * @param dest  文件目的地
         */
        public void mdClean(String src,String dest){
            //默认UTF-8编码,可以在构造中传入第二个参数做为编码
            //hutool工具包,读取文件到String中
            FileReader fileReader = new FileReader(src);
            String result = fileReader.readString();
    
            //输出流
            StringBuilder sb=new StringBuilder();
            FileWriter writer = new FileWriter(dest);
    
            //md标题一共有6级,#空格后面写标题内容,我们想匹配到这个位置,所以是(?=(^#{1,6}\s+))
    //            Pattern p =Pattern.compile("^\\r?\\n(?=(^#{1,6}\\s+))",Pattern.MULTILINE);
                Pattern p =Pattern.compile("(\\r?\\n)(?=[\\d第])",Pattern.MULTILINE);
            String[] split = p.split(result);
            for (int i = 0; i <split.length ; i++) {
                if (split[i].equals("")){
                    //如果是空字符串,什么都不处理
                    continue;
                }
                //先清除字符串前后的所有空格,空行,再加4个\r\n,相当于每个标题之间空三行
                if (i!=split.length-1){
                    sb.append("# ").append(split[i].trim()).append("\r\n\r\n\r\n\r\n");
                }else {
                    //文章最后一行不需要空空行
                    sb.append("# ").append(split[i].trim());
                }
            }
            System.out.println("文档标题的格式整理完毕!");
            //中文标点换成英文的
            String string = this.punctuationMarksAlter(sb.toString());
            writer.write(string);
        }
    }
    
    
    展开全文
  • c++split函数

    2013-02-08 07:00:43
    由于c++不含内置分割split,此文档包含c++spilt函数,和输出
  • void Stringsplit(const string& str, const char split, vector& res) { Stringsplit(str, string(1,split), res); // 调用上一个版本的Stringsplit() } 下面给出一个测试用例,我们分别使用单/双引号传入分割的...

    如:

    string str1 = "This is a test";
    string str2 = "This-is-a-test";
    string str2 = "This+is+a+test";
    

    我们如何将以上字符串按照某种分隔符( ,-,+),将其分割成四个子串,其值分别为 “This” “is” “a” “test” 。

    一、使用stringstream

    这里我们只需要用到 istringstream(字符串输入流) 构造字符串流,然后从字符串流中按照一定的格式读取数据即可。

    通常我们使用 cin 从流中读取数据,而我们也可以使用 getline 读取,而后者在读取时可以选择接受的数据格式,其函数原型如下:

    // istream & getline(char* buf, int bufSize);	// 读到 \n 为止
    istream & getline(char* buf, int bufSize, char delim); //读到 delim 字符为止
    				// \n 或 delim 都不会被读入 buf,但会被从文件输入流缓冲区中取走
    

     因此,我们可以按照此方式设计一个C++中的string split函数。

    void Stringsplit(string str,const const char split)
    {
    	istringstream iss(str);	// 输入流
    	string token;			// 接收缓冲区
    	while (getline(iss, token, split))	// 以split为分隔符
    	{
    		cout << token << endl; // 输出
    	}
    }
    

    如此,我们就设计出了我们的Stringsplit() 函数。该函数有以下 2 种语法格式

    void Stringsplit(string str,const const char split);
    // 默认将传入的字符串str以split为分隔符进行分割,并将得到的子串打印在屏幕上,无返回值
    void Stringsplit(string str, const const char split,vector<string>& rst);
    // 默认将传入的字符串str以split为分隔符进行分割,    不会将子串打印在屏幕上,无返回值
    // 					分割的子串将会保存在rst数组中被带出函数。
    

     以上,我们简单的设计了一种C++中的分割字符串的函数,下面来看一个测试用例:

    int main() {
    
    	string str("This is a test");
    	Stringsplit(str, ' ');		// 打印子串
    	
    	vector<string> strList;
    	string str2("This-is-a-test");
    	Stringsplit(str2, '-', strList);	// 将子串存放到strList中
    	for (auto s : strList)
    		cout << s << " ";
    	cout << endl;
    
    	return 0;
    }
    
    # 输出
    This
    is
    a
    test
    This is a test
    

    二、使用string类提供的find方法与substr方法

    find函数原型: 

    size_type find( const basic_string& str, size_type pos = 0 ) const;
    

    参数:
    str - 要搜索的 string , pos - 开始搜索的位置
    返回值
    找到的子串的首字符位置,或若找不到这种子串则为 npos 。

    substr函数原型: 

    basic_string substr( size_type pos = 0, size_type count = npos ) const;
    

    参数:
    pos - 要包含的首个字符的位置 ,count - 子串的长度
    返回值
    含子串 [pos, pos+count) 的 string 。

    由以上两个函数我们便可以设计出我们的Stringsplit()来。同时,因为find()函数查找的可以是字符串,因此我们的分隔符可以是单个的字符,也可以是一个字符串。 

    // 使用字符分割
    void Stringsplit(const string& str, const char split, vector<string>& res)
    {
    	if (str == "")		return;
    	//在字符串末尾也加入分隔符,方便截取最后一段
    	string strs = str + split;
    	size_t pos = strs.find(split);
    
    	// 若找不到内容则字符串搜索函数返回 npos
    	while (pos != strs.npos)
    	{
    		string temp = strs.substr(0, pos);
    		res.push_back(temp);
    		//去掉已分割的字符串,在剩下的字符串中进行分割
    		strs = strs.substr(pos + 1, strs.size());
    		pos = strs.find(split);
    	}
    }
    // 使用字符串分割
    void Stringsplit(const string& str, const string& splits, vector<string>& res)
    {
    	if (str == "")		return;
    	//在字符串末尾也加入分隔符,方便截取最后一段
    	string strs = str + splits;
    	size_t pos = strs.find(splits);
    	int step = splits.size();
    
    	// 若找不到内容则字符串搜索函数返回 npos
    	while (pos != strs.npos)
    	{
    		string temp = strs.substr(0, pos);
    		res.push_back(temp);
    		//去掉已分割的字符串,在剩下的字符串中进行分割
    		strs = strs.substr(pos + step, strs.size());
    		pos = strs.find(splits);
    	}
    }
    

    下面是一个测试用例:

    int main()
    {
    	vector<string> strList;
    	string str("This-is-a-test");
    	Stringsplit(str, '-', strList);
    	for (auto s : strList)
    		cout << s << " ";
    	cout << endl;
    
    	vector<string> strList2;
    	string str2("This%20is%20a%20test");
    	Stringsplit(str2, "%20", strList2);
    	for (auto s : strList2)
    		cout << s << " ";
    	cout << endl;
    	return 0;
    }
    
    # 输出
    This is a test
    This is a test
    

    三、使用C库函数strtok

    char* strtok( char* str, const char* delim );
    

    参数:
    str - 指向要记号化的空终止字节字符串的指针
    delim - 指向标识分隔符的空终止字节字符串的指针
    返回值:
    指向下个记号起始的指针,或若无更多记号则为空指针。

    需要注意的是,该函数使用一个全局的静态变量来保存每次分割后的位置,因此在多线程中是不安全的,这里我们也可以选择使用它的线程安全版本

     char *strtok_r(char *str, const char *delim, char **saveptr); 。
    void Stringsplit(const string& str, const string& split, vector<string>& res)
    {
    	char* strc = new char[str.size() + 1];
    	strcpy(strc, str.c_str());   // 将str拷贝到 char类型的strc中
    	char* temp = strtok(strc, split.c_str());
    	while (temp != NULL)
    	{
    		res.push_back(string(temp));		
    		temp = strtok(NULL, split.c_str());	// 下一个被分割的串
    	}
    	delete[] strc;
    }
    

    如此,我们的使用 strtok 版本的Stringsplit() 就完成了。不过,我们使用这种方法实现的字符串分割函数只能根据字符来分割,而我们传入的参数是字符串类型,这样可能会对函数的使用这造成误导(注:参数传入字符串用的双引号,传入字符用的单引号),因此我们也可以使用下面的方法封装一个参数是字符类型的函数。

    void Stringsplit(const string& str, const char split, vector<string>& res)
    {
    	Stringsplit(str, string(1,split), res);	// 调用上一个版本的Stringsplit()
    }
    

     下面给出一个测试用例,我们分别使用单/双引号传入分割的限定字符。

    int main()
    {
    	vector<string> strList;
    	string str("This+is+a+test");
    	Stringsplit(str, '+', strList);
    	for (auto s : strList)
    		cout << s << " ";
    	cout << endl;
    
    	vector<string> strList2;
    	string str2("This-is-a-test");
    	Stringsplit(str2, "-", strList2);
    	for (auto s : strList2)
    		cout << s << " ";
    	cout << endl;
    
    
    	return 0;
    }
    

    四、使用regex_token_iterator(正则表达式)

    正则表达式(regular expression)描述了一种字符串匹配的模式(pattern),可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。 

    而在C++的正则中,把这种操作称为Tokenize分词(或者叫切割)。这种操作刚好可以满足我们的需求,用模板类regex_token_iterator<>提供分词迭代器,可以完成字符串的分割。

    void Stringsplit(const string& str, const string& split, vector<string>& res)
    {
    	//std::regex ws_re("\\s+"); // 正则表达式,匹配空格 
    	std::regex reg(split);		// 匹配split
    	std::sregex_token_iterator pos(str.begin(), str.end(), reg, -1);
    	decltype(pos) end;              // 自动推导类型 
    	for (; pos != end; ++pos)
    	{
    		res.push_back(pos->str());
    	}
    }
    

    测试用例:

    int main()
    {
    	// 单个字符分词
    	vector<string> strList;
    	string str("This is a test");
    	Stringsplit(str," ", strList);
    	for (auto s : strList)
    		cout << s << " ";
    	cout << endl;
    
    	// 使用字符串分词
    	vector<string> strList2;
    	string str2("ThisABCisABCaABCtest");
    	Stringsplit(str2, "ABC", strList2);
    	for (auto s : strList2)
    		cout << s << " ";
    	cout << endl;
    }
    
    # 输出
    This is a test
    This is a test
    

     

    展开全文
  • mysql split函数用法实例

    千次阅读 2021-01-19 00:22:16
    首先,大家要知道的是,在mysql中并没有split函数,需要自己写。比如下面几个mysql split函数的例子。例1,获得按指定字符分割的字符串的个数:复制代码 代码示例:DELIMITER $$DROP FUNCTION IF EXISTS `sims`.`func...

    首先,大家要知道的是,在mysql中并没有split函数,需要自己写。

    比如下面几个mysql split函数的例子。

    例1,获得按指定字符分割的字符串的个数:

    复制代码 代码示例:

    DELIMITER $$

    DROP FUNCTION IF EXISTS `sims`.`func_get_split_string_total`$$

    CREATE DEFINER=`root`@`localhost` FUNCTION `func_get_split_string_total`(

    f_string varchar(1000),f_delimiter varchar(5)

    ) RETURNS int(11)

    BEGIN

    declare returnInt int(11);

    if length(f_delimiter)=2  then

    return 1+(length(f_string) - length(replace(f_string,f_delimiter,'')))/2;

    else

    return 1+(length(f_string) - length(replace(f_string,f_delimiter,'')));

    end if;

    END$$

    DELIMITER ;

    调用:

    func_get_split_string_total('abc||def||gh','||')

    结果为3

    例2,得到第i个分割后的字符串。

    复制代码 代码示例:

    DELIMITER $$

    DROP FUNCTION IF EXISTS `sims`.`func_get_split_string`$$

    CREATE DEFINER=`root`@`localhost` FUNCTION `func_get_split_string`(

    f_string varchar(1000),f_delimiter varchar(5),f_order int) RETURNS varchar(255) CHARSET utf8

    BEGIN

    declare result varchar(255) default '';

    set result = reverse(substring_index(reverse(substring_index(f_string,f_delimiter,f_order)),f_delimiter,1));

    return result;

    END$$

    DELIMITER ;

    调用:func_get_split_string('abc||def||gh','||',2)

    结果为def

    例3,需求:A表中的一个字段值为1||2, 在select 时要通过和B字典表的关联得到a,b

    复制代码 代码示例:

    CREATE DEFINER=`root`@`localhost` FUNCTION `getDictName`(v_str varchar(100)) RETURNS varchar(100) CHARSET utf8

    BEGIN

    DECLARE i int(4);

    DECLARE dictCode varchar(100);

    DECLARE dictName varchar(100);

    DECLARE returnStr varchar(100);

    set i = 1;

    set returnStr = '';

    if(v_str is null or length(v_str)=0) then

    return returnStr;

    else

    while i<=func_get_split_string_total(v_str,'||')

    do

    set dictCode = func_get_split_string(v_str,'||',i);

    select names into dictName from sims_dd_dict where code = dictCode;

    set returnStr = concat(returnStr,',',dictName);  -- 这里要用中文的逗号,否则导出EXCEL的时候会串行,因为程序中是以逗号分隔的

    set i = i+1;  ---//(脚本学堂 www.jbxue.com 编辑整理)

    end while;

    set returnStr = subString(returnStr,2);

    return returnStr;

    end if;

    END$$

    在mysql数据库中使用split,有时要考虑接收返回值的问题,下面来看两个例子。

    例1,mysql使用split接收返回值。

    复制代码 代码示例:

    DELIMITER $$;

    DROP FUNCTION IF EXISTS `func_getSplitCount`$$

    CREATE FUNCTION `func_getSplitCount`(

    f_string varchar(1000),f_delimit varchar(5)

    ) RETURNS int(11)

    BEGIN

    return 1+(length(f_string) - length(replace(f_string,f_delimit,'')));

    END$$

    DELIMITER ;$$

    DELIMITER $$;    DROP FUNCTION IF EXISTS `func_getSplitCount`$$    CREATE FUNCTION `func_getSplitCount`(   f_string varchar(1000),f_delimit varchar(5)  ) RETURNS int(11)  BEGIN   return 1+(length(f_string) - length(replace(f_string,f_delimit,'')));  END$$    DELIMITER ;$$

    例2:

    复制代码 代码示例:

    DELIMITER $$;

    DROP FUNCTION IF EXISTS `func_getSplitString`$$

    CREATE FUNCTION `func_getSplitString`(

    f_string varchar(1000),f_delimit varchar(5),f_order int

    ) RETURNS varchar(255)

    BEGIN

    declare result varchar(255) default '';

    set result = reverse(substring_index(reverse(substring_index(f_string,f_delimit,f_order)),f_delimit,1));

    return result;

    END$$

    DELIMITER ;$$

    DELIMITER $$;    DROP FUNCTION IF EXISTS `func_getSplitString`$$    CREATE FUNCTION `func_getSplitString`(   f_string varchar(1000),f_delimit varchar(5),f_order int  ) RETURNS varchar(255)  BEGIN    declare result varchar(255) default '';    set result = reverse(substring_index(reverse(substring_index(f_string,f_delimit,f_order)),f_delimit,1));    return result;  END$$    DELIMITER ;$$

    参考文档:mysql实现字符串分割SPLIT函数的四种方法

    最后,通过几个例子,仔细体会下mysql中split函数的实现与用法。

    先设置:SET GLOBAL log_bin_trust_function_creators = 1;

    1,函数func_splitStringTotal:将字符串按指定方式分割,并计算单元总数

    代码:

    复制代码 代码示例:

    DELIMITER $$

    CREATE FUNCTION `func_get_splitStringTotal`(

    f_string varchar(10000),f_delimiter varchar(50)

    ) RETURNS int(11)

    BEGIN

    return 1+(length(f_string) - length(replace(f_string,f_delimiter,'')));

    END$$

    DELIMITER ;

    2,函数func_splitString:将字符串按指定方式分割,获取指定位置的数

    代码:

    复制代码 代码示例:

    DELIMITER $$

    DROP function IF EXISTS `func_splitString` $$

    CREATE FUNCTION `func_splitString`

    ( f_string varchar(1000),f_delimiter varchar(5),f_order int)

    RETURNS varchar(255) CHARSET utf8

    BEGIN

    declare result varchar(255) default '';

    set result = reverse(substring_index(reverse(substring_index(f_string,f_delimiter,f_order)),f_delimiter,1));

    return result;

    END$$

    SELECT func_splitString('1,2,3,4,5,6,7',',',1);

    3,过程splitString 将字符串分割,并放到临时表tmp_split中

    代码:

    复制代码 代码示例:

    DELIMITER $$

    DROP PROCEDURE IF EXISTS `splitString` $$

    CREATE PROCEDURE `splitString`

    (IN f_string varchar(1000),IN f_delimiter varchar(5))

    BEGIN

    declare cnt int default 0;

    declare i int default 0;

    set cnt = func_split_TotalLength(f_string,f_delimiter);

    DROP TABLE IF EXISTS `tmp_split`;

    create temporary table `tmp_split` (`val_` varchar(128) not null) DEFAULT CHARSET=utf8;

    while i < cnt

    do

    set i = i + 1;

    insert into tmp_split(`val_`) values (func_split(f_string,f_delimiter,i));

    end while;

    END$$

    call splitString('a,s,d,f,g,h,j',',');

    SELECT * from tmp_split;

    更多有关mysql split函数的用法,请参考:在mysql中实现split函数的几种方法 。

    就介绍这些吧,希望借助以上的例子,大家可以实现更好的mysql split函数,也欢迎分享更多的精彩实例。

    展开全文
  • C++中string如何实现字符串分割函数split()

    万次阅读 多人点赞 2020-12-17 15:25:32
    void Stringsplit(const string& str, const char split, vector<string>& res) { Stringsplit(str, string(1,split), res); // 调用上一个版本的Stringsplit() } 下面给出一个测试用例,我们分别使用单/双引号...
  • C# vs2010 实现SplitContainer(上下左右)隐藏与显示 通过设置不同的Panel 项目源代码
  • java split 两个参数(java split 空格)

    千次阅读 2021-03-07 10:16:49
    负数表示最大值再用split将第一行 第二行分别做一个链表然后就是如何进行差异比较(string巴菲特复利倍增名言String a = "abcd"; String[] b = a.split(""); for(int i=0;i:实用|连接多个分隔符。例如用;和空格...
  • :没用理解按大小分割的意思,大概是按指定长度分割吧?比较直接的方法:# 比如7个字符分割c =7 s ...python中的split()不带任何参数是个很好用的特性:忽略具体的空格数来分割字符串。请看一下代码:handle_string ...
  • split用法详解

    千次阅读 2022-05-13 09:37:39
    split() 方法根据匹配给定的正则表达式来拆分字符串。 注意: . 、 $、 | 和 * 等转义字符,必须得加 \\。 注意:多个分隔符,可以用 | 作为连字符。 语法: public String[] split(String regex, int limit) ...
  • split_step_fourier_method_split_split-stepfourier_opticalfiber_分布傅里叶_分布傅里叶算法_源码.zip
  • CAN SPLIT功能作用和SPLIT电容作用

    千次阅读 2022-02-25 10:18:08
    1、CAN总线显隐电平定义 CAN2.0B规范定义: ...(1)如下图示为CAN芯片SPLIT管脚内部原理,在CAN芯片为normal模式时,SPLIT的电压为0.5VCC,能够为CAN总线2.5V的共模电压; (2)减少EME(电磁辐射),为DC电.
  • If you've ever used JavaScript's split method, there's a good chance that you've encountered the following error: TypeError: Cannot read property 'split' of undefined.如果你曾经使用过 JavaScript 的 ...
  • python中split()和split(' ')的区别

    千次阅读 2021-04-27 01:17:43
    总结:split()的时候,多个空格当成一个空格;split(‘ ‘)的时候,多个空格也要分割,会分割出来空。例1:牛客网:牛客最近来了一个新员工Fish,每天早晨总是会拿着一本英文杂志,写些句子在本子上。同事Cat对Fish...
  • Linux之split命令详解

    千次阅读 2021-05-14 17:16:16
    Linux split命令用于将一个文件分割成数个,该指令将大文件分割成较小的文件,在默认情况下将按照每1000行切割成一个小文件,其基本语法是split [--help][--version][-][-b ][-C ][-l ][要切割的文件][输出文件名]。...
  • 最近在学python,发现有一个split()分割的小问题,因而记录一下。 搜了一下大家的回答大多是:split()会按照字符中间的空格进行分割,多个空格当成一个空格进行分割。split(' ')会把字符中间的多个空格当成多个空格...
  • flutter Android CPU包构建命令 --split-per-abi

    千次阅读 多人点赞 2022-01-11 16:49:31
    : flutter create flutter_abi 找到创建好的flutter工程下对应的安卓工程目录下的build.gradle进行配置基于不同的abi架构 flutter build apk --split-per-abi 执行命令打开编译后存储安装包的目录 (包括各种CPU架构...
  • str.split和re.split中空格的区别

    千次阅读 2020-12-17 19:45:07
    一、str.split和re.split的基本用法1、str.spli的基本用法现用下面的文件:1 maqing:abc123我们要建立一个用户名和用户密码的匹配关系:1 with open("test.txt","r") as file:2 list =file.readlines()3 for line ...
  • java中split用法

    千次阅读 2020-11-29 15:54:37
    Java中的我们可以利用split把字符串按照指定的分割符进行分割,然后返回字符串数组,下面是string.split的用法实例及注意事项: java.lang.string.split split 方法 将一个字符串分割为子字符串,然后将结果作为字符...
  • mysql中split函数

    千次阅读 2021-02-05 14:26:51
    在mysql中并没有split函数,需要自己写:1)获得按指定字符分割的字符串的个数:DELIMITER $$DROP FUNCTION IF EXISTS `sims`.`func_get_split_string_total`$$CREATE DEFINER=`root`@`localhost` FUNCTION `func_get...
  • Linux命令之分割文件split

    千次阅读 2022-05-24 15:48:32
    `split` 命令可以用于切割文件,将大文件切割成几个小文件。
  • SQL Server中的STRING_SPLIT函数

    千次阅读 2020-07-15 11:23:50
    This article will cover the STRING_SPLIT function in SQL Server including an overview and detailed usage examples. 本文将介绍SQL Server中的STRING_SPLIT函数,包括概述和详细的用法示例。 SQL ...
  • Linux命令之文件分割split命令

    万次阅读 2022-01-26 15:31:12
    一、split命令简介   Linux split命令用于将一个文件分割成数个。该指令将大文件分割成较小的文件,在默认情况下将按照每1000行切割成一个小文件。默认前缀为“x”。没有输入,或者当输入为-,则读取标准输入。 二...
  • JAVA中split函数的用法

    千次阅读 2022-04-18 15:39:58
    JAVA中split函数的用法 只写经常使用的,并不完整。 1.基本用法,将字符串按照指定字符串进行分割,例如: public class Main { public static void main(String[] args) { String ss = "abcabcdefg"; String[] ...
  • hbase split操作

    千次阅读 2018-11-07 14:39:57
    HBase - 解析split操作 split操作:意义 HBase数据写入首先会写入缓存,缓存写满会执行一次flush操作,每次flush都会生成一个HFile文件。随着HFile的增多,文件的读取效率势必会降低,HBase采用compact机制不断的对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,438,989
精华内容 575,595
关键字:

Split()

友情链接: JSwebgame.rar