13字符串-Java编程思想

比眉伴天荒 2022-09-26 01:56 204阅读 0赞

有意思的地方：在idea中，输入sout,再按tab就可以出现输出打印的一行代码。

psvm,再按tab即可出现public static void main

运行时候按键control，shift，r。

当运行的代码需要额外的输入args的时候，在run/edit configurations/program arguments中编辑即可。

字符串操作是程序中最常见的行为。

String对象是不可变的，看起来在修改对象的实际上都是创建了一个全新的对象。对象具有可读性。

重载操作符：操作符在用于特定的类的时候，被赋予特殊的意思。String的+，+=是java中仅有的重载操作符，java不允许程序员重载操作符。

**关于String，StringBuffer，StringBuilder**

String是定长的，是不可变对象，每次对String对象进行改变长度的操作实际都是生成了新的对象。对StringBuilder与StringBuffer对象的操作都是针对其自身，在字符串对象会经常改变的情况下使用这两个比较好。StringBuffer是线程安全的，而StringBuilder是非线程安全的，所以StringBuilder要快一些。StringBuilder是javaSE5引入的。

●对于“+”，se5以前是对于String创建三个对象，se5以后jvm进行了优化，编译器调用了StringBuilder。

代码段：

public static void main(String[] args){
    
    String mango="mango";
    
    String s="abc"+mango+""def"+47;
    
    }

如果是为一个类编写toString()，字符串操作比较简单就可以依赖编译器。如果在toString()方法中使用了循环，那么最好自己创建StringBuilder对象来构造最终的结果。

public class StringBuilderTest {
        public static Random random=new Random(47);
        @Override
        public String toString() {
            StringBuilder result=new StringBuilder("[");
            for(int i=0;i<25;i++  ){
                result.append(random.nextInt(100));
                result.append(", ");
            }
            result.delete(result.length() -2, result.length());
            result.append("]");
            return result.toString();
        }
        public static void main(String[] args) {
            StringBuilderTest stringBuilderTest=new StringBuilderTest();
            System.out.println(stringBuilderTest);
        }
    }

//结果：\[58, 55, 93, 61, 61, 29, 68, 0, 22, 7, 88, 28, 51, 89, 9, 78, 98, 61, 20, 58, 16, 40, 11, 22, 4\]

容器类都有覆写toString()方法，例如ArrayList().toString()方法遍历ArrayList所有对象，调用每个元素的toString()方法。

String上的操作：length（）字符个数，charAt(Int)取得该索引位置上的char，toCharArray()把String字符生成char\[\]，equals(String)比较两个String是否相同，compareTo(String)按字典顺序比较String内容（比较结果为负数0或正数，大小写不同），contains(String)如果String中包括参数的内容就返回true，startsWith()、endsWith()判断是否是以某参数为开头或结尾的，indexOf（）判断String是否包含该参数，没有就返回-1。

当需要改变字符串内容的时候，String方法会返回一个新的Stirng对象。如果内容没有发生改变，String方法知识返回原对象的引用而已。

### 格式化输出 ###

对输出格式和排练提供更大的控制能力。

printf("Row 1: \[%d %f\]\\n",x,y);不仅仅说明了插入数据的位置，还说明了变量类型。%d表示x是一个整数，%f表示y是浮点数。

javaSE5引入的format方法实际等价于printf方法。format方法作用于PrintStream,PrintWrite方法,其中包括System.out方法。

//Old way
    System.out.print("Row 1: ["+i+" x "+j+" ]\n");
    //printf way
    System.out.printf("Row 1: [%d x %f]\n",i,j);
    //format way
    System.out.format("Row 1: [%d x %f]\n",i,j);
    //Row 1: [10 x 1.000000]

java中所有格式化的功能由java.util.Formatter类处理，Formatter一个翻译器，把格式化字符串和数据翻译。创建Formatter对象的时候，向构造器传递一些信息，告诉最终结果输出到哪里。最常用的是PrintStream(),OutputStream,File。这个地方需要领悟的是，更高级的格式化输出查看Formatter部分。对于更加精细的控制，例如控制对齐方式，尺寸大小等参考Java编程思想原书。

String.format()是一个static方法，它接受Formatter.format()方法一样的参数，返回String方法，实际上这种方式非常方便。

String s="wan";
    
            int a=1,b=2;
    
            System.out.println(String.format("(t%d,q%d) %s",a,b,s));

**正则表达式**

强大而灵活的文本处理工具。用编程的方式构造复杂的文本模式，并对输入的字符串进行搜索，一旦搜索到匹配到的部分，就可以随心所欲的进行处理。正则表达式提供了完全通用的方式，能解决各类字符串处理相关的问题：匹配，选择，编辑，验证。

public class StringMatch1Test {
        //正则表达式,简单的String.matches方法
        public static void main(String args[]){
            System.out.println("-1234".matches("-?\\d+"));
            System.out.println("5678".matches("-?\\d+"));
            System.out.println("+911".matches("-?\\d+"));
            System.out.println("+911".matches("(-?|\\+)\\d+"));
            //true true false true
        }
    }

public class StringMatch2Test {
        //正则表达式,split方法
        public static String s="helln, i am here learning javn,i love java so much,and i enjoy play with datn.";
        public static void spilt(String regex){
            System.out.println(Arrays.toString(s.split(regex)));
        }
        public static void main(String args[]){
            spilt(" ");//以空格为划分
            spilt("\\W+");//以非单词字符划分
            spilt("n\\W+");//
            spilt("i");
            //下面的方法是为了证明说split后的形式
            String[] strings="i want to study java.".split(" ");
            for (String s:strings
                 ) {
                System.out.println(s);
            }
    
        }
    }
    [helln,, i, am, here, learning, javn,i, love, java, so, much,and, i, enjoy, play, with, datn.]
    [helln, i, am, here, learning, javn, i, love, java, so, much, and, i, enjoy, play, with, datn]
    [hell, i am here learning jav, i love java so much,and i enjoy play with dat]
    [helln, ,  am here learn, ng javn,,  love java so much,and ,  enjoy play w, th datn.]
    
    i
    want
    to
    study
    java.

关于替代：

public class StringReplace {
        //替代
        private static String s="i love java , and i love being a pm , i enjoy my life";
        public static void main(String args[]){
            System.out.println(s.replaceFirst("o\\w+","oo"));
            //i loo java , and i love being a pm , i enjoy my life
            System.out.println(s.replaceAll("i|my","wanpro"));
            //wanpro love java , and wanpro love bewanprong a pm , wanpro enjoy wanpro lwanprofe
            System.out.println(s.replaceAll("i\\W+","wanpro "));
            //wanpro love java , and wanpro love being a pm , wanpro enjoy my life
        }
    }

public class StringMatch3Test {
        public static void main(String args[]){
            String[] strings={"Rudolph","[rR]udolph","[rR][aeiou][a-z]ol.*","R.*"};
            for (String s:strings
                 ) {
                System.out.println("Rudolph".matches(s));
            }
        }
    }
    //true true true true
     
    Pattern和Matcher

先生存一个Pattern对象，然后把需要检索的内容传入matcher方法创建出Matcher的对象。

该程序在300页.在测试自己写的正则表达式是否具有匹配功能时候有用

pattern对象表示编译后的正则表达式，我们用已经编译的pattern对象的matcher方法加上一个字符串，共同创建了一个Matcher对象。

public class StringRegularExpression {
        public static void main(String args[]){
            if (args.length<2){
                System.out.print("Usage:\njava TestRegularExpression");
                System.exit(0);
            }
            //下面用到了转义符
            System.out.println("Input: \""+args[0]+"\"");
            for (String arg:args
                 ) {
                System.out.println("Regular Expression : \""+arg+" \"");
                Pattern p=Pattern.compile(arg);<span style="font-family: Menlo; font-size: 9pt;">//**********************************
    </span>            Matcher m=p.matcher(args[0]);<span style="font-family: Menlo; font-size: 9pt;">//**********************************</span>
                while(m.find()){
                    System.out.println("Match \""+m.group()+"\" at positons "+m.start()+"-"+(m.end()-1));
                }
            }
        }
    }Input: "abcabcabcabcdefabc"
    Regular Expression : "abcabcabcabcdefabc "
    Match "abcabcabcabcdefabc" at positons 0-17
    Regular Expression : "abc+ "
    Match "abc" at positons 0-2
    Match "abc" at positons 3-5
    Match "abc" at positons 6-8
    Match "abc" at positons 9-11
    Match "abc" at positons 15-17
    Regular Expression : "(abc)+ "
    Match "abcabcabcabc" at positons 0-11
    Match "abc" at positons 15-17
    Regular Expression : "(abc){2,} "
    Match "abcabcabcabc" at positons 0-11

public class StringRegular2Expression {
        public static void main(String[] args) {
            Matcher m= Pattern.compile("\\w+").matcher("wanpro want data");
            while(m.find()){
                System.out.print(m.group()+" ");
            }
            int i=0;
            System.out.println();
            while(m.find(i)){
                System.out.print(m.group()+" ");
                i++;
            }
        }
    }
    //wanpro want data 
    //wanpro anpro npro pro ro o want want ant nt t data data ata ta a

前面的\\\\w+将字符串划分为单词，find()像迭代器一样遍历输入的字符串。第二个find能指定接收整数作为参数，该整数作为字符串中字符的位置，作为搜索的起点。