Java 的API
1.1定义
API: Application(应用) Programming(程序) Interface(接口)
Java API就是JDK中提供给开发者使用的类，这些类将底层的代码实现封装了起来，不需要关心这些类是如何实现的，只知道如何使用即可。
JDK安装目录下有个src.zip文件，里面是所有Java类的源文件。可以查看源码。
但是不方便，所以用api手册查，
打开后，点显示，索引，输入想查看的类，选择第一项，就可以了
可以查看：类的继承体系，接口，子类，成员变量，构造方法，成员方法。就可以学会这个类的使用方法了。
2 Object类
Object类是Java语言中的根类，即所有类的父类。
它中描述的所有方法，子类都可以使用。
所有类在创建对象的时候，最终找的父类就是Object。
2.1equals方法
用于比较两个对象是否相同，实际是使用两个对象的内存地址在比较。
例：
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
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;
};
}
public class Test {
public static void main(String[] args) {
Person p1=new Person("张三",18);
Person p2=new Person("李四",18);
System.out.println(p1.equals(p2)); //比的是地址
System.out.println(p1==p2); //比的是地址
}
}
都比的地址，可以查看一下equals的源码（放在上面，ctrl+点击）
可以看到，Object类中的equals方法，就是用的==比较。
比较地址没有意义，比较内容才有意义，比如这里要判断同龄人，
所以需要重写equals方法 （一般Object类里的方法都要重写的）
但是直接这样写不对，因为传进来的是一个Person对象，而参数obj是Object类型，这是多态，所以obj是访问不到age的，这时必须向下转型，转成Person类型才可以，用instanceof做判断：
但是，还是报错：
因为这个equals方法的返回值是boolean，所以如果转型失败呢，就得不到正确的返回值了，所以要加一个return false;
//比较年龄
public boolean equals(Object obj) {
if(obj instanceof Person){
Person p=(Person)obj;
return this.age==p.age;
}
return false;
}
这时再运行test中的p1.equals(p2)
这个方法还需要提高健壮性，如果传入了一个null呢，如果把对象本身传过去了呢？所以最后为：
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
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;
};
//比较年龄
public boolean equals(Object obj) {
if(obj==null){ //传了null
return false;
}
if(obj==this){ //把自己传进来
return true;
}
if(obj instanceof Person){ //向下转型
Person p=(Person)obj;
return this.age==p.age;
}
return false; //转型失败返回false
}
}
而且这个重写方法也有快捷添加方式：
在Person类中，写上equals，然后Alt+/，就出现提示了
回车即可：
String里面的equals就是比较值：
public class Test3 {
public static void main(String[] args) {
String s1="abc";
String s2="abc";
String s3="123";
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
}
}
这就是因为String类重写了equals方法，可以查一下看看：
所以自己写的类，一定要重写equals方法，才能进行值的比较，而且注意必须向下转型。
2.2 toString方法
返回该对象的字符串表示。
例：还是上面那个Person类，
public class Test2 {
public static void main(String[] args) {
Person p1=new Person("小红",18);
System.out.println(p1);
System.out.println(p1.toString());
}
}
两个结果都是地址，说明直接打印引用数据类型，就是在自动调用toString方法。
同样的，地址没什么用，需要的是对象的内容，也就是能把对象的属性打印出来就好了，所以要重写toString方法。
public String toString() {
return "name="+name+",age="+age;
}
这个也有快捷方式点出来：
右键--Source--Generate toString()... 选择上属性，
出来是是这样的：
Test结果为：
这个格式更好看。
同样的，字符串可以直接打印内容，就是因为重写了toString方法：
public class Test4 {
public static void main(String[] args) {
String s="abc";
System.out.println(s);
System.out.println(s.toString());
}
}
3 String类
String 类代表字符串。所有字符串字面值（如 "abc" ）都作为此类的实例实现（对象）
3.1字符串是常量
字符串的本质是一个字符的数组。
例：
public class Demo01 {
public static void main(String[] args) {
String str1="abc";
String str2="abc";
String str3=new String("abc");
System.out.println(str1==str2);
System.out.println(str1.equals(str2));
System.out.println();
System.out.println(str1==str3);
System.out.println(str1.equals(str3));
}
}
理解：
堆里有一块区域 叫 常量池，（用final修饰的成员变量都进常量池）
字符串就在常量池里。
引号就是一个对象,一旦创建不能改变。
而这种
String s=”abd”;
S=”123”;
改的是变量s，而abc，123 都不会被改变。
String str1="abc";
String str3=new String("abc");
str1创建，在内存中只有一个对象。这个对象在字符串常量池中
str3创建，在内存中有两个对象：一个new的对象在堆中，一个字符串本身对象，在字符串常量池中。
图：
3.2 String类构造方法
例：
//string构造方法
public class Demo02 {
public static void main(String[] args) {
method01();
method02();
method03();
}
public static void method01(){
System.out.println("method01的结果：");
byte[] bytes={65,66,67,68};
String str=new String(bytes);
System.out.println(str);
byte[] bytes2={-65,-66,-67,-68};
String str2=new String(bytes2);
System.out.println(str2);
}
public static void method02(){
System.out.println();
System.out.println("method02的结果：");
byte[] bytes={65,66,67,68};
String str=new String(bytes,1,2);
System.out.println(str);
}
public static void method03(){
System.out.println();
System.out.println("method03的结果：");
//字符数组转字符串
char[] ch={'中','a','2','A'};
String str=new String(ch);
System.out.println(str);
String str2=new String(ch,0,1);
System.out.println(str2);
}
}
说明：
1）method01中，打印的是ASCII值对应的字符：
http://www.runoob.com/tags/html-ascii.html
只用记三个值就好：
0：48
A：65
a：97
字节byte范围的会自动走ASCII，例：
public class Test {
public static void main(String[] args) {
char ch=97;
char ch2='a';
int i=(int)ch2;
System.out.println(ch);
System.out.println(ch2);
System.out.println(i);
}
}
2）method01中，负数是打印汉字。一个汉字两个字节。
如果只写了三个字符，那么第二字汉字就是乱码：
3）method03是字符数组转字符串，以后学IO流时会再遇到
4）method02中new String(bytes,1,2);
两个数字参数为：起点（下标从0开始），个数
3.3 String类常用方法
1）字符串的长度
public class Test {
public static void main(String[] args) {
String str="abcd";
System.out.println(str.length());
}
}
2）字符串截取
public class Test {
public static void main(String[] args) {
String str="chinanihao";
String s=str.substring(5); //要有一个对象接收新的
System.out.println(s);
}
}
3）字符串截取：从开始索引一直截取到结束索引（不包含结束索引）
public class Test {
public static void main(String[] args) {
String str="chinanihao";
String s=str.substring(5,6); //要有一个对象接收新的
System.out.println(s);
}
}
4）判断一个字符串是否以一个字符串前缀开始
public class Test {
public static void main(String[] args) {
String str="javanihao";
boolean flag=str.startsWith("java");
System.out.println(flag);
}
}
5）判断一个字符串是否以一个字符串前缀结尾（常用于IO流中判断文件类型）
public class Test {
public static void main(String[] args) {
String str="Person.java";
boolean flag=str.endsWith(".java");
System.out.println(flag);
}
}
6）判断一个字符串中是否包含另一个字符串
public class Test {
public static void main(String[] args) {
String str="javanihao";
boolean flag=str.contains("ni");
System.out.println(flag);
}
}
7）获取小字符串在大字符串中第一次出现的索引，如果不存在，返回-1
public class Test {
public static void main(String[] args) {
String str="javanihaojava";
int index=str.indexOf("java");
int index2=str.indexOf("php");
System.out.println(index);
System.out.println(index2);
}
}
8）字符串转字节数组 & 字符串转字符数组
public class Test {
public static void main(String[] args) {
String str="china";
byte[] bytes=str.getBytes(); //字符串转字节数组
char[] ch=str.toCharArray(); //字符串转字符数组
for(int i=0;i<bytes.length;i++){
System.out.print(bytes[i]+" ");
}
System.out.println();
for(int i=0;i<ch.length;i++){
System.out.print(ch[i]+" ");
}
}
}
9）比较字符串
public class Test {
public static void main(String[] args) {
String str="javagood";
System.out.println(str.equals("javaGood"));
System.out.println(str.equalsIgnoreCase("javaGood")); //不区分大小写
}
}
10）获取字符串对象中的内容
public class Test {
public static void main(String[] args) {
String str="abcdefg";
System.out.println(str);
System.out.println(str.toString());
}
}
直接打印引用类型变量时，默认调用该类型进行重写后的toString方法。
10）判断是否为空的字符串
public class Test2 {
public static void main(String[] args) {
String str="xyz";
boolean flag=str.isEmpty();
System.out.println(flag);
}
}
11）获取字符串中指定位置上的字符
public class Test2 {
public static void main(String[] args) {
String str="hello";
char s=str.charAt(1);
System.out.println(s);
}
}
12）大小写转换
public class Test2 {
public static void main(String[] args) {
String str1="ABC";
String str2=str1.toLowerCase();
System.out.println(str2);
String str3="abc";
String str4=str3.toUpperCase();
System.out.println(str4);
}
}
13）替换
public class Test2 {
public static void main(String[] args) {
String str="zyxhello";
String nstr1=str.replace('z','a');
String nstr2=str.replace("zy","ab");
System.out.println(nstr1);
System.out.println(nstr2);
}
}
14）去除字符串两端空格，中间的不会去除
public class Test2 {
public static void main(String[] args) {
String str=" ab c ";
String nstr=str.trim();
System.out.println(nstr);
}
}
3.4练习
1）获取指定字符串中，大写字母、小写字母、数字的个数
public class E1 {
public static void main(String[] args) {
String str="ABCabcd12345";
int big=0;
int small=0;
int num=0;
for(int i=0;i<str.length();i++){
int n=str.charAt(i);
if(n>='A'&&n<='Z'){
big++;
}else if(n>='a'&&n<='z'){
small++;
}else if(n>='0'&&n<='9'){
num++;
}
}
System.out.println("大写字母的个数是"+big);
System.out.println("小写字母的个数是"+small);
System.out.println("数字的个数是"+num);
}
}
2）将字符串中，第一个字母转换成大写，其他字母转换成小写，并打印改变后的字符串。
public class E2 {
public static void main(String[] args) {
String str="abcdEFG";
String s1=str.substring(0,1);
String s2=str.substring(1);
s1=s1.toUpperCase();
s2=s2.toLowerCase();
System.out.println(s1+s2);
}
}
3）在“hellojava,nihaojava,javazhenbang”中查询出现“java”的次数。
public class E3 {
public static void main(String[] args) {
int count=getCount("hellojava,nihaojava,javazhenbang", "java");
System.out.println(count+"次");
}
public static int getCount(String big, String small){
int count=0;
int index=-1;
while(true){
index=big.indexOf(small);
if(index!=-1){
count++;
big=big.substring(index+1);
//big=big.substring(index+"java".length());也可以
}else break;
}
return count;
}
}
优化代码：
public class E3_2 {
public static void main(String[] args) {
int count = getCount("hellojava,nihaojava,javazhenbang", "java");
System.out.println(count + "次");
}
public static int getCount(String big, String small) {
int count = 0;
int index = -1;
while ((index = big.indexOf(small)) != -1) {
count++;
big = big.substring(index + 1);
}
return count;
}
}
4字符串缓冲区
4.1 StringBuffer类
String 是常量不可变，所以要有一个可变的。
StringBuffer是个字符串的缓冲区，就是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
4.1.1构造方法
StringBuffer();
StringBuffer(String str);
4.1.2常用方法
1）添加
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer();
sb.append("a").append('中').append(true).append(1.2);
System.out.println(sb); //返回的是一个String类型，困为默认调的toString方法
}
}
这里是一种用法：链式调用：用一个方法后，返回一个对象，然后使用返回的对象继续调用方法。这种时候，就可以把代码写在一起。
2）删除（包含起始索引，不包含结束索引）
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abcde");
sb.delete(1,3); //包头不包尾
System.out.println(sb);
}
}
3）在指定位置插入元素
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abcde");
sb.insert(0,"java");
System.out.println(sb);
}
}
4）替换
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abcde");
sb.replace(1, 2, "hello"); //包头不包尾
System.out.println(sb);
}
}
5）反转
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abcde");
sb.reverse();
System.out.println(sb);
}
}
6）截取
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abcde");
String sb2=sb.substring(2);
System.out.println(sb2);
}
}
7）删除指定位置上的字符
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abcde");
sb.deleteCharAt(0);
System.out.println(sb);
}
}
4.1.3 String和StringBuffer对比
public class Test {
public static void main(String[] args) {
StringBuffer str1=new StringBuffer("abcde");
str1.replace(0, 4, "111");
System.out.println("str1："+str1);
String str2="abcde";
String str3=str2.replace("abcd", "111");
//str2=str2.replace("abcd", "111"); 还可以这样写，更简便
System.out.println("str2："+str2);
System.out.println("str3："+str3);
}
}
这说明，String不可变，StringBuffer可变。String进行一些操作时，一定要有另一个String变量接收（或者再赋值给本身）。而StringBuffer可以直接操作。
4.1.4练习：int[] arr = {34,12,89,68}; 打印：[34,12,89,68]
public class Test {
public static void main(String[] args) {
int[] arr = {34,12,89,68};
method2(arr);
}
public static void method2(int[] arr){
StringBuffer str=new StringBuffer();
str.append('[');
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1){
str.append(arr[i]+","); //这里不能写单引号的','，那样就是加ASCII值了
}else{
str.append(arr[i]+"]");
}
}
System.out.println(str);
}
}
4.2 StringBuilder类
和StringBuffer的用法一模一样。
该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。（以后学习线程时再学）