常用API

API概述

API概念

API(Application Programming Interface) : 应用程序编程接口
也称之为 : 帮助文档
e.g. 编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类

快速使用API步骤:

• 打开帮助文档
• 点击显示，找到索引，看到输入框
• 你要学习什么内容，你就在框框里面输入什么内容
  举例：Random
• 看包
  java.lang包下的类在使用的时候是不需要导包的
• 看类的描述
  Random类是用于生成随机数的类
• 看构造方法
  Random():无参构造方法
  Random r = new Random();
• 看成员方法
  public int nextInt(int n):产生的是一个[0,n)范围内的随机数
  调用方法：
  看返回值类型：人家返回什么类型，你就用什么类型接收
  看方法名：名字不要写错了
  看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
  int number = r.nextInt(100);

Scanner类

Scanner类作用

用Scanner类的方法可以完成接收键盘录入的数据,接收的数据类型为基本数据类型和字符串类型.

案例代码（Scanner类接受键盘录入的字符串）

package com.itheima;

import java.util.Scanner;

/*
 * Scanner:用于获取键盘录入数据。(基本数据类型，字符串数据)
 * public String nextLine()：获取键盘录入字符串数据
 */
public class ScannerDemo {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//接收数据
		System.out.println("请输入一个字符串数据：");
		String line = sc.nextLine();
		
		//输出结果
		System.out.println("line:"+line);
	}
}

Object类

Object类作用

Object:是类层次结构的根类，所有的类都直接的或者间接的继承自该类。

案例代码（Object类的toString()方法）

package com.itheima_01;

public class Student {
	private String name;
	private int age;
	
	public Student() {}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}

package com.itheima_01;
/*
 * Object:是类层次结构的根类，所有的类都直接的或者间接的继承自该类。
 * 构造方法：Object()
 * 
 * 直接输出对象名，输出底层调用的是该对象的toString()
 * 
 * 查看API，我们发现建议所有子类都重写toString()。
 * 到底该如何重写该方法呢?自动生成的就可以。
 */
public class ObjectDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.setName("林青霞");
		s.setAge(30);
		System.out.println(s);
		//System.out.println(s.toString());
		/*
		 public void println(Object x) { //Object x = s;
	        String s = String.valueOf(x);
	        synchronized (this) {
	            print(s);
	            newLine();
	        }
	    }
	    
	    public static String valueOf(Object obj) { //Object obj = x;
        	return (obj == null) ? "null" : obj.toString();
    	}
	    */
	}
}

案例代码（Object类的equals()方法）

package com.itheima_02;

public class Student {
	private String name;
	private int age;
	
	public Student() {}
	
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}


	@Override
	public boolean equals(Object obj) {
		//s1.equals(s2)
		//this -- s1
		//obj -- s2
		
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		//比较的是对象是否是同一个类的对象
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj; //other -- s2
		if (age != other.age) //this.age -- s1.age
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			//字符串的equals()比较的是字符串的内容是否相同
			return false;
		return true;
	}
}

package com.itheima_02;
/*
 * ==:
 * 		可以比较基本数据类型，比较基本数据类型的时候比较的是基本数据类型的值是否相同
 * 		也可以比较引用数据类型，比较引用数据类型的时候比较的是引用数据类型的地址值是否相同
 * 
 * 而我们现在想比较的是对象的内容是否相同?该怎么办呢?
 * 通过查看API，我们找到了比较对象是否相等的方法：
 * public boolean equals(Object obj)
 * Object类中的equals()方法默认比较的是对象的地址是否相同。
 * 如果我们想比较对象的内容是否相同，就必须自己重写该方法。
 * 如何重写该方法呢?
 * 		自动生成即可。
 */
public class ObjectDemo {
	public static void main(String[] args) {
		Student s1 = new Student("林青霞", 30);
		Student s2 = new Student("林青霞", 30);
		
		//System.out.println(s1 == s2);//false
		
		System.out.println(s1.equals(s2));//false
		/*
	    public boolean equals(Object obj) {
	    	//this -- s1
	    	//obj -- s2
	        return (this == obj);
	    }
	    */
	}
}

String类

String类概述

通过JDK提供的API，查看String类的说明

• "abc"是String类的一个实例,或者成为String类的一个对象
• 字符串字面值"abc"也可以看成是一个字符串对象
• 字符串是常量，一旦被赋值，就不能被改变
• 字符串本质是一个字符数组

String类的构造方法

• String(String original):把字符串数据封装成字符串对象
• String(char[] value):把字符数组的数据封装成字符串对象
• String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象

案例代码（常用构造方法）

package com.itheima_01;
/*
 * String：代表字符串类。
 * 		由多个字符组成的一串数据。
 * 		字符串的本质就是一个字符数组。		
 * 
 * 构造方法：
 * 		String(String original):把字符串数据封装成字符串对象
 * 		String(char[] value):把字符数组的数据封装成字符串对象
 * 		String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
 * 
 * public String toString():返回此对象本身（它已经是一个字符串！）。 
 */
public class StringDemo {
	public static void main(String[] args) {
		//String(String original):把字符串数据封装成字符串对象
		String s1 = new String("hello");
		System.out.println(s1);
		System.out.println("----------");
		
		//String(char[] value):把字符数组的数据封装成字符串对象
		char[] value = {'h','e','l','l','o'};
		String s2 = new String(value);
		System.out.println(s2);
		System.out.println("----------");
		
		//String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
		//String s3 = new String(value,0,value.length);
		String s3 = new String(value,0,3);
		System.out.println(s3);
		System.out.println("----------");
		
		//最常用的
		String s4 = "hello";
		System.out.println(s4);
	}
}

案例代码（创建字符串对象两种方式的区别）

package com.itheima_02;
/*
 * String类创建对象的特点：
 * 		A:通过构造方法创建对象
 * 		B:通过直接赋值的方式创建对象
 * 这两种方式的创建是有区别的。
 * 通过构造方法创建的字符串对象是在堆内存。
 * 通过直接赋值的方式创建的字符串对象是在方法区的常量池。
 */
public class StringDemo {
	public static void main(String[] args) {
		String s1 = new String("hello");
		String s2 = new String("hello");
		
		String s3 = "hello";
		String s4 = "hello";
		
		System.out.println(s1 == s2);//false
		System.out.println(s1 == s3);//false
		System.out.println(s3 == s4);//true
	}
}

案例代码（String的练习之模拟用户登录）

• boolean equals(Object obj):比较字符串的内容是否相同
• boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

package com.itheima_03;

import java.util.Scanner;

/*
 * 需求：模拟登录,给三次机会,并提示还有几次
 * 分析：
 * 		A:定义两个字符串对象，用于存储已经存在的用户名和密码
 * 		B:键盘录入用户名和密码
 * 		C:拿键盘录入的用户名和密码去跟已经存在的用户名和密码进行比较
 * 			如果内容相同，就提示登录成功
 * 			如果内容不同，就提示登录失败，并提示还有几次机会
 * public boolean equals(Object anObject):比较字符串的内容，严格区分大小写(用户名和密码)
 * public boolean equalsIgnoreCase(String anotherString):比较字符串的内容，不考虑大小写(验证码)
 */
public class StringTest {
	public static void main(String[] args) {
		//定义两个字符串对象，用于存储已经存在的用户名和密码
		String username = "admin";
		String password = "admin";
		
		for(int x=0; x<3; x++) {
			//键盘录入用户名和密码
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入用户名：");
			String name = sc.nextLine();
			System.out.println("请输入密码：");
			String pwd = sc.nextLine();
			
			//拿键盘录入的用户名和密码去跟已经存在的用户名和密码进行比较
			if(username.equals(name) && password.equals(pwd)) {
				System.out.println("登录成功");
				break;
			}else {
				if((2-x) == 0){
					System.out.println("你的帐号被锁定，请与管理员联系");
				}else {
					System.out.println("登录失败，你还有"+(2-x)+"次机会");
				}
			}
		}
	}
}

案例代码（String类的获取功能）

• public char charAt(int index):返回指定索引处的值
• public int length():返回字符串中的字符个数，字符串的长度

package com.itheima_03;
/*
 * 需求：遍历字符串(获取字符串中的每一个字符)
 */
public class StringTest2 {
	public static void main(String[] args) {
		//要遍历字符串，你首先得有一个字符串
		String s = "abcde";
		
		//思考：如何获取字符串中的每一个字符
		//假如让我们来提供方法，我们应该提供一个根据索引返回指定位置的字符的方法
		//返回值：char
		//形式参数：int index
		//public char charAt(int index):返回指定索引处的值
		//原始做法
		System.out.println(s.charAt(0));
		System.out.println(s.charAt(1));
		System.out.println(s.charAt(2));
		System.out.println(s.charAt(3));
		System.out.println(s.charAt(4));
		System.out.println("-------------------");
		
		//用for循环改进
		for(int x=0; x<5; x++) {
			System.out.println(s.charAt(x));
		}
		System.out.println("-------------------");
		
		//目前for循环中的数据5是我们数出来的，那么字符串有没有提供一个方法，用于获取字符串中字符的个数呢?
		//public int length():返回字符串中的字符个数，字符串的长度
		for(int x=0; x<s.length(); x++) {
			System.out.println(s.charAt(x));
		}
	}
}

案例代码（对字符串的拼接案例）

package com.itheima_03;
/*
 * 需求：把数组中的数据按照指定个格式拼接成一个字符串
 * 举例：int[] arr = {1,2,3};
 * 输出结果：[1, 2, 3]
 * 
 * 分析：
 * 		A:定义一个int类型的数组
 * 		B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串
 * 		C:调用方法
 * 		D:输出结果
 */
public class StringTest3 {
	public static void main(String[] args) {
		//定义一个int类型的数组
		int[] arr = {1,2,3};
		
		//写方法实现把数组中的元素按照指定的格式拼接成一个字符串
		
		//调用方法
		String result = arrayToString(arr);
		
		//输出结果
		System.out.println("result:"+result);
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：String
	 * 		参数列表：int[] arr
	 */
	public static String arrayToString(int[] arr) {
		String s = "";
		//[1, 2, 3]
		s+="[";
		
		for(int x=0; x<arr.length; x++) {
			if(x==arr.length-1) {
				s += arr[x];
			}else {
				s += arr[x];
				s += ", ";
			}
		}
		
		s+="]";
		return s;
	}
}

案例代码（String类的反转案例）

package com.itheima_03;

import java.util.Scanner;

/*
 * 需求：字符串反转
 * 举例：键盘录入”abc”		
 * 输出结果：”cba”
 * 
 * 分析：
 * 		A:键盘录入字符串数据
 * 		B:写方法实现字符串数据的反转
 * 			把字符串倒着遍历，在把每一个得到的字符拼接成一个字符串
 * 		C:调用方法
 * 		D:输出结果
 */
public class StringTest4 {
	public static void main(String[] args) {
		//键盘录入字符串数据
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		
		//写方法实现字符串数据的反转
		
		//调用方法
		String result = reverse(s);
		
		//输出结果
		System.out.println("result:"+result);
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：String
	 * 		参数列表：String s
	 */
	public static String reverse(String s) {
		//把字符串倒着遍历，在把每一个得到的字符拼接成一个字符串
		String ss = "";
		
		for(int x=s.length()-1; x>=0; x--) {
			ss += s.charAt(x);
		}
		
		return ss;
	}
}

StringBuilder类

StringBuilder类概述

• StringBuilder:是一个可变的字符串。字符串缓冲区类。
• String和StringBuilder的区别：
• String的内容是固定的
• StringBuilder的内容是可变的
• +=拼接字符串耗费内存原因:
  每次拼接都会产生新的字符串对象,而利用StringBuilder来拼接字符串自始至终用的都是同一个StringBuilder容器
  

案例代码（StringBuilder类的常用方法）

• 构造方法:
  public StringBuilder()
  public StringBuilder(String str)
• 成员方法:
  public String toString():返回此序列中数据的字符串表示形式。
  public StringBuilder append(任意类型):添加数据，并返回对象本身。
  public StringBuilder reverse():字符串本身进行反转

	package com.itheima_01;
/*
 * StringBuilder:是一个可变的字符串类。
 * 
 * String和StringBuilder的区别：
 * 		String的内容是固定的。
 * 		StringBuilder的内容是可变的。
 * 
 * 构造方法
 * public StringBuilder()
 * public StringBuilder(String str)
 * 
 * public String toString():返回此序列中数据的字符串表示形式。
 */
public class StringBuilderDemo {
	public static void main(String[] args) {
		//public StringBuilder()
		StringBuilder sb = new StringBuilder();
		System.out.println("sb:"+sb);
		System.out.println(sb.length());
		System.out.println("----------------");
		
		//public StringBuilder(String str)
		StringBuilder sb2 = new StringBuilder("helloworld");
		System.out.println("sb2:"+sb2);
		System.out.println(sb2.length());
	}
}

案例代码（添加功能和反转功能）

package com.itheima_02;
/*
 * 添加功能
 * 		public StringBuilder append(任意类型):添加数据，并返回对象本身。
 * 反转功能
 * 		public StringBuilder reverse()
 */
public class StringBuilderDemo {
	public static void main(String[] args) {
		//创建对象
		StringBuilder sb = new StringBuilder();
		
		//public StringBuilder append(任意类型)
		/*
		StringBuilder sb2 = sb.append("hello");
		
		System.out.println("sb:"+sb);
		System.out.println("sb2:"+sb2);
		System.out.println(sb == sb2);//true
		*/
		
		/*
		sb.append("hello");
		sb.append("world");
		sb.append(true);
		sb.append(100);
		*/
		
		//链式编程
		sb.append("hello").append("world").append(true).append(100);
		
		System.out.println("sb:"+sb);
		
		//public StringBuilder reverse()
		sb.reverse();
		System.out.println("sb:"+sb);
	}
}

案例代码（StringBuilder和String通过方法完成相互转换）

package com.itheima_03;
/*
 * StringBuilder和String的相互转换
 * 
 * StringBuilder -- String
 * 		public String toString():通过toString()就可以实现把StringBuilder转换为String
 * 
 * String -- StringBuilder
 * 		public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder
 */
public class StringBuilderTest {
	public static void main(String[] args) {
		/*
		//StringBuilder -- String
		StringBuilder sb = new StringBuilder();
		sb.append("hello");
		
		//错误的
		//String s = sb;
		//public String toString()
		String s = sb.toString();
		System.out.println(s);
		*/
		
		//String -- StringBuilder
		String s = "hello";
		StringBuilder sb = new StringBuilder(s);
		System.out.println(sb);
	}
}

案例代码（利用StringBuilder把数组拼接成一个字符串）

package com.itheima_03;
/*
 * 把数组拼接成一个字符串
 * 举例：int[] arr = {1,2,3};
 * 输出结果：[1, 2, 3]
 * 
 * 分析：
 * 		A:定义一个int类型的数组
 * 		B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串
 * 		C:调用方法
 * 		D:输出结果
 * 
 */
public class StringBuilderTest2 {
	public static void main(String[] args) {
		//定义一个int类型的数组
		int[] arr = {1,2,3};
		
		//写方法实现把数组中的元素按照指定的格式拼接成一个字符串
		
		//调用方法
		String result = arrayToString(arr);
		
		//输出结果
		System.out.println("result:"+result);
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：String
	 * 		参数列表：int[] arr
	 */
	public static String arrayToString(int[] arr) {
		StringBuilder sb = new StringBuilder();
		//[1, 2, 3]
		sb.append("[");
		
		for(int x=0; x<arr.length; x++) {
			if(x==arr.length-1) {
				sb.append(arr[x]);
			}else {
				sb.append(arr[x]).append(", ");
			}
		}
		
		sb.append("]");
		
		String s = sb.toString();
		
		return s;
		
	}
}

案例代码（利用StringBuilder完成字符串反转）

package com.itheima_03;

import java.util.Scanner;

/*
 * 把字符串反转
 * 举例：键盘录入”abc”		
 * 输出结果：”cba”
 * 
 * 分析：
 * 		A:键盘录入一个字符串数据
 * 		B:写方法实现字符串数据的反转
 * 			String -- StringBuilder -- reverse() -- String
 * 		C:调用方法
 * 		D:输出结果
 */
public class StringBuilderTest3 {
	public static void main(String[] args) {
		//键盘录入一个字符串数据
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		
		//写方法实现字符串数据的反转
		
		//调用方法
		String result = myReverse(s);
		
		//输出结果
		System.out.println("result:"+result);
		
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：String
	 * 		参数列表：String s
	 */
	public static String myReverse(String s) {
		//String -- StringBuilder -- reverse() -- String
		/*
		StringBuilder sb = new StringBuilder(s);
		sb.reverse();
		String ss = sb.toString();
		return ss;
		*/
		
		return new StringBuilder(s).reverse().toString();
	}
}