JAVA编程学习记录（API常用类（一））

第五周 API常用类（一）

API（Applicaton Programming Interface）——应用程序编程接口

Java API就是Java提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。就像是一本成语词典!

学习编程就像学汉语，我们需要掌握一些基本语法，学习大量成语，掌握技巧和手法 ，再加上大量练习，最后就可以熟练的使用了

Object类

概述：Object类是类层次结构的根类，所有类都直接或间接的继承自该类；每个类都使用Object作为超类，都实现这个类的方法。

构造方法：public Object（  ）

常见方法：

1.public int hashCode（ ）返回该对象的哈希码值（地址值，不是实际意义的地址值）；

2.Public final Class getClass（ ）返回此Object的运行时类；

    //Class类中有一个方法：public String getName（ ）以String的形式返回此Class对象所表示的实体（类、接口、数组、基本类型或void）名称。返回值是Class。

3.public String toString（ ）返回该对象的字符串表示；

    public static String toHexString（int  i）：以十六进制字符串形式直接输出对象名称以十六进制表示对字符串形式直接输出对象名称:实际执行了Object中的toString(),输出的全类名@十六进制数据我现在输出对象名称,不想让toString()直接输出的是一个地址值(对象的地址值) 就需要重写Object中的toSring(),一般情况:自动生成即可。    //建议所有子类都重写此方法。

4.public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。 

==:比较的值相等(地址值）

equals:本身属于Object类中的方法,默认比较的是地址值是否相同

按照正常情况:equals方法底层实际执行的两个对象在==,比较是地址值;假如:学生的年龄和姓名一致,看成同一个人。

在自定义的类中,重写Object中的equals()方法,比较的是两个对象的成员变量的值是否相同。

5.protected Object clone( ):创建并返回此对象的一个副本

Object 类的 clone 方法执行特定的复制操作。首先，如果此对象的类不能实现接口Cloneable，则会抛出 CloneNotSupportedException异常。

注意：所有的数组都被视为实现接口 Cloneable

Scanner类

简单文本扫描器

jdk5以后用于获取用户的键盘输入

构造方法：public Scanner （ipputSream source）：以输入流的形式录入数据的

        InputStream:字节输入流

        InputStream  in = System.in ; //底层执行返回的是一个字节输入流(标准输入流)

常见方法：

XXX 变量名 = 键盘录入对象.nextXXX()

在Scanner类中它提供一个判断功能:

public boolean hasNextXXX( )：当前扫描器判断是否有下一个可以录入的XXX类型数据

//其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串，则可以省略XXX

    常见异常：java.util.InputMismatchException:录入的数据和接收的数据类型不匹配异常

//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入数据
		System.out.println("请输入一个数据:");
		if(sc.hasNextInt()) {
			int num = sc.nextInt() ;
			System.out.println("num:"+num);
		}else {
			System.out.println("您输入的数据类型不匹配...");
		}

问题:

键盘录入两个int类型的数据,分别输出；

//录入两个int类型的数据
		Scanner sc = new Scanner(System.in) ;
		
		int a = sc.nextInt() ;
		int b = sc.nextInt() ;
		
		System.out.println("a:"+a+",b:"+b);

没有问题

键盘录入两个String类型的数据,分别输出；

//录入字符串
String str1 = sc.nextLine() ;
		String str2 = sc.nextLine() ;
		System.out.println("str1:"+str1+",str2:"+str2);

没有问题

先录入一个String类型的数据,在录入int类型的数据；

String a = sc.nextLine() ;
		int  b = sc.nextInt() ;
		System.out.println("a:"+a+",b:"+b);

没有问题

先录入一个int类型的数据,在录入String类型的数据；

有问题,第二个数据是字符串类型,又由于录入下一个数据要"空格"本身是一个字符串；b是空格,b的值没有录入!

		int a = sc.nextInt() ;
		String b = sc.nextLine() ;
		System.out.println("a:"+a+",b:"+b);

解决方法：重写创建键盘录入对象

		int a = sc.nextInt() ;
		//创建键盘录入对象
		Scanner sc2 = new Scanner(System.in) ;
		String b = sc2.nextLine() ;
		System.out.println("a:"+a+",b:"+b);

String类

在实际开发中，字符串的操作是最常见的操作，没有之一。而Java没有内置的字符串类型，所以，就在Java类库中提供了一个类String供我们来使用。

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

字符串是常量；它们的值在创建之后不能更改。

String是一种特殊的引用类型:默认值:null

构造方法：String( )：无参构造

String(byte[ ] bytes) ：将字节数转换成字符串

//定义一个字节数组
		byte[] bys = {97,98,99,100,101} ;
		String s2 = new String(bys) ;
		System.out.println("s2:"+s2);//结果abcde

public String(byte[ ] bytes, int index,int length)：将字节数组的一部分转换成字符串

		//定义一个字节数组
		byte[] bys = {97,98,99,100,101} ;
		String s = new String(bys,1,2);
		System.out.println("s:"+s);
		//结果：s:bc

//只显示转换的部分

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

		//定义一个字符数组
		char[] ch = {'爱','学','习'} ;
		String s = new String(ch) ;
		System.out.println("s:"+s);//结果s:爱学习

toCharArray()：将字符串转换成字符

public String(char[ ] value, int index, int count)：将字符数组的一部分转换成字符串

public String(String original)：将一个字符串常量构造成一个字符串对象

常用方法：

public int length()：返回此字符串的长度

//注意是一个length方法，数组中的是length属性

String s = new String();
		System.out.println("s:"+s);
		//结果：s:

上面结果不是地址值:说明String类本身就是重写Object类中的toString()方法；

String字符串最大的特点：一但被赋值，其值不能改变。

代码实例：

public class Demo {
	public static void main(String[] args) {

		String s = "hello" ;
		s+="world" ;
		System.out.println("s:"+s);
		
		String s1 = "abc" ;
		String s2 = "world" ;
		System.out.println("s1:"+s1+",s2:"+s2);
		//String作为形式参数:它的效果和基本类型是一样的,形式参数的改变对对实际参数没有影响 (它一旦赋值,不能被改变)
		change(s1,s2) ;
		System.out.println("s1:"+s1+",s2:"+s2);
	}
public static void change(String s1, String s2) {
		
		s1 = s1 +"java" ;
		s1 = s2+"hello" ;
		
	}

结果

s:helloworld
s1:abc,s2:world
s1:abc,s2:world

由结果可知，String字符串可以拼接，但不能替换；

 例题：看程序写结果

public class StringDemo {
	public static void main(String[] args) {
		String s1 = new String("hello");
		String s2 = new String("hello");
		System.out.println(s1 == s2);//false
		System.out.println(s1.equals(s2));//true

		String s3 = new String("hello");
		String s4 = "hello";
		System.out.println(s3 == s4);//false
		System.out.println(s3.equals(s4));//true

		String s5 = "hello";
		String s6 = "hello";
		System.out.println(s5 == s6);//true
		System.out.println(s5.equals(s6));//true
	}
}

==:比较的是地址值

equals:默认的比较是地址值,String底层重写了equals方法,所有比较的内容是否相同

String类常用的判断功能

boolean equals(Object obj):将此字符串与指定的对象比较

实例：

		String s1 = "helloworld" ;
		String s2 = "HelloWorld" ;
		System.out.println("equals:"+s1.equals(s2));//false

boolean equalsIgnoreCase(String str)将此 String 与另一个 String 比较，不考虑大小写

实例：

                String s1 = "helloworld" ;
		String s2 = "HelloWorld" ;
		System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));//true

boolean contains(String str):判断当前字符串中是否包含子字符串  (重点)

实例：

                String s1 = "helloworld" ;
		String s2 = "HelloWorld" ;
		System.out.println("contains:"+s1.contains("llo"));//true
		System.out.println("contains:"+s1.contains("android"));//false

boolean startsWith(String str):判断是否以当前str字符串开头(重点)

实例：

                String s1 = "helloworld" ;
		String s2 = "HelloWorld" ;
		System.out.println("startsWith:"+s1.startsWith("he"));//true

boolean endsWith(String str):以当前str字符串结尾(重点)

写法同上；

boolean isEmpty():判断字符串是否为空

实例：   

                String s1 = "helloworld" ;
		String s2 = "HelloWorld" ;
		System.out.println("isEmpty:"+s1.isEmpty());//false

public String concat(String str):字符串的特有功能:拼接功能和“+”拼接符是一个意思

                String s1 = "hello" ;
		String s2 = "world" ;
		System.out.println("contact():"+s1.concat(s2));//helloworld

String类的常用获取功能

public int length():获取字符串的长度

		String s = "helloworld" ;
		System.out.println("length():"+s.length());//length():10

public char charAt(int index)返回指定索引处的字符

		String s = "helloworld" ;
		System.out.println("charAt():"+s.charAt(5));//charAt():w

public int indexOf(int ch)返回指定字符在此字符串中第一次出现处的索引

		String s = "helloworld" ;
		System.out.println("indexOf():"+s.indexOf("l"));//indexOf():2

public int indexOf(int ch,int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。

		String s = "helloworld" ;
		System.out.println("indexOf():"+s.indexOf("l", 4));//indexOf():8

截取功能:

public String substring(int beginIndex):从指定位置开始截取,默认截取到末尾,返回新的字符串

		String s = "helloworld" ;
		System.out.println("subString():"+s.substring(5));//subString():world

public String substring(int beginIndex, int endIndex):从指定位置开始到指定位置末尾结束,包前不包含

		String s = "helloworld" ;
		System.out.println("substirng():"+s.substring(3, 6));//substirng():low

String类的常用转换功能

public byte[] getBytes() :将字符串转换为字节数组

		String s = "helloworld" ;
		byte[] bys = s.getBytes();
		for(int x = 0 ; x < bys.length; x ++) {
			System.out.println(bys[x]);
		}
/*104
101
108
108
111
119
111
114
108
100*/

public char[] toCharArray() :将字符串转换成字符数组(重点)

		String s = "helloworld" ;
		char[] chs = s.toCharArray() ;
		for(int x = 0 ; x < chs.length ; x ++) {
			System.out.print(chs[x]);
		}
//helloworld

public static String valueOf(int i):将int类型的数据转换成字符串(重点)

System.out.println("valueOf():"+String.valueOf(4396));//valueOf():4396

这个方法可以将任何类型的数据转化成String类型

public String toLowerCase():字符串中所有的字符转成小写

		String s = "HELLOworld" ;
		System.out.println("toLowerCase():"+s.toLowerCase());//toLowerCase():helloworld

public String toUpperCase():字符串中所有的字符转成大写

		String s = "HELLOworld" ;
		System.out.println("toLowerCase():"+s.toUpperCase());//toLowerCase():HELLOWORLD

String类的其他功能

public String replace(char oldChar,char newChar):将大字符串中的某个字符替换掉成新的字符

		String s = "Helloworld" ;
		System.out.println("replace:"+s.replace('H', 'h'));
                //replace:helloworld

public String replace(String oldStr,String newStr):将大字符串中的某个子字符串替换掉

		String s = "Helloworld" ;
		System.out.println("replace:"+s.replace("world", "China"));
                //replace:HelloChina

public String trim():去除字符串两端空格

		String s1 = " helloWorld " ;
		System.out.println("s1:"+s1+"----");
		String s2 = s1.trim() ;//去两端空格
		System.out.println("s2:"+s2+"----");
                //s1: helloWorld ----
                //s2:helloWorld----

public int compareTo(String anotherString)按字典顺序比较两个字符串

如果参数字符串等于此字符串，则返回值0；如果此字符串按字典顺序小于字符串参数，则返回一个小于0的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于0的值。

/**
 * 比较结果是2:
 * 不知道怎么计算的? 怎么办?
 * 看源码:
 * @author Administrator
 *
 */
public class StringTest4 {
	
	public static void main(String[] args) {
		
		String s1 = "hello" ;
		String s2 = "hel" ;
		System.out.println(s1.compareTo(s2));//2
	}
}

String类中功能的常见用法

1.遍历一个字符串

public class StringDemo {
public static void main(String[] args) {
		
		//定义字符串
		String s = "Helloworld" ;
		for(int x=0;x<s.length();x++) {//借助length
			System.out.println(s.charAt(x));//借助charAt(int index) ，获取指定位置的字符
		}
	}
}

编程题:    //作业
1: 字符串反转
  举例：键盘录入”abc”
输出结果：”cba”

public class StringDemo {
public static void main(String[] args) {
		
		//定义字符串
		String s = "abc" ;
		for(int x=s.length()-1;x>=0;x--) {//借助length
			System.out.print(s.charAt(x));//借助charAt(int index)
		}
	}
}

2.统计一个字符串中大、小写、数字字符出现的次数

import java.util.Scanner;
/**
 * 分析:
		1)定义统计变量
			bigCount = 0
			smallCount = 0 ;
			numberCount=0;
		2)键盘录入字符串:有大写字母字符,小写字母字符,数字字符
		3)获取每个
			可以将录入的字符串遍历
			char charAt(int index)和length方法
		4)判断
				'a'		97
				'A'		65
				'0'		48
	更简单方法
		如果:
			char>'a' && char<'z':属于小写字母字符	smallCount++
			'A'	 'Z'			:大写字母字符		bigCount++
			'0'  '9' 			:数字字符			numberCount++
 *
 */
public class StringDemo {
	public static void main(String[] args) {
		// 定义三个统计变量
		int bigCount = 0;
		int smallCount = 0;
		int numberCount = 0;

		// 键盘录入对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine();

		// 将字符串遍历
		for (int x = 0; x < line.length(); x++) {
			// 可以通过索引获取每一个字符
			char ch = line.charAt(x);
			// 判断他是否大写字母,小写字母,还是数字字符
			if (ch >= 'a' && ch <= 'z') {
				// 小写字母字符
				smallCount++;
			} else if (ch >= 'A' && ch <= 'Z') {
				bigCount++;
			} else if (ch >= '0' && ch < '9') {
				numberCount++;
			}
		}

		System.out.println("大写字母字符有:" + bigCount + "个");
		System.out.println("小写字母字符有:" + smallCount + "个");
		System.out.println("数字字母字符有:" + numberCount + "个");

	}
}

3.把一个小写（大写）字符串指定位置的字符转成大写（小写）

import java.util.Scanner;
/**
 *	分析:
 *		获取第一个字符:通过截取 返回一个新的字符串s1
 *		将s1转换成大写
 *		在获取除了第一个1字符以为的其他字符,截取s2
 *		s2转换成小写
 *		s1和s2拼接
 *
 */
public class StringDemo {
	public static void main(String[] args) {
		//键盘录入一个字符串
				Scanner sc = new Scanner(System.in) ;
				
				System.out.println("请输入一个字符串:");
				String s = sc.nextLine();
				
				//截取当前第一个字符
				String s1 = s.substring(0, 1) ;
				//在截取除了第一个字符以为的其他字符
				String s2 = s.substring(1);
				
				//将s1转换成大写
				String s3 = s1.toUpperCase() ;
				//s2转换成小写
				String s4 = s2.toLowerCase() ;
				
				//s3和s4拼接
				String result = s3.concat(s4) ;
				System.out.println("result:"+result);
				
				System.out.println("-----------------");
				
				//链式编程
				String result2 = s.substring(0, 1).toUpperCase().concat(
						s.substring(1).toLowerCase()) ;
				System.out.println("result2:"+result2);
	}
}

4.把数组中的数据按照指定个格式拼接成一个字符串(用方法改进)

/**
 *	假设有一个数组:
 * 		int[] arr = {1 ,2, 3} ;
 * 
 * 最终结果是一个String数据
 * 		[1, 2, 3]
 * 
 * 分析:
 * 		1)定义一个int类型的数组
 * 		2)定义一空字符串:String s = "" ;
 * 
 * 		3)遍历数组之前:拼接一个[
 * 		4)遍历int类型 数组
 * 			判断是否最后一个元素
 * 				拼接每一个元素
 * 				拼接]
 * 			否则
 * 				拼接每一个元素
 * 				拼接, 
 *
 */
public class StringDemo {
public static void main(String[] args) {
		
		//定义一个int类型的数组
		int[] arr = {1, 2, 3};
		
		//定义空字符串
		String result = "" ;
		
		//拼接左中括号
		result += "[";
		
		//遍历int类型的数组
		for(int x = 0 ; x < arr.length ; x ++) {
			//判断当前索引是否是对应的最后一个元素
			if(x==arr.length-1) {
				//拼接元素以及右]
				result += arr[x] ;
				result += "]" ;
			}else {
				result += arr[x] ;
				result += ", " ;
			}
		}
		
		System.out.println("reuslt:"+result);
		
		System.out.println("---------------------");
		
		//方法改进
		String result2 =pringArr(arr)  ;
		System.out.println("result2:"+result2);
	}
	
	/**
	 * 两个明确:
	 * 		明确返回值类型:String
	 * 		明确参数类型:int[] arr
	 */
	public static String pringArr(int[] arr) {
		//定义一个空字符串
		String s = "" ;
		
		//拼接[
		s += "[" ;
		for(int x = 0 ; x < arr.length ; x ++) {
			if(x==arr.length-1) {
				s+=arr[x] ;
				s += "]" ;
			}else {
				s += arr[x] ;
				s += ", " ;
			}
		}
		return s ;
	}
}

5.统计大串中小串出现的次数    //作业

在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"中出现“java”的次数；

自己写的投机取巧方法

public class StringDemo {
	public static void main(String[] args) {
		// 定义一个字符串（大串）
		String s = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
		// 定义一个统计变量
		int javaCount = 0;
		for (int i = 0; i < s.length(); i++) {
			//通过字符串索引获取字符串中的每一个值
			char sc = s.charAt(i);
			if (sc == 'j')	//出现一次‘j’，统计数自增一次
				javaCount++;
		}

		System.out.println(javaCount);

	}
}

网上看来的方法

/**
 * 思想：
 * 1.定义大串和小串，以及统计变量；
 * 2.获取第一次小串
 * 		如果有，则索引返回-1；统计变量自增一次；
 * 		否则，返回统计量
 * 3.从刚才索引到的位置进行截取
 * 	举例：
 * 		在	“woaiava wozhenaijava wozhendeaijava”中第一次索引到java
 * 			统计量自增一次；
 * 		截取获得后面的“wozhenaijava wozhendeaijava”部分，赋值给原字符串
 * 		在	“wozhenaijava wozhendeaijava”中获取第二次java
 * 			统计量自增一次
 * 		截取后面的“wozhendeaijava”，赋值给原字符串
 * 		......
 * 		直到获取不到，返回统计变量...
 *
 */
public class StringDemo {
	public static void main(String[] args) {
		// 定义一个字符串（大串）
		String da = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
		// 定义一个小串
		String xiao = "java";
		// 定义一个统计变量
		int javaCount = 0;
		// 定义一个获取indexOf返回值的变量,索引值统计
		int index;
		
		/*	无法知道判断次数，定义while循环
		 	把indexOf索引到的返回值，赋值给index；-->indexOf返回的是 在大串中找到的小串的位置
		*/
		while ((index = da.indexOf(xiao)) != -1) { // 设置跳出条件为：index不等于-1时
			// 索引到时自增量加一
			javaCount++;
			// 截取第一次索引后面的字符串
			da = da.substring(index + xiao.length());
			// 查看每次截取后的字符串
			System.out.println(da);
		}
		System.out.println(javaCount);
	}
}

程序结果

/**
*	wozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun
*	wozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun
*	wozhendehenaijavaxinbuxinwoaijavagun
*	xinbuxinwoaijavagun
*	gun
*	5
*/

总结：API常用类有大量的类和方法需要去学习，要长期敲代码实例才能完全搞懂学以致用！