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

ApI概念

Apl:指的是官方给开发人员提供的说明文档，对语言中有哪些类，类中有哪些方法进行说明

Objict 类

java.lang.Object

是java类体系结构中最顶层的类

Object可以表示java中任意的类

 

 Object类中的方法

toString()

 输出一个对象，但是对象在内存中，是不能输出的
当输出一个对象时，会默认调用此对象的toString()，
如果类中没有定义toString()，会调用object类中toString()，
Object类中toString()，是把对象在内存中的哈希值返回（以16进制返回）
把对象信息以字符串形式输出

equals()

boolearn equals(Object obj) 判断两个对象是否相等
Object类中的equals
public boolean equals(Object obj){
return (this==obj)默认比较的时两个对象的地址是否相等

public boolean equals(Object obj) {
    if(obj instanceof person){
        person other = (person) obj;
        return this.name.equals(other.name)&&this.age==other.age;
    }

    return false;
}

 == 比较等号两边是否相等
当==用于基本类型比较时，比较的是变量值是否相等
当==用于引用类型比较时，比较的是对象的地址是否相等

Arrays类

 java,util.Arrays类

● equals 方法

比较两个数组对象中元素是否相等.

而数组对象中的equals用来判断与另一个数组对象是否相等。

声明：public static boolean equals(type[]a,type[]a2) 参数的类型可以是原生数据类型和引用类型的任意一种类型

System.out.println(  Arrays.equals(a,b));

● copyOf方法

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

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

●fill方法

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

Arrays.fill(b,0);
System.out.println(Arrays.toString(b));

●toString方法

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

System.out.println(Arrays.toString(d));

●sort －排序

作用于数组的所有元素 public static void sort(type[] a)

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

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

long [] a={5,4,3,2,1,0};
Arrays.sort(a);//0--length-1
//Arrrays.sort(a,开始位置，结束位置（不包含）)
Arrays.sort(a,0,4);
System.out.println(Arrays.toString(a));

●binarySearch -使用二分搜索算法搜索指定数组

/*
binarySearch() 二分搜素算法查找指定的元素位置，如果未找到返回负数
 */
int []b={2,3,4,1,5};
int index=Arrays.binarySearch(b,1);
System.out.println(index);
Arrays.sort(b);
int flag=Arrays.binarySearch(b,1);
System.out.println(flag);

●自定义类实现Comparable接口

 重写compareTo方法

我们一个类进行排序，那么这个类必须实现Compaareable接口，

指定一个排序方式（这样所有的类都使用统一的方法进行排序了） 用来指定排序规则， 可以执行用类中那个属性作为排序的项
这个方法在sort（）方法底层使用

@Override
public int compareTo(student o) {
    return this.id-o.id;
}
------------------------------------------   
   Arrays.sort(students);
        System.out.println(Arrays.toString(students));

        String s="a";
        String sr="b";
        System.out.println(s.compareTo(sr));

基本数据类型封装类

基本类型包装类：

Java中的基本数据类型使用8个关键字声明的，不是面向对象的

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

●包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法。

类的用途主要包含两种：

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

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

类型转换：

自动拆箱：把引用类型 转为 基本类型

自动装箱：把基本类型 转为 引用类型

会默认调用valueof()方法，

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

/*
自动拆箱
 */
int c=a.intValue();
int d=b;
/*
自动装箱
 */
int z=128;
Integer x=Integer.valueOf(z);
Integer y=z;

String类

java.lang.String

"abc"-->字符串对象 底层是一个char数组 private final char value[]

字符串对象创建方式：

1.String s="abc";

创建时先去字符串常量池中去查找有没有相同值的对象，如果没有，就创建一个字符串对象，并返回地址
如果字符串常量中已经存储，就不用创建新的，直接返回已存在对象的地址

String s1="abc";
String s2="abc";
System.out.println(s1==s2);
System.out.println(s1.equals(s2));

2.String s1=new String();

new 每次都是在堆中创建新的字符串对象

String s3=new String("abc");
String s4=new String("abc");
System.out.println(s3==s4);
System.out.println(s3.equals(s4));

字符串不变：

他们的值在创建后不能被更改

String s="abc";// abc   第一个字符串对象
s+="bcd";// abcbcd      第二个字符串对象
s+="aaa";// abcbcdaaa   第三个字符串对象
System.out.println(s);

String类方法

构造方法

String()

String(String s)

String(byte[] bytes)

public static void main(String[] args) throws UnsupportedEncodingException {
    String s1="你好";
    byte[] bytes=s1.getBytes("GBK");
    System.out.println(Arrays.toString(bytes));

    String s2=new String(bytes,"GBK");
    System.out.println(s2);

}

 public String(char[] value)

public static void main(String[] args) {
    String s="bac";
    char[] chars=s.toCharArray();
    Arrays.sort(chars);
    System.out.println(Arrays.toString(chars));
    String s2=new String(chars);
    System.out.println(s2);
}

●判断功能

boolean equals(Object obj)  比较字符串内容是否相等
boolean equalsIgnoreCase(String str)   比较字符串内容是否相等（忽略字母大小）
boolean contains(String str)    判断字符串中是否包含指定字串
boolean isEmpty()      判断字符串是否为"'空
boolean startsWith(String prefix)   判断字符串是否以指定开头
boolean endsWith(String suffix)     判断字符串是否以指定结尾

String s1=new String("aabc");
String s2=new String("aaBc");

System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.contains("bc"));
System.out.println(s1.isEmpty());
System.out.println(s1.startsWith("ab"));
System.out.println(s1.endsWith("bc"));

●获取功能

int length()    获取字符串长度 

char charAt(int index)   获取指定位置上的字符

int indexOf(String str) 返回的指定字符串首次出现的位置 

int indexOf(String str,int fromIndex)从指定位置开始查找，返回指定字符串首次出现的位置

int lastindexOf("ch")从后向前查找，返回的指定字符串首次出现的位置 

String substring(int start) 从在指定位置开始截取一个字符串到完

String substring(int start,int end)从在指定位置开始截取一个字符串副本到指定位置（不包含指定位置）

String s1="abcdefg";
System.out.println(s1.length());
System.out.println(s1.charAt(1));
System.out.println(s1.indexOf("c"));
System.out.println(s1.indexOf("d",1));
System.out.println(s1.substring(0));
System.out.println(s1.substring(1,5));

● 转换功能

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 s="ac;vna;nBX";
  String s1=String.valueOf("a");
    System.out.println(s1);

    System.out.println( s.toLowerCase());
    System.out.println(s.toUpperCase());
  String s3=  s.concat("dddd");
    System.out.println(s3);
String[] s4=s.split(";");
    System.out.println(Arrays.toString(s4));
}

● 替换功能

 String replace(char old,char new) 

String replace(String old,String new) 用新内容替换字符串中指定的字符串

replaceAll(String regex, String replacement)用新内容替换字符串中正则表达式匹配字符串  

replaceFirst(String regex,Stringreplacement) 用新内容替换字符串中正则表达式匹配字符串  ，只替换第一个 

 String s="adan2ca5";
s.replace("c","C");
s.replaceAll("\\d","a");
s.replaceFirst("\\d","d");
    System.out.println(s.trim());

● 去除字符串两端空格

String trim()

StringBuffer

StringBuffer是内容可以改变的字符串

public static void main(String[] args) {
    /*
    因为String声明的字符串对象值一旦给定就不能改变了，
    每次拼接都会创建新的字符串对象，耗时，占用空间

    StringBuffer是内容可以改变的字符串
    char[] value；没有使用final修饰，每次添加内容都是堆此数组进行操作，不会创建新的字符串对象
     */
    //SstringBuffer s1 =new StringBuffer("abcd");//创建 内容长度+16的char数组
    // StringBuffer s2=new StringBuffer();//空参的构造方法 指定底层数组长度是16
    StringBuffer s = new StringBuffer(11);
    s.append("acb");//向在字符串末尾添加内容
    s.append("acjanvnavn");
    s.insert(1, "a");//向指定的位置插入指定字符串
    s.deleteCharAt(2);//删除指定位置上的字符串
    s.delete(0, 2);//删除指定区域的元素  包含开始位置，不包含结尾
    s.replace(0, 3, "aaa");//替换字符串
    s.reverse();//反转字符串

}

String类StringBuffer类StringBuilder区别

● String：是字符常量,适用于少量的字符串操作的情况

● StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

● StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

● StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程 安全的

Math类

abs 绝对值
sqrt 平方根
pow(double a, double b) a的b次幂
max(double a, double b)
min(double a, double b)
random() 返回 0.0 到 1.0 的随机数
long round(double a) double型的数据a转换为long型（四舍五入）

System.out.println(Math.max(18,5));
System.out.println(Math.abs(-15));
System.out.println(Math.sqrt(16));
System.out.println(Math.random());
System.out.println(Math.pow(2,4));

Random类

● Random类概述 此类用于产生随机数

● 构造方法 public Random()

● 成员方法 public int nextInt() public int nextInt(int n)

Random random=new Random();
System.out.println(random.nextBoolean());
System.out.println(random.nextInt());
System.out.println(random.nextInt(35)+1);