![javaapi中文手册_java调用api接口[通俗易懂]"](https://img.bianchenghao.cn/app/bianchenghao_cn/380b242d4116473485a94cb25821811b.jpg "javaapi中文手册_java调用api接口[通俗易懂]插图")
目录
一、API 概述
Java–API（官方对提供的类，接口功能进行说明的文档）
API文档 在文档中对Java语言中提供的类和接口的功能进行说明
二、Object类
在继承中，当一个类没有直接使用extends关键字继承其他类时，这个类默认继承Object类，Object是整个Java类体系中最顶级的类
Object中定义的一些方法
toString（）
在输出对象时，将对象转为字符串形式，默认调用类中的toString()
如果类中没有toString（），那么会调用父类的方法，Object类中的toSrting默认输出对象内存地址需要对象中的值，
拿到类名 @ hashCode()难道对象在内存中的哈希值（10进制整数）
Integer.toHexString(哈希值) 转为16进制整数
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}equals（）
== 基本类型比较 比较值是否相等
引用类型比较 比较的是引用变量所指向的内存空间的地址是否相等
有时需要比较对象内容是否相等，重写object中equals（）方法比较内容是否一致
常用的String，Integer….几乎都重写了这一方法
public boolean equals(Object obj) {
return (this == obj);
}三、基本类型包装类
基本类型———-8中基本数据类型
byte short int long float double Boolean char
基本类型通过8种关键字，声明定义
int a=10；值就为10 结构简单，实际使用时存在很多的不便。
基本数据类型，使用关键字定义，不是面向对象的，实际使用时存在很多的不便。
在Java语言种，为每种基本类型都提供了一个类进行包装表示，这样就是以面向对象的方式进行操作
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.BYTES);//4
System.out.println(Integer.SIZE);//32
System.out.println(Integer.toBinaryString(3));//11
System.out.println(Integer.toOctalString(9));//11
System.out.println(Integer.toHexString(15));//F
//通过构造方法，将字符串数字，将基本类型的值，包装到一个包装类对象中，
// 使用面向对象方式进行操作
Integer integer = new Integer("10");
Integer integer1 = new Integer(10);
System.out.println(integer==integer1);//比较地址
System.out.println(integer.equals(integer1));//比较内容
System.out.println(integer.compareTo(integer1));//比较对象内容大小
int a=integer.intValue();//返回包装类型的原始基本值
int c=Integer.parseInt("100");//把字符串数字 转为基本类型int
Integer d=Integer.valueOf(10);//把基本类型转为包装类型
Integer e=Integer.valueOf("100");//把字符串数字也可以转为包装类型
}自动装箱与自动拆箱
基本类型与基本类型包装类之间的转换：
有时需要以面向对象方式操作，希望拿到包装类型
有时需要获取包装类型的基本数据类型
自动装箱：把基本类型 转为包装类型
自动拆箱：把包装类型 转为基本类型
public static void main(String[] args) {
int a=10;
/*
把基本类型，直接付给引用类型，进行包装，产生了一个Integer类的对象
称为自动装箱
【-128，127】
integer类中为了节省空间，对-128----127之间的255个对象进行缓存
在这之间直接从数组中获取，值相同的时候，取得的对象是相同的
如果不在这之间，每次会创建新的对象
Integer a=127; 默认会调 Integer.valueof（int i）
*/
Integer ba=a;
/*
把包装类型 转为基本类型
称为自动拆箱
*/
Integer c=new Integer(10);
int d=c;//拆箱时，默认会调用c.intvalue（）；取出其中的int值 是隐式的
}四、Arrays
public static void main(String[] args) {
int []a={9,8,7,6,5,4,3,2,1};
System.out.println(Arrays.toString(a));//输出数组
Arrays.sort(a);//对数组进行排序
System.out.println(Arrays.toString(a));
int []b={9,8,7,6,5,4,3,2,1};
Arrays.sort(b,2,7);//对指定下标 进行排序
System.out.println(Arrays.toString(b));
System.out.println(Arrays.binarySearch(a,55));
//二分搜索 查找值的下标 返回下标 不存在返回 -（插入点） -10
System.out.println(Arrays.binarySearch(a,0,5,6));
//在指定下标范围内查找元素 返回下标 不存在返回 -（插入点） -6
System.out.println(Arrays.binarySearch(a,0,5,3));
int []c={1,2};
int []d={1,2,3};
System.out.println(Arrays.equals(c,d));//flase比较数组是否相等
}对于自定义类
Comparable是Java中进行排序功能,进行方法的定义
public static void main(String[] args) {
String []arrays={"b","c","d","a"};
Arrays.sort(arrays);
System.out.println(Arrays.toString(arrays));
/*
有四位学生，想对他们排序
*/
Student student1 = new Student(101,"jim1");
Student student2 = new Student(102,"jim2");
Student student3 = new Student(103,"jim3");
Student student4 = new Student(104,"jim4");
Student []students=new Student[4];
students [0]=student4;
students [1]=student3;
students [2]=student2;
students [3]=student1;
/*
使用Array。sort（）对自定义的数组进行排序
Animal a=new cat();
Dog b=(Animal)a;类型不匹配
*/
Arrays.sort(students);
System.out.println(Arrays.toString(students));
//输出的是对象的地址，在Student中重写
/*
/*
compareto就是提供的自定义排序比较规则的方法
此方法会在sort（）方法中的源码中调用
返回值是整数，小于0，等于0，大于0
*/
@Override
public int compareTo(Student o) {
return this.num-o.num;//定义通过学号进行排序
}
*/
}数组的扩容
public static void main(String[] args) {
/*
java中的数组长度是固定的，但是程序运行时的数据长度是变化的
又时数据多了，需要对数组进行扩容
*/
int []a={1,2,3,4,5};
//int []b=new int[a.length*2];
//创建一个指定容量的新数组，并把原来的数组复制到新数组中
//Arrays.copyOf(原数组，新数组长度);
int[]b=Arrays.copyOf(a,a.length*2);
System.out.println(Arrays.toString(b));
}五、String
开发使用频率最高的类型 字符串
字符串是由多个字符组成的一串数据（字符序列）的字符串常量，Java中所有的字符串都是String类的实例
字符串：一串字符，一串字符由多个单个字符组成，只是对外表示为一个整体，底层还是一个一个的独立的字符。
字符：指的是一个单独的字符 计算机中能显示的所有符号都是一个个独立是，对应一个编码表。
Java中字符串不变：他们的值在创建后不能被更改
public static void main(String[] args) {
/*
字符串
private final char value[];['a','b','c']
byte value[];[97,98,99]
*/
String s="abc";//在内存中创建了一个String对象，创建后值就不可改变
String s1=new String("abc");//字符串地址是1001
s1+="def";
//字符串地址是1002 创建一个字符串对象，把新数组填充到字符串中，给新数组地址赋为是s1
System.out.println(s1);
}创建字符串对象
String s1=“abc”;
String s2=”abc”;
System.out.println(s1==s2);//true
//隐式的创建，会先去字符串常量池中检测，有没有对应的字符串对象
//字符串常量池:堆内存中
//如果没有，就会在字符串常量池创建一个字符串对象
//如果有，就会直接将字符串常量池中的地址返回String类中的构造方法
public static void main(String[] args) {
/*
String类中的构造方法
String() 无参构造
String(String s) 有一个 String类型参数
String(byte[] b) 把一个byte数组转为字符串
String(char[] c) 把一个char类型数组转为字符串
String()
*/
String s=new String();
String s1=new String("abc");
byte[] bytes="abc".getBytes();
System.out.println(Arrays.toString(bytes));
//编码 ：把字符串转为byte数组 数字化传输
String s2=new String(bytes);
System.out.println(s2);
//解码 ：把byte数组转为字符串
//getBytes()转为byte数组
//toCharArray()转为char数组
char[] chars="cba".toCharArray();
Arrays.sort(chars);
String s3=new String(chars);
System.out.println(s3);
/*
排序
char[] chars="cba".toCharArray();
将字符串转为数组，以数组的形式进行操作，把char数组转为字符串
*/
System.out.println(String.valueOf(chars));String中的判断功能
public static void main(String[] args) {
/*
boolean equals(Object obj) 重写object的方法判断内容是否相同
boolean equalsIgnoreCase(String str) 不区分大小写比较内容
boolean contains(String str) 是否包含某个指定的子串（连续的）
boolean isEmpty() 判断是否为空 ""
boolean startsWith(String prefix) 判断是否以指定子串为开头
boolean endsWith(String suffix) 判断是否以指定子串结尾
boolean compareTo（String anotherString） 按照字典比较字符串
*/
String s1="abc";
System.out.println(s1.equals("ab"));
System.out.println(s1.equalsIgnoreCase("ABC"));
System.out.println(s1.contains("bc"));
System.out.println(s1.isEmpty());
System.out.println(s1.startsWith("a"));
System.out.println(s1.endsWith("bc"));
System.out.println("a".compareTo("b"));
}String中的获取功能
public static void main(String[] args) {
/*
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)截取字符串，指定开始，指定结束
*/
String s="abcdecfdsdfs";
System.out.println(s.length());
char a=s.charAt(2);
System.out.println(a);//c
int index=s.indexOf("c");
int index1=s.indexOf("c",index+1);
System.out.println(index);
System.out.println(index1);
String sub=s.substring(2);
String sub1=s.substring(2,5);
//sub是新字符串 s不变
System.out.println(sub);
System.out.println(sub1);
}String中的替换功能
替换功能
String replace(char old,char new) 新的替换旧的
String replace(String old,String new)用新的字符串替换指定的所有的子串
replaceAll(String regex, String replacement) regex
用新的字符串替换指定的所有的子串,使用正则表达式匹配
replaceFirst(String regex, String replacement)
用新的字串替换指定的第一个子串
*去除字符串两端的空格，中间的空格不能去除
六、正则表达式
正则—-规则—-模式 去匹配某个字符串，看字符串是否满足某种规则
String s=”dsfsgsa64565654″;//手机号格式
可以通过正则表达式来制定一个规则，用规则去匹配某个字符串，可以快速的进行模式匹配。
使用字符串对象中的内容，去与指定的正则表达式匹配，成功返回true，否则返回false
matches(“正则表达式”)学习正则表达式常用的特点的字符
匹配数字[0-9],[1,2,3,4], \d, \D(非数字)
匹配单词字符 \w == [a-z,A-Z,0-9,_] .匹配任意的字符 需要进行转义
匹配数量 ? * + {n} {n,} {n,m}
.表示任意字符 有时需要转义 //.
String s="13754245437";
//boolean res=s.matches("[0-9]");
//boolean res=s.matches("[1,2,3,4]");
//boolean res=s.matches("\\d");
//boolean res=s.matches("\\D");
//boolean res=s.matches("[0-9]?");//?表示一次或一次也没有
//boolean res=s.matches("[0-9]*"); *0次或多次
//boolean res=s.matches("[0-9]+"); +一次或多次
//boolean res=s.matches("[0-9]{6}"); 固定的n位
//boolean res=s.matches("[0-9]{6,}"); //至少是n位
//boolean res=s.matches("[0-9]{6,9}"); //最少是n位，最大m位
//boolean res=s.matches("[1][3,5,7,8,9]\\d{9}"); 手机号码
boolean res=s.matches("[1-9]\\d{6,12}");
System.out.println(res);
String s = "aa9644_";
//boolean res=s.matches("[a-z]"); 小写
//boolean res=s.matches("[A-Z]"); 大写
//boolean res=s.matches("[A-z]"); 大小写
boolean res=s.matches("\\w+"); // [a-z,A-Z,0-9,_]
boolean res = s.matches("[\\u4e00-\\u9fa5]+");//匹配汉字
System.out.println(res);
//邮箱规则? 有字母, 数字 @ qq/163/sina,yahu .com/com.cn（或）
boolean res = s.matches("\\w{6,10}@\\w{2,6}\\.(com|com\\.cn)");七、StringBuffer
String对象的值是不可改变的，产生问题，经常拼接字符串时，会创建对各字符串对象，造成浪费
如果某一些场景需要大量拼接字符串，可以使用StringBuffer
StringBuffer: 线程安全的，可变的字符串
public static void main(String[] args) {
/*
capacity 容量=16
new StringBuffer()默认底层数组容量是16
new StringBuffer(20) 指定底层数组容量是20
new StringBuffer("abcd")容量是 内容长度+16
char[] value 没有被final修饰，可以改变
*/
StringBuffer s=new StringBuffer("abcd");//4+16=20
s.append("efg");//在末尾添加字符串，并没有创建新的StringBuffer和底层数组对象
s.append("fksdjfljfojfosdjfosdj");
//当底层数组容量不够时,会创建一个新的数组对象赋给value数组
s.insert(1,"000");//在指定的位置上插入字符串
System.out.println(s);
s.deleteCharAt(1);//删除指定位置的字符串
System.out.println(s);
s.delete(1,2);//删除指定区间的字符串
System.out.println(s);
s.replace(2,5,"55");//替换字符串
System.out.println(s);
s.reverse();//反转字符串
System.out.println(s);
//上面都是在底层数组进行操作
String s1 = s.substring(2,8);//截取时,返回一个新的字符串,原字符串不变，新创建一次
System.out.println(s1);
System.out.println(s);
sofjds
jdsofjdsofjofjlfjdskfgfe550a
}八、Stringbuilder
StringBuffer 是线程安全的 这个类中的方法上加了一个synchronized(同步锁)关键字, StringBuilder 类中的方法没有加synchronized关键字,是多线程不安全
StringBuffer 和 StringBuilder区别
不同点: StringBuffer是线程安全的 StringBuilder是线程不安全的(适合单线程情况)
相同点: 都是可变的字符串对象
底层都有一个char数组,
char[] value; 创建之初,会创建一个指定容量的数组,增删改查都是在此数组上操作. 数组如果空间不够,会新创建一个数组,Arrays.copyOf();
最终实现,调用的都是AbstractStringBuilder父类中方法实现.
String,StringBuffer 和 StringBuilder区别
String 值不可改变,适用于少量拼接的
StringBuffer 可变 多线程安全的 适用于大量拼接的
StringBuilder区别 可变 多线程不安全的 适用于大量拼接的
九、Math,Random
/*
Math类: 提供了许多关于数学运算的方法 例如平方根,四舍五入,三角函数
*/
System.out.println(Math.PI);//Π
System.out.println(Math.abs(-9));//绝对值
System.out.println(Math.sqrt(9));//平方根
//public static native double pow(double a, double b);
//native修饰的方法是本地方法(操作系统中的方法),没有方法体,java没有实现,直接调用C/C++系统
System.out.println(Math.pow(2,3));//求幂次方
System.out.println(Math.random());//返回0-1之间的随机数
System.out.println(Math.round(5.4));//四舍五入
System.out.println(Math.floor(5.9));//向下取整
System.out.println(Math.ceil(5.1));//向上取整
System.out.println(Math.max(2,5));//返回大的
Random random=new Random();
System.out.println(random.nextInt());//返回int型随机数 int范围内
System.out.println(random.nextInt(10));//0-9之间 不包含10
//获取指定区间的随机数十、日期相关类
Data
public static void main(String[] args) {
/*
想知道此时程序运行的时间
Date date =new Date();
创建一个日期对象，包含程序员运行那一刻的时间信息
*/
Date date =new Date();
System.out.println(date);
//Thu Dec 29 20:43:39 CST 2022
System.out.println(date.getYear()+1900);//2022-1900
System.out.println(date.getMonth()+1);//月份从0开始
System.out.println(date.getDate());
System.out.println(date.getDay());
System.out.println(date.getHours());
System.out.println(date.getMinutes());
System.out.println(date.getSeconds());
//删除线 表示选择的Java版本中已经不建议使用，有新的方法代替
System.out.println(date.getTime());
//返回1970.1.1 0：0：0 至今（程序运行时间）的毫秒差
//1672318611802L
}Calender(日历)
日历类中，提供了更多关于日期时间的方法
public static void main(String[] args) {
/*
输入一个日期（年月日），计算是当年的第几天
日历类中，提供了更多关于日期时间的方法
*/
//Calendar calendar=Calendar.getInstance();
//返回的是Calendar这个抽象类的子类对象
Calendar calendar=new GregorianCalendar();
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.MONTH)+1);
System.out.println(calendar.get(Calendar.DATE));
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
//今年的第几天
System.out.println(calendar.get(Calendar.WEEK_OF_YEAR));
//今年的第几周
System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
//这周的第几天 从0开始
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
}SimpleDateFormat
public static void main(String[] args) throws ParseException {
/*
SimpleDateFormat 简单的日期格式化
Java中表示日期 new Date() new GregorianCalendar();
在前端需要显示时，需要把Java中的Date对象，转为指定格式的字符串
Date date=new Date();
String s=date.getYear()+"-"+date.getMonth(); 不灵活
*/
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM-dd HH:mm:ss");
Date date=new Date();
String s=simpleDateFormat.format(date);
System.out.println(s);
// 把日期对象转为字符串
/*
把字符串转为日期对象
2001-4-1 从前端获取的都是String，获取年月日非常麻烦
将字符串日期转为date对象，就可以以面向对象的方式操作
*/
String bir="2002-4-4";
SimpleDateFormat simpleDateFormat1=new SimpleDateFormat("yyyy-MM-dd");
Date date1=simpleDateFormat1.parse(bir);
System.out.println(date1.getYear()+1900);十一、BigInteger BigDecimal
BigInteger
类型可以准确地表示任何大小的整数值而不会丢失任何信息。
public static void main(String[] args) {
/*
BigInteger 大整数
*/
//System.out.println(Long.MAX_VALUE);//9223372036854775807
BigInteger a=new BigInteger("999999999999990000000999999999999");
BigInteger b=new BigInteger("11111111111111111111111");
BigInteger c=a.add(b);// add+ subtract()- multiply()* divide()/
System.out.println(a);
System.out.println(b);
System.out.println(c);
}BigDecimal
计算机中 float double 都是浮点数，计算机是二进制的，浮点数会失去精度
根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可
能不精确。只能无限接近于那个值
例如
2 — 10
2.5 — 无限接近的一个近似值
public static void main(String[] args) {
/*double a = 1.0-0.9;//0.09999999999999998
double b = 0.8-0.7;//10000000000000009
System.out.println(a);
System.out.println(b);
System.out.println(a==b); // false*/
BigDecimal a=new BigDecimal("1.0");
BigDecimal b=new BigDecimal("0.9");
BigDecimal c=a.subtract(b);
System.out.println(c);
// add+ subtract()- multiply()* divide()/
}今天的文章javaapi中文手册_java调用api接口[通俗易懂]分享到此就结束了，感谢您的阅读。
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/71703.html
