【详细+超基础】Java-学习笔记

九、常用类库

String

用String创建的字符串是固定的，不可改变的对象，每一个字符串常量都是字符串类String的一个对象。

String类的常用的构造方法：

1.遇到双引号" "自动创建String类的对象

String s = "hello";  
String w = "world";

2.使用构造方法创建String类的对象

1) public String ( );  // 生成一个空字符串
	String s = new String (); 
2) public String (String str); // 创建一个以str为内容的字符串
   	String s = new String ("hello world");
3) public String (char a[]); // 将字符数组a中的字符创建一个新字符串
	char a[] = {'a','b','c'};
	String s = new String (a); 
4) public String (char a[], int startIndex,int count); // 将字符数组a中第startIndex个字符串开始的count个字符组合起来创建为一个新字符串。 startInder从零开始。
	char a[] ={'a','b','c','d','e'};
	String s=new string(a,2,2);
5) public String (byte [] array); // 将字节数组array创建一个新的字符串
	byte[] a={ 54,55,56};
	String s=new String (a); // s="678",'6'的unicode码是54
6) public String (byte [] array,int offset,int length); // 将字节数组array的第offset个数组元素开始的length个字节创建一个新字符串。
	byte[] a={54, 55, 56};
	String s=new String (a,1,2); // s="78";
注意：
    通过双引号和String的构造方法创建字符串对象方式的区别：通过双引号自动创建的字符串对象存在于常量池，通过构造方法创建字符串对象存在于堆内存中。

String类的对象的常用成员方法

1) 获取字符串的长度
    public int length(); // 获取字符串长度
 	int n ="hello world".length();
2) 字符串的比较
    public boolean equals(String s); // 判断字符串的内容是否相同
	String first =new String ("hello");
	String second =new String ("abc");
	boolean bol=first.equals(second); 
	
	public boolean equalsIgnoreCase(String s); // 判断字符串是否相同
	String first= new String ("ABC");
	String second= new String ("abc");
	boolean bol=first.equalsIgnoreCase(second);

	public boolean startsWith(String prefix); // 判断字符是否以字符串prefix为前缀
	String first ="hello";
	first.startsWith("he");
	
	public boolean  endsWith(String suffix); // 判断字符是否以字符串prefix为后缀
	String first ="hello";
	first.startsWith("lo");

	public int compareTo(String s); // 按照字典顺序进行字符串的计较
	String str="abc"; 
	String s="cde";
	int k=str.compareTo(s);			// k=-2,a比b的Unicode码少2
    int z=str.compareTo("abc");	 	// z=0;
	int i=str.compareTo("abcdef");	// i=-3,abc比abcdef的长度少3

	注意： 
        1.使用"=="判断两个字符串是否相同，是比较两个字符串的引用是否相同，即地址是否相同，使用equals方		 法比较的才是字符串的内容是否相同
        
3) 	public String trim(); // 返回字符串的副本，去掉前导空格和尾部空格   

4) 字符串的检索
	public int indexOf(String s); 
	// 从第一个字符开始寻找s子串首先出现的位置
	public int indexOf(String s,int startpoint);
	// 从第startpoint个字符开始寻找s子串首先出现的位置
	public int lastIndexOf(String s);
	// 从第一个字符开始寻找s子串最后出现的位置
	public int lastIndexOf(String s,int startpoint); 
	// 从第startpoint个字符开始寻找s子串最后出现的位置
	
	String s="hello world hello java";
	s1=s.indexOf("hello");   	// s1=0     从0开始算，第一个字符的索引是0
	s2=s.indexOf("hello",5); 	// s2=12
	s3=s.lastIndexOf("lo",1);	// s3=15 

5) 字符的检索
    public int indexOf(int char); 
	// 返回从第一个字符开始寻找字符char首次出现的位置
	public int indexOf(int char,int startpoint);
	// 从第startpoint个字符开始寻找字符char首先出现的位置
	public int lastIndexOf(int char );
	// 从第一个字符开始寻找字符char最后出现的位置
	public int lastIndexOf(int char,int startpoint); 
	// 从第startpoint个字符开始寻找字符char最后出现的位置

6) 截取字符串
    public String substring (int startpoint); 
	// 返回从第startpoint个位置开始到结束截取的字符串
	public String substring (int start,int end);
    // 返回从第start个位置到第end个位置（不包括end位置）开始到结束截取的字符串
	
7) 替换
    public String replace(char oldChar,char newChar);
	// 用新字符串newChar替换字符串当中的旧字符串oldChar，返回替换后的新字符串
	public String replace(String regex, String newString);
 	// 用新字符串newString替换字符串中所有的旧字符串regex,返回替换后的新字符串

	String s="i mist thssp";
	String temp=s.replace('t','s');
 	// temp的值为"i miss sheep"
	
8) 字符串连接
    public String concat(String s)
    String str="hello";
	String s="java";
	String k=str.concat(s);

9) 字符串向字符数组转换
    public void getChar(int start,int end,char c[],int offset);
	// 将字符串从start到(end-1)位置的字符复制到字符数组c中，并从c的第offset位置开始存放这些字符
	public char[] toCharArray();
	// 将字符串中的全部字符复制到字符数组当中，返回该数组的引用
	public byte[] 
    // 将字符串转成字节数组
        
10) public String [] split(String regex); // 返回基于regex拆分此字符串后形成的字符串数组
	String s ="hello world";
	String [] sArray=s.split(" "); // 按空格拆分字符串s
	for (int i=0;i<aArray.length;i++ ){
        System.out.print(sArray[1]);
    }

11) public static String valueOf(type var);
	// valueOf方法：将var转换成字符串，type可以是任何基本类型
	String str =String.valueOf(120);
	// str的值是“120”

StringBuffer

String 定义的字符是不可改变的，如果对 String 对象作出改变，就会改变生成新对象，这种操作方式非常消耗内存，这种操作方式比较消耗内存，为了降低内存消耗和提高系统速度, Java提供了可变字符串缓冲类——StringBuffer。

StringBuffer可以实现多次增删改查字符串内容而不产生新对象，每一个StringBuffer对象都有初始容量，只要字符长度不超过其容量，就不需要分配新的内部缓冲容量。

StringBuffer的构造方法

public StringBuffer(); // 创建一个空的StringBuffer类的对象
public StringBuffer(int length); // 创建长度为length的StringBuffer对象
public StringBuffer(String str); // 用字符串str作参数进行创建StringBuffer对象

String的大多数方法StringBuffer都可以使用，在此之上，StringBuffer增加了String没有的删除字符串的方法。

StringBuffer的成员方法

1) StringBuffer append(type x)
    double d=3.14;
	StringBuffer st= new StringBuffer();
	st.append(true);
	st.append('c').append(d).append(15); // 最终st的值是true3.1415

2)  public char charAt(int n); 获取字符串中索引是n的字符，索引从0开始。
3)  public

String Tokenizer

StringTokenizer类用于将一个字符串分解成若干个子串。

StringTokenizer的构造方法

public StringTokenizer (String str); // 构造一个使用默认分隔符解析 str 的StringTokenizer对象，Java默认分隔符包括空格、换行符、回车键、Tab键。
public StringTokenizer (String str); // 构造一个指定分隔符delim 解析 str 的StringTokenizer对象

StringTokenizer s1= new StringTokenizer ("我是 中国人");
StringTokenizer s2= new StringTokenizer ("I,am,a,chengxuyuan",",");

StringTokenizer的成员方法

1) public boolean hasMoreTokens(); // 是否还有分隔符，如果有返回true，没有则返回false;
2) public String nextToken(); // 返回字符串中的下一个字符；
3) public Object nextElement(); 
// 返回字符串的下一个子串，与nextToken 方法类似，不同之处在于本方法的返回值是Object,而不是String。
4) public int countTokens(); // 返回字符串中子串的个数。

案例：
import java.util.StringTokenizer;

public class StringTokenizerDemo {
	public static void main(String []args) {
		String s="123,大家好。hello";
		StringTokenizer s1= new StringTokenizer(s,",。");
		while(s1.hasMoreElements()){
			System.out.println(s1.nextElement());
		}
	}
}
运行结果：
    123
	大家好
	hello