第十三章字符串

桃扇骨 2022-12-12 13:53 170阅读 0赞

### 文章目录 ###

*   *   *   *   *  1.不可变String
                 *  2.重载"+"与StringBuilder
                 *  3.无意识的递归
                 *  4.String上的操作
                 *  5.格式化输出
                 *   *  Formatter转换
                 *  6.正则表达式
                 *   *  基础
                     *  创建正则表达式
                     *  量词
                     *  Pattern和Matcher
                 *  7.扫描输入
                 *   *  Scanner定界符
                     *  用正则表达式扫描

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpYW5jNjY2_size_16_color_FFFFFF_t_70_pic_center]

##### 1.不可变String #####

1.  String对象是不可变的,字符串对象作为方法的参数传递时,实际传递的是引用的一个拷贝.该引用所指的对象其实一直待在单一的物理位置上,从未动过
2.  给String对象赋值本质上是改变该String对象引用的指向

##### 2.重载"+"与StringBuilder #####

1.  因为String对象具有只读特性,所以指向它的任何引用都不可能改变它的值
2.  不可变性会带来一定的效率问题,为String对象重载的"+"操作符就是一个例子
3.  String的"+"操作经过编译器优化后是利用的StringBuilder对字符串进行拼接,性能不如直接使用StringBuilder拼接字符串要好
4.  StringBuffer是线程安全的

##### 3.无意识的递归 #####

1.  想打印对象的内存地址,在toString()方法中不能使用this关键字的返回字符串,this关键字会转换为String对象,从而递归调用toString()方法,会抛出异常.
2.  解决方案: 使用super.toString()方法打印内存地址.这里的super父类是Object类.

##### 4.String上的操作 #####

<table> 
 <thead> 
  <tr> 
   <th align="center"><strong>方法</strong></th> 
   <th align="left"><strong>参数,重载版本</strong></th> 
   <th align="left"><strong>应用</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">构造器</td> 
   <td align="left">重载版本:默认版本,String,StringBuilder,StringBuffer,char数组,byte数组</td> 
   <td align="left">创建String对象</td> 
  </tr> 
  <tr> 
   <td align="center">length()</td> 
   <td align="left"></td> 
   <td align="left">String中字符的个数</td> 
  </tr> 
  <tr> 
   <td align="center">charAt()</td> 
   <td align="left">Int索引</td> 
   <td align="left">取得String中该索引位置上的char</td> 
  </tr> 
  <tr> 
   <td align="center">getChars(),getBytes()</td> 
   <td align="left">要复制的部分的起点和终点的索引,复制的目标数组,目标数组的起始索引</td> 
   <td align="left">复制char或byte到一个目标数组中</td> 
  </tr> 
  <tr> 
   <td align="center">toCharArray()</td> 
   <td align="left"></td> 
   <td align="left">生成一个char[],包含String的所有字符</td> 
  </tr> 
  <tr> 
   <td align="center">equals(),equalsIgnoreCase()</td> 
   <td align="left">与之进行比较的String</td> 
   <td align="left">比较两个String的内容是否相同</td> 
  </tr> 
  <tr> 
   <td align="center">compareTo</td> 
   <td align="left">与之进行比较的String</td> 
   <td align="left">按词典顺序比较String的内容,比较结果为负数,零或正数.注意,大小写并不等价</td> 
  </tr> 
  <tr> 
   <td align="center">contains</td> 
   <td align="left"></td> 
   <td align="left">如果该String对象包含参数的内容，则返回true</td> 
  </tr> 
  <tr> 
   <td align="center">contentEquals()</td> 
   <td align="left">与之比较的CharSequence或StringBuffer</td> 
   <td align="left">如果该String与参数的内容完全一致,则返回true（StringBuffer对象和String对象返回false！）</td> 
  </tr> 
  <tr> 
   <td align="center">equalsIgnoreCase()</td> 
   <td align="left">与之进行比较的String</td> 
   <td align="left">忽略大小写,如果两个String的内容相同,则返回true</td> 
  </tr> 
  <tr> 
   <td align="center">regionMatcher()</td> 
   <td align="left">该String的索引偏移量,另一个String及其索引偏移量,要比较的长度.重载版本增加了"忽略大小写"功能</td> 
   <td align="left">返回boolean结果,以表明所比较区域是否相等</td> 
  </tr> 
  <tr> 
   <td align="center">startsWith()</td> 
   <td align="left">可能的起始String.重载版本在参数中增加了偏移量</td> 
   <td align="left">返回boolean结果,以表明String是否以此参数起始</td> 
  </tr> 
  <tr> 
   <td align="center">endsWith()</td> 
   <td align="left">该String可能的后缀String</td> 
   <td align="left">返回boolean结果,以表明此参数在String中的起始索引.lastIndexOf()是从后向前搜索</td> 
  </tr> 
  <tr> 
   <td align="center">indexOf(),lastIndexOf()</td> 
   <td align="left">重载版本包括:char,char与起始索引,String,String与起始索引</td> 
   <td align="left">如果该String并不包含此参数,就返回-1;否则返回此参数在String中起始的索引.lastIndexOf()是从后向前搜索</td> 
  </tr> 
  <tr> 
   <td align="center">substring(subSequence())</td> 
   <td align="left">重载版本:起始索引;起始索引+终点坐标</td> 
   <td align="left">返回一个新的String,以包含参数指定的子字符串</td> 
  </tr> 
  <tr> 
   <td align="center">concat()</td> 
   <td align="left">要连接的String</td> 
   <td align="left">返回一个新的String对象,内容为起始Stirng连接上参数String</td> 
  </tr> 
  <tr> 
   <td align="center">replace()</td> 
   <td align="left">要替换掉的字符,用来进行替换的新字符,也可以用一个CharSequence来转换另一个CharSequence</td> 
   <td align="left">返回替换字符后的新String对象.如果没有替换发生,则返回原始的String对象</td> 
  </tr> 
  <tr> 
   <td align="center">toLowerCase,toUpperCase()</td> 
   <td align="left"></td> 
   <td align="left">将字符的大小写改变后,返回一个新String对象.如果没有发生改变,则返回原始的String对象</td> 
  </tr> 
  <tr> 
   <td align="center">trim()</td> 
   <td align="left"></td> 
   <td align="left">将String两端的空白字符删除后,返回一个新的String对象.如果没有改变发生,则返回原始的String对象</td> 
  </tr> 
  <tr> 
   <td align="center">valueOf()</td> 
   <td align="left">重载版本:Object;char[];char[],偏移量,字符个数; boolean; char; int; long; float; double</td> 
   <td align="left">返回一个表示参数内容的String</td> 
  </tr> 
  <tr> 
   <td align="center">intern()</td> 
   <td align="left"></td> 
   <td align="left">为每个唯一的字符序列生成一个且仅生成一个String引用</td> 
  </tr> 
 </tbody> 
</table>

##### 5.格式化输出 #####

1.  pringtf()：C语言中的格式修饰符
2.  System.outformate()：System.out.format()可以用于PrintStream或PrintWriter对象,其中包括System.out对象.
3.  Formatter类：Formatter类可以将格式化字符串与数据翻译成需要的结果.
4.  格式化说明符

*  Formatter类格式化抽象语法: %\[argument\_index\]\[flags\]\[width\]\[.precision\]conversion
    
    i.用"-“标志来改变对齐方向(默认右对齐),添加了”-"表示左对齐  
    ii.width: 控制一个域的最小尺寸,  
    iii.precision: 用来指明最大尺寸,用于String时,它表示打印String时输出字符的最大数量.用于浮点数时,表示小数显示的位数(默认6位),小数过多则舍入,过少则在尾部补零.用于整数时,会出发异常.

1.  ###### Formatter转换 ######

*  <table> 
     <thead> 
      <tr> 
       <th align="center">类型转换字符</th> 
       <th align="center">说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="center">d</td> 
       <td align="center">整数型(十进制)</td> 
      </tr> 
      <tr> 
       <td align="center">c</td> 
       <td align="center">Unicode字符</td> 
      </tr> 
      <tr> 
       <td align="center">b</td> 
       <td align="center">Boolean值</td> 
      </tr> 
      <tr> 
       <td align="center">s</td> 
       <td align="center">String</td> 
      </tr> 
      <tr> 
       <td align="center">f</td> 
       <td align="center">浮点数(十进制)</td> 
      </tr> 
      <tr> 
       <td align="center">e</td> 
       <td align="center">浮点数(科学计数法)</td> 
      </tr> 
      <tr> 
       <td align="center">x</td> 
       <td align="center">整数(十六进制)</td> 
      </tr> 
      <tr> 
       <td align="center">h</td> 
       <td align="center">散列码(十六进制)</td> 
      </tr> 
      <tr> 
       <td align="center">%</td> 
       <td align="center">字符’%’</td> 
      </tr> 
     </tbody> 
    </table>
 *  b对于各种类型都是合法的，但非boolean基本类型或者Boolean对象，只要不为null，转换结果永远为true（数字0结果为true）

1.  String.format()

*  (1) 是一个static方法,接受与Formatter.format()方法一样的参数,但返回一个String对象.
 *  (2) String.format()内部,它也是创建一个Formatter对象,然后将你传入的参数转给Formatter.

##### 6.正则表达式 #####

*  正则表达式可以：匹配、选择、编辑和验证字符串

1.  ###### 基础 ######

*  (1) “\\” ：插入一个正则表达式的反斜线
 *  (2) “\\\\” ： 插入一个普通的反斜线
 *  (3) “\\d” ： 表示一位数字
 *  (4) 换行或制表符之类的，只需要单斜线 ：“/n”，“/t”
 *  (5) 有或没有负号，后面跟着一个或多个数字 ：“-?\\d+”
 *  (6) 正则表达式“（）”有分组的效果
 *  (7) 正则表达式“|”是“或”的操作
 *  (8) String.split() : 将字符串从正则表达式匹配的地方分割（删除）
 *  (9) \\W ：表示非单词字符（\\w小写w表示一个单词字符）
 *  (10) String.split() 还有个重载版本可以限制分割次数
 *  (11) replaceFirst(“正则表达式”，欲替换字符串) ：只替换正则表达式第一个匹配子串
 *  (12) replaceAll()替换所有匹配的地方

1.  ###### 创建正则表达式 ######

*  （1）字符说明：
    
    <table> 
     <thead> 
      <tr> 
       <th align="center">字符</th> 
       <th align="center">说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="center">B</td> 
       <td align="center">指定字符B</td> 
      </tr> 
      <tr> 
       <td align="center">\xhh</td> 
       <td align="center">十六进制值为oxhh的字符</td> 
      </tr> 
      <tr> 
       <td align="center">\uhhhh</td> 
       <td align="center">十六进制表示为oxhhhh的Unicode字符</td> 
      </tr> 
      <tr> 
       <td align="center">\t</td> 
       <td align="center">制表符Tab</td> 
      </tr> 
      <tr> 
       <td align="center">\n</td> 
       <td align="center">换行符</td> 
      </tr> 
      <tr> 
       <td align="center">\r</td> 
       <td align="center">回车</td> 
      </tr> 
      <tr> 
       <td align="center">\f</td> 
       <td align="center">换页</td> 
      </tr> 
      <tr> 
       <td align="center">\e</td> 
       <td align="center">转移(Escape)</td> 
      </tr> 
     </tbody> 
    </table>
 *  （2）字符类说明
    
    <table> 
     <thead> 
      <tr> 
       <th align="center">字符类</th> 
       <th align="center">说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="center">.</td> 
       <td align="center">任意字符</td> 
      </tr> 
      <tr> 
       <td align="center">[abc]</td> 
       <td align="center">包含a,b和c的任何字符(和a或b或c作用相同)</td> 
      </tr> 
      <tr> 
       <td align="center">[abc]</td> 
       <td align="center">除了a,b和c之外任何字符串(否定)</td> 
      </tr> 
      <tr> 
       <td align="center">[a-zA-Z]</td> 
       <td align="center">从a到z或从A到Z的任何字符(范围)</td> 
      </tr> 
      <tr> 
       <td align="center">[abc[hij]</td> 
       <td align="center">任意a,b,c,h,i和j字符(与a或b或c或h或i或j作用相同)(合并)</td> 
      </tr> 
      <tr> 
       <td align="center">[a-z&amp;&amp;[hij]]</td> 
       <td align="center">任意的h,i或j(交)</td> 
      </tr> 
      <tr> 
       <td align="center">\s</td> 
       <td align="center">空白符(空格,tab,换行,换页和回车)</td> 
      </tr> 
      <tr> 
       <td align="center">§</td> 
       <td align="center">非空白符([^\s])</td> 
      </tr> 
      <tr> 
       <td align="center">\d</td> 
       <td align="center">数组[0-9]</td> 
      </tr> 
      <tr> 
       <td align="center">\D</td> 
       <td align="center">非数字[0-9]</td> 
      </tr> 
      <tr> 
       <td align="center">\w</td> 
       <td align="center">词字符[a-zA-Z0-9]</td> 
      </tr> 
      <tr> 
       <td align="center">\W</td> 
       <td align="center">非此字符[^\w]</td> 
      </tr> 
     </tbody> 
    </table>
 *  （3）边界匹配符
    
    <table> 
     <thead> 
      <tr> 
       <th align="center">字符类</th> 
       <th align="center">说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="center">.</td> 
       <td align="center">任意字符</td> 
      </tr> 
      <tr> 
       <td align="center">[abc]</td> 
       <td align="center">包含a,b和c的任何字符(和a或b或c作用相同)</td> 
      </tr> 
      <tr> 
       <td align="center">[abc]</td> 
       <td align="center">除了a,b和c之外任何字符串(否定)</td> 
      </tr> 
      <tr> 
       <td align="center">[a-zA-Z]</td> 
       <td align="center">从a到z或从A到Z的任何字符(范围)</td> 
      </tr> 
      <tr> 
       <td align="center">[abc[hij]</td> 
       <td align="center">任意a,b,c,h,i和j字符(与a或b或c或h或i或j作用相同)(合并)</td> 
      </tr> 
      <tr> 
       <td align="center">[a-z&amp;&amp;[hij]]</td> 
       <td align="center">任意的h,i或j(交)</td> 
      </tr> 
      <tr> 
       <td align="center">\s</td> 
       <td align="center">空白符(空格,tab,换行,换页和回车)</td> 
      </tr> 
      <tr> 
       <td align="center">§</td> 
       <td align="center">非空白符([^\s])</td> 
      </tr> 
      <tr> 
       <td align="center">\d</td> 
       <td align="center">数组[0-9]</td> 
      </tr> 
      <tr> 
       <td align="center">\D</td> 
       <td align="center">非数字[0-9]</td> 
      </tr> 
      <tr> 
       <td align="center">\w</td> 
       <td align="center">词字符[a-zA-Z0-9]</td> 
      </tr> 
      <tr> 
       <td align="center">\W</td> 
       <td align="center">非此字符[^\w]</td> 
      </tr> 
     </tbody> 
    </table>

1.  ###### 量词 ######

*  贪婪型:量词总是贪婪的,除非有其他的选项被设置.贪婪型表达式会为所有可能的模式发现尽可能多的匹配.导致此问题的一个典型理由就是嘉定我们的模式技能匹配第一个可能的字符组,如果它是贪婪的,那么它就会继续往下匹配.
 *  勉强型:用问号来制定,这个量词匹配满足模式所需的最少字符数,也称作懒惰的,最少匹配的,非贪婪的,不贪婪的.
 *  占有型:目前,这种类型的量词只有在Java中才可用.当正则表达式被应用于字符串时,它会产生相当多的状态,以便在匹配失败的时候可以回溯.它们常常可以用于防止正则表达式时空,因此可以使用正则表达式执行起来更有效.
 *  <table> 
     <thead> 
      <tr> 
       <th align="center">贪婪型</th> 
       <th align="center">勉强型</th> 
       <th align="center">占有型</th> 
       <th align="center">如何匹配</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="center">X?</td> 
       <td align="center">X??</td> 
       <td align="center">X?+</td> 
       <td align="center">一个或零个X</td> 
      </tr> 
      <tr> 
       <td align="center">X*</td> 
       <td align="center">X*?</td> 
       <td align="center">X*+</td> 
       <td align="center">零个或多个X</td> 
      </tr> 
      <tr> 
       <td align="center">X+</td> 
       <td align="center">X+?</td> 
       <td align="center">X++</td> 
       <td align="center">一个或多个X</td> 
      </tr> 
      <tr> 
       <td align="center">X{n}</td> 
       <td align="center">X{n}?</td> 
       <td align="center">X{n}+</td> 
       <td align="center">恰好n次X</td> 
      </tr> 
      <tr> 
       <td align="center">X{n,}</td> 
       <td align="center">X{n,}?</td> 
       <td align="center">X{n,}+</td> 
       <td align="center">至少n次X</td> 
      </tr> 
      <tr> 
       <td align="center">X{n,m}</td> 
       <td align="center">X{n,m}?</td> 
       <td align="center">X{n,m}+</td> 
       <td align="center">X至少n次,且不超过m次</td> 
      </tr> 
     </tbody> 
    </table>

1.  ###### Pattern和Matcher ######

*  (1) Pattern.compile()方法用来编译正则表达式并返回一个Pattern对象.
 *  (2) Pattern对象的matcher()方法会生成一个Matcher对象.
 *  (3) Matcher的方法,能够判断各种不同配型的匹配是否成功
    
     *  i.boolean matches() ：判断整个输入字符串是否匹配正则表达式模式
     *  ii.boolean lookingAt() ：判断该字符串的始部分是否匹配正则表达式模式
     *  iii.boolean find()
        
         *  a.find() ：像迭代器遍历输入字符串
         *  b.find(int i) : i表示字符串字符的位置，并以其作为搜索的起点
     *  vi.组号为0表示整个表达式，组号1表示被第一对括号括起来的组
        
            例：
            
            A（B(C)）D
            
            第0组：ABCD
            
            第1组：BC
            
            第2组：C
     *  v.int groupCount() : 返回该匹配器的模式中的分组数目，不包括第0组
     *  vi.String group()
        
         *  a.group() ：返回第一次匹配操作的第0组
         *  b.group(int i) : 返回前一次匹配操作期间指定的组号，如果匹配成功，但没有输入字符串中任意一部分，返回null
     *  vii.int start() : 返回先前匹配的起始位置的索引
     *  viii.int end() ：返回所匹配的最后字符索引加一的值
     *  ix.matches() ：只有在这个输入都匹配正则表达式时才会成功
     *  x.lookingAt() : 只要输入的第一部分匹配就会成功
     *  xi.reseet() ：将Matcher对象重新设置到当前字符序列的起始位置
 *  (4) Pattern标记
    
     *  Pattern类的compile()方法还有另一个版本,接受标记参数,调整匹配的行为：Pattern Pattern.compile(String regex, int flag)
     *  Pattern标记（flag常量）
        
        <table> 
         <thead> 
          <tr> 
           <th align="center">编译标记</th> 
           <th align="center">效果</th> 
          </tr> 
         </thead> 
         <tbody> 
          <tr> 
           <td align="center">Pattern.CANONEQ</td> 
           <td align="center">两个字符当且仅当它们的完全规范分解相匹配时,就认为它们是匹配的.例如:如果我们指定这个标记,表达式a\u030A就会匹配字符串?.在默认的情况下,匹配不考虑规范的等价性.</td> 
          </tr> 
          <tr> 
           <td align="center">Pattern.CASEINSENSITIVE(?i)</td> 
           <td align="center">默认情况下,大小写不敏感的匹配只有US-ASCII字符集中的字符才能进行.这个标记运行模式匹配不必考虑大小写(大写或小写).通过指定UNICODECASE标记及结合此标记,基于Unicode的大小写不敏感的匹配模式也可以开启了</td> 
          </tr> 
          <tr> 
           <td align="center">Pattern.COMMENTS(?x)</td> 
           <td align="center">在这种模式下,空格符将被忽略掉,并且以#开始直到行末的注释也会被忽略掉.通过嵌入的标记表达式也可以开启Unix的行模式</td> 
          </tr> 
          <tr> 
           <td align="center">Pattern.DOTALL(?s)</td> 
           <td align="center">在dotall模式中,表达式".“匹配所有字符,包括行终结符.默认情况下,”."表达式不匹配行终结符</td> 
          </tr> 
          <tr> 
           <td align="center">Pattern.MULTILINE(?m)</td> 
           <td align="center">在多行模式下,表达式和<span><span><span> 分 别 匹 配 一 行 的 开 始 和 结 束 . 还 匹 配 输 入 字 符 串 的 开 始 , 而 分别匹配一行的开始和结束.还匹配输入字符串的开始,而 </span><span><span><span style="height: 0.3em; vertical-align: -0.19444em;"></span><span>分</span><span>别</span><span>匹</span><span>配</span><span>一</span><span>行</span><span>的</span><span>开</span><span>始</span><span>和</span><span>结</span><span>束</span><span>.</span><span>还</span><span>匹</span><span>配</span><span>输</span><span>入</span><span>字</span><span>符</span><span>串</span><span>的</span><span>开</span><span>始</span><span>,</span><span style="margin-right: 0.166667em;"></span><span>而</span></span></span></span></span>还匹配输入字符串的结尾.默认情况下,这些表达式仅匹配输入的完整字符串的开始和结束</td> 
          </tr> 
          <tr> 
           <td align="center">Pattern.UNICODECASE(?u)</td> 
           <td align="center">当指定这个标记,并且开启CASEINSENSITIVE时,大小写不敏感的匹配将按照与Unicode标准相一致的方式进行.默认情况下,大小写不敏感的匹配假定只能在US-ASCII字符集中的字符才能进行</td> 
          </tr> 
          <tr> 
           <td align="center">Pattern.UNIXLINES(?d)</td> 
           <td align="center">这种模式下,在. ^和$行为中,只识别行终结符\n</td> 
          </tr> 
         </tbody> 
        </table>

##### 7.扫描输入 #####

1.  StringReader将String转化为刻度的流对象，然后用这个对象来构造BufferReader对象
2.  readLine() ：将一行输入转为String对象
3.  Scanner构造器可以接受任何类型的输入对象，包括File对象、InputStream、String或Readable对象
4.  Scanner有hasNext方法，用以判断下一个输入分词是否所需的类型
5.  ###### Scanner定界符 ######

*  (1) useDelimiter() ：设置定界符(正则表达式)
 *  (2) delimiter() ：用来返回当前正在作为定界符的Pattern对象

1.  ###### 用正则表达式扫描 ######

*  (1) next() ：找到下一个匹配该模式的输入部分
 *  (2) match() ：获得匹配结果（如果正则表达式中含有定界符，那么永远也不会匹配成功）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpYW5jNjY2_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/9e8334e2c8264d33afad59c14e348c66.png