API常见类

　　——- android培训、java培训、期待与您交流！ ———-

1:Object类

(1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。
(2)Object类的构造方法有一个，并且是无参构造
这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造
(3)要掌握的方法：
A:toString()
返回对象的字符串表示，默认是由类的全路径+’@’+哈希值的十六进制表示。
这个表示其实是没有意义的，一般子类都会重写该方法。
如何重写呢?基本上就是要求信息简单明了。
但是最终还是自动生成。

package cn.itcast_02;

public class Student {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(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;
    }

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

    // @Override
    // public String toString() {
    // // return super.toString();
    // // return "hello";
    // return "姓名:" + name + ",年龄:" + age;
    // }


}

package cn.itcast_02;

/*
 * public String toString():返回该对象的字符串表示。
 * 
 * Integer类下的一个静态方法：
 *      public static String toHexString(int i)：把一个整数转成一个十六进制表示的字符串
 * 
 * 建议所有子类都重写该方法。
 * 怎么重写呢?
 *      把该类的所有成员变量值组成返回即可。
 * 重写的最终版方案就是自动生成toString()方法。
 * 
 * 注意：
 *   直接输出一个对象的名称，其实就是调用该对象的toString()方法。
 */
public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.hashCode());
        System.out.println(s.getClass().getName());
        System.out.println("--------------------");
        System.out.println(s.toString());// cn.itcast_02.Student@42552c
        System.out.println("--------------------");
        // toString()方法的值等价于它
        // getClass().getName() + '@' + Integer.toHexString(hashCode())
        // this.getClass().getName()+'@'+Integer.toHexString(this.hashCode())

        // cn.itcast_02.Student@42552c
        // cn.itcast_02.Student@42552c

        System.out.println(s.getClass().getName() + '@'
                + Integer.toHexString(s.hashCode()));

        System.out.println(s.toString());

        // 直接输出对象的名称
        System.out.println(s);
    }
}

B:equals()
比较两个对象是否相同。默认情况下，比较的是地址值是否相同。
而比较地址值是没有意义的，所以，一般子类也会重写该方法。
重写过程，我也详细的讲解和分析了。
但是最终还是自动生成。

package cn.itcast_03;

public class Student {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(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;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

//  @Override
//  public boolean equals(Object obj) {
//      // return true;
//      //这里要改进，根据这里比较的成员变量来决定返回true还是false
//      //这里其实要比价的就是name和age
//      //但是，name是String类型的，而String是引用类型的，所以，在这里不能直接用==比较，应该用equals()比较
//      //String的equals()方法是重写自Object类的，比较的是字符串的内容是否相同
//      //this -- s1
//      //obj -- s2
//      //我们要使用的是学生类的特有成员变量,所以要向下转型
//      Student s = (Student)obj; //s -- obj -- s2;
//      if(this.name.equals(s.name) && this.age == s.age) {
//          return true;
//      }else {
//          return false;
//      }
//  }

//  @Override
//  public boolean equals(Object obj) {
//      //为了提高效率
//      if(this == obj){
//          return true;
//      }
//      
//      //为了提供程序的健壮性
//      //先判断一下，obj是不是学生的一个对象，如果是，再做向下转型，如果不是，直接返回false。
//      //这个时候，我们要判断的是对象是否是某个类的对象?
//      //记住一个格式：对象名 instanceof 类名
//      //表示：判断该对象名是否是该类名一个对象
//      if(!(obj instanceof Student)){
//          return false;
//      }
//      //如果是就继续
//      
//      Student s = (Student)obj;
//      //System.out.println("同一个对象，还需要向下转型并比较吗?");
//      return this.name.equals(s.name) && this.age == s.age;
//  }


}

package cn.itcast_03;

/*
 * public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。 
 * 这个方法，默认情况下比较的是地址值。比较地址值一般来说意义不大，所以我们要重写该方法。
 * 怎么重写呢?
 *      一般都是用来比较对象的成员变量值是否相同。
 * 重写的代码优化：提高效率，提高程序的健壮性。
 * 最终版：
 *      其实还是自动生成。
 * 
 * 看源码：
 *      public boolean equals(Object obj) {
 *          //this - s1
 *          //obj - s2
 *          return (this == obj);
 *      }
 * 
 * ==:
 *      基本类型：比较的就是值是否相同
 *      引用类型：比较的就是地址值是否相同
 * equals:
 *      引用类型：默认情况下，比较的是地址值。
 *      不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同
 */
public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("林青霞", 27);
        System.out.println(s1 == s2); // false
        Student s3 = s1;
        System.out.println(s1 == s3);// true
        System.out.println("---------------");

        System.out.println(s1.equals(s2)); // obj = s2; //false
        System.out.println(s1.equals(s1)); // true
        System.out.println(s1.equals(s3)); // true
        Student s4 = new Student("风清扬",30);
        System.out.println(s1.equals(s4)); //false

        Demo d = new Demo();
        System.out.println(s1.equals(d)); //ClassCastException

    }
}

class Demo {}

(4)要了解的方法：
A:hashCode() 返回对象的哈希值。不是实际地址值，可以理解为地址值。
B:getClass() 返回对象的字节码文件对象，反射中我们会详细讲解
C:finalize() 用于垃圾回收，在不确定的时间
D:clone() 可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。
(5)两个注意问题；
A:直接输出一个对象名称，其实默认调用了该对象的toString()方法。
B:面试题
==和equals()的区别?

            A:==
                基本类型：比较的是值是否相同
                引用类型：比较的是地址值是否相同
            B:equals()
                只能比较引用类型。默认情况下，比较的是地址值是否相同。
                但是，我们可以根据自己的需要重写该方法。

2:Scanner的使用
(1)在JDK5以后出现的用于键盘录入数据的类。
(2)构造方法：
A:讲解了System.in这个东西。
它其实是标准的输入流,对应于键盘录入
B:构造方法
InputStream is = System.in;
Scanner(InputStream is)
C:常用的格式
Scanner sc = new Scanner(System.in);
(3)基本方法格式：
A:hasNextXxx() 判断是否是某种类型的
B:nextXxx() 返回某种类型的元素
(4)要掌握的两个方法
A:public int nextInt()
B:public String nextLine()
(5)需要注意的小问题
A:同一个Scanner对象，先获取数值，再获取字符串会出现一个小问题。
B:解决方案：
a:重新定义一个Scanner对象
b:把所有的数据都用字符串获取，然后再进行相应的转换

package cn.itcast_03;

import java.util.Scanner;

/*
 * 常用的两个方法：
 *      public int nextInt():获取一个int类型的值
 *      public String nextLine():获取一个String类型的值
 * 
 * 出现问题了：
 *      先获取一个数值，在获取一个字符串，会出现问题。
 *      主要原因：就是那个换行符号的问题。
 * 如何解决呢?
 *      A:先获取一个数值后，在创建一个新的键盘录入对象获取字符串。
 *      B:把所有的数据都先按照字符串获取，然后要什么，你就对应的转换为什么。
 */
public class ScannerDemo {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);

        // 获取两个int类型的值
        // int a = sc.nextInt();
        // int b = sc.nextInt();
        // System.out.println("a:" + a + ",b:" + b);
        // System.out.println("-------------------");

        // 获取两个String类型的值
        // String s1 = sc.nextLine();
        // String s2 = sc.nextLine();
        // System.out.println("s1:" + s1 + ",s2:" + s2);
        // System.out.println("-------------------");

        // 先获取一个字符串，在获取一个int值
        // String s1 = sc.nextLine();
        // int b = sc.nextInt();
        // System.out.println("s1:" + s1 + ",b:" + b);
        // System.out.println("-------------------");

        // 先获取一个int值，在获取一个字符串
        // int a = sc.nextInt();
        // String s2 = sc.nextLine();
        // System.out.println("a:" + a + ",s2:" + s2);
        // System.out.println("-------------------");

        int a = sc.nextInt();
        Scanner sc2 = new Scanner(System.in);
        String s = sc2.nextLine();
        System.out.println("a:" + a + ",s:" + s);
    }
}

3:String类的概述和使用
(1)多个字符组成的一串数据。
其实它可以和字符数组进行相互转换。

(2)构造方法：
A:public String()
B:public String(byte[] bytes)
C:public String(byte[] bytes,int offset,int length)
D:public String(char[] value)
E:public String(char[] value,int offset,int count)
F:public String(String original)
下面的这一个虽然不是构造方法，但是结果也是一个字符串对象
G:String s = “hello”;

(3)字符串的特点
A:字符串一旦被赋值，就不能改变。
注意：这里指的是字符串的内容不能改变，而不是引用不能改变。
B:字面值作为字符串对象和通过构造方法创建对象的不同
String s = new String(“hello”);和String s = “hello”的区别?

(4)字符串的面试题(看程序写结果)

    A:==和equals()
            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
   B:字符串的拼接
            String s1 = "hello";
            String s2 = "world";
            String s3 = "helloworld";
            System.out.println(s3 == s1 + s2);// false
            System.out.println(s3.equals((s1 + s2)));// true

            System.out.println(s3 == "hello" + "world");// true
            System.out.println(s3.equals("hello" + "world"));// true

(5)字符串的功能
A:判断功能
boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean startsWith(String str)
boolean endsWith(String str)
boolean isEmpty()
B:获取功能
int length()
char charAt(int index)
int indexOf(int ch)
int indexOf(String str)
int indexOf(int ch,int fromIndex)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)
C:转换功能
byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
static String valueOf(int i)
String toLowerCase()
String toUpperCase()
String concat(String str)
D:其他功能
a:替换功能
String replace(char old,char new)
String replace(String old,String new)
b:去空格功能
String trim()
c:按字典比较功能
int compareTo(String str)
int compareToIgnoreCase(String str)

(6)字符串的案例

package cn.itcast_07;

/*
 * 需求：把数组中的数据按照指定个格式拼接成一个字符串
 * 举例：
 *      int[] arr = {1,2,3};    
 * 输出结果：
 *      "[1, 2, 3]"
 * 分析：
 *      A:定义一个字符串对象，只不过内容为空
 *      B:先把字符串拼接一个"["
 *      C:遍历int数组，得到每一个元素
 *      D:先判断该元素是否为最后一个
 *          是：就直接拼接元素和"]"
 *          不是：就拼接元素和逗号以及空格
 *      E:输出拼接后的字符串
 * 
 * 把代码用功能实现。
 */
public class StringTest2 {
    public static void main(String[] args) {
        // 前提是数组已经存在
        int[] arr = { 1, 2, 3 };

        // 写一个功能，实现结果
        String result = arrayToString(arr);
        System.out.println("最终结果是：" + result);
    }

    /*
     * 两个明确： 返回值类型：String 参数列表：int[] arr
     */
    public static String arrayToString(int[] arr) {
        // 定义一个字符串
        String s = "";

        // 先把字符串拼接一个"["
        s += "[";

        // 遍历int数组，得到每一个元素
        for (int x = 0; x < arr.length; x++) {
            // 先判断该元素是否为最后一个
            if (x == arr.length - 1) {
                // 就直接拼接元素和"]"
                s += arr[x];
                s += "]";
            } else {
                // 就拼接元素和逗号以及空格
                s += arr[x];
                s += ", ";
            }
        }

        return s;
    }
}

package cn.itcast_07;

import java.util.Scanner;

/*
 * 字符串反转
 * 举例：键盘录入”abc”     
 * 输出结果：”cba”
 * 
 * 分析：
 *      A:键盘录入一个字符串
 *      B:定义一个新字符串
 *      C:倒着遍历字符串，得到每一个字符
 *          a:length()和charAt()结合
 *          b:把字符串转成字符数组
 *      D:用新字符串把每一个字符拼接起来
 *      E:输出新串
 */
public class StringTest3 {
    public static void main(String[] args) {
        // 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        /*
        // 定义一个新字符串
        String result = "";

        // 把字符串转成字符数组
        char[] chs = line.toCharArray();

        // 倒着遍历字符串，得到每一个字符
        for (int x = chs.length - 1; x >= 0; x--) {
            // 用新字符串把每一个字符拼接起来
            result += chs[x];
        }

        // 输出新串
        System.out.println("反转后的结果是：" + result);
        */

        // 改进为功能实现
        String s = myReverse(line);
        System.out.println("实现功能后的结果是：" + s);
    }

    /*
     * 两个明确： 返回值类型：String 参数列表：String
     */
    public static String myReverse(String s) {
        // 定义一个新字符串
        String result = "";

        // 把字符串转成字符数组
        char[] chs = s.toCharArray();

        // 倒着遍历字符串，得到每一个字符
        for (int x = chs.length - 1; x >= 0; x--) {
            // 用新字符串把每一个字符拼接起来
            result += chs[x];
        }
        return result;
    }
}

package cn.itcast_07;

/*
 * 统计大串中小串出现的次数
 * 举例：
 *      在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
 * 结果：
 *      java出现了5次
 * 
 * 分析：
 *      前提：是已经知道了大串和小串。
 * 
 *      A:定义一个统计变量，初始化值是0
 *      B:先在大串中查找一次小串第一次出现的位置
 *          a:索引是-1，说明不存在了，就返回统计变量
 *          b:索引不是-1，说明存在，统计变量++
 *      C:把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
 *      D:回到B
 */
public class StringTest4 {
    public static void main(String[] args) {
        // 定义大串
        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
        // 定义小串
        String minString = "java";

        // 写功能实现
        int count = getCount(maxString, minString);
        System.out.println("Java在大串中出现了：" + count + "次");
    }

    /*
     * 两个明确： 返回值类型：int 参数列表：两个字符串
     */
    public static int getCount(String maxString, String minString) {
        // 定义一个统计变量，初始化值是0
        int count = 0;

        // 先在大串中查找一次小串第一次出现的位置
        int index = maxString.indexOf(minString);

        // 索引不是-1，说明存在，统计变量++
        while (index != -1) {
            count++;
            // 把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
            int startIndex = index + minString.length();
            maxString = maxString.substring(startIndex);
            // 继续查
            index = maxString.indexOf(minString);
        }

        return count;
    }
}

package cn.itcast_07;

/*
 * 统计大串中小串出现的次数
 * 举例：
 *      在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
 * 结果：
 *      java出现了5次
 * 
 * 分析：
 *      前提：是已经知道了大串和小串。
 * 
 *      A:定义一个统计变量，初始化值是0
 *      B:先在大串中查找一次小串第一次出现的位置
 *          a:索引是-1，说明不存在了，就返回统计变量
 *          b:索引不是-1，说明存在，统计变量++
 *      C:把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
 *      D:回到B
 */
public class StringTest5 {
    public static void main(String[] args) {
        // 定义大串
        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
        // 定义小串
        String minString = "java";

        // 写功能实现
        int count = getCount(maxString, minString);
        System.out.println("Java在大串中出现了：" + count + "次");
    }

    /*
     * 两个明确： 返回值类型：int 参数列表：两个字符串
     */
    public static int getCount(String maxString, String minString) {
        // 定义一个统计变量，初始化值是0
        int count = 0;

        /*
        // 先在大串中查找一次小串第一次出现的位置
        int index = maxString.indexOf(minString);
        // 索引不是-1，说明存在，统计变量++
        while (index != -1) {
            count++;
            // 把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
            // int startIndex = index + minString.length();
            // maxString = maxString.substring(startIndex);
            maxString = maxString.substring(index + minString.length());
            // 继续查
            index = maxString.indexOf(minString);
        }
        */

        int index;
        //先查，赋值，判断
        while((index=maxString.indexOf(minString))!=-1){
            count++;
            maxString = maxString.substring(index + minString.length());
        }

        return count;
    }
}

4:StringBuffer
(1)用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了
一个字符串缓冲区类。StringBuffer供我们使用。
(2)StringBuffer的构造方法
A:StringBuffer()
B:StringBuffer(int size)
C:StringBuffer(String str)
(3)StringBuffer的常见功能(自己补齐方法的声明和方法的解释)
A:添加功能
B:删除功能
C:替换功能
D:反转功能
E:截取功能(注意这个返回值)
(4)StringBuffer的练习
A:String和StringBuffer相互转换
String – StringBuffer
构造方法
StringBuffer – String
toString()方法

B:字符串的拼接
C:把字符串反转
D:判断一个字符串是否对称

package cn.itcast_07;

import java.util.Scanner;

/*
 * 判断一个字符串是否是对称字符串
 * 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
 * 
 * 分析：
 *      判断一个字符串是否是对称的字符串，我只需要把
 *          第一个和最后一个比较
 *          第二个和倒数第二个比较
 *          ...
 *      比较的次数是长度除以2。
 */
public class StringBufferTest4 {
    public static void main(String[] args) {
        // 创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();

        // 一个一个的比较
        boolean b = isSame(s);
        System.out.println("b:" + b);

        //用字符串缓冲区的反转功能
        boolean b2 = isSame2(s);
        System.out.println("b2:"+b2);
    }

    public static boolean isSame2(String s) {
        return new StringBuffer(s).reverse().toString().equals(s);
    }


    // public static boolean isSame(String s) {
    // // 把字符串转成字符数组
    // char[] chs = s.toCharArray();
    //
    // for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
    // if (chs[start] != chs[end]) {
    // return false;
    // }
    // }
    //
    // return true;
    // }

    public static boolean isSame(String s) {
        boolean flag = true;

        // 把字符串转成字符数组
        char[] chs = s.toCharArray();

        for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
            if (chs[start] != chs[end]) {
                flag = false;
                break;
            }
        }

        return flag;
    }
}

(5)面试题
小细节：
StringBuffer：同步的，数据安全，效率低。
StringBuilder：不同步的，数据不安全，效率高。
A:String,StringBuffer,StringBuilder的区别
B:StringBuffer和数组的区别?

package cn.itcast_08;

/*
 * 面试题：
 * 1：String,StringBuffer,StringBuilder的区别?
 * A:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。
 * B:StringBuffer是同步的，数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高
 * 
 * 2：StringBuffer和数组的区别?
 * 二者都可以看出是一个容器，装其他的数据。
 * 但是呢,StringBuffer的数据最终是一个字符串数据。
 * 而数组可以放置多种数据，但必须是同一种数据类型的。
 * 
 * 3:形式参数问题
 * String作为参数传递
 * StringBuffer作为参数传递 
 * 
 * 形式参数：
 *      基本类型：形式参数的改变不影响实际参数
 *      引用类型：形式参数的改变直接影响实际参数
 * 
 * 注意：
 *      String作为参数传递，效果和基本类型作为参数传递是一样的。
 */
public class StringBufferDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1 + "---" + s2);// hello---world
        change(s1, s2);
        System.out.println(s1 + "---" + s2);// hello---world

        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println(sb1 + "---" + sb2);// hello---world
        change(sb1, sb2);
        System.out.println(sb1 + "---" + sb2);// hello---worldworld

    }

    public static void change(StringBuffer sb1, StringBuffer sb2) {
        sb1 = sb2;
        sb2.append(sb1);
    }

    public static void change(String s1, String s2) {
        s1 = s2;
        s2 = s1 + s2;
    }
}

(6)注意的问题：
String作为形式参数，StringBuffer作为形式参数。

5:数组高级以及Arrays
(1)排序
A:冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。

            public static void bubbleSort(int[] arr) {
                for(int x=0; x<arr.length-1; x++) {
                    for(int y=0; y<arr.length-1-x; y++) {
                        if(arr[y] > arr[y+1]) {
                            int temp = arr[y];
                            arr[y] = arr[y+1];
                            arr[y+1] = temp;
                        }
                    }
                }
            }

B:选择排序
把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。

public static void selectSort(int[] arr) {
        for(int x=0; x<arr.length-1; x++) {
        for(int y=x+1; y<arr.length; y++) {
            f(arr[y] < arr[x]) {
                int temp = arr[x];
                arr[x] = arr[y];
                arr[y] = temp;
                        }
                    }
                }
            }

(2)查找
A:基本查找
针对数组无序的情况

public static int getIndex(int[] arr,int value) {
        int index = -1;

        for(int x=0; x<arr.length; x++) {
            if(arr[x] == value) {
                index = x;
                break;
                    }
                }

        return index;
            }

B:二分查找(折半查找)
针对数组有序的情况(千万不要先排序，在查找)

            public static int binarySearch(int[] arr,int value) {
                int min = 0;
                int max = arr.length-1;
                int mid = (min+max)/2;

                while(arr[mid] != value) {
                    if(arr[mid] > value) {
                        max = mid - 1;
                    }else if(arr[mid] < value) {
                        min = mid + 1;
                    }

                    if(min > max) {
                        return -1;
                    }

                    mid = (min+max)/2;
                }

                return mid;
            }

(3)Arrays工具类
A:是针对数组进行操作的工具类。包括排序和查找等功能。
B:要掌握的方法(自己补齐方法)
把数组转成字符串：
排序：
二分查找：
(4)Arrays工具类的源码解析
(5)把字符串中的字符进行排序
举例：
“edacbgf”
得到结果
“abcdefg”

6:Integer
(1)为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
(2)Integer的构造方法
A:Integer i = new Integer(100);
B:Integer i = new Integer(“100”);
注意：这里的字符串必须是由数字字符组成
(3)String和int的相互转换
A:String – int
Integer.parseInt(“100”);
B:int – String
String.valueOf(100);
(4)其他的功能
进制转换
(5)JDK5的新特性
自动装箱 基本类型–引用类型
自动拆箱 引用类型–基本类型
把下面的这个代码理解即可：
Integer i = 100;
i += 200;
(6)面试题
-128到127之间的数据缓冲池问题

package cn.itcast_06;

/*
 * 看程序写结果
 * 
 * 注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据
 */
public class IntegerDemo {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);
        System.out.println(i1.equals(i2));
        System.out.println("-----------");

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);
        System.out.println(i3.equals(i4));
        System.out.println("-----------");

        Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6);
        System.out.println(i5.equals(i6));
        System.out.println("-----------");

        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8);
        System.out.println(i7.equals(i8));

        // 通过查看源码，我们就知道了，针对-128到127之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间
        // Integer ii = Integer.valueOf(127);
    }
}

4:Character
(1)Character构造方法
Character ch = new Character(‘a’);
(2)要掌握的方法：(自己补齐)
A:判断给定的字符是否是大写
B:判断给定的字符是否是小写
C:判断给定的字符是否是数字字符
D:把给定的字符转成大写
E:把给定的字符转成小写
(3)案例：
统计字符串中大写，小写及数字字符出现的次数

package cn.itcast_03;

import java.util.Scanner;

/*
 * 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
 * 
 * 分析：
 *      A:定义三个统计变量。
 *          int bigCont=0;
 *          int smalCount=0;
 *          int numberCount=0;
 *      B:键盘录入一个字符串。
 *      C:把字符串转换为字符数组。
 *      D:遍历字符数组获取到每一个字符
 *      E:判断该字符是
 *          大写  bigCount++;
 *          小写  smalCount++;
 *          数字  numberCount++;
 *      F:输出结果即可
 */
public class CharacterTest {
    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();

        // 把字符串转换为字符数组。
        char[] chs = line.toCharArray();

        // 历字符数组获取到每一个字符
        for (int x = 0; x < chs.length; x++) {
            char ch = chs[x];

            // 判断该字符
            if (Character.isUpperCase(ch)) {
                bigCount++;
            } else if (Character.isLowerCase(ch)) {
                smallCount++;
            } else if (Character.isDigit(ch)) {
                numberCount++;
            }
        }

        // 输出结果即可
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字字符：" + numberCount + "个");
    }
}

　　——- android培训、java培训、期待与您交流！ ———-