Java基础/新手入门之API(part01)

常用类(API)

API

API(Application Programming Interface)应用程序编程接口,是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明.

1)语言中提供的类、接口；2)对类、接口功能的说明文档。

基本数据类型包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类。

即Java为每种基本类型提供了一个类，这些类被称为包装类.

这些包装类分别封装了一个相应的基本数据类型，并为其提供了一系列操作方法。

以Integer包装类为例：

public static void main(String[] args) {
        //基本数据类型包装类:Byte,Short,Character,Integer,Long,Float,Double,Boolean
        //7个基本数据类型:byte,int,short,long,float,double,boolean
        int num = 5;
        Integer num1 = new Integer(num);//将int值包装在Integer类的对象中
        Integer num2 = new Integer("11");//把字符串类型数值转换为int值

        //Integer类中就可以提供很多的方法来对int类型进行操作
        System.out.println(Integer.MAX_VALUE);//最大的int型数
        System.out.println(Integer.MIN_VALUE);//最小的int型数
        System.out.println(Integer.SIZE);//int类型32位
        System.out.println(Integer.BYTES);//int类型4个字节

        System.out.println(num1.compareTo(num2));//num1 和num2 比较.    小于返回-1;等于返回0;大于返回1

        System.out.println(num1.equals(num2));//比较数值.      相等时返回true,不相等返回false
        System.out.println(num1==num2);//引用类型比较两对象内存地址.   相等时返回true,不相等返回false

        //转换方法
        System.out.println(Integer.toBinaryString(13));//Binary 将10进制数转换成2进制数
        System.out.println(Integer.toOctalString(11));//Octal 转换成8进制数
        System.out.println(Integer.toHexString(28));//Hex 转换成16进制数
        System.out.println(num1.intValue());//取出对象中包含的具体的值
        System.out.println(Integer.parseInt("77"));//把字符串类型转换成int类型   输出77
        System.out.println(Integer.toString(123));//把数值类型转换成字符串类型
        System.out.println(Integer.valueOf(num2));//static Integer valueOf(int i)
        System.out.println(Integer.valueOf("526"));//static Integer valueOf(String s)
    }

装箱和拆箱：

装箱(Auto-boxing):

• 自动将基本类型装换为包装类类型
• 装箱的时候自动调用的是Integer的valueOf()方法

拆箱(unboxing):

• 自动将包装类类型装换为基本数据类型
• 拆箱的时候自动调用的是Integer的intValue()方法

 public static void main(String[] args) {
        //构造方法
        Integer num0 = new Integer(10);
        Integer num1 = new Integer(10);
        System.out.println(num0.equals(num1));//true
        System.out.println(num0==num1);//false
       
        int a = 127;
/*      
        Integer num2 = Integer.valueOf(127);
        Integer num3 = Integer.valueOf(127);
 */
        Integer num2 = a;//自动装箱
        Integer num3 = a;
        
        //使用装箱valueOf在创建对象时,值值如果在-128~127之间如果多个值相同,指向的时内存中同一个地址
        System.out.println(num2.equals(num3));//true
        System.out.println(num2==num3);//true ,false

        //将引用类型转换为基本类型
//    int b = num3.intValue();
        int b = num3;//自动拆箱
    }

Object类

Object类是java中所有类的父类。

**常用方法：**将对象输出时，会调用toString()方法;做比较时，会调用equals()方法，等同于 ==

  public static void main(String[] args) {

/*
        Object类是java中所有类的父类
*/
/*
     将对象输出时，会调用 toString()方法
     当类中没有定义toString()时，会默认调用父类(Object)中的toString。
 	 父类(Object)中的toString,将对象地址转为16进制的字符串输出，可以在类中重写Object类中的toString()
         public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
           }
         public native int hashCode();
          native:调用本地方法，java语言不实现，调用操作系统实现
*/
      
        //创建一个People类，并重写Object类中的toString()方法
        People p = new People("jam",22);
        //调用People类中重写后的toString()，输出想要的 字符串
        System.out.println(p+"hello");


/*
        Object类中的 equals() 比较对象地址是否相等，等同于 ==
        public boolean equals(Object obj) {
            return (this == obj);
          }
 */
        People p1 = new People("jam",22);
        People p2 = new People("jam",22);
        System.out.println(p1.equals(p2));
        System.out.println(p1==p2);

        //其他类基本上都是重写了 equals() 比较的是内容是否相等

        Integer a1 = 128;
        Integer a2 = 128;
        System.out.println(a1.equals(a2));//调用的是Integer类的equals(),比较的是值
        System.out.println(a1==a2);//128不在Integer范围区内，会创建Integer对象

    }

String类

字符串是多个字符组成的字符序列，是常量（值是不能改变的）。

字符串对象创建两种方式:

1.String s = “abc”; 第一次创建时,会在字符串常量池中检测有没有,没有就在字符串常量池中创建一个对象, 第二次创建时,如果常量池中已经存在,直接指向常量池中的对象即可.

2.使用 new + 构造方法()创建.只要是new出来的对象,在内存中一定是一个独一无二的对象空间.

public static void main(String[] args) {
        String  s = "abc";
        String  s1 = "abc";
        String  s4 = "abc";
        System.out.println(s.equals(s1));//输出true
        System.out.println(s==s1);//true
        System.out.println(s==s4);//true
    
        String s2 = new String("abc");
        String s3 = new String("abc");
        System.out.println(s2.equals(s3));//true
        System.out.println(s2==s3);//false
    }

字符串值是常量,值不能改变,一旦改变是在内存中重新创建了一个新的对象.

private final char value[];

字符串底层是char数组存储 ,

单个字符串存储final修饰的值不能改变.

        String  s = "abc";
                s+="efg";
                s+="aaaa";
                s+="bbbb";
                s+="ccc";
        System.out.println(s);
        String  s2 ="abcefgaaaabbbbccc";
        System.out.println(s==s2);
        String s1 = new String("abc");

String类中常用方法构造方法:

不含参的构造方法String();

含参的构造方法 String(String str).

public static void main(String[] args) {
          //创建一个字符串对象  值为""
          //String str = new String();
          //String  str = new String("abc");

         /*
            判断功能
          */
         String str1 = new String("abc");
         String  str2 = new String("abc");
         System.out.println(str1.equals(str2));//true

         System.out.println(str1.equalsIgnoreCase("aBC"));//不区分大小写比较内容是否相等

         System.out.println(str2.contains("a"));//str2中是否包含ab
         System.out.println(str2.contains("ab"));

         String str3 = new String("");
         System.out.println(str3.isEmpty());//true

         System.out.println(str2.startsWith("ab"));//true  是否以ab开头?
         System.out.println(str2.endsWith("c"));//true  是否以c结尾?

         System.out.println("c".compareTo("a"));//比较值大小  用于排序比较
         //ASCII表:c为99 a为97 99-97=2 输出2
    }

获取功能的方法

/*
        获取功能
         int length()
         char charAt(int index)
         int indexOf(String str)
         int indexOf(String str,int fromIndex)
         String substring(int start)
         String substring(int start,int end)
      */
     public static void main(String[] args) {
         String s = "abcdefgcs";
                  // 012345678
         System.out.println(s.length());//获得字符串长度 9

         System.out.println(s.charAt(2));//输出c
           //若索引失败,则抛出异常StringIndexOutOFBoundsException(*);

         System.out.println(s.indexOf("d")); //从0向后找 字符首次出现的位置  输出3
     //System.out.println(s.indexOf("c",3));//输出7    从指定位置向后找 字符首次出现的位置

         System.out.println(s.lastIndexOf("c"));//从后向前找字符首次出现的位置
         System.out.println(s.lastIndexOf("c",6));//从后向前找字符首次出现的位置
         System.out.println(s.indexOf("x"));//不存在返回-1


         System.out.println(s.substring(2));//输出cdefgcs  从指定位置截取到结束,返回一个新的字符串,原来的字符串不变
         System.out.println(s.substring(2,6));//输出cdef   (包含开始,不包含结束)
         System.out.println(s);

     }

替换功能

/*
    替换功能
        String replace(char old,char new)
        String replace(String old,String new)
        replaceAll(String regex, String replacement)
        replaceFirst(String regex, String replacement)
        去除字符串两空格
        String trim()
     */
    public static void main(String[] args) {

        String s = "abcde1fbc3g";
                          //s.replace(oldchar,newchar)
        System.out.println(s.replace('c','C'));
        System.out.println(s.replace("bc","BC"));    //输出aBCde1fBC3g


         //替换,用正则表达式匹配字符串
        System.out.println(s.replaceAll("\\d","BC"));//输出abcdeBCfbcBCg
        System.out.println(s.replaceFirst("\\d","BC"));//输出abcdeBCfbc3g

        String s1 = " ab c ";
        System.out.println(s1.length());//6
        //String s2 = s1.trim();//去掉前后的空格,没办法去掉中间的空格
        String s2 = s1.replace(" ","");
        System.out.println(s2.length());//3
    }

转换功能

/*转换功能
        byte[] getBytes()
        char[] toCharArray()
        static String valueOf(char[] chs)
        String toLowerCase()
        String toUpperCase()
        String concat(String str)
        Stirng[] split(分割符);
*/
    public static void main(String[] args) {
        String s = "AabcDEFgh";

        //把String字符串转换为字节数组
        byte[] b = s.getBytes();//编码:把字符->字节
        System.out.println(Arrays.toString(b));//输出[65, 97, 98, 99, 68, 69, 70, 103, 104]
        String s0 = new String(b);//解码:字节->字符

        String zw = "中文";
        try {
            byte[] b0 = zw.getBytes("utf-8");
            System.out.println(Arrays.toString(b0));//输出[-28, -72, -83, -26, -106, -121]

            byte[] b1 = zw.getBytes("GB2312-80");
            System.out.println(Arrays.toString(b1));//[-42, -48, -50, -60]

            String zw1 = new String(b0,"utf-8");
            System.out.println(zw1);//输出:中文

            String zw2 = new String(b0,0,3,"utf-8");//一个中文字符占三个字节.输出从0开始起三个字节的字
            System.out.println(zw2);//输出:中

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }


        //把字符串转换为字符数组
        char[] c =s.toCharArray();
       System.out.println(c);//输出AabcDEFgh

        //把字符数组转换为字符串
        char[] a ={'f','f','k','j'};
        String s1 = String.valueOf(a);
        System.out.println(s1);

        //把字符串转换为小写的字母
            System.out.println(s.toLowerCase());//aabcdefgh
        //把字符串转换为大写的字母
            System.out.println(s.toUpperCase());//AABCDEFGH

        //字符串拼接在一起
        String s2 = "Hcj";
        String s3 =s.concat(s2);//把s2拼接在s的后面
        System.out.println(s3);//输出AabcDEFghHcj
        System.out.println(s3.concat(s3));//输出AabcDEFghHcjAabcDEFghHcj
        String s4 = s + "xxxx"; //效率最低的字符串拼接,"xxxx"调用了StringBuilder类导致效率最低.     而concat()效率更高一些.

        //对字符串进行分割(split),得到字符串数组

        //   String[] s5= s.split("\\\\",2);//regex是要分割的字符,limit是要限制分割后的数量
        //for (int i = 0; i <s5.length ; i++) {
        //    System.out.println(s5[i]);
        //}
        /*对于特殊字符的分割 | $ * . ( ) \ / 等都是   正则表达式    的一部分,只能通过前面加\\进行转义.
           注意用\字符前必须用三个\\\,也就是split("\\\\").

        */
        String s6="name=Tom&age=18&sex=boy";
        String[] strArr = s6.split("&");  //srtArr={name=Tom,age=18,sex=boy}
        System.out.println(Arrays.toString(strArr));
    }

StringBuffer类

StringBuffer类是无参的构造方法,底层创建一个长度为16的char数组. (char[] value)

我们对字符串进行拼接是,每次拼接,都会构建一个新的String对象，既耗时又浪费空间.而StringBuffer就可以解决这个问题.

public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();//无参
        StringBuffer S2 = new StringBuffer(10);//有参的构造方法
        StringBuffer s = new StringBuffer("String");

        //大量的字符串拼接,应使用StringBuffer类,不会创建新的对象
        s.append("Buffer");
        s.append("Demo");//String  Buffer Demo
                         //012345  678    12
        //s.insert(6,"_");//向指定位置插入指定的字符串
        s.delete(6,12);//StringDemo 从6开始,12结束(不到12)
        //s.deleteCharAt(0);
        s.replace(6,9,"demooo");//用指定的String中的字符替换此序列的子字符串中的 String

        //s.reverse();//逆序排序

        System.out.println(s);
        System.out.println(s.substring(1,3));//返回一个新的 String,其中包含此序列中当前包含的字符的子序列
    }

StringBuilder类

 StringBuilder s = new StringBuilder();
              s.append("ABC");

String类StringBuffer类StringBuilder类的区别:

String 是字符常量,适用于少量的字符串操作的情况,且内容不可变

StringBuffer 线程安全,内容可变

StringBuilder 内容可变

---

既然都看到这了,那就动动小手点个赞吧!!!