java------String

char[]就是一串字符，Java 中可以作为字符串

字符串对象的创建

String str="abc";

String s=new String("abc");

用字符数组创建字符串：

new String(char[] value) ====== String.copyValueOf(char[] value) ----创建一个char[]内容的字符串
new String(char[] value, int 起始下标, int 长度)======String.copyValueOf(char[] value, int 起始下标, int 长度) ----创建一个char[]内容的子内容字符串

用字符串创建新的字符串(相当于字符串复制)

new String(String original) 获取一个original的副本(相当于复制)

用动态字符串StringBuffer 创建字符串

new String(StringBuffer buffer) ----创建一个包含字符串缓冲区参数中当前包含的字符序列,对StringBuffer的后续修改不会影响所建的String

 

 

字符串方法

获取指定下标的 字符

char [] c =str1.charAt(int index)

获取指定字符的下标

int index = str1.indexOf(Object o) -------------------------------------第一次出现处参数的下标
int index = str1.lastIndexOf(Object o) --------------------------------最后一次出现处参数的下标
int index = str1.indexOf(Object o ,指定查询开始的下标) --------从指定位置开始第一次出现处参数的下标
int index = str1.lastIndexOf(Object o ,指定查询开始的下标) ---从指定位置开始最后一次出现处参数的下标

获取字符串长度

int index = str1.length()

复制字符串替换字符数组

str1.getChars(复制开始下标,复制结束下标,char[]目标数组,被替换字符的开始下标) -----截取String的字符替换char[]中的字符

替换字符串内容
str1.replace(char old, char new) -------------------------------------将字符串的指定字符用新字符替换
str1.replace(CharSequence "zc",CharSequence "abc") ----将str1中的"zc"用"abc"替换(注意：zc整体，若没有的话不替换)

str1.replaceAll(String regex, String 指定字符串) -------使用 指定字符串 替换str1中所有正则匹配的字符串

str1.replaceFirst(String regex, String 指定字符串) ----使用 指定字符串 替换str1中正则匹配的第一个字符串

字符串截取

str1.substring(int beginIndex) ------------------------------------------截取指定下标后的字符串

str1.substring(int beginIndex, int endIndex) ------------------------截取下标之间的字符串

字符串-----〉字符数组

char [] c = str1.toCharArray() 

字符串<------字符数组

String str = String.copyValueOf(char[] data)

String str = String.copyValueOf(char[] data ,子数组初始偏移量 ,子数组长度)

对象---------〉字符串

String str = String .valueOf(Object obj) =======String str = obj .toString();

Long-------->字符串

String str = String .valueOf(Long o) =======String str = Long .toString(Long o);

字符串-----〉集合

CharSequence subSequence(int beginIndex, int endIndex) ---截取下标之间的字符序列（类似字符list集合）

去掉字符串前后的空格

String str = str1.trim()

字符串拼接

str1.concat(str2)====== str1 + str2

判断字符串开始、结束标识

Boolean b = str1.endsWith(String suffix) ------判断str1是否是以指定的字符串suffix结束
Boolean b = str1.startsWith(String prefix) ----判断str1是否是以指定的字符串prefix开始

判断字符串关系

Boolean b = str1.contains(CharSequence str2) ------------判断是否包含(注意：内容和顺序，str2="abc"作为整体)

Boolean b = str1.contentEquals(CharSequence str2) ----判断是否相等(注意：内容和顺序）

Boolean b = str1.equals(Object anObject)-------------------判断是否相等

判断字符串是否为空

Boolean b = str1.isEmpty()  -------------------------------------当且仅当 length() 为 0 时返回 true。 

判断字符串是否匹配正则
Boolean b = str1.matches(String regex)

拆分字符串(用正则)

String[] str = str1.split(String regex)

字符串格式化

String.format(String format, Object args,... ) -----将一个或多个对象按指定的字符串格式（format中用特殊的类型转换符表示：插入数据的位置、类型以及如何格式化）进行格式化字符串输出

如：String k=String.format("%s的工资：$%d", "king",100);------>king的工资：$100
String.format("%tF%n", Date date) ------将日期按指定字符串格式以字符串形式输出

 

集锦：

JAVA组合字符串，长度不足用0补齐

 private String lpad(int length, int number) {

        String f = "%0" + length + "d";

        return String.format(f, number);

 }  

 System.out.println(test.lpad(5, 23));   //00023

 

Java字符串长度不够前面或后面补0

1、 第一种字符串补0方法，已测试过，代码如下：
 public static String addZeroForNum(String str, int strLength) {
     int strLen = str.length();
     StringBuffer sb = null;
     while (strLen < strLength) {
           sb = new StringBuffer();
           sb.append("0").append(str);// 左(前)补0
        // sb.append(str).append("0");//右(后)补0
           str = sb.toString();
           strLen = str.length();
     }
     return str;
 }

2、数字流水号长度不够补0方法，已测试过，代码如下：
 public static String codeAddOne(String code, int len){
    Integer intHao = Integer.parseInt(code);
    intHao++;
    String strHao = intHao.toString();
    while (strHao.length() < len) {
        strHao = "0" + strHao;
     }
    return strHao;
 }

 用java中的DecimalFormat，可以简化：

 // 流水号加1后返回，流水号长度为15
 private static final String STR_FORMAT = "000000000000";
 public static String haoAddOne(String liuShuiHao){
      Integer intHao = Integer.parseInt(liuShuiHao);
      intHao++;
     DecimalFormat df = new DecimalFormat(STR_FORMAT);
     return df.format(intHao);
 }

 字符串空值判断方法：

方法一: 最多人使用的一个方法, 直观, 方便, 但效率很低.
方法二: 比较字符串长度, 效率高, 是我知道的最好一个方法.
方法三: Java SE 6.0 才开始提供的方法, 效率和方法二几乎相等, 但出于兼容性考虑, 推荐使用方法二.
 
1：if(s == null || s.equals(""));    <==否定形式==>  if(s != null &&  !" ".equals(s));
 
2：if(s == null || s.length() <= 0);
 
3：if(s == null || s.isEmpty());

 

 

 

 

 

常用方法：

 

Java 中但凡表示"范围"，都是“包含前，不包含后”如上例表示：[3，9)

String 类：数据+相关的操作，即 char[ ]+操作（String 内部就是一个 char[]）

char 数组只是数据，没有操作

一串字符就是字符串：char[]、String、StringBuilder

charAt()

  length()

  trim()

  toLowerCase()

  toUpperCase()

  indexOf()

  lastIndexOf()

  endsWith()

  startsWith()

  substring(int start, int end)

  substring(int start)

  toCharArray()      ----------------------------------- 字符串----〉字符

 

      String str = new String(new char[]{'1','2','3'});字符-----〉字符串

      char[] chs = str.toCharArray();                         字符串----〉字符

 

正则表达式

字符集

  [1234]          表示  1,2,3,4  之一

  [^12]          表示除了  1,2

  [1-5]          表示  1,2,3,4,5

  [a-f]            表示  a-f  之间的

      [0-9a-fA-F]        表示一个 16 进制字符

0[xX][0-9a-fA-F]{1,8}   表示整数的 16 进制数表达式

[\w-]{8,15}       表示 8-15 个人以字符、下划线、数字及“-”

 

预定义字符集

  \d            表示[0-9]

  “.”点        表示任意字符

  \w          表示单词字符  [0-9a-zA-Z_]   注：包含下划线“_”

  \s          表示匹配空白:  \t \n \r \ b \ p      

  \D          （丌常用）表示非数字

  \S          （丌常用）表示非空白

  \W          （丌常用）表示非单词字符  [0-9a-zA-Z_]

  {m,n}          表示数词 m 到 n 个

  {n}          表示数词 n 个，比如表示“5 个以上”用{5，} 

         ?            表示能出现 0 到 1 次  {0，1}

+            表示能出现 1 到 n 次  {1，}

*            表示能出现 0 到 n 次  {0，}

 

正则表达式以“^”开头，“$”结尾

 

 String 对正则表达式的支持

 

1)  String  对正则表达式的支持，重点掌握如下 3 个方法：

  .matches()               匹配正则表达式

  .split("[,\s\|]")        切分字符串为字符串数组

  .replaceAll()   

 

2)  Integer.parseInt()，转换字符串到整数，如: "23"-> 23

StringBuilder 和 StringBuffer   **

 

String  = char[] +  操作(复制创建新对象)           char[]不可变

StringBuilder = char[] +  对 char[]操作(处理当前数组内容)   char[]可变

StringBuilder 内部的 char[]数组内容可变，如果长度丌够，利用变长算法维护，自动扩容长度。

注：

  append()方法，表示“追加”，该方法反复操作的始终是 1 个对象

  insert()方法，表示“插入”

  delete()方法，表示“删除”

 

 StringBuilder

1)  StringBuilder 是变长字符序列

2)  StringBuilder 方法：append，insert ...  都返回当前  StringBuilder  对象本身的引用

3)  如果软件需要大量字符串处理时候建议使用 StringBuilder

4)  String s = s1+s2; Java 实际上是如下代码运行：

String s=new StringBuilder(s1).append(s2).toString();

5)  String s = s1+s2+s3+s4;  被优化为

String s = new StringBuilder(s1).append(s2).append(s3).append(s4).toString();

6)  s += "a";会产生两个新对象(StringBuilder, String)

StringBuilder buf=new StringBuilder();

buf.append("a");

buf.append("a");

7)  StringBuffer  和  StringBuilder API 几乎一样！

StringBuffer  是 java 早期提供的（JDK1.0），速度稍慢，线程安全

s += "A";相当于 s = new StringBuilder(s).append("A").toString ，每当做一次字符创拼接，

就会创建一个 StringBuilder 新对象，同时 JVM 在适时回收这些对象，如此会严重影响性能结论：当处理少量字符串拼接时使用 String s = "a"+"b"，大量字符串拼接操作时使用

StringBuilder，

如果对字符串性能有极高要求，则直接操作 char[]数组