黑马程序员——java基础---常用API

一、String类

　　概念：String类代表字符串。Java 程序中的所有字符串字面值("abc")都作为此类的实例实现。又因为该类被final修饰，表明它不能被其它类所继承，其下的一系列关于字符串的操作方法也就无法被复写。

　　特点：字符串一旦被创建，将无法改变其值。

public class StringTest {
    
    public static void main(String[] args) {
        String s1 = "abc";
        s1 = "cba";
        System.out.println(s1);
    }

}

//运行结果：cba

 

　　 上面结果原因：因为String为引用对象，所以String s1 = "abc"执行后，是建立一个索引指向"abc"的内存，接着s1 = "cba"执行，是将原先指向"abc"的索引重新指向了"cba"，所以结果才会是"cba"，但是内存中关于"abc"这个值却始终没有改变。

public class StringTest {
    
    public static void main(String[] args) {
        String s1 = "abc";
        String s3 = new String("abc");
        System.out.println(s1 == s3);
        System.out.println(s1.equals(s3));
    }

}
/**
 * 运行结果：
 * false
 * true
 */

　　  上面结果原因：s3创建时会先去常量池中找"abc"，然后建立一个新的存储"abc"的对象，然后由s3指向新建的对象。而s1指向的是常量池中的"abc",所以s1=s3返回false；如果这样来说，那么s1.equals(s3)也应该返回false，因为equals()方法比较的是内存的地址，这是应为String类对equals()方法进行了复写，它在String类中实现的效果是比较两个地址中的内容是否相同。

　　因为String类用来描述字符串类事物，所以他提供了多种对字符串进行操作的方法：

　　1、获取

               length()：返回的是字符串的长度，也就是字符串中包含的字符个数。

               charAt(int index)：返回的是字符串中某个位置(index)上的字符。

               indexOf(int ch)：返回字符(ch）在字符串中第一次出现的索引。如果字符串中没有该字符，就返回-1。它还有其它的重载方法，最终都是为了返回字符串中某个字符的索引。
代码：

package filetools;

public class StringTest {
    
    public static void main(String[] args) {
        String s1 = "abc";
        System.out.println(s1.length()+"\r"+s1.charAt(1)+"\r"+s1.indexOf('b'));
    }

}
/**
 * 运行结果：
 * 3
 * b
 * 1
 */

 

     2、判断
              contains(String str) ：判断字符串中是否包含某一个子串。

　　 　      isEmpty() :判断字符串中是否有内容。原理就是判断长度是否为0。""和 null 不一样，""是一个对象， null 是指向空。

    　　     startsWith(String str)：判断字符串是否是以指定内容开头。

    　　     endsWith(String str)：判断字符串是否是以指定内容结尾。

    　　　  equals(String str)： 判断字符串内容是否相同。复写了Object类中的equals方法。

　　　　    equalsIgnoreCase(String str)：判断内容是否相同，并忽略大小写。

代码：

public class StringTest {
    
    public static void main(String[] args) {
        String s1 = "abcdefg";
        boolean b1 = s1.contains("de");
        boolean b2 = s1.isEmpty();
        boolean b3 = s1.startsWith("ab");
        boolean b4 = s1.endsWith("fg");
        boolean b5 = s1.equals("abcd");
        boolean b6 = s1.equalsIgnoreCase(s1.toUpperCase());
        System.out.println("b1 = "+ b1);
        System.out.println("b2 = "+ b2);
        System.out.println("b3 = "+ b3);
        System.out.println("b4 = "+ b4);
        System.out.println("b5 = "+ b5);
        System.out.println("b6 = "+ b6);    
    }

}
/**
 * b1 = true
 * b2 = false
 * b3 = true
 * b4 = true
 * b5 = false
 * b6 = true
 */

 

　　3、转换

　　　　　　构造方法：

　　 　　　  public String(char[] value): 将字符数组转成字符串

        　　   public String(char[] value,int offset,int count): 将字符数组中的一部分转成字符串。

        　　　toCharArray(): 将字符串转换为字符数组。

    　　　　  构造方法：

       　　　  public String(byte[] byter): 将指定字节数组转成字符串。

                 public String(byte[] byter,int offset,int count): 将字节数组中的一部分转成字符串。

        　　　 getBytes(): 将字符串转成字节数组。

       　　　  valueOf(int i): 将基本数据类型转成字符串。重载方法没有byte和short类型，它们会自动提升为int型。 注意：也可以用+" "的方法转换。

　　4、替换
    　　　　  replace(char oldchar,char newchar)：通过用newChar替换字符串中所有oldChar。如果要替换的字符不存在，返回的还是原串。

代码：
                 
　　5、切割
    　　　　  split(String regex) ：返回的是一个字符串数组，数组中元素是被分割的字符串。 
  
　　6、子串
   　　　　   substring(int beginIndex)：返回一个新的字符串，从指定位置开始到结尾。
    　　　　  substring(int beginIndex,int endIndex)：返回一个新字符串，包含开始，不含结尾。

代码：

public class StringTest {
    
    public static void main(String[] args) {
        String s1 = "abcdcfc";
        //替换
        System.out.println(s1.replace("bcd", "dcb"));
        //切割
        String[] str = s1.split("c");
        for(String s : str)
        System.out.print(s+"  ");
        System.out.println();
        //子串
        System.out.println(s1.substring(2));
        System.out.println(s1.substring(2, 5));
        
    }

}
/**
 * 运行结果：
 * adcbcfc
 * ab  d  f  
 * cdcfc
 * cdc
 */

        
　　7、其它
    　　　　  toUpperCase() ：将此 String 中的所有字符都转换为大写
    　　　　  toLowerCase() ：将此 String 中的所有字符都转换为小写
    　　　　  trim()： 返回字符串的副本，忽略前部空白和尾部空白。如果没有空白返回的还是这个字符串。 
    　　　　  compareTo(String anotherString)：比较两个字符串。如果参数字符串等于此字符串，则返回0；如果此字符串按字典顺序小于字符串参数，则返回一个负数；否则则返回一个正数。
        　　　 compareToIgnoreCase(String str)：忽略大小写后，进行比较，类似上一个方法。

代码：

public class StringTest {
    
    public static void main(String[] args) {
        String s1 = "abcdcfc";
        //toUpperCase()
        System.out.println(s1.toUpperCase());
        //toLowerCase()
        System.out.println("AJSHD".toLowerCase());
        //trim()
        System.out.println(("  " + s1 +"   " + "sdkfj" + "  ").trim()+"ddd");
        //compareTo()
        System.out.println(s1.compareTo("abcdcf"));
    }

}
/**
 * 运行结果：
 * ABCDCFC
 * ajshd
 * abcdcfc   sdkfjddd
 * 1
 */

 

 

二、StringBuffer类

　　概念：线程安全的可变字符序列。一个类似于String的字符串缓冲区，但不能修改。String类中字符串一旦赋值，便不能修改。StringBuffer类是可以通过方法调用对其中的字符串进行修改。

　　特点：

　　　　1、长度可变。
    　　 2、可操作多种数据类型。
    　　 3、可用toString方法转化成字符串。

　　注意：StringBuffer sb = new StringBuffer();  StringBuffer sb1 = sb.append(data); 执行过后 sb == sb1。

　　常用的方法：

　　1、存储

　　　　　   append(datatype data) ：在StringBuffer末尾添加上制定类型的数据。
    　　　　  insert(int index,data) ：在指定的位置(index)插入制定的数据(data)。

　　2、删除

　　　　　   delete(int start,int end): 删除StringBuffer中指定范围内的数据，不含start，含end。

　　　　　　deleteCharAt(int index): 删除StringBuffe中指定位置(index0的字符。

　　  3、获取

　　　　　　charAt(int index) 
   　　　　   indexOf(String str) 
   　　　　   lastIndexOf(String str) 
   　　　　   length() 
   　　　　   substring(int start)
   　　　　   substring(int start, int end) 

　　　　以上方法的用法和String类中用法一样，只不过操作对象由String换成了StringBuffer。

 　　　　     toString() ：返回StringBuffer中数据的字符串表示形式。

　　 4、修改

　　　　　　 setCharAt(int index, char ch): 将指定位置(index)处的字符设置为字符(ch)。

　　　　　　 replace(int start,int end,String str)：将指定的字符串(str)换到调用对象的指定位置。包含start，不含end。

　　 5、反转。
    　　　　  reverse()：将调用对象中的数据头尾倒置。
    
　　6、转存
　　　　　　 getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：将StringBuffer中指定位置的数据转存储到指定字符数组中的指定位置。含befin不含end。
       

代码：

public class StringBufferTest {

    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        
        System.out.println(sb == sb.append("sadfjhkgjh"));
        System.out.println(sb.insert(2,"ttt"));
        System.out.println(sb.delete(2, 4));
        System.out.println(sb.deleteCharAt(3));
        sb.setCharAt(1, 'p');
        System.out.println(sb);
        System.out.println(sb.reverse());
        
        char[] ch = sb.toString().toCharArray();
        sb.getChars(2,5, ch, 3);
        for(char c : ch)
            System.out.print(c);
    }

}
/**
 * 运行结果：
 * true
 * satttdfjhkgjh
 * satdfjhkgjh
 * satfjhkgjh
 * sptfjhkgjh
 * hjgkhjftps
 * hjggkhftps
 */

 

 

三、StringBuilder类

　　Stringbuilder是JDK1.5版本后出现的，其作用和StringBuffer类似。

　　不同点：StringBuffer支持线程同步，StringBuilder不支持线程同步。

　　优点：

　　　　1、提高效率  

　　　　2、简化书写  

　　　　3、提高安全性

　　我们可以在单线程时使用Stringbuffer，多线程时使用Stringbuilder。

 

四、基本数据类型的包装类

　　概念：基本数据类型分别包装后的对象类。

　　　　　如：int--Integer；

　　　　　　   long--Long；

　　　　　　   short--Short；

　　　　　　　byte--Byte；

　　　　　　　char--Character；

　　　　　　　float--Float；

　　　　　　   double--Double；

　　　　　　　boolean--Boolean；

　　 作用：通过将基本数据包装成类对象，可以通过方法调用来完成数据类型间的转化以及数据对象的其它操作。

　　 针对包装类，JDK1.5后出现的新特性：自动装箱和自动拆箱

　　　　如：Integer x = 23；//自动装箱：将基本数据类型自动装箱成对象。

　　　　　　x = x + 4；//自动拆箱：当x与4相加时，会自动变成基本类型，而当其和赋值给x时，又会自动装箱成对象。

　　  因为包装后已经属于对象了，所以会多出一个null值。

　　  注意：Integer m = 128；

　　　　　  Integer n = 128；

　　　　　     m == n；//false

　　　　　  Integer a = 127；

　　　　　  Integer b = 127；

　　　　　　   a == b；//true

　　　出现这样的结果是因为：当数值在byte的范围内，对于新特性，如果该数值已经存在于内存中，将不会为新对象开辟空间，而是将其指向已有的对象。