目录
API
API（Application Programming Interface，应用程序接口）是一些预先定义的接口（如函数、HTTP接口），或指软件系统不同组成部分衔接的约定。 用来提供应用程序与开发人员基于某软件或硬件得以访问的一组例程，而又无需访问源码，或理解内部工作机制的细节。
基本数据类型包装类
包装类:为了解决java基本数据类型的使用方便,设计类时为每个基本类型设计了一个对应的代表类,这样八个基本数据类型对应的类统称为包装类
如(Integer,Character等)
常用的属性和方法:以Integer为例
public class IntegerDemo01 {
public static void main(String[] args) {
Integer integer1 = new Integer(10);
System.out.println(integer1);
System.out.println(integer1.intValue());
Integer integer2 = new Integer("10");
System.out.println(integer1.equals(integer2));//比较,返回值为boolean
System.out.println(integer1.compareTo(integer2));
Integer integer3 = new Integer("20");
System.out.println(Integer.toBinaryString(integer3));//转为2进制
System.out.println(Integer.toHexString(integer3));//转为16进制
System.out.println(Integer.toOctalString(integer3));//转为八进制
int integer4 = new Integer("12345");
System.out.println(integer4);
System.out.println(Integer.valueOf("45678"));
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
}
}装箱和拆箱
装箱:自动将基本数据类型转换为包装类型;装箱的时候自动调用的是Integer的valueOf(int)方法
拆箱:自动将包装类型转换为基本数据类型;拆箱的时候自动调用的是Integer的intValue方法
public class IntegerDemo02 {
public static void main(String[] args) {
int i = 128;//装箱
Integer i1 = Integer.valueOf(i);
int i2 = i1.intValue();//拆箱
}
}
Object类
Object类是所有类的祖先(根基类),每个类都使用Object作为父类.所有对象都实现这个类的方法
如果未用extends声明继承哪个类,则默认都继承Object类
toString方法
package com.ffyc.java.API.Object;
public class Person{
String name;
int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
@Override//这里重写了toString的方法
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
equals方法
如果没有重写,在Object中,默认返回的是判断两个是否为同一对象的引用,是则返回True,否则为False
public class Person{
String name;
int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
@Override//这里重写了equals方法
public boolean equals(Object o) {
Person person = (Person) o;
return this.age == person.age && this.name.equals(person.name);
}
}
Arrays类
Arrays类位于 java.util 包中，主要包含了操作数组的各种方法。
用于操作数组工具类,里面定义了常见操作数组的静态方法。
除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。
equals方法
import java.util.Arrays;
public class EqualsDemo {
public static void main(String[] args) {
int [] a = {1,2,3,4,5};
int [] b = {1,2,3,4,5};
System.out.println(Arrays.equals(a, b));//true
System.out.println(a.equals(b));//false
}
}Arrays.equals(a, b)为true,由于重写了equals方法,比较是他们的值;而a.equals(b)则为false,比较的是两个数组的地址
sort方法
sort(排序)
public class SortDemo {
public static void main(String[] args) {
int [] a = {2,2,1,6,4,5};
Arrays.sort(a);//从小到大排序
System.out.println(Arrays.toString(a));
Arrays.sort(strArray, Collections.reverseOrder());
int [] b = {2,2,1,6,4,5};//从指定位置进行排序(0到3,但是不包括三;区间都是左闭右开)
Arrays.sort(b,0,3);
System.out.println(Arrays.toString(b));
}
}自定义排序
自定义实现Comparable<>接口,重写compareTo方法
public class Test {
public static void main(String[] args) {
User user1 = new User(1, "123456", "111111");
User user2 = new User(2, "123456", "222222");
User user3 = new User(3, "123456", "333333");
User user4 = new User(4, "123456", "444444");
User user5 = new User(5, "123456", "555555");
User [] users = {user1,user3,user2,user5,user4};//自定义数组
Arrays.sort(users);
System.out.println(Arrays.toString(users));
}
}
public class User implements Comparable<User>{
private int Id;
private String account;
private String password;
@Override
public String toString() {
return "User{" +
"Id=" + Id +
", account='" + account + '\'' +
", password='" + password + '\'' +
'}' + "\n";
}
@Override//将自定义数组进行排序
public int compareTo(User o) {
return this.Id-o.Id;
}
}
BinarySearch
二分查找法找指定元素的索引值（下标）(数组一定是排好序的,否则就会出现错误)
public class BinarySearchDemo {
public static void main(String[] args) {
int a [] = {2,4,1,5,7,3,6};
Arrays.sort(a);//先将数组排好顺序
System.out.println(Arrays.binarySearch(a, 7));//在数组中找到7的位置,返回其下标
System.out.println(Arrays.binarySearch(a, 5, 7, 6));//在数组a中,在5到7之间寻找6,返回其下标
}
}copyOf()方法
copyOf():截取数组
public class CopyOfDemo {
public static void main(String[] args) {
int a [] = {2,4,1,5,7,3,6};
int [] b = Arrays.copyOf(a,10);//将数组a中的数值全部复制到b数组
System.out.println(Arrays.toString(b));
int[] c = Arrays.copyOfRange(a, 1, 4);
System.out.println(Arrays.toString(c));//将数组a中的数值复制到c数组,指定从1-4(不包括4)
}
}二分法查找
public class Demo01 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9};
Arrays.sort(arr);
System.out.println(BinarySearch(arr,7));
}
public static int BinarySearch(int[] arr, int key) {
int low = 0;
int high = arr.length - 1;
int middle = 0;
if (key > high || key < low || low > high) {
return -1;
}
while (low <= high) {
middle = (low + high) / 2;
if (arr[middle] > key) {
high = middle - 1;
} else if (arr[middle] < key) {
low = middle + 1;
} else {
return middle;
}
}
return -1;
}
}String类
String:是将多个字符拼接成一串数据
第一种创建方式: String str = "abc";
第二种创建方式:String str = new String("abc");
判断功能
equals:将两个字符串进行比较,判断其内容是否相同
equalsIngoreCase:将两个字符串进行比较,判断其内容是否相同(忽略大小写)
contains:判断该字符串中是否包含" "写入的内容
isEmpty:判断是否为空
startsWith:判断该字符串开头是否以指定字符串开头
endsWith:判断该字符串结尾是否以指定字符串结尾
compareTo:判断两个字符串的大小
public class StringDemo02 {
public static void main(String[] args) {
String s1 = "asd";
String s2 = "asd";
String s3 = "asD";
System.out.println(s1.equals(s2));//比较其内容
System.out.println(s1.equalsIgnoreCase(s3));//忽视大小写进行比较
String s = "asdfgh jklasd";
System.out.println(s.contains("hjk"));//判断是否包含该子串
System.out.println(s.isEmpty());//判断是否为空
System.out.println(s.startsWith("a"));//判读是否以该字符为开始
System.out.println(s.endsWith("l"));//判读是否以该字符为开始
System.out.println(s1.compareTo(s3));//字符串比较大小
}
}获取功能
.length():获取字符串长度
.charAt():获取字符串的指定位置的字符
indexOf:获取指定字符在字符串中的位置(从前往后找,只找首次出现的位置)
lastIndexOf:获取指定字符在字符串中的位置(从后往后找,只找首次出现的位置)
substring():截取输入位置到结束的字符构成新的字符串,也可以截取指定范围内的字符
public class StringDemo02 {
public static void main(String[] args) {
String s = "asdfghj";
char c = s.charAt(5);//截取当前位置的字符输出
System.out.println(c);
System.out.println(s.length());//获取字符串长度
System.out.println(s.indexOf("d"));//获取该字符出现的位置
int index = s.indexOf("a");
int index2 = index + 1 ;
System.out.println(index2);
String s4 = s.substring(2);//从第二个位置开始截取
System.out.println(s4);
String s5 = s.substring(1, 5);//从第一个位置开始,到第五个位置结束
System.out.println(s5);
}
}
转换功能
byte[] getBytes():将字符串转换为Byte数组
char[] toCharArray():将字符串转换为char型数组保存
toLowerCase():全部转换为小写
toUpperCase():全部转换为大写
concat("Hello"):连接新的字符串
split():断开,分割符
public class StringDemo03 {
public static void main(String[] args) {
String s = "中国";
byte[] b = s.getBytes();//将字符串转换为Byte数组
System.out.println(Arrays.toString(b));
String s1 = new String(b);//还原
System.out.println(s1);
String s2 = "asdfgdf";
char[] chars = s2.toCharArray();//将字符串转换为char型数组保存
System.out.println(Arrays.toString(chars));
String s3 = new String(chars);
System.out.println(s3);
String s5 = "agfSHfh";
System.out.println(s5.toLowerCase());//转换为小写
System.out.println(s5.toUpperCase());//转换为大写
System.out.println(s5.concat("Hello"));//在字符串后连接新的字符串
String s6 = "shjsh&dsh&hsjh";
String[] s7 = s6.split("&");//断开,分割符
System.out.println(Arrays.toString(s7));
}
}
替换功能
replace:可以替换一个字符或者是一个字符串
replaceAll:与replace相同,但是replaceAll基于正则表达式
replaceFirst:替换第一次出现的字符,或是字符串,也是基于正则表达式
trim():去除字符串两端的空格
public class StringDemo04 {
public static void main(String[] args) {
String s = " fvhfvuyb213 ";
System.out.println(s.replace("v", "a"));//将字符串中的全部"v",替换为"a"
System.out.println(s.replaceAll("\\d", "b"));//将字符串中的全部数字,替换为"b"
System.out.println(s.replaceFirst("v", "z"));//将字符串中的第一个"v",替换为"z"
System.out.println(s.length());//获取字符串长度
System.out.println(s.trim().length());//去除字符串两端的空格
}
}replace与replaceAll
区别:replace支持字符或者是字符串的替换;replaceAll参数是regex(基于正则表达式的替换)
相同点:都是全部替换,如果要替换第一次的则使用replaceFirst
StringBurref类与StringBuilder类
StringBurref
众所周知String作为不可修改的对象，即每次更改String都会产生一个新的字符串对象，与之相对应的StringBuffer类的对象能够进行多次修改并且不会产生新的未使用的对象，因此在内存上要优于String对象
StringBuffer是单线程的,但是安全
StringBuffer对象的初始化:
StringBuffer stringBuffer = new StringBuffer("asd");
功能:
它具有增加,删除,替换,反转,截取(与前几个功能不相同,截取返回的是String类型,本身没有发生改变)的功能
public class StringBufferDemo {
public static void main(String[] args) {
StringBuffer stringBuffer = new StringBuffer("asdfgh");
//System.out.println(stringBuffer.append("jkl"));//增加
//System.out.println(stringBuffer.insert(0,"x"));//在指定位置增加
//System.out.println(stringBuffer.delete(2,4));//在指定位置删除
//System.out.println(stringBuffer.replace(0, 2, "xxx"));//替换指定位置字符
//System.out.println(stringBuffer.reverse());//反转
System.out.println(stringBuffer.substring(2));//截取功能
}
}
StringBuilder
StringBuilder类功能和StringBuffer功能完全一致
StringBuilder可以用在多线程中,但是安全性不高
总结
因为StringBuilder 相比StringBuffer 有速度优势，所以大多数情况下建议使用StringBuilder 类。但当对应用程序有线程安全要求时，就必须使用StringBuffer 类。
Math类
Math类:java.lang.Math提供了一系列静态方法用于科学计算
它具有的方法:
public class MathDemo {
public static void main(String[] args) {
System.out.println(Math.abs(-456));//取绝对值
System.out.println(Math.sqrt(16));//平方根
System.out.println(Math.pow(2, 3));//a的b次方
System.out.println(Math.PI);
System.out.println( Math.random());//产生0-1之间的一个随机数
System.out.println(Math.floor(7.3));//向下取整
System.out.println(Math.ceil(7.3));//向上取整
System.out.println(Math.round(7.3));//四舍五入
System.out.println(Math.round(7.7));
}
}Random类
Random类:用于随机数的产生
public class RandomDemo {
public static void main(String[] args) {
Random random = new Random();
System.out.println(random.nextInt());
System.out.println(random.nextInt(10));//10以内的随机数
}
}System类
System类代表当前Java程序的运行平台，位于java.lang包下，该类被private修饰，所以不能创建System类的对象，System类提供了一些类变量和方法，允许直接通过System类来调用这些类变量和方法。
public class SystemDemo {
public static void main(String[] args) {
System.out.println(System.getenv());//会获取环境变量
System.out.println(System.getenv("path"));//会获取指定的环境变量
System.out.println(System.currentTimeMillis());//得到系统当前时间,为 long型
System.exit(0);//用于正常退出
System.exit(1);//常用于catch（）中，表示异常退出
System.out.println("5555");//由于前边程序正常退出,便不会输出后续的内容
}
}Date类
使用Date类代表当前系统时间
public class DateDemo {
public static void main(String[] args) {
Date date = new Date();//获取当前系统时间
long l = System.currentTimeMillis();
Date date1 = new Date(l);
System.out.println(date);//此处输出和下边的结果是一样的
System.out.println(date1);
System.out.println(l);//此处输出和下边的结果是一样的
System.out.println(date.getTime());
}
}Calender类(日历类)
因为这个类可以让我们像看日历一样得到这个时间的所有属性,所以也叫做日历类
public class CalendarDemo {
public static void main(String[] args) {
Calendar calendar = new GregorianCalendar();//GregorianCalendar为Calendar子类
System.out.println(calendar.getWeekYear());//今年是哪年
int day = calendar.get(Calendar.DAY_OF_YEAR);//今年中的第几天
System.out.println(day);
}
}
SimpleDateFormat类
SimpleDateFormat类:日期格式化类
public class Demo {
public static void main(String[] args) {
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");//格式
String str = simpleDateFormat.format(date);//日期转字符串
System.out.println(str);
String s = "1998-08-08";
try {
System.out.println(simpleDateFormat.parse(s));//字符串转日期
} catch (ParseException e) {
e.printStackTrace();
}
}
}BigInteger
BigInteger 类:我们都知道Integer是int的包装类,若要使用比int更大的数时,int就无法使用了,就会用到BigInteger 类
BigInteger 类位于java.math包中
public class Demo {
public static void main(String[] args) {
BigInteger b = new BigInteger("111111111111111111111111111111111111111");
BigInteger c = new BigInteger("111111111111111111111111111111111111111");
System.out.println(b.add(c));//相加
System.out.println(b.subtract(c));//相减
System.out.println(b.multiply(c));//相乘
System.out.println(b.divide(c));//相除
}
}BigDecimal
BigDecimal类: 用来对超过16位有效位的数进行精确的运算
public static void main(String[] args) {
double a = 12.0;
double b = 11.92;
System.out.println(a-b);
}
//运行结果为 0.08000000000000007为什么会出现上述这种情况呢,由于在计算机中不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去 一定的精确度
根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可能不精确。只能无限接近于那个值
public static void main(String[] args) {
BigDecimal c = new BigDecimal(12.0);
BigDecimal d = new BigDecimal(11.92);
System.out.println(c.subtract(d));
}
//运行结果为0.0800000000000000710542735760100185871124267578125由上可知使用BigDecimal结果也会发生问题,也不太建议使用
同时BigDecimal和BigInteger一样,也有加减乘除的方法