菜鸡的Java笔记 第十四 String 类常用方法

/*String 类常用方法
    将所有String类的常用方法全部记下来，包括方法名称，参数作用以及类型
    一个成熟的编程语言，除了它的语法非常完善之外，那么也需要提供有大量的开发类库
    而需要知道的java的类库除了本身提供的JDKDoc之外还会有大量的
    本次操作主要是以文档的查找为主，文档没有中文的，只有英文或者是日文。
    一般来讲每一份文档的组成都会包含有如下几个部分：
        1.类的定义以及实现的父类，父接口，子类，子接口等
        2.类的一些使用的简单的简单说明
        3.成员摘要说明
        4.构造说明
        5.普通方法说明
        6.具体的成员，构造，普通方法依次的完整解释
    理论上以后所编写的开发代码大家都是需要动态查询文档得到的，但是像一般比较常用的类或者是方法就需要大家记住了
    在本次讲解完成之后，要求记住所讲解方法的作用，返回值的意义，参数的类型，参数的意义
*/
// Deprecated  看到这个单词表示这个方法不用了
/*    一，字符与字符串
        很多的编程语言都会强调利用字符数组来描述字符串，实际上在java里面也存在有类似的概念
        在String类中也提供有一系列与字符操作有关的方法

方法名称	类型	说明
public String(char[]value)	普通	将全部的字符数组作为String的内容
public String(char[]value,int offset,int count)	构造	将部分的字符数组变为字符串，offset：开始点，count：个数
public char charAt(int index)	普通	返回指定索引位置上的字符
public char[] toCharArray()	普通	将字符串以字符数组的形式返回

        范例：验证charAt()方法

public class commonMethod{
    public static void main(String args[]){
        String str = "hello";char c = str.charAt(0);  // 如果是 1 返回的就是 e
        System.out.println(c);  // h
    }
}

            在程序中字符串索引的都是从0开始的，数据库是从1开始的
            而后最为关键的是实现字符串与字符数组间的互相转换
        范例：将字符串变为字符数组

public class commonMethod{
    public static void main(String args[]){
        String str = "helloworld";char[] dsta = str.toCharArray(); // 将字符串变为字符数组
        for(int x = 0:x<dsta.length；x++){
            System.out.println(dsta[x]+"."); // h.e.l.l.o.w.o.r.l.d
        }
    }
}

            当字符串变为字符数组之后就可以针对与里面的每一个字符进行操作
        范例：将字符串中的小写字母变为大写字母
            小写字母的编码>大写字母的编码，差了32，也就是说每个字符都减去32即可

public class commonMethod{
    public static void main(String args[]){
        String str = "helloworld";char[] dsta = str.toCharArray(); // 将字符串变为字符数组
        for(int x = 0:x<dsta.length；x++){
            dsta[x]-=32; // 编码减去32

        }
        System.out.println(new String(dsta)); 
　　　　// new String  可以把 字符数组变为字符串  //  结果：HELLOWORLD
        System.out,println(new String (dsta,5,5));  
　　　　// 第5个索引之后取5个长度的内容   // 结果：WORLD
    }
}

            下面可以利用此操作功能判断某一个字符串是否全部由数字所组成
                将字符串变为字符数组，这样做的目的可以进行每个字符的依次判断
                判断每一个字符的范围是否是数字：“0”~“9”之间
        范例：现实判断
            为了实现判断方便可以单独定义有一个isNumber（）方法，这个方法返回boolean类型，但是在java里面有一种命名规范
            如果方法返回的是boolean类型，建议以“isXxx（）”命名

public class commonMethod{
    public static void main(String args[]){
        String str = "helloworld";
        System.out.println(isNumbar(str));
    }
    public static boolean isNumbar(String temp){
        char dsta[] = temp.toCharArray();  // 将字符串变为字符数组
        for(int x = 0:x<dsta,length；x++){
            if(dsta[x]<'0'||dsta[x]>'9'){  // 不是数字
                return false;
            }
        }
        return true;
    }
}// 结果：false

*/

/*    字节与字符串   Bytes and strings
        除了字符可以与字符串进行互相转换之外，字节也可以进行转换，但是这样的转换往往会出现在实际的开发环节之中

方法名称	类型	说明
public String(byte[] bytes)	普通	将全部字节数组变为字符串
public String(byte[]byte,int offset,int count)	构造	将部分字节数组变为字符串
public byte[]getBytes()	普通	将字符串变为字节数组
public byte[]getBytes(String charsetName)	普通	编码转换
throwsUnsupporledEncodingException

            首先对于byte 一定要清楚，虽然它的范围要比char小，但是byte还是可以明确的描述出字母的范围的
        范例：利用字节数组实现小写字母变大写字母的操作

public class bytesAndStrings{
    public static void main(String args[]){
        String str = "helloworld";byte dsta[] = str.getBytes();  // 将字符串变为字节数组
        for(int x = 0:x<dsta.length:x++){
            dsta[x]-=32;  // 改变编码
        }
        System.out.println(new String(dsta));  // HELLOWORLD
    }
}

            以上的这种代码只能够说针对于字节的使用入了个门，而实际中字节的时候需要结合IO，结合网络一起分析才能够进行
*/

/*    string comparison    字符串比较
        现在至少应该知道了字符串比较有equals（）方法
        范例：观察equals（）的问题

public class stringComparison{
    public static void main(String args[]){
        String strA = "hello";
        String strB = "HELLO";
        System.out.println(strA.equals(strB));  // false
    }
}

            但是此方法本身是属于区分大小写的比较，在此在java里面对于字符串的比较实际上还有其他方法

方法名称	类型	说明
public boolean equals(String anObject)	普通	区分大小写的字符串比较
public boolean equalsIgnoreCase(String anobjectString)	普通	不区分大小写的字符串比较
public int compareTo(String anobjectString)	普通	比较字符串大小
public int compareToIgnoreCase(String str)	普通	不区分大小写比较字符串大小

            不区分大小写的字符串比较

public class stringComparison{
    public static void main(String args[]){
        String strA = "hello";
        String strB = "HELLO";
        System.out.println(strA.equals(strB));  // false
        System.out.println(strA.equalsIgnoreCase(strB));  // true
    }
}

            验证码操作中可真的不分大写或者是小写字母
        在进行字符串相等的比较操作之中，最为关键的一个方法是：compareTo()
        这个方法本身返回一个int型数据，而这个int型数据有三种结果：大于（>0）,小于(<0)，等于（=0）
        范例：比较字符串大小（A 比较 a）

public class stringComparison{
    public static void main(String args[]){
        String strA = "A";
        String strB = "a";
        System.out.println(strA.compareTo(strB));  // -32
        System.out.println(strA.compareToIgnoreCase(strB));  // 0
    }
}

            在compareTo()方法之中要进行比较是依据编码进行相减得来的
            如果是System.out.println(strA.compareToIgnoreCase(strB)):  // 0  那就是忽略大小写
            所以利用compareTo()返回值范围进行判断就可以区分大小关系了

public class stringComparison{
    public static void main(String args[]){
        String strA = "A";
        String strB = "a";
        System.out.println(strA.compareTo(strB));  // -32
        System.out.println(strA.compareToIgnoreCase(strB));  // 0
        if(strA.compareTo(strB)==0){
            System.out.println("两个字符串的内容相同");  //  
        }
    }
}

*/

/*    字符串查找
        从一个完整字符串之中查找一些字符串，而可以实现这种字符串查找功能的方法有如下几个

方法名称	类型	说明
public boolean contains(String s)	普通	判断某一个字符串是否存在
public int indexOf(String str)	普通	取得某一个子字符串的索引位置，找不到返回-1
public int indexOf(String str,int fromIndex)	普通	从指定索引位置开始检索子字符串位置，找不到返回-1
public int lastIndexOf(String str)	普通	从后向前查找指定子字符串的位置，找不到返回-1
public int lastIndexOf(String str,int fromIndex)	普通	从指定位置由后向前查找子字符串的位置，找不到返回-1
public boolean startsWith(String prefix)	普通	判断是否以某个字符串开头
public boolean startsWith(String prefix,int toffset)	普通	从指定位置判断是否以某个字符串开头
public boolean endsWith(String suffix)	普通	是否以指定的字符串结尾

            如果要查找中间的内容，那么现在基本上都是使用contains（）方法了
        范例：使用contains（）方法

public class stringLookup{
    public static void main(String args[]){
        String str = "hello";  // 0：h，1：e，2：l，3：l,4:o
        if(str.contains("l")){  // 此方法直接返回true 或者是false
            System.out.println("查找到！！！");
        }
    }
}

            contains（）方法虽然现在用的比较多，但是其是在JDK1.5后才提供的。
            而在JDK1.5之前那么只能够通过indexOf（）方法实现
        范例：利用indexOf（）方法判断

public class stringLookup{
    public static void main(String args[]){
        String str = "hello";  // 0：h，1：e，2：l，3：l,4:o
        System.out.println(str.indexOf("l"));  // 2
        if(str.indexOf("l")!=-1){ // 现在表示索引查找到了
            System.out.println("内容已经查找到！！！");
        }
    }
}

            默认情况下intdexOf（）都是从第一个字母开始查找。那么也可以利用其的重载方法从指定索引位置查找，通过源代码可以发现 contains() 方法只是对 indexOf() 方法的一种包装
        范例：其他方法

public class stringLookup{
    public static void main(String args[]){
        String str = "hello";  // 0：h，1：e，2：l，3：l,4:o
        System.out.println(str.indexOf("l",2));  // 如果是从3开始 返回的就是3  // 2
        System.out.println(str.lastIndexOf("l")); // 3
    }
}

            在字符串查找操作里面还可以判断开头或者结尾
        范例：判断开头或者结尾

public class stringLookup{
    public static void main(String args[]){
        String str = "***@@@hello###";
            System.out.println(str.startsWith("**"));  // true
            System.out.println(str.startsWith("@@",2)); // true
            System.out.println(str.endsWith("##"));  // true
    }
}

            这几个查询现在出现最多的就是contains（），startsWith(),endsWith()
以后学习到后期设计的时候，对字符串的处理（格式定义），这些方法极为重要

*/

/*    substr 字符串的截取
        可以通过一个完整的字符串截取里面的子字符串，那么这个时候使用方法如下：

方法名称	类型	说明
public String substring(int beginIndex)	普通	从指定索引位置截取到结尾
public String substring(int beginIndex,int endIndex)	普通	截取指定索引范围的内容

        范例：观察截取操作

public class substr{
    public static void main(String args[]){
        String str = "helloworldsubstr";
        System.out.println(str.substring(5));  // 截取 结果  worldsubstr
        System.out.println(str.substring(5,10));  // world
        System.out.println(str.substring(0,5));  // hello
    }
}

            千万不要忽略了一点，实际的工作之中，这种截取操作很常用
*/

/*    stringReplacement 字符串替换
        将一个指定的字符串替换为其他内容，就属于替换功能，在String类中有如下的方法支持替换操作

方法名称	类型	说明
public String replaceAll(String regex,String replacement)	普通	字符串的全部替换
public String replaceFirst(String regex,String replacement)	普通	替换第一个内容

        范例：观察替换操作

public class stringReplacement{
    public static void main(String args[]){
        String str = "helloworldsubstr";
        System.out.println(str.replaceAll("l","_"));  // he__owor_dsubstr
        System.out.println(str.replaceFirst("l","_"));  // he_loworldsubstr
    }
}

            实际上利用替换的功能可以消除掉数据中的空格

public class stringReplacement{
    public static void main(String args[]){
        String str = "h e l l o w o r l d substr";
        System.out.println(str.replaceAll(" ",""));  // helloworldsubstr
    }
}

对于替换的操作后期还要结合正则表达式来进行深入讲解
*/

/*    String resolution    字符串拆分
        可以将一个完整的字符串根据指定的内容进行拆分，拆分后的结果就是多个字符串，也就是一个字符串的对象数组
        可以使用的操作方法有如下几个：

方法名称	类型	说明
public String split(String regex)	普通	全部拆分，数组长度为拆分后的子字符串个数
public String split(String regex,int limit)	普通	部分拆分

        范例：观察Split()方法的使用

public class stringResolution{
    public static void main(String args[]){
        String str = "hello world mldn nihao";
        String result[] = str.split(" ");  // 全部拆分
        for(int x = 0:x<result.length:x++){
            System.out.println(result[x]);
        }
    }
}
/*
结果：
hello
world
mldn
nihao
*/

            现在是按照空格全部进行了拆分
        范例：拆分部分内容

public class stringResolution{
    public static void main(String args[]){
        String str = "hello world mldn nihao";
        String result[] = str.split(" ",2);  // 全部拆分
        for(int x = 0:x<result.length:x++){
            System.out.println(result[x]);
        }
    }
}
/*
结果：
hello
world mldn nihao
*/

            现在如果给你一个ip地址，那么一定是按照“.”拆
        范例：拆分 IP

public class stringResolution{
    public static void main(String args[]){
        String str = "192.168.1.1";
        String result[] = str.split(".");  // 全部拆分
        for(int x = 0:x<result.length:x++){
            System.out.println(result[x]);
        }
    }
}
// 结果：（没有结果）

            原因：这个“.”不能够直接使用，因为它属于正则表达式的定义范畴
                    所以日后如果发现不能够拆分的数据必须进行转义，使用“\”

public class stringResolution{
    public static void main(String args[]){
        String str = "192.168.1.1";
        String result[] = str.split("\.");  // 全部拆分
        for(int x = 0:x<result.length:x++){
            System.out.println(result[x]);
        }
    }
}
/*
结果：
192
168
1
1
*/

            在字符串的组成之中，也可能包含有“|”问题

public class stringResolution{
    public static void main(String args[]){
        String str = "192|168|1|1";
        String result[] = str.split("|");  // 全部拆分
        for(int x = 0:x<result.length:x++){
            System.out.println(result[x]);
        }
    }
}
/*
结果：
1
9
2
|
1
6
8
|
1
|
1
*/

---

public class stringResolution{
    public static void main(String args[]){
        String str = "192|168|1|1";
        String result[] = str.split("\|");  // 全部拆分
        for(int x = 0:x<result.length:x++){
            System.out.println(result[x]);
        }
    }
}
/*
结果：
192
168
1
1
*/

            发现 regex 这个单词 这个就是正则的定义范畴，就需要转义
*/

/*    其他操作方法
        以上是一些可以进行归类的操作方法，但是有一些操作方法在日后的课程里面还会有详细的讲解
        而还有一些小的操作方法

方法名称	类型	说明
public int length()	普通	取得字符串的长度
public boolean isEmpty()	普通	判断是否为空字符串（不是null）
public String toLowerCase()	普通	转为小写
public String toUpperCase()	普通	转为大写
public String trim()	普通	去掉左右空格，但是不去掉中间内容
public String concat(String str)	普通	字符串连接，与“+”一样
public String intern()	普通	手工入池

        范例：计算字符串的长度

public class commonMethod{
    public static void main(String args[]){
        String str = "上课睡觉";
        System.out.println(str,length());  // 方法有括号
    }
}

            因为JAVA使用了Unicode编码，所以中文与英文的长度相同，这一点极大的方便了开发者，在数组定义中存在有一个 数组名称.length 它可以获取数组的长度
            String 类中使用的是length（）方法，而数组中使用的是“length”属性           
        范例：判断是否为空字符串

public class commonMethod{
    public static void main(String args[]){
        String str = "上课睡觉";
        System.out.println(str,isEmpty());  // 结果：false
        System.out.println("",isEmpty());  // 结果：true
    }
} // 结果：false

       
        范例：转大，小写操作

public class commonMethod{
    public static void main(String args[]){
        String str = "Hello World @#&*()(";
        System.out.println(str,toLowerCase());  // 结果：hello world @#&*()(
        System.out.println(str,toUpperCase());  // 结果：HELLO WORLD @#&*()(
    }
}

            所有字母的内容都发生了转变，但是非字母的内容不会发生改变
        范例：观察trim（）

public class commonMethod{
    public static void main(String args[]){
        String str = " hello world ";
        System.out.println("内容："+str);  // 结果： hello world
        System.out.println("内容："+str.trim());   // 结果:hello world
    }
}

           
        范例：观察 concat()

public class commonMethod{
    public static void main(String args[]){
        String str = " hello ".concat("world ");
        System.out.println("内容："+str);  // 结果： hello world
    }
}

            基本上开发中不会使用 concat() 实现字符串的连接，都会使用“+”描述
        非常遗憾的是在整个String类设计的过程之中并没有提供有类似于数据库中的 initcap() 函数的功能
    虽然String类提供有大量的操作方法支持，但是有一个功能其并没有提供：首字母大写
        范例：实现一个首字母大写的操作形式

public class commonMethod{
    public static void main(String args[]){
        String att = "name";
        System.out.println(initcap(att));  // 结果： Name
    }
    public static String initcap(String str){
        if(str == null||str,length()==0){
            return str;
        }
        return str.substring(0,1).toUpperCase()+str.substring(1);
    }
}

            进行一些原理分析的时候，此类代码就需要使用到了
*/