23个常用类大全

1.API

概述：

全称：Application programing Interface应用程序编程接口 相当于Java使用说明书。

2.Object类(hashCode();)

概述：

类层次的根

所有类都直接或间接的继承该类

构造方法：

public Object(){}

/*Object类
* 概述：类Object是类层次结构的根类，每个类都使用Object作为超类。
*
*方法：public int hashCode()：返回此对象的一个哈希码值，类Object定义的hashCode方法确实为不同的对象返回不同的整数。 （这一般是将该对象的内部地址转换成一个整数来实现的）
 *
 * 理解：1.返回的整数就是所谓的哈希码值
 *      2.哈希码值是根据实际地址转换而来
 *      3.虽然不是真实地址，但是在理解上，我们可以认为它代表地址。
 *  */
public class ObjectDemo {
    public static void main(String[] args){
        ObjectDemo od1 = new ObjectDemo();
        System.out.println(od1.hashCode());//1854778591

        ObjectDemo od2 = new ObjectDemo();
        System.out.println(od2.hashCode());//2054798982
        ObjectDemo od3 = od2;
        System.out.println(od3.hashCode());//2054798982
    }

}

3.Object_getClass()

package org.wdit.unit10;
/*
* Object类
*         getClass（）
*          格式：public final class getClass()
*           返回值：Class类
*                  public String getName()返回此类对象表示的实体名称（类，接口，数组类，基本类型或void），作为String 。
* */
public class ObjectDemo2 {
    public static void main(String[] args) {
        ObjectDemo2 od1=new ObjectDemo2();
        Class c=od1.getClass();
        System.out.println(c.getName());
    }
}

4.Object_toString()

package org.wdit.unit10;
/*Object类-------toString方法
                  返回对象的字符串表示形式。
                  通常， toString方法返回一个“文本表示”此对象的字符串。
                  结果应该是简洁但信息丰富的表示，便于人们阅读。 建议所有子类都覆盖此方法。
*
*toString()方法建议子类都进行重写，重写的内容一般是该子类所有的属性信息。
*
* */
public class ObjectDemo3 {
    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());
        //getClass().getName() + '@' + Integer.toHexString(hashCode())
       String b= s.getClass().getName()+'@'+Integer.toHexString(s.hashCode());
        System.out.println(b);
        System.out.println("-------------------------");
        s.setName("周杰伦");
        s.setAge(18);
        System.out.println("name:"+s.getName()+","+"age:"+s.getAge());
        System.out.println("--------------------");
        System.out.println(s.toString());
    }
}

5.Object_equals()

6.Object_equals()优化

7.Object_clone()

package org.wdit.unit10;
/*object类----clone方法
*     1.protected Object clone（）；创建并返回此对象的副本。
*       首先，要实现复制，被复制的类要实现Cloneable接口，此接口叫标记接口，实现它的含义是调用Clone（）方法时是合法的
*        然后必须重写Object的Clone()方法。因为该方法是protected修饰的，只能在子类中被访问。
*
*    2.protected void finalize();当垃圾收集确定没有对该对象的更多引用时，由对象上的垃圾收集器调用。
*     虽然我们告诉垃圾回收器可以回收该对象，但是，垃圾回收器只有等他空闲的时候才会执行该操作

 */
public class ObjectDemo5 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student();
        s1.setName("周杰伦");
        s1.setAge(18);
        System.out.println(s1.toString());
        System.out.println("-----------------");
        Object object=  s1.clone();
        Student s2=(Student)object;
        System.out.println(s2.toString());
        System.out.println("-------------------------");

        Student s3=s1;
        System.out.println(s3.toString());
        System.out.println("-------------------------");

        s1.setName("空燃比");
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println(s3.toString());

    }
}

8.String 类

概述：

字符串是由多个字符组成的一串数据（字符序列）

字符串可以看成字符数组

构造方法：

• public String()

• public String(byte[]bytes)

• public String (byte[]bytes,int offset,int length)

• public String(char[]value)

• public String (char[]value,int offset,int count)

• public String(String original)

package org.wdit.unit10.String;
/*
* 字符串：由多个字符组成的一串数据。它可以看成一个字符数组
*   通过API我们学习到了两点：
*         1.字符串的字面值“abc”可以被看成字符串对象。
*         2.字符串是常量，一旦被赋值就不能改变
*  构造方法：
*  public String()无参构造
 public String(byte[]bytes)把字节数组转换成字符串
public String (byte[]bytes,int index,int length)把字节数组中的一部分转换成字符串，从index开始转length个长度
public String(char[]value)把字符数组转换成字符串
public String (char[]value,int index,int count)把字符数组中的一部分转换成字符串，从index开始转count个长度
public String(String original)把字符串常量转换为字符串
*
* 字符串方法：
*     public int length()返回此字符串的长度。
* */
public class StringDemo {
    public static void main(String[] args) {
        //public String()无参构造
        String s1 = new String();
        s1="你好";
        System.out.println(s1);
        System.out.println(s1.length());
        System.out.println("-----------------");


        // public String(byte[]bytes)把字节数组转换成字符串
        byte[] bytes = {97, 98, 99,100};
        String s2 = new String(bytes);
        System.out.println(s2);
        System.out.println(s2.length());
        System.out.println("-------------");


        //String (byte[]bytes,int index,int length)把字节数组中的一部分转换成字符串，从index开始转length个长度
        String s3 = new String(bytes, 1, 2);
        System.out.println(s3);
        System.out.println(s3.length());
        System.out.println("----------");


        //public String(char[]value)把字符数组转换成字符串
        char[] chars = {'a', 'b', 'c', '你', '好'};
        String s4 = new String(chars);
        System.out.println(s4);
        System.out.println(s4.length());
        System.out.println("-----------");

        //public String (char[]value,int index,int count)把字符数组中的一部分转换成字符串，从index开始转count个长度
        String s5 = new String(chars, 3, 2);
        System.out.println(s5);
        System.out.println(s5.length());
        System.out.println("----------");


        //public String(String original)把字符串常量转换为字符串
        String s6 = new String("abc");
        System.out.println(s6);
        System.out.println(s6.length());
        System.out.println("---------");
    }
}

特点：字符串是常量，它的值在赋值后不会改变。引用可以

成员方法：

1.判断方法：

1. boolean equals(Object obj)：比较字符串是否相同

2. boolean equalsIgnoreCase（String str）：比较字符串是否相同，（忽略大小写)

3. boolean contains（String str）：判断字符串是否包含以str

4.boolean startsWith（String str）：判断字符串是否以“str”开头

5.boolean endsWith（String str）：判断字符串是否以“str”结尾

6.boolean isEmpty（）：判断字符串是否为空

注意：字符串内容为空与字符串对象为空的区别？

package org.wdit.unit10.String;
/*String类---判断功能
boolean equals(Object obj)：比较字符串是否相同（区分大小写）
boolean equalsIgnoreCase（String str）：比较字符串是否相同，（忽略大小写)
boolean contains（String str）：判断字符串是否包含以str
boolean startsWith（String str）：判断字符串是否以“str”开头
boolean endsWith（String str）：判断字符串是否以“str”结尾
boolean isEmpty（）：判断字符串是否为空
区分：
String s=“”；空字符串
String s=null；空引用
**/
public class StringDemo2 {
    public static void main(String[] args) {
       //创建字符串对象
        String s1 = "abcdef";
        String s2 = "abcdef";
        String s3 = "AbcDeF";
        //1.boolean equals(Object obj)：比较字符串是否相同（区分大小写）
        System.out.println("equals:"+s1.equals(s2));
        System.out.println("equals:"+s1.equals(s3));
        System.out.println("-----------------");


        //2.boolean equalsIgnoreCase（String str）：比较字符串是否相同，（忽略大小写)
        System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));
        System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s3));
        System.out.println("-----------------------");

        //3.boolean contains（String str）：判断字符串是否包含以"str"
        System.out.println("contains:"+s1.contains("cd"));//true
        System.out.println("contains:"+s1.contains("af"));//false
        System.out.println("contains:"+s1.contains("ace"));//false
        System.out.println("-----------------------");

        //4.boolean startsWith（String str）：判断字符串是否以“str”开头
        System.out.println("startsWith"+s3.startsWith("Ab"));
        System.out.println("startsWith"+s3.startsWith("Ae"));//flase
        System.out.println("startsWith"+s3.startsWith("b"));
        System.out.println("------------------------------");

        //5.boolean endsWith（String str）：判断字符串是否以“str”结尾
        System.out.println("endsWith"+s3.endsWith("F"));
        System.out.println("endsWith"+s3.endsWith("eF"));
        System.out.println("endsWith"+s3.endsWith("cF"));
        System.out.println("------------------------------");

        //6.boolean isEmpty（）：判断字符串是否为空
        String s4 = "";//有对象，值为空
        String s5=null;//无对象，空引用
        System.out.println(s4.isEmpty());//true
        System.out.println(s5.isEmpty());//空指针异常
    }
}

2.获取方法：

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

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

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

4.int indexOf(String str):返回指定字符串在当前字符串中第一次出现的索引，如果不出现返回-1

5.int indexOf(int ch,int fromIndex):返回指定字符在指定位置后第一次出现的索引

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

7.String subString(int start):从指定位置截取当前字符串

8.String subString(int start，int end)：从指定位置开始到指定位置结束。

package org.wdit.unit10.String;
/*String 获取功能练习
1.int length():获取字符串的长度
2.char charAt(int index):获取指定位置索引的字符
3.int indexOf(int ch):返回指定字符在此字符串中第一次出现的索引
4.int indexOf(String str):返回指定字符串在当前字符串中第一次出现的索引
5.int indexOf(int ch,int fromIndex):返回指定字符在指定位置后第一次出现的索引
6.int indexOf(String str,int fromIndex):返回指定字符串在指定位置后第一次出现的索引
7.String subString(int start):从指定位置截取当前字符串
8.String subString(int start，int end)：从指定位置开始到指定位置结束。*/
public class StringDemo3 {
    public static void main(String[] args) {
        String s ="HelloWorld!";
        //1.int length():获取字符串的长度
        System.out.println("length():"+s.length());
        //2.char charAt(int index):获取指定位置索引的字符
        System.out.println("charAt():"+s.charAt(5));
        //3.int indexOf(int ch):返回指定字符在此字符串中第一次出现的索引
        System.out.println("indexOf():"+s.indexOf("l"));
       // 4.int indexOf(String str):返回指定字符串在当前字符串中第一次出现的索引
        System.out.println("indexOf():"+s.indexOf("or"));
       // 5.int indexOf(int ch,int fromIndex):返回指定字符在指定位置后第一次出现的索引
        System.out.println("indexOf():"+s.indexOf("l",5));
        //6.int indexOf(String str,int fromIndex):返回指定字符串在指定位置后第一次出现的索引
        System.out.println("indexOf():"+s.indexOf("or",5));
       // 7.String subString(int start):从指定位置截取当前字符串
        System.out.println("subString():"+s.substring(5));
       // 8.String subString(int start，int end)：从指定位置开始到指定位置结束。
        System.out.println("subString():"+s.substring(5,7));
    }
}

3.String类转换功能：

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

for（byte b ：bytes）{}

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

3.static String valueOf(char [] chs):把字符数组转换为字符串

4.static String valueOf(int i):把任意数据类型转换为字符串,想传什么形式都行

5.String toLowerCase():把字符串转换为小写

6.String toUpperCase():把字符串转换为大写

7.String concat(String str)：拼接字符串

4.替换功能

String replace（char old ,char new）

String replace（String old String new）

5.去除字符串两端的空格

String trim（）

6.按字典顺序比较字符串

int compareTo（String str）

int compareToIgnoreCase（String str）

9.StringBuffer

概述：

• 我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String 对象，既降低了效率，又浪费系统资源。而StringBuffer就可以解决这个问题。

• 线程安全的的可变字符序列

构造方法：

public StringBuffer()

public StringBuffer(int capacity)初始容量

public StringBuffer(String str)

1.添加功能

public StringBuffer append(String str) public StringBuffer insert(int offest,String str)在指定索引之前加

2.删除功能

public StringBuffer deleteCharAt(int index）

public StringBuffer delete(int start，int end ）

3./替换功能

public StringBuffer replace(int start，int end ，String str)

4.反转功能

public StringBuffer reverse()

package org.wdit.unit10.String.Stringbuffer;
/*线程安全：（多线程）
        安全-----同步-----数据安全性
        不安全----不同步----数据的访问效率


//添加功能

public StringBuffer append(String str)
public StringBuffer insert(int offest,String str)在指定索引之前加
//删除功能

public StringBuffer deleteCharAt(int index）
public StringBuffer delete(int start，int end ）
//替换功能
public StringBuffer replace(int start，int end ，String str)
//反转功能
public StringBuffer reverse()

*    */
public class StringbufferDemo {
    /***构造方法：**
     public StringBuffer()
     public StringBuffer(int capacity)创建一个指定容量的字符串缓冲区对象
     public StringBuffer(String str)*/
    public static void main(String[] args) {
        //1.无参构造
        StringBuffer sb = new StringBuffer();
        System.out.println("sb:"+sb);
        //2.public int capacity()查看缓冲区大小
        System.out.println("容量："+sb.capacity());
        System.out.println("长度："+sb.length());
        System.out.println("------------");
        //3.public StringBuffer(int capacity)
        StringBuffer sb2=new StringBuffer(1024);
        System.out.println("容量："+sb2.capacity());
        System.out.println("长度："+sb2.length());
        System.out.println("------------");

        String s="我是字符";
        StringBuffer sb3=new StringBuffer(s);
        System.out.println("容量："+sb3.capacity());
        System.out.println("长度："+sb3.length());
        System.out.println("------------");

        /*添加功能*/
     //public StringBuffer append(String str)
        StringBuffer sb4=new StringBuffer();
        sb4.append("Hello");
        System.out.println("sb4:"+sb4);

        //public StringBuffer insert(int offest,String str)在指定索引之前加
        sb4.insert(4,"----");
        System.out.println(sb4);

        /*删除功能
        * */
        StringBuffer sb5=new StringBuffer();
        sb5.append("hxrrrrrrrrrrrrrr");
       // sb5.deleteCharAt(0);

       sb5.delete(5,9);//包含左边，不包含右边
        System.out.println(sb5);


        //替换功能  public StringBuffer replace(int start，int end ，String str)包左不包右

        StringBuffer sb6=new StringBuffer();
        sb6.append("hxhellojava");
        System.out.println("sb6:"+sb6);
        sb6.replace(2,5,"qiyang");
        System.out.println("----------");
        System.out.println("sb6:"+sb6);

        //反转功能  public StringBuffer reverse()
        StringBuffer sb7=new StringBuffer();
        sb7.append("hxhellojava");
        System.out.println("sb7:"+sb7);
        System.out.println("----------");
        System.out.println("sb7:"+sb7.reverse());

    }
}

5.截取方法：

• public String substring (int start)

• public String substring(int start,int end)

  与之前的方法不同：

• 返回值类型不同

• 截取的内容并不影响原内容数据

1.String和StringBuffer相互转换

 

package org.wdit.unit10.String.Stringbuffer;
/*
* String 和StringBuffer相互转换问题*/
public class StringBufferDemo2 {
    public static void main(String[] args) {
        //1.String---------->StringBuffer
        String s1="Hello";
                   //a.构造方法
        StringBuffer sb=new StringBuffer(s1);
                   //b.append方法
        StringBuffer sb1=new StringBuffer();
        sb.append(s1);


        //2.StringBuffer---------->String
      StringBuffer sb2=new StringBuffer("Hello");
        //a.构造方法
        String  s2=new String(sb2);
        System.out.println(s2);
        //b.使用toString方法
        String s3 = sb2.toString();
        System.out.println(s3);
    }


}

2.package org.wdit.unit10.String.Stringbuffer;
/*练习：将数组拼接成字符串*/
public class StringBufferTest {
    public static void main(String[] args) {
      int[]arr={24,35,77,2,18};
      String s1=arrayToString(arr);
        System.out.println("方式1："+s1);
        String s2=arrayToStringBuffer(arr);
        System.out.println("方式2："+s2);

    }


    /**
     * 将数组转换为字符串
     * @param arr  被转换数组
     * @return  所的字符串
     */
    public static String arrayToString(int[] arr) {

        String s1 = "";
        s1 = s1.concat("[");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                s1 = s1.concat(arr[i] + ",");
            } else {
                s1 = s1.concat(arr[i] + "]");
            }
        }
        return s1;
    }
    //方法2：使用StringBuffer改进
    public  static String arrayToStringBuffer(int[]arr){
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
               sb.append(arr[i]).append(",");
            } else {
                sb.append(arr[i]).append("]");
            }
        }
        String s2=new String(sb);
        return s2;
    }

3.判断字符串是否是对称字符串

package org.wdit.unit10.String.Stringbuffer;
/*练习2.判断一个字符串是否是对称字符串
*     比如：abcNcba，asdpdsa
*    分析：
*          1，第一个和最后一个比较
*          2，第二个和倒数第二个比较
             ..............
*          比较的次数是：length/2
*/

public class StringBufferTest2 {
    public static void main(String[] args) {
        String str="abcdcb";
       // System.out.println(isDuiCheng(str));
        System.out.println(isDuiCheng2(str));
    }

    /*//方法一
    public static boolean isDuiCheng(String str) {
        //1.将字符串转换为字符数组
        char[] chars = str.toCharArray();
        boolean flag=true;
        //2.循环比较
        for (int start = 0, end = chars.length - 1; start <= end; start++, end--) {
            if (chars[start] != chars[end]) {
                return false;

            }
        }

        return flag;
    }*/


    //2.方法2
    public static boolean isDuiCheng2(String str){
       /** StringBuffer sb=new StringBuffer(str);
        sb.reverse();
        String s=sb.toString();
        if(s.equals(str)){
            return true;

        }else{
            return false;
        }*/
    return  new StringBuffer(str).reverse().toString().equals(str);
    }

}

数组（高级）

10.冒泡排序

•相邻两个元素依次比较，较大的向后移动，一轮比较之后，最大值就会移动到数组最大索引处

•多轮比较之后，我们会得到一个已排序好的序列

规律：

1.相邻元素比较，大的后移

2.每完成一次比较，下一次比较的元素会较少一个

3.每一轮比较次数会递减一，最多数组长度减一轮

package org.wdit.unit10.Array;
/**
 * 冒泡排序:
 *      相邻两个元素依次比较，较大的向后移动，一轮比较之后，最大值就会移动到数组最大索引处
 *      多轮比较之后，我们会得到一个已排序好的序列
 */
public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = {25, 71, 88, 54, 9};
        System.out.println("排序前：");
        printArray(arr);
        //调用冒泡排序的方法
        bubbleSort(arr);
       

   /*     //第一轮比较
        for (int i = 0; i < arr.length-1; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;

            }
        }
        System.out.println("第一轮比较");
        printArray(arr);
        //第二轮比较
        for (int i = 0; i < arr.length-1-1; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;

            }
        }
        System.out.println("第二轮比较");
        printArray(arr);
        //第三轮比较
        for (int i = 0; i < arr.length-1-1-1; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;

            }
        }
        System.out.println("第三轮比较");
        printArray(arr);*/

        /*//冒泡排序代码
        for(int j=0;j<arr.length-1;j++){
            for (int i = 0; i < arr.length-1-j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;

                }
            }

        }
        System.out.println("冒泡排序后：");
        printArray(arr);*/
    }


        /*冒泡排序
         * */
        public static void bubbleSort(int[]arr){
            for (int j = 0; j < arr.length - 1; j++) {
                for (int i = 0; i < arr.length - 1 - j; i++) {
                    if (arr[i] > arr[i + 1]) {
                        int temp = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = temp;

                    }
                }

            }
            System.out.println("冒泡排序后：");
            printArray(arr);
        }

    //遍历数组的方法
    public static void printArray(int[]arr){
        System.out.print("[");
        for (int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                System.out.print(arr[i]);
            }else{
                System.out.print(arr[i]+", ");
            }

        }
        System.out.println("]");
    }
}

11.选择排序

•返从0索引开始，依次与后面的元素进行比较，较小的元素与0索引的元素进行交换，一轮比较之后，最小值会出现在最小索引处

规律：

1.比较次数：数组长度减一

2.第一次从索引0

第二次从索引1.........

3.最后一次比较的是索引为length-2与索引为length-1比较

package org.wdit.unit10.Array;

import java.util.jar.JarOutputStream;

/**
 * 选择排序
 *      返从0索引开始，依次与后面的元素进行比较，较小的元素与0索引的元素进行交换，
 *      一轮比较之后，最小值会出现在最小索引处
 */
public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = {25, 71, 88, 54, 9};
        System.out.println("排序前：");
        printArray(arr);
        selectSort(arr);
        System.out.println("选择排序后");
        printArray(arr);

       /* //第一轮比较
        int j=0;
        for(int i=1;i<arr.length;i++){
            if(arr[i]<arr[j]){
                int temp=arr[j];
                arr[j]=arr[i];
                arr[i]=temp;
            }
        }
        System.out.println("第一轮比较：");
        printArray(arr);
        //第二轮比较
         j=1;
        for(int i=j+1;i<arr.length;i++){
            if(arr[i]<arr[j]){
                int temp=arr[j];
                arr[j]=arr[i];
                arr[i]=temp;
            }
        }
        System.out.println("第二轮比较：");
        printArray(arr);
        //第三轮比较
         j=2;
        for(int i=1+j;i<arr.length;i++){
            if(arr[i]<arr[j]){
                int temp=arr[j];
                arr[j]=arr[i];
                arr[i]=temp;
            }
        }
        System.out.println("第三轮比较：");
        printArray(arr);*/
    }
    //选择排序
    public static void selectSort(int[]arr){
        for(int j=0;j<arr.length-1;j++) {
            for (int i = 1 + j; i < arr.length; i++) {
                if (arr[i] < arr[j]) {
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
    }
    //遍历数组的方法
    public static void printArray(int[]arr){
        System.out.print("[");
        for (int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                System.out.print(arr[i]);
            }else{
                System.out.print(arr[i]+", ");
            }

        }
        System.out.println("]");
    }
}

12.查找

• 基本查找：数组可以是无序的

• 二分查找（折半查找）：数组必须是有序的

思想：每次都找中间元素，比较大小，每找一次就可以排除一半的元素

13.Arrays工具类

概述：

• 针对数组进行操作的工具类

• 提供了排序，查找功能

成员方法：

• public static String toString(int[]a)

• public static void sort(int[]a)

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

package org.wdit.unit10.Array;

import java.util.Arrays;

/*Arrays：
*     此类包含用来操作数组（比如排序和搜索）的各种方法。
* 1.遍历：public static String toString(int[] a)返回指定数组内容的字符串表示形式。
* 2.排序：public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序。
* 3.查找：public static int binarySearch(int[] a,int key)使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。*/
public class ArrayDemo4 {
    public static void main(String[] args) {
        int[]arr={35,46,33,2,224589,78,90};
       //遍历Arrays.toString,排序sort
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        System.out.println("排序后：");
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //查找
        System.out.println("binarySearch元素所在索引:"+Arrays.binarySearch(arr,33));

    }
}

14.基本类型的包装类

包装类概述：

1. 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

2. 常用操作：用于基本数据类型与字符串之间的转换

基础数据对应的包装类类型

byte---Byte

short----Short

int---Integer

long---Long

float---Float

double--Double

boolean---Boolean

char--Character

Integer构造方法

public Integer(int value)
构造一个新分配的 Integer 对象，它表示指定的 int 值。

public Integer(String s)
        throws NumberFormatException
        构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

注意：字符串中只能含有数字 不能含其他字符

int类型和String类型相互转换

int--------String

int s=88;
1.String s1=s+"";

2.String s2=String.valueOf(s);

3.Integer ss=new Integer(s);
String s3=ss.toString();

4.String s4=Integer.toString(s)

String----int

1.Integer i=new Integer(s);
int a=i.intValue();

2.int b=Integer.parseInt(s);

• public int intValue()

• public static int parseInt(String s)

• public static Integer valueOf(String s)

• public static String toString(int i)

• public static Integer valueOf(int i)

15.自动拆箱，自动装箱

自动装箱：

将基本数据类型转化为相应的包装类

注意；在装箱时，编译器会自动判断是否在-128~127之间，超出范围会new一个地址，在范围之内会直接用byte常量池

自动拆箱：

将包装类转换为相应的基本数据类型、

注意：在使用自动拆箱时，建议先判断，是否为null，然后再使用

16.Character类

概述：

• Character类在对象中包装一个基本数据类型char的值

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

构造方法

public Character（char value）构造一个新分配的 Character 对象，用以表示指定的 char 值。

成员方法

public static boolean iaUpperCase（char ch）

public static boolean iaLowerCase(char ch)

public static boolean isDigit(char ch)

public static char toUpperCase(char ch)

public static char toLowerCase(char ch)

17.正则表达式

 

1.字符

• x 字符 x

• \\ 反斜线字符

• t 制表符 ('\u0009')

• \n （换行）符('\u000A')

• \r 回车符 ('\u000D')

• \f 换页符 ('\u000C')

2.字符类

• [abc] a、b 或 c（简单类）

• [^abc] 任何字符，除了 a、b 或 c（否定）

• [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）

3.预定义

.任何字符

\d：数字，【0-9】

\D:非数字，【^0-9】

\s:空白字符【\t\n\x98\f\r】

\S:非空白字符【^\s】

\w:单词字符【a-zA-Z_0-9】

\W:非单词字符【^\w】

 

5.Greedy 数量词

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次 X{n} X，恰好 n 次 X{n,} X，至少 n 次 X{n,m} X，至少 n 次，但是不超过 m 次

18.System类

概述

System类包含一些有用的类字段和方法，它不能被实例化。

成员方法

• public static void gc()

  运行垃圾回收器（Object finalize)

• public static long currentTimeMills()

• public static void exit(int staus)

• public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

19.BigInteger类

概述

可以让超过Integer范围内的数据进行运算

构造方法

public BigInteger(String val)

成员方法

• public BigInteger add(BigInteger val)

• public BigInteger substract(BigInteger val)

• public BigInteger multiply(BigInteger val)

• public BigInteger divide(BigInteger val)

• public BigInteger[]divideAndRemainder (BigInteger val)

20.BigDecimal类

概述

• 不可变的、任意精度的有符号十进制数

由来

由于在运算时，float和double很容易丢失精度，所以为了能精确地表示、计算浮点数，Java提供了BigDecimal

构造方法

public BigDecimal（String val）

成员方法

• public BigDecimal add(BigDecimal a)

• public BigDecimal substract(BigDecimal a)

• public BigDecimal multiply(BigDecimal a)

• public BigDecimal divide(BigDecimal a)

• public BigDecimal divide(BigDecimal a,int scale,int roundingMode)

21.Date类

概述

类Date表示特定的瞬间

构造方法

public Date()

public Date(long date)

成员方法

public long getTime()

public void setTime(long time)

22.DateFormat

概述

• DateFormat是日期/时间格式子类对象的抽象类，它以语言无关的方式格式化并解析日期或时间

• 是抽象类，所以使用其子类SimpleDateFormat

SimpleDateFormat构造方法

• public SimpleDateFormat()

• public SimpleDateForamt(String pattern)

成员方法

• public final String format(Date date)

• public Date parse(string source)

• 字母	日期或时间元素	表示	示例
  G	Era 标志符	Text	AD
  y	年	Year	1996; 96
  M	年中的月份	Month	July; Jul; 07
  w	年中的周数	Number	27
  W	月份中的周数	Number	2
  D	年中的天数	Number	189
  d	月份中的天数	Number	10
  F	月份中的星期	Number	2
  E	星期中的天数	Text	Tuesday; Tue
  a	Am/pm 标记	Text	PM
  H	一天中的小时数（0-23）	Number	0
  k	一天中的小时数（1-24）	Number	24
  K	am/pm 中的小时数（0-11）	Number	0
  h	am/pm 中的小时数（1-12）	Number	12
  m	小时中的分钟数	Number	30
  s	分钟中的秒数	Number	55
  S	毫秒数	Number	978
  z	时区	General time zone	Pacific Standard Time; PST; GMT-08:00
  Z	时区	RFC 822 time zone	-0800

两种应用场景：

Date--------String（格式化）

String------Date（解析）

23.Calender类

概述

Calender类是一个抽象的类，它为特定瞬间与一组诸如YEAR、MONTH（从0开始）、DAY_OF_MOTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

成员方法

• public static Calendar getInstance()获取对象

• public int get(int field)

• public void add(int field,int mount)

• public final void set(int year,int month,int date)