黑马程序员——Java编程语言学习总结 – API(上)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

API概述

应用程序编程接口（ApplicationProgramming Interface)

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

 

API 常用类

Object类/Scanner类

String类/StringBuffer类/StringBuilder类

数组高级和Arrays类

基本类型包装类(Integer,Character)

正则表达式(Pattern,Matcher)

Math类/Random类/System类

BigInteger类/BigDecimal类

Date类/DateFormat类/Calendar类

 

(一)           Object 类的

1.       Object常用的两个方法：

public boolean equals(Object obj)：

默认就是比较对象是否相等，比较的是地址值。

而一般来说，同一个类的不同对象的地址值肯定是不相同的，所以Object的equals（）方法默认操作是没有意义的，所以建议Object的所有子类重写Object的equals方法，根据自己的需求设置比较的内容。例如：

public boolean equals(Object obj){

if (this == obj){

              returntrue;}

       if(!(obj instanceof Student)){

              returnfalse;}

       Studentother = (Student) obj;

       returnthis.age==other.age&&this.name.equals(other.name);

}

 

public string toString()

返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于： getClass().getName() + '@' + Integer.toHexString(hashCode())

建议所有子类都重写此方法。例如：//有一个学生类，有name和age两属性，重写toString()

public String toString() {

              return"Student [name=" + name + ", age=" + age + "]";

       }

2.       Object类其他方法

A：hashCode() 返回对象的哈希值。不是实际地址值，可以理解为地址值。

B：getClass() 返回对象的字节码文件对象，反射中我们会详细讲解 

C：protected void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。

 D：protected Object clone():创建并返回此对象的一个副本。

Cloneable:此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。这个接口是标记接口，告诉我们实现该接口的类就可以实现对象的复制了。

3.       ==和equals()的区别?

==:

      基本类型：比较的就是值是否相同

      引用类型：比较的就是地址值是否相同

equals:

      引用类型：默认情况下，比较的是地址值。

      不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同

String类的equals方法源码解析：

       Strings1 = new String("hello");

       Strings2 = new String("hello");

      

       s1.equals(s2);       --     true

      

      

      

       publicboolean equals(Object anObject) {

              //this -- s1

              //anObject-- s2

      

       if (this == anObject) {

           return true;

       }

       

       //如果s2是String类的对象，就进去。

       if (anObject instanceof String) {

            //对anObject向下转型

           String anotherString = (String) anObject;

           

           //value在String中的定义

           //private final char[] value

           //字符串 -- 底层字符数组。

           int n = value.length;  //s1长度5

           //value.length -- this.value.length -- s1.toCharArray().length

           //把s1字符串转变成了一个字符数组

           //char[] value = s1.toCharArray();

           //char[] value = {'h','e','l','l','o'};

         

          //把字符串s2也转变成了字符数组，然后获取长度，和n进行比较

          //如果长度相等就进去。

          //char[] value2 ={'h','e','l','l','o'};

           if (n ==anotherString.value.length) {

               //如果长度相同，就进来继续比较。

           

                char v1[] = value;//{'h','e','l','l','o'};

                char v2[] =anotherString.value; //{'h','e','l','l','o'};

                int i = 0;

               

                //n=5;是字符串的长度

               

                while (n-- != 0) {

                   //n=4,

                   //依次按索引位置比较每一个字符是否相同，如果不同，就返回false.

                   //如果每个索引对应的值都相同，那么整个字符串是相同的。

                    if (v1[i] != v2[i])

                            return false;

                    i++;

                }

                return true;

           }

       }

       return false;

}

 

 

 

(二)           String类

 

字符串：就是由多个字符组成的一串数据。也可以看成是一个字符数组。

  通过查看API，我们可以知道

         A:字符串字面值"abc"也可以看成是一个字符串对象。

 B:字符串是常量，一旦被赋值，就不能被改变。

 

1.       构造方法：

            publicString():空构造

             public String(byte[] bytes):把字节数组转成字符串

             public String(byte[] bytes,intindex,int length):把字节数组的一部分转成字符串

         publicString(char[] value):把字符数组转成字符串

             public String(char[] value,intindex,int count):把字符数组的一部分转成字符串

             public String(String original):把字符串常量值转成字符串

 

4.       String类的判断功能：

  boolean equals(Object obj):比较字符串的内容是否相同,区分大小写

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

  boolean contains(String str):判断大字符串中是否包含小字符串

  boolean startsWith(String str):判断字符串是否以某个指定的字符串开头

  booleanendsWith(String str):判断字符串是否以某个指定的字符串结尾

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

  

 注意：

         字符串内容为空和字符串对象为空。

            Strings = "";

            Strings = null;（会报空指针异常！）

 

5.       String类的获取功能

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

  char charAt(int index):获取指定索引位置的字符

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

            为什么这里是int类型，而不是char类型?

            原因是：'a'和97其实都可以代表'a'

  int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。

  int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。

  int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

 Stringsubstring(int start):从指定位置开始截取字符串,默认到末尾。

 String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。

例1 ： 遍历字符串获取每一个字符：

public class StringTest {

       publicstatic void main(String[] args) {

              //定义字符串

              Strings = "helloworld";

              for(int x = 0; x < s.length(); x++) {

                     //char ch = s.charAt(x);

                     //System.out.println(ch);

                     //仅仅是输出，我就直接输出了

                     System.out.println(s.charAt(x));

              }

       }

}

例2  设计一个方法,用于获取一个字符串中指定子串出现的次数。

  比如说“hanbasdnbafllgnbahjnbakqqqqlnbaxi”中有几个nba？

实现代码1：

public class StringTest5 {

       publicstatic void main(String[] args) {

StringmaxString= " hanbasdnbafllgnbahjnbakqqqqlnbaxi ";

              StringminString = "nba";

              intcount = getCount(maxString, minString);

              System.out.println("Java在大串中出现了：" + count + "次");

       }

       publicstatic int getCount(String maxString, String minString) {

              intcount = 0;

              intindex;

              while((index=maxString.indexOf(minString))!=-1){

                     count++;

                     maxString= maxString.substring(index + minString.length());

              }

              returncount;

       }

}

 

实现代码2：public class StringTest5 {

       publicstatic void main(String[] args) {

 

   String str = " hanbasdnbafllgnbahjnbakqqqqlnbaxi";

                     Stringstr1 = str+"5";//所+字符串为非截取的小字符串（”nba”）

                     String[]s = str1.split("nba");

                     System.out.println(s.length-1);

              }

}

6.        String的转换功能：

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

 char[] toCharArray():把字符串转换为字符数组。

  static String valueOf(char[] chs):把字符数组转成字符串。

  static String valueOf(int i):把int类型的数据转成字符串。

            注意：String类的valueOf方法可以把任意类型的数据转成字符串。

  String toLowerCase():把字符串转成小写。

  String toUpperCase():把字符串转成大写。

  String concat(String str):把字符串拼接。

例子：

需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

 举例：

             helloWORLD

  结果：

             Helloworld

 

代码实现：

String s =” helloWORLD”;

String result = s.substring(0,1).toUpperCase()

                            .concat(s.substring(1).toLowerCase());

              System.out.println(result);

7.        String类的其他功能：

 

  替换功能：

  String replace(char old,char new)

 Stringreplace(String old,String new)

 

  去除字符串两空格     

  String trim()

  

  按字典顺序比较两个字符串 

  int compareTo(String str)

  int compareToIgnoreCase(String str)

 

 

8.       String类的compareTo方法源码解析：

 private final char value[];

 

    字符串会自动转换为一个字符数组。

 

 public int compareTo(String anotherString) {

            //this -- s1 -- "hello"

            //anotherString -- s2 --"hel"

 

       int len1 = value.length; //this.value.length--s1.toCharArray().length--5

       int len2 = anotherString.value.length;//s2.value.length --s2.toCharArray().length--3

       int lim = Math.min(len1, len2); //Math.min(5,3); -- lim=3;

       char v1[] = value; //s1.toCharArray()

       char v2[] = anotherString.value;

       

       //char v1[] = {'h','e','l','l','o'};

       //char v2[] = {'h','e','l'};

 

       int k = 0;

       while (k < lim) {

           char c1 = v1[k]; //c1='h','e','l'

           char c2 = v2[k]; //c2='h','e','l'

           if (c1 != c2) {

                return c1 - c2;

           }

           k++;

       }

       return len1 - len2; //5-3=2;

   }

  

  String s1 = "hello";

  String s2 = "hel";

  System.out.println(s1.compareTo(s2)); // 2

 

 

(三)           Scanner类

用于接收键盘录入数据。

1.        静态的字段：

            publicstatic final InputStream in; 标准的输入流，对应着键盘录入。

     InputStream is = System.in;

2.       基本格式：

            publicboolean hasNextXxx():判断是否是某种类型的元素

            publicXxx nextXxx():获取该元素

3.       常用的两个方法：

            publicint nextInt():获取一个int类型的值

            publicString nextLine():获取一个String类型的值

  

  出现问题了：

             先获取一个数值，在获取一个字符串，会出现问题。

            主要原因：就是那个换行符号的问题。

  如何解决呢?

            A:先获取一个数值后，在创建一个新的键盘录入对象获取字符串。

             B:把所有的数据都先按照字符串获取，然后要什么，你就对应的转换为什么。

 

 

(四)             StringBuffer类:

  StringBuffer线程安全的可变字符串。

  

1.         StringBuffer和String的区别?

  前者长度和内容可变，后者不可变。

  如果使用前者做字符串的拼接，不会浪费太多的资源。

  

2.        StringBuffer的构造方法：

            publicStringBuffer():无参构造方法

             public StringBuffer(int capacity):指定容量的字符串缓冲区对象

             public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

 

3.        StringBuffer的方法：

             public int capacity()：返回当前容量。      理论值

             public int length():返回长度（字符数）。 实际值

 

4.       StringBuffer的添加功能：

  public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

  

  public StringBuffer insert(int offset,Stringstr):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

 

5.        StringBuffer的删除功能

  public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身

  public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身

 

6.       StringBuffer的替换功能：

public StringBuffer replace(int start,intend,String str):从start开始到end用str替换

 

7.       StringBuffer的反转功能：

  public StringBuffer reverse()

 

StringBuffer的截取功能:注意返回值类型不再是StringBuffer本身了

  public String substring(int start)

  public String substring(int start,int end)

 

 

8.       String和StringBuffer的相互转换?

// String -- StringBuffer

              Strings = "hello";

// 方式1:通过构造方法

              StringBuffersb = new StringBuffer(s);

              //方式2：通过append()方法

              StringBuffersb2 = new StringBuffer();

              sb2.append(s);

 

// StringBuffer -- String

              StringBufferbuffer = new StringBuffer("java");

              //String(StringBuffer buffer)

              //方式1:通过构造方法

              Stringstr = new String(buffer);

              //方式2：通过toString()方法

              Stringstr2 = buffer.toString();

 

9.       String,StringBuffer,StringBuilder的区别?

   A:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。

   B:StringBuffer是同步的，数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高

   

10.   StringBuffer和数组的区别?

   二者都可以看出是一个容器，装其他的数据。

   但是呢,StringBuffer的数据最终是一个字符串数据。

   而数组可以放置多种数据，但必须是同一种数据类型的。

   

   3:形式参数问题

   String作为参数传递

   StringBuffer作为参数传递

   

   形式参数：

           基本类型：形式参数的改变不影响实际参数

           引用类型：形式参数的改变直接影响实际参数

   

   注意：

           String作为参数传递，效果和基本类型作为参数传递是一样的。

 

 

(五)           Arrays类

1.       Arrays的常用方法：

public static String toString(int[] a)

public static void sort(int[] a) 底层是快速排序

public static int binarySearch(int[] a,intkey)

开发原则：

       只要是对象，我们就要判断该对象是否为null。

2.       Arrays类方法应用举例：

int[] arr = { 24, 69, 80, 57, 13 };

System.out.println("排序前：" + Arrays.toString(arr));

 

public static String toString(int[] a) {

       //a-- arr -- { 24, 69, 80, 57, 13 }

 

   if (a == null)

       return "null"; //说明数组对象不存在

   int iMax = a.length - 1; //iMax=4;

   if (iMax == -1)

       return "[]"; //说明数组存在,但是没有元素。

 

   StringBuilder b = new StringBuilder();

   b.append('['); //"["

   for (int i = 0; ; i++) {

       b.append(a[i]); //"[24, 69, 80, 57, 13"

       if (i == iMax)

            //"[24, 69, 80, 57,13]"

           return b.append(']').toString();

       b.append(", "); //"[24, 69, 80, 57, "

    }

}

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

 

int[] arr = {13, 24, 57, 69, 80};

System.out.println("binarySearch:"+ Arrays.binarySearch(arr, 577));

 

public static int binarySearch(int[] a, intkey) {

       //a-- arr -- {13, 24, 57, 69, 80}

       //key-- 577

   return binarySearch0(a, 0, a.length, key);

}

 

private static int binarySearch0(int[] a,int fromIndex, int toIndex,

                                 int key) {

   //a -- arr --  {13, 24, 57, 69,80}

   //fromIndex -- 0

   //toIndex -- 5

   //key -- 577                          

                                

                                

   int low = fromIndex; //low=0

   int high = toIndex - 1; //high=4

 

   while (low <= high) {

       int mid = (low + high) >>> 1; //mid=2,mid=3,mid=4

       int midVal = a[mid]; //midVal=57,midVal=69,midVal=80

 

       if (midVal < key)

           low = mid + 1; //low=3,low=4,low=5

       else if (midVal > key)

           high = mid - 1;

       else

           return mid; // key found

    }

   return -(low + 1);  // key notfound.

}

 

 

(六)             Character 类

在对象中包装一个基本类型char 的值

此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然

1.       构造方法：

           Character(char value)

2.       成员方法

public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符

public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符

public static boolean isDigit(char ch):判断给定的字符是否是数字字符

public static char toUpperCase(char ch):把给定的字符转换为大写字符

public static char toLowerCase(char ch):把给定的字符转换为小写字符

 

为了对基本数据类型进行更多的操作，更方便的操作，Java就针对每一种基本数据类型提供了对应的类类型。包装类类型。

   byte                     Byte

   short                     Short

   int                         Integer

   long                      Long

   float               Float

   double                  Double

   char                      Character

   boolean                 Boolean

   

   用于基本数据类型与字符串之间的转换。

 

(七)           Integer类

1.       构造方法：

   publicInteger(int value)

   publicInteger(String s)

           注意：这个字符串必须是由数字字符组成

 

 

2.       int类型和String类型的相互转换

   

   int --String

           String.valueOf(number)

   

   String-- int

           Integer.parseInt(s)

 

 

3.          常用的基本进制转换

   publicstatic String toBinaryString(int i)

   publicstatic String toOctalString(int i)

   publicstatic String toHexString(int i)

4.          十进制到其他进制

   publicstatic String toString(int i,int radix)

   由这个我们也看到了进制的范围：2-36

   为什么呢?0,...9,a...z

5.        他进制到十进制

   publicstatic int parseInt(String s,int radix)

6.        JDK5的新特性

   自动装箱：把基本类型转换为包装类类型

   自动拆箱：把包装类类型转换为基本类型

   

   注意一个小问题：

           在使用时，Integer  x = null;代码就会出现NullPointerException。

           建议先判断是否为null，然后再使用。

  /