JavaAPI（Object,Arrays,包装类,String,StringBuffer,StringBuilder）

一.JavaAPI概述

        API(Application Programming Interface)应用程序编程接口

是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供

给开发人员进行使用帮助说明

二.Object类

        Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类

（父类）。所有对象（包括数组）都继承实现这个类的方法。

如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

        public class Person { ... }
        //等价于
        public class Person extends Object {
        }

equals方法

        Object类中定义有：

public boolean equals(Object obj)方法,判断对象是否相等的逻辑。

public boolean equals(Object obj) {

return (this == obj);

}

Object 中的 equals 方法默认使用==比较,比较的是对象地址,这点需

要注意. ● JDK提供的一些类，如String，Date等，重写了Object的equals方

法，调用这些类的equals方法， x.equals (y) ,当x和y所引用的对象

是同一类对象且属性内容相等返回 true 否则返回 false。

三.Arrays类

● java.util.Arrays类用于操作数组工具类，里面定义了常见操作数组的静态方法

1.equals方法

比较两个数组对象中元素是否相等. 而数组对象中的equals用来判断与另一个数组对象是否相等。

声明：public static boolean equals(type[]a,type[]a2)

参数的类型可以是原生数据类型和引用类型的任意一种类型

返回：如果两个相等，则返回true，否则返回false

 /*
            比较两个数组是否相同
         */
        int []a = {1,2,3,4};
        int []b = {1,2,3,4};
        System.out.println(Arrays.equals(a,b));

2.sort方法

● sort －排序

● 作用于数组的所有元素

public static void sort(type[] a)

● 作用于数组指定范围内的元素

public static void sort(type[] a, int fromIndex(包括), int

toIndex(不包括))

将指定的类型数组所有元素按数字升序进行排序。

l 自定义对象排序

自定义类实现Comparable接口

重写compareTo方法

 public static void main(String[] args) {

        /*
            sort()对指定的数组进行升序排序
         */
        int [] a = {5,4,3,1,2};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //Arrays.sort(a,开始排序的位置,结束排序的位置（不包含结束);
        int [] b = {5,4,3,2,1};
        Arrays.sort(b,0,3);
        System.out.println(Arrays.toString(b));
}

3.binarySearch

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

public static int binarySearch(long[] a,int fromIndex,int

toIndex,long key)

● 参数：

a - 要搜索的数组。

key - 要搜索的值。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

● 如果key在数组中，则返回搜索值的索引；否则返回负数,表示不存在

        /*
          binarySearch（）二分搜索算法查找指定元素位置，如果未找到则返回负数，前提是数组必须有序
        */

        int []c = {2,3,4,5,1};

        System.out.println(Arrays.binarySearch(c,1));
        Arrays.sort(c);
        System.out.println(Arrays.binarySearch(c,1));

4.copyof，fill，toString()方法

copyof方法

● 数组复制,将指定数组中的元素复制到一个指定长度的新数组中,并返回

新数组. ● static int[] copyOf(int[] a, int newLength)

fill方法

● 将指定的int值分配给指定的int数组的每个元素。

● fill(int[] a, int val)

toString() 方法

● public static String toString(type[] a)

● 返回指定数组内容的字符串表示形式。

/*
            copyof 数组复制
                    将原数组内容复制到一个指定长度的新数组中
         */

       int []c = Arrays.copyOf(a,10);
        System.out.println(Arrays.toString(c));

        /*
                fill（）用指定的值，将指定数组中的每个元素填充
         */

        int []d = new int[5];
        Arrays.fill(d,5);
        System.out.println(Arrays.toString(d));
        /*
              toString（）将数组中的元素内容拼接成一个字符串输出
         */

四.基本类型包装类

1.概念

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面

向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设

计类时为每个基本数据类型设计了一个对应的类进表示，这样八个和基

本数据类型对应的类统称为包装类. ● 包装类（如：Integer，Double等）这些类封装了一个相应的基本数据

类型数值，并为其提供了一系列操作方法。

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

2.用途

对于包装类来说，这些类的用途主要包含两种：

● 作为和基本数据类型对应的类类型存在。

● 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操

作方法。

3.常用方法

   public static final int MAX_VALUE 最大的int型数（231-1）
    public static final int MIN_VALUE 最小的int型数（-231）
    //构造方法
    Integer(int a);
    Integer(String a);
    //比较方法
    static int compareTo(Integer a);
    boolean equals(Object);
    int max(int a,int b);
    int min(int a,int b);
    //基本数据类型封装类
    //转换方法
    static toBinaryString(int i);
    static String toHexString(int i);
    static String toOctalString(int i);
    int intValue();
    static int parseInt(String s);
    String toString();
    static Integer valueOf(int i)
    static Integer valueOf(String s)

4.自动装箱拆箱

装箱

自动将基本数据类型转换为包装器类型

装箱的时候自动调用的是Integer的valueOf(int)方法

拆箱

自动将包装器类型转换为基本数据类型

拆箱的时候自动调用的是Integer的intValue方法

        Integer a = new Integer(128);
        Integer b = new Integer(10);
        System.out.println(b);
        String  x = "100";
        int m = Integer.valueOf(x);
        System.out.println(m);

        //自动拆箱，将引用类型转为基本类型
        int c = a;
        int d = a.intValue();   //自动拆箱默认调用intValue()方法

        //自动装箱，将基本类型转为引用类型

        /*
            在valueof()方法中如果基本类型值在-128-127之间会从缓存数组中直接取出一个Integer对象，减少创建次数
            如果两个值相同，获取的是同一个对象
            基本类型值如果不在-128-127之间，每次都创建一个新Interger对象返回

         */
        Integer y = c;
        Integer yy = Integer.valueOf(c);

        System.out.println(y == yy);
        System.out.println(y.equals(yy));

五.String类

1.String类概述

字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字

符串都是String类的实例.

 2.有两种创建形式：

第一种:

String s = "abc";

先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找

有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中

的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建.

第二种:

一概在堆中创建新对象，值存储在堆内存的对象中。

String s = new String("abc");

3.构造方法

public String()

public String(String str)

public String(byte[] bytes)

public String(char[] value)

        String s1 = new String();
        String s2 = new String("abc");

        String s3 = "你好";
        byte[] bytes = s3.getBytes(); //编码  把字符转为字节数组（数字）
        System.out.println(Arrays.toString(bytes));//[-28, -67, -96, -27, -91, -67]

        String s4 = new String(bytes); //解码，把字符数组转为字符
        System.out.println(s4);//你好

        String s5 = "你好";
        byte[] bytes1 = s5.getBytes("GBK"); //编码  把字符转为字节数组（数字）
        System.out.println(Arrays.toString(bytes));//[-28, -67, -96, -27, -91, -67]

        String s6 = new String(bytes,"UTF-8"); //解码，把字符数组转为字符
        System.out.println(s6);//你好

        String s7 = "cab";
        char []chars = s7.toCharArray(); //将字符串转为字符数组
        Arrays.sort(chars);
        String s8 = new String(chars);
        System.out.println(s8);

4.判断功能

        String s1 = new String("abc");
        String s2 = new String("abc");
        String s3 = new String("");
        System.out.println(s1.equals(s2));      //判断内容是否相等
        System.out.println(s1.equalsIgnoreCase(s2));     //判断内容是否相等（忽略大小写）
        System.out.println(s1.contains("ac"));      //判断字符串是否连续包含
        System.out.println(s3.isEmpty());       //判断字符串是否为""
        System.out.println(s1.startsWith("ab"));        //判断字符串开头字母
        System.out.println(s1.endsWith("bc"));      //判断字符串结尾字母

5.获取功能

        /*
            ●获取功能
                int length()        获取字符串长度
                char charAt(int index)      获取指定位置上的字符
                int indexOf(String str)     返回指定字符串首次出现的位置
                int indexOf(String str,int fromIndex)    从指定位置开始查找返回指定字符串首次出现的位置
                int lastindexof(string str)  从最后一次出现的位置开始查找指定字符
                String substring(int start)     从指定位置开始截取一个字符串到完
                String substring(int start,int end)     从指定位置开始开始截取一个字符串副本到指定位置（不包含结束位置）
         */

        String s = "abcdcfg";
                //  0123456
        System.out.println(s.length());
        System.out.println(s.charAt(4));
        System.out.println(s.indexOf("ab"));
        System.out.println(s.indexOf("c",4));
        System.out.println(s.substring(3));
        System.out.println(s.substring(3,5));
        StringBuffer ss = new StringBuffer(s);
        ss.substring(3);
        System.out.println(ss);

6.转换功能

    /*
    转换功能
        byte[] getBytes()       将字符串转为byte数组
        char[] toCharArray()    将字符串转为字符数组
        static String valueOf(char[] chs)
        static String valueOf(int a)   将传入的参数转为字符串类型
        String toLowerCase()        将英文字母转为小写
        String toUpperCase()        将英文字母转为大写
        String concat(String str)   拼接指定的字符串内容到原字符串末尾，返回到一个新的字符串对象
        Stirng[] split(分割符);
     */

    public static void main(String[] args) {
        String s1 = "abcdef";
        System.out.println(s1.getBytes());
        String s = String.valueOf(1000);
        System.out.println(s);
        String ss = String.valueOf("abc".toCharArray());
        System.out.println(ss);

        String s2 = "ab;cd;EFG";
        System.out.println(s2.toLowerCase());
        System.out.println(s2.toUpperCase());
        System.out.println(s2.concat("aaa"));
        String[] strings = s2.split(";");
        System.out.println(Arrays.toString(strings));

7.替换功能

        /*
            替换功能
                String replace(char old,char new)
                String replace(String old,String new)   用新内容替换字符串中指定的字符串
                replaceAll(String regex, String replacement)    用新内容替换字符串中正则表达式匹配的字符串
                replaceFirst(String regex, String replacement)  用新内容替换字符串中正则表达式匹配的字符串  只替换第一个
            去除字符串两空格
                String trim()
         */

        String s1 = " abc2d2e ";
        System.out.println(s1.replace("c","a"));
        System.out.println(s1.replaceAll("\\d","9"));
        System.out.println(s1.replaceFirst("\\d","9"));
        System.out.println(s1.trim());
        System.out.println(s1.trim().length());
        System.out.println(s1);

六.StringBuffer和StringBuilder

1.StringBuffer类概述

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String

对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题

线程安全的可变字符序列

2.使用

        /*
            String声明的字符串对象值一旦给定就不能改变了
            每次拼接都会创建新的字符串对象，耗时，占用空间

            StringBuffer是内容可以改变的字符串
            char[] value 没有使用final修饰，每次添加内容都是对此数组进行操作
            不会创建新的字符串对象
         */

        StringBuffer s1 = new StringBuffer(16);  //创建内容长度为+16的char数组

        StringBuffer s2 = new StringBuffer();  //空参的构造方法    指定底层数组长度是16

        StringBuffer s3 = new StringBuffer(10);//指定数组容量
                    s3.append("abxdax");//像字符串末尾添加内容
                    s3.append("qw");
                    s3.append("mkz");
        System.out.println(s3);
                    s3.insert(2,"c");//向指定位置插入指定的字符串
        System.out.println(s3);
                    s3.deleteCharAt(2); //删除指定位置上的字符
        System.out.println(s3);
                    s3.delete(0,3); //删除指定区间的元素 包含开始位置，不包含结尾的
        System.out.println(s3);
                    s3.replace(0,3,"AAA");      //将区间内容替换
        System.out.println(s3);
                    s3.reverse();//反转数组
        System.out.println(s3);

3.String类StringBuffer类StringBuilder区别

            String:是一个值不可以改变的字符串

            StringBuffer:   值可以改变且不需要创建新的对象，  方法上都加了锁，是在多线程（任务）执行时是安全的

            StringBuilder:  值可以改变且不需要创建新的对象， 由于方法上都没有枷锁，在多线程（任务）执行时是不安全的，适合单线程