黑马程序员--Java基础之API

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！


Java常用API整理

一、String

重点问题：
A.（面试题）字符串最大特点：一旦被初始化就不可以被改变。
指的是字符串在常量池中的值不可改变，但是指向该字符串的引用是可以改变的，也就是说这个引用可以改变后指向别的字符串。
eg.     String str = "abcd";
      str+="efgh";
System.out.println(str);//输出结果为abcdefgh
解释：1."abcd"这个内容在常量池中，不可改变；2."efgh"也在常量池中开辟一个空间，也不可改变；3.再开辟一个空间，存放"abcdefgh",然后指向"abcd"的引用指向了"abcdefgh".
===>另一种类型题(面试题)：
基本类型：形式参数改变不影响实际参数；
引用类型：形式参数改变直接影响实际参数。
但是，String是一种特殊的引用类型，它的形式参数的改变不影响实际参数
eg.
public class Test {
public static void main(String[] args) {
String s = "abc";
change(s);
System.out.println(s);//abc
}
public static void change(String s){
s+="hello";
System.out.println(s);//abchello
}
}
B.(面试题)
class StringDemo
{
public static void main(String[] args)
{
String s1 = "abc";//s1是一个类类型变量，"abc"是一个对象。
String s2 = new String("abc");//s1和s2有什么区别？s1在内存中有一个对象，s2在内存中有两个对象。
}
}
String str = new String("abc");和 String str ="abc";有什么区别吗？
有区别。前者在内存中有两个内存空间，后者只有一个。原因是前者创建对象在堆内存中开辟了一个空间，然后又在常量池中给"abc"开辟了一个空间，对象引用指向堆内存，堆内存指向常量池；后者只在常量池中开辟一个空间存储"abc"，没有再堆内存中开辟空间。
===>与之类似的题目（面试题）：常量相加会直接累加，然后在常量池里面去找有没有，如果有，就是常量池里面的值，不会再开辟新的空间存储；
 而变量则会开辟新的空间。
eg.
public class Test {
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 ="ab";
System.out.println(s3==s1+s2);//false  s1+s2相当于在堆中创建了一个新的字符串，指向"ab"
System.out.println(s3=="a"+"b");//true
}
}


关于null和””说法正确的是(  ABD  )
a) null是常量
b) “”是字符串对象
c) null可以调用方法   不可以，空指针异常
d) “”可以调用方法


-----------------------------------------------------------------


String类适用于描述字符串事物，那么它就提供了多个方法对字符串进行操作。
常见操作："abcd"


1.构造方法：
A.String():
初始化一个新创建的 String 对象，使其表示一个空字符序列。
B.String(byte[] bytes) ：
将字节数组转为字符串，注意此时将byte型数字转换为了ASC码中对应的字符，下面的构造方法同理。
C.String(byte[] bytes, int offset, int length)：
将字节数组的offset位置开始，长度为length的部分截取为字符串。
D.String(char[] value)：
将字符数组转换为字符串。
E.String(char[] value, int offset, int length)：
将字符数组的offset位置开始，长度为length的部分截取为字符串。
F.String(String original)：
创建字符串original的副本。
G.最简单的赋值方法：
如：String s = "abcdf";，这时s依然是一个对象。
2.成员方法：
（1）.获取：
     1.1 字符串中包含的字符数，也就是字符串的长度。
 int length():获取长度
注意与数组中的区别，数组那是属性length，如array.length ,而这里是方法，应为arr.length();
     1.2 根据位置获取位置上某个字符
 char charAt(int index)
     1.3 根据字符获取该字符在字符串的位置
 int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
 int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。


 int indexOf(String str):返回的是str在字符串中第一次出现的位置（类似数组，是从0开始往后计算的）         
 int indexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置。


 int lastIndexOf(int ch)  

（2）.判断：
     2.1 字符串中是否包含某一个字串。
 boolean contains(str):
特殊之处：indexOf(str)：可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含 if(str.indexOf("aa")!=-1).而且该方法既可以判断，又可以获取出现的位置。
     2.2 字符串中是否有内容
  boolean isEmpty():原理就是判断长度是否为0
 String s = "";//isEmpty()  true
 String s = null;//空指针异常
     2.3 字符串是否是以指定内容开头
boolean startsWith(str);
     2.4 字符串是否是以指定内容结尾
boolean endsWith(str);
     2.5 判断字符串内容是否相同。复写了Object类中的equals方法。区分大小写
boolean equals(str);
     2.6 判断内容是否相同，并忽略大小写
boolean equalsIgnoreCase();


（3）.转换：
     3.1 将字符数组转成组字符串。
 构造函数：String(char[])
  String(char[],offset,count):将字符数组中的一部分转成字符串
 静态方法：static String copyValueOf(char[]);//把字符数组转换成字符串。     
  static String copyVlaueOf(char[] data,int offset,int count)            
  static String valueOf(char[])
     3.2 将字符串转成字符数组。**
char[] toCharArray()
     3.3 将字节数组转成字符串
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串
     3.4 将字符串转成字节数组
byte[] getBytes()
     3.5 将基本数据类型转成字符串
static String valueOf(int)//把int类型基本数据转换成字符串。
static String valueOf(double)
//3+"";//String.valueOf(3);
特殊：字符串和字节数组在转换过程中，是可以指定编码表的
注意：参数类型可以是Object，所以可以接收任意类型的
    3.6 String concat(String str)：
将指定字符串连接到此字符串的结尾。


（4）.替换： 
 String replace(char oldChar, char newChar) 
用新字符去替换字符串中指定的旧字符 
 String replace(String oldString,String newString) 
用新字符串去替换字符串中指定的旧字符串
（5）.切割：
 String[] split(String regex) 
以regex字符串为标记进行切割，并将切割后的各个子字符串存入String型数组中。
（6）.子串：获取字符串的一部分
     String subString(begin);//（包括此指定位置）[begin,到最后
     String subString(begin,end);//（包左不包右）[begin,end)


（7）.转换，去空格，比较
     7.1 将字符串转成大写或者小写
 String toUpperCase();
 String toLowerCase();
     7.2 将字符串两端的多个空格去除
 String trim();
     7.3 对两个字符串进行自然顺序的比较
int compareTo(String anotherString) 
按字典顺序比较两个字符串（注：两个字符串收个不相同的字符之差）。 
eg.   String s1 = "abcd";
String s2 = "abcd";
String s3 = "abce";
System.out.println(s1.compareTo(s2));//0
     System.out.println(s1.compareTo(s3));//-1
int compareToIgnoreCase(String str) 
按字典顺序比较两个字符串，不考虑大小写。 
Demo:
StringMethodDemo.java


Test1：模拟登录：给三次机会，并提示还有几次
StringTest1.java


Test2：统计数据：给一个字符串，如"HelloWorld12345",统计大写字母、小写字母、数字的个数
StringTest2.java


   Test3：需求 : 把字符串的首字母转成大写，其余为小写
   StringTest3.java


   Test4:需求:设计一个方法,用于获取一个字符串中指定子串出现的次数。
比如说"hanbasdnbafllgnbahjnbakqqqqlnbaxi" 在这个字符串中，有多少个nba？
获取一个字符串中指定字串出现的次数.jpg
StringTest4.java
小总结：   
字符串转成字符数组：String s  ="asdfg";
char[] chs = s.toCharArray();
字符数组转成字符串：char[] arr = {'a','s','d','f','g'};
String s = new String(arr);

二、StringBuffer

StringBuffer是字符串缓冲区，是一个容器。字符串缓冲区是为了提高字符串的操作效率
特点：
1.长度是可变化的
2.可以直接操作多个数据类型
3.最终会通过toString方法变成字符串
StringBuffer是线程安全的


1.StringBuffer与String区别？
String一旦被赋值，值不能再改变；而StringBuffer，值还可以改变。
原因：
StringBuufer采用的是缓冲区机制。一开始，首先开辟一些空间，然后，随着数据的增多，还可以继续开辟空间，这些操作针对的是同一个对象。
===>赋值运算之后值变不变的问题？
String：形参的改变不影响它；
StringBuffer：形参的改变影响它；
eg.public class Test {
public static void main(String[] args) {
StringBuffer sb =new StringBuffer("abc");
System.out.println(Test.change(sb));
}
public static StringBuffer change(StringBuffer sb){
return sb.append("def");
}
}
运行结果是：abcdef




2.构造方法：
StringBuffer()
初始容量为16个字符（不是字节！）
StringBuffer(int capacity)
指定初始容量的字符串缓冲区（指定之后就不再有那个默认的16字符的空间）。
StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容（这时会在后面默认加上16个字符空间）。
可以通过此构造方法实现String和StringBuffer之间的转换。


3.成员方法：
CURT　create update read delete


1.存储
    StringBuffer append():将指定数据作为参数添加到已有数据结尾处。(任意类型数据)
注意：操作的是同一个StringBuffer
    StringBuffer insert(index,数据)：可以将数据插入到指定index位置。
2.删除
    StringBuffer delete(start,end):删除缓冲区中指定开始位置和结束位置间的数据，包含start，不包含end
    StringBuffer deleteCharAt(index):删除指定位置的字符
3.获取
    char charAt(int index)
    int indexOf(String str)
    int lastIndexOf(String str)
    int length()//字符个数，实际长度。
    int capacity()字符容量，理论长度。
    String subString(int satrt,int end)
4.修改
    StringBuffer replace(satrt,end,String);
    void setCharAt(int index,char ch);
5.反转
    StringBuffer reserve();


6. 返回此序列中数据的字符串表示形式。 
    String toString() 


JDK1.5版本之后出现了StringBuilder


StringBuffer是线程同步的，StringBuilder是线程不同步的
以后开发，建议使用StringBuilder
升级三个因素：
1.提高效率
2.简化书写
3.提高安全性

三、基本数据类型对象包装类

基本数据类型对象包装类：为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为。丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。


8个基本数据类型：
byte     Byte
short     Shaort
int     Integer
long     Long
float     Float
double     Double
char     Character
boolean     Boolean


该包装对象主要用于基本数据类型和字符串之间的转换。


基本数据类型 ---> 字符串：
    1.基本数据类型+""
    2.用String类中的静态方法alueOf（基本数据类型值）；


    基本数据类型.toString(基本数据类型值);
    如：Integer.toString(34);//将34整数变为"34"


字符串 ---> 基本数据类型
    1. xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123");
double d = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
只有Character没有parse方法
    2.如果字符串被Integer进行了对象的封装，可以使用intValue();
      讲一个Integer对象转成基本数据类型值


十进制 ---> 其他进制：
    toBinaryString();
    toHexString();
    toOctalString();


其他进制 ---> 十进制
    parseInt(string,index);


基本数据类型包装类新特性：JDK1.5之后 自动装箱拆箱 简化书写
    Integer i = 4;//i = new Integer(4);
    i= i+6;//i = new Integer(i.intValue() + 6);
    Integer i = null;//当值为null时调用intValue方法会出现异常


Integer a = new Integer(127);
Integer b = new Integer(127);

System.out.println(a==b);//false
System.out.println(a.equals(b));//true


Integer x = 127;
Integer y = 127;
System.out.println(x==y);//true JDK1.5以后，自动装箱，如果装的是一个字节，那么还数据会被共享不会重新开辟空间
System.out.println(x.equals(y));//true


Integer a = new Integer(128);
Integer b = new Integer(128);

System.out.println(a==b);//false
System.out.println(a.equals(b));//true


Integer x = 128;
Integer y = 128;
System.out.println(x==y);//false
System.out.println(x.equals(y));//true
Integer类（重点）
1.字段：如 static int MAX_VALUE 
  它表示 int 类型能够表示的最大值。 
 static int MIN_VALUE 
  它表示 int 类型能够表示的最小值。 
2.构造方法：
A.Integer(int value) 
 构造一个新分配的 Integer 对象，将int类型的value变成Integer类型的。
eg. int num=100;
Integer i =new Integer(num);
  System.out.println(i); //100
===>JDK5.0之后的新特性：
a.自动装箱，也就是把基本类型直接复制给引用类型。
eg.Integer i = 100;
b.自动拆箱，也就是把引用类型直接拆成基本类型。
eg. Integer i = 100;
i = i+200;//先拆箱后装箱
==>但是要注意对i进行不为null判断，当i为null时，会报指针异常。
B.Integer(String s) 
 构造一个新分配的 Integer 对象，将String类型的s变成Integer类型的，这里的s只能是数字形式的字符串,不能含有非数字字符。 
eg. String s = "1";
Integer ii = new Integer(s);
   System.out.println(s);//1
3.成员方法：
A.进制转换
  static String toBinaryString(int i) 
以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。 
  static String toHexString(int i) 
以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。 
  static String toOctalString(int i) 
以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。 
eg.
System.out.println(Integer.toBinaryString(60));//111100


B.int类型数据与String类型的数据之间的相互转换：
推荐方法：
int--->String
1)String.valueOf(int i)
2)Integer.toString(int i)
String --int
Integer.parseInt(String s)
public class StringAndInt {
public static void main(String[] args) {
int num = 100;
//int--->String
//方式一：开发常见，但是不专业
String s1 = num+"";

//方式二（推荐）：String的静态方法:public static String valueOf(int i) 
String s2 = String.valueOf(num);

//方式三：int--Integer--String
Integer i = new Integer(num);
String s3 =i.toString();

//方式四（推荐）：Integer的静态方法：public static String toString(int i) 
String s4 = Integer.toString(num);

//String--->int
String s = "100";//注意这里的s只能是数字形式的字符串！

//方式一：String--Integer--int
//调用Integer的  public int intValue()
Integer ii= new Integer(s);
int num2 = ii.intValue();


//方式二(推荐)：调用Integer的静态方法  public static int parseInt(String s)
int num3 = Integer.parseInt(s);
}

}
4.byte常量池（面试题）

四、Object类

1.Object类是所有类默认的的父类，被称为根类。


2.重要方法：
A.tostring():用于输出对象地址值。
eg.
public class StudentTest 
{
public static void main(String[] args)
{
Student s = new  Student();
System.out.println(s);//此句与下面那句是等效的
System.out.println(s.toString());
}
}
打印结果：Object.Student@1833eca
      Object.Student@1833eca
注：1.用输出语句直接输出对象的名称，其实底层调用了该对象的toString()方法；
   2.为了让对象的显示有意义，一般Object的子类都重写了该方法。


B.equals():用于比较对象是否相等，比较的是地址值；而一般来说，同一个类的不同对象，地址值肯定不一样，
    Object类的equals()方法的默认操作是没有意义的。所以，我们一般会根据需求重写此方法，如用于比较
    类的成员变量值是否相等。
a.重写equals()一般就是为了比较某个类的多个对象的所有成员变量值是否相等
如果成员变量是基本类型，就用==比较；
如果成员变量是引用类型，就用该变量所对应的数据类型的equals()方法比较。
eg.Student类中比较成员变量的函数：
public boolean equals(Object obj)//参数Object类型的，也就是说任何类型的对象都可以传入（向上默认自动转型）
{
if(this==obj)//为了提高代码效率，对传入的对象做一个是否是自己的判断。
{
return true;
}
if(!(obj instanceof Student))//为提高代码健壮性，对传入对象做一个是否为Student类型的判断；
{
return false;
}
Student s = (Student) obj;//向下转型
return this.age==s.age && this.name.equals(s.name);
}//这里this.name是String类型，则其调用的就是String类的equals()方法。

五、与时间有关的类

DateFormat的子类。
1.构造方法：
SimpleDateFormat(String pattern) 
 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat的对象。
常用的两种用法：
1）从Date类型向String类型转；
public final String format(Date date)//这个方法存在于其父类DateFormat中，其内并没有重写，所以找的时候在DateFormat中找。
常见日期模式：
yyyy年MM月dd日 HH:mm:ss
yyyy年MM月dd日
HH:mm:ss
yyyy-MM-dd HH:mm:ss
……
eg.
import java.text.SimpleDateFormat;
import java.util.Date;


public class DateFormatTest {
public static void main(String[] args) {
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String str = sdf.format(d);
System.out.println(str);
}
}
结果：2014年09月25日 22:38:23


2）从String类型向Date转。
Date parse(String source)//这个方法存在于其父类DateFormat中，其内并没有重写，所以找的时候在DateFormat中找。
从给定字符串的开始解析文本，以生成一个日期。 
注意点：如果是字符串到日期的转换，自己指定的日期模式必须与字符串的格式相同。
eg.
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;


public class DateFormatTest2 {
public static void main(String[] args) throws ParseException {
String s ="2014-09-24 11:30:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//必须与s的格式一样！
Date d = sdf.parse(s);
System.out.println(d);
}
}
===>如果给了你一个格式的String，让你输出另一个格式的Date。
思路：String==>转成同形式的Date==>转换成另一种形式的String并输出。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;


public class DateFormatTest2 {
public static void main(String[] args) throws ParseException {
String s ="2014-09-24 11:30:00";       //给的是这个形式的String
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date d = sdf.parse(s);   //换成上述形式的Date
SimpleDateFormat sdf2 = new SimpleDateFormat("dd-MM-yyyy");
String s2 = sdf2.format(d); //再把上边的Date换成所要的形式的String
System.out.println(s2);
}
}
输出：24-09-2014