javaSE第五章_＜API常用类(1)＞【基本数据类型包装类,自动装箱,Object类,Arrays类,String类】

---

API应用程序编程接口

概述：
API多指API文档，对java提供的类和接口的功能进行说明

基本数据类型包装类

包装类：
（如：Integer，Double等）
作用：

• 这些类封装了一个相应的基本数据类型，作为对应的类类型存在
• 包含每种数据类型相关属性，如max,min，提供了一系列操作方法。
  

自动装箱

自动装箱: 基本数据类型—>包装器类型
自动拆箱: 包装器类型—>基本数据类型

//int a=10;
Integer n=new Integer(10);
Integer x=10;
Integer m=new Integer(10);
== 在比较基本类型时，比较的就是值是否相等
== 在比较引用类型时，比较对象在内存中的地址是否相等

      自动装箱调用valueOf()
      public static Integer valueOf(int i){
           判断值如果在 -128到127之间  会从缓存数组中取出一个对象返回。
           多个值相同,返回的是同一个对象
           if(i>=IntegerCache.low && i<=IntegerCache.high)
              return IntegerCache.cache[i+(-IntegerCache.low)];
           return new Integer(i);  不在-128到127之间 会创建新的对象返回

Demo:

package api1;

//Demo就是int这个基本类型的包装类
public class Demo {

    int num;
    public Demo(int n){
        this.num=n;
    }
    public void check(){

    }

    public static void main(String[] args) {
        //int a=10
        Demo d=new Demo(10);
    }
}

IntegerDemo1:

package api1;

public class IntegerDemo1 {
    public static void main(String[] args) {
        //int a=10;
        Integer n=new Integer(10);
        //包装一些关于int类的相关信息
        System.out.println(n.MAX_VALUE); //最大的int型数 2147483647
        System.out.println(n.MIN_VALUE);  //最小的int型数-2147483648
        System.out.println(Integer.SIZE);   //32
        System.out.println(Integer.BYTES);   //4

        //构造方法
        Integer m=new Integer(8);
        System.out.println(m+10); //18

        //比较方法
        Integer m1=new Integer(10);
        Integer m2=new Integer(12);
        //比较大小
        System.out.println(m.compareTo(n)); //m小于n -1
        System.out.println(m1.compareTo(n)); //m等于n 0
        System.out.println(m2.compareTo(n)); //m大于n 1
        System.out.println(n.equals(m)); //比较是否相等 false
        System.out.println(Integer.max(10,5)); //10

        System.out.println(Integer.toBinaryString(3)); //返回二进制 11
        System.out.println(Integer.toOctalString(9)); //返回八进制  11
        System.out.println(Integer.toHexString(17));   //返回十六进制 11
    }
}

IntegerDemo2:

package api1;

public class IntegerDemo2 {
    public static void main(String[] args) {
        //int a=10;
        int x=10;
        Integer n=new Integer(x);
        int m=n.intValue(); //去取对象中包含的int值
              n.longValue();

        String s="10";
        int y=Integer.parseInt(s); //将String类型转换成int

        String s1=n.toString(); //将整数 转为 String
        Integer in=Integer.valueOf(x);
        Integer in1=Integer.valueOf("10");

    }

}

IntegerDemo3:

package api1;

public class IntegerDemo3 {
    int x=10;
    /*
      基本类型转引用类型
      Integer n=new Integer(x);
      Integer n1=Integer.valueOf(x);
     */
    Integer n=x; //自动装箱 默认调用vauleOf()方法  创建一个Integer对象
         //n.intValue()
    int y=n;  //自动拆箱  将引用类型转为基本类型 默认调用intValue()方法 取出包含的int值
}

IntegerDemo4:

package api1;

public class IntegerDemo4 {
    public static void main(String[] args) {
        /*
          自动装箱问题

          == 在比较基本类型时，比较的就是值是否相等
          == 在比较引用类型时，比较对象在内存中的地址是否相等

          自动装箱调用valueOf()
          public static Integer valueOf(int i){
               判断值如果在 -128到127之间  会从缓存数组中取出一个对象返回。
               多个值相同,返回的是同一个对象
               if(i>=IntegerCache.low && i<=IntegerCache.high)
                  return IntegerCache.cache[i+(-IntegerCache.low)];
               return new Integer(i);  不在-128到127之间 会创建新的对象返回
          }
         */
        //Integer x=Integer.valueOf(10);
        Integer x=10;
        Integer y=10;
        System.out.println(x==y); //10true 128false

        Integer m=new Integer(10);
        Integer n=new Integer(10); //两个不同的对象比较
        System.out.println(m==n);  //10false 128false
    }
}

Objects类

类是所有Java类的祖先（根基类）。
● 每个类都使用 Object 作为 超类（父类）。所有对象（包括数组）都实现这个类的方法。
● 如果在类的声明中未使用extends关键字指明其基类，则默认基类为 Object类

toString()方法

System.out.println§; 输出对象，此时会默认调用对象中的toString()
Person类默认继承了Object类
Public String toString(){
return getClass().getname()+"@"+Integer.toHexString(hashCode());
重写toString() 会调用自己的toString方法
得到：Person{name=‘张三’, age=20}
一般情况下可以重写Object类中的toString()

equals()方法

几乎API中所有；类都重写Object类中的equals(),
// 比较的是对象中包含的内容是否相等
Person:

package api1.objectdemo;

public class Person extends Object{
    private String name;
    private int 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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;
        return age==person.age&&(name.equals(((Person)o).name));
    }

}

ObjectToString:

package api1.objectdemo;

public class ObjectToString {
    public static void main(String[] args) {
        Person p=new Person();
               p.setName("张三");
               p.setAge(20);
        /*
           System.out.println(p);  输出对象，此时会默认调用对象中的toString()
           Person类默认继承了Object类
           Public String toString(){
               return getClass().getname()+"@"+Integer.toHexString(hashCode());
            重写toString() 会调用自己的toString方法
            得到：Person{name='张三', age=20}
            一般情况下可以重写Object类中的toString()
           }
         */
        System.out.println(p); //api1.objectdemo.Person@1b6d3586
    }
}

ObjectEquals:

package api1.objectdemo;

public class ObjectEquals {
    /*
      Object类中equals
          public boolean equals(Object obj){
              return(this==obj);
          }
     */
    public static void main(String[] args) {
        Person p1=new Person();
               p1.setName("张三");
               p1.setAge(20);

        Person p2=new Person();
               p2.setName("张三");
               p2.setAge(20);

        System.out.println(p1.equals(p2)); //false 重写Person类equals方法后为true

        //几乎API中所有；类都重写Object类中的equals(),
        // 比较的是对象中包含的内容是否相等
        String s=new String("abc");
        String s1=new String("abc");
        System.out.println(s==s1);   //false
        System.out.println(s.equals(s1));  //true

        Integer x=128; //new Integer(128);
        Integer y=128; //new Integer(128);
        System.out.println(x==y); //false
        System.out.println(x.equals(y));//true
    }
}

Arrays类

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

equals()方法

相等，则返回true，否则返回false

sort()方法

排序（所有数，指定区间数，自定义排序）
自定义类实现Comparable接口，重写compareTo方法

binarySearch()方法

二分查询,查询指定值在数组中的位置
前提: 数组要有序 否则查找不到返回负数
Arrays.sort(a);
//对数组排序 1,2,3,4,5,6,7,8
System.out.println(Arrays.binarySearch(a,6));

toString()方法

返回指定数组内容的字符串形式
System.out.println(Arrays.toString(a));

copyOf()方法

数组复制，返回一个指定长度的新数组,并将原数组中的内容复制到新数组中
int[] c=Arrays.copyOf(a,10);

ArraysEquals：

package api1.arraysdemo;

import java.util.Arrays;

public class ArraysEquals {
    public static void main(String[] args) {
        int []a={1,2,3,4,5};
        int []b={1,2,3,4,5};

        System.out.println(a==b); //false
        System.out.println(Arrays.equals(a,b)); //true
    }
}

ArraysSort:

package api1.arraysdemo;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArraysSort {
    public static void main(String[] args) {
        int []a={5,4,3,2,1};

        //Arrays.sort(a); //0---length  对整个数组进行排序
        Arrays.sort(a,0,3); //[3, 4, 5, 2, 1] 0---3-1  对指定区间进行排序

        System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 5]
    }

}

Student:

package api1.arraysdemo;

public class Student implements Comparable<Student>{
    private int num;
    private String name;

    //构造方法
    public Student(int num, String name) {
        this.num = num;
        this.name = name;
    }

    //用来作比较，提供一个自定排序规则的方法
    //compareTo()方法会在sort()底层调用
    @Override
    public int compareTo(Student o) {
        return this.num-o.num; //小于0  等于0  大于0
    }

    @Override
    public String toString() {
        return "Student{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }
}

ArraysSortObject:

package api1.arraysdemo;

import java.util.Arrays;

public class ArraysSortObject {
    public static void main(String[] args) {
        Student [] students=new Student[5];

        Student s1=new Student(101,"张三1");
        Student s2=new Student(101,"张三2");
        Student s3=new Student(101,"张三3");
        Student s4=new Student(101,"张三4");
        Student s5=new Student(101,"张三5");

        students[0]=s2;
        students[1]=s5;
        students[2]=s1;
        students[3]=s4;
        students[4]=s3;

        //对引用类型数组进行排序时，类实现
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));

        String []sarr={"a","b","c","d"};
        Arrays.sort(sarr);
        System.out.println(Arrays.toString(sarr)); //[a, b, c, d]
    }
}

ArraysBinarySearch：

package api1.arraysdemo;

import java.util.Arrays;

public class ArraysBinarySearch {
    public static void main(String[] args) {
        //二分查询,查询指定值在数组中的位置
        //前提:数组要有序  否则查找不到返回负数
        int []a={2,1,3,7,6,5,8};

        Arrays.sort(a);
        //对数组排序 1,2,3,4,5,6,7,8
        System.out.println(Arrays.binarySearch(a,6)); //4
        System.out.println(Arrays.binarySearch(a,2)); //1
        System.out.println(Arrays.binarySearch(a,4)); //-4 返回-1或-插入点
        System.out.println(Arrays.binarySearch(a,0,5,6)); //4
    }
}

ArraysToString：

package api1.arraysdemo;

import java.util.Arrays;

public class ArraysToString {
    public static void main(String[] args) {
        int []a={1,2,3,4,5};
        //System.out.println(a); //[I@1b6d3586
        //数组操作的工具类
        System.out.println(Arrays.toString(a)); //StringBulider方法 [1, 2, 3, 4, 5]
    }
}

ArraysCopyOf：

package api1.arraysdemo;

import java.util.Arrays;

public class ArraysCopyOf {
    public static void main(String[] args) {
        //数组复制
        int[] a={1,2,3,4,5};
        int[] b=new int[5];
        for(int i=0;i<a.length;i++){
            b[i]=a[i];
        }
        System.out.println(Arrays.toString(b)); //[1, 2, 3, 4, 5]

        //返回一个指定长度的新数组,并将原数组中的内容复制到新数组中
        int[] c=Arrays.copyOf(a,10);
        System.out.println(Arrays.toString(c)); //[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

    }
}

---

String类

String类创建

字符串值不可改变

字符串创建

• 所有的字符串都是String类的实例(对象)
  字符串的值不能改变(一旦给定字符串的值，值就不能改变) 因为底层用到一个final修饰的char数组
  private final char value[]; 底层是单个字符存储 char a=97 b=98 c=99
• String对象的两种创建方式

1. String s=“abc”
   首先会在字符串常量池中查找，如果没有，就在常量池中创建,
   如果常量池已经存在，就不需要创建，直接返回地址即可
2. String s1=new String(“abc”)
   都会在堆中创建一个对象

StringDemo1:

package api1.stringdemo;

public class StringDemo1 {
    /*
      String 表示字符串
      所有的字符串都是String类的实例(对象)
      字符串的值不能改变(一旦给定字符串的值，值就不能改变) 因为底层用到一个final修饰的char数组
          private final char value[]; 底层是单个字符存储 char a=97 b=98 c=99
     */

    public static void main(String[] args) {
        String s="abc";
        String s2="abc";
        String s1=new String("abc");
               s1+="efg";
               s1+="hijk";
        System.out.println(s1); //abcefghijk
    }

}

StringDemo2:

package api1.stringdemo;
public class StringDemo2 {
    /*
      String对象的两种创建方式
      1、String s="abc"
      2. String s1=new String("abc")
     */
    public static void main(String[] args) {
        String s1="abc"; //首先会在字符串常量池中查找，如果没有，就在常量池中创建
        String s2="abc"; //如果常量池已经存在，就不需要创建，直接返回地址即可
        System.out.println(s1==s2); //true
        System.out.println(s1.equals(s2)); //true

        String s3=new String("abc");
        String s4=new String("abc"); //都会在堆中创建一个对象
        System.out.println(s3==s4);  //false
        System.out.println(s3.equals(s4)); //true
    }
}

String类常用方法

== 比较地址是否相等
equal() 比较值是否相等
equalsIgnoreCase() 比较值是否相等，忽略大小写
功能：判断，获取，转换，构造

判断功能

package api1.stringdemo;

public class StringPanDuan {
    public static void main(String[] args) {
        /*
         构造方法
         判断功能
        */
        String s=new String(); //创建一个"" this.value="".value;

        String s1=new String("abc");
        String s2=new String("abC"); //this.value=original.value

        System.out.println(s1.equals(s2)); //false equals都比较是值,内容是否相等
        System.out.println(s1.equalsIgnoreCase(s2));//比较值/内容 是否相等 忽略大小写

        String s3="abcdef";
        System.out.println(s2.contains("ab")); //判断是否包含指定字符串
        String s4=null;
        //System.out.println(s4.isEmpty()); //true 判断是否为空("") 为空返回true 字符串长度为0 空指针异常
        System.out.println(s3.startsWith("ab")); //true 判断是否以指定字符串开头
        System.out.println(s3.endsWith("ab"));  //false 判断是否以指定字符串结尾
        System.out.println("a".compareTo("c")); //-2 比较两个字符串位置
    }
}

---

获取功能

package api1.stringdemo;

public class Stringhuoqu {
    public static void main(String[] args) {
        /*
           获取功能
        */
        String s="abcdefgh";
        //01234567
        System.out.println(s.length()); //8 字符串长度
        char c=s.charAt(3);  //d 返回指定索引字符
        System.out.println(c);

        int index=s.indexOf("d"); //3 获取指定字符串首次出现的位置 从前向后找
        System.out.println(index);

        int index1=s.indexOf("d",4); //-1 从指定位置开始，获取指定字符串首次出现的位置
        System.out.println(index1);

        int index2=s.lastIndexOf("d");
        System.out.println(index2);

        String s1="abcedfgh";
                 //01234567
        String s2=s1.substring(2); //从s1 截取指定区间的字符串 从指定位置 开始到结束
        System.out.println(s1); //abcdefgh
        System.out.println(s2); //cdefgh

        String s3=s1.substring(2,6); //从指定区间截取  开始位置--结束位置(获取功能)
        System.out.println(s3); //cedf
    }
}

---

转换功能

package api1.stringdemo;

import java.util.Arrays;

public class StringZhuanHuan {
    /*
      转换功能
     */
    public static void main(String[] args) {
        String s="adbcEFG";
        System.out.println(s.toLowerCase()); //adbcefg 转小写
        System.out.println(s.toUpperCase()); //ADBCEFG 转大写

        String s1=s.concat("HOJK"); //两个字符串拼接 并返回新的字符串对象
        System.out.println(s1); //adbcEFGHOJK

        String s2="ab:cd:E:FGH";
        String[] array=s2.split(":"); //用指定符号 来分割字符串为数组
        System.out.println(Arrays.toString(array)); //[ab, cd, E, FGH]
    }
}

---

构造功能

编码，解码
public String(byte[] bytes)
public String(char[] value)

package api1.stringdemo;

import java.util.Arrays;

public class Stringgouzao {
    /*
      构造方法
      public String(byte[] bytes) 通过平台默认字符集解码指定字节数组来构造新的String
     */
    public static void main(String[] args) {
        /*
        String s="abc";
        byte[] b=s.getBytes(); //编码 [97, 98, 99]
        System.out.println(Arrays.toString(b));

        String s1=new String(b); //解码 abc
        System.out.println(s1); */

        String s="中文";
        //byte[] b=s.getBytes("GBK"); utf-8
        byte[] b=s.getBytes(); //编码 [-28, -72, -83, -26, -106, -121]
        System.out.println(Arrays.toString(b));

        //String s1=new String(b,"GBK") utf-8
        String s1=new String(b); //解码 中文 乱码问题：编码和解码两边使用的编码格式不统一
        System.out.println(s1);

        //String s2=new String(b,2,2,"GBK"); //指定区间
        //System.out.println(s2);

    }
}

package api1.stringdemo;

import java.util.Arrays;

public class Stringgouzao2 {
    /*
       public String(char[] value)
       char[] toCharArray()  字符串转换成数组
       static String valueOf(char[] chs)
     */
    public static void main(String[] args) {
        String s="cab";
        char[] chars=s.toCharArray();
        Arrays.sort(chars);
        System.out.println(Arrays.toString(chars)); //编码 [a, b, c]

        String s1=new String(chars);
        System.out.println(s1); //解码 abc

        String s2=String.valueOf(chars);
        System.out.println(s2); //abc
    }
}

---