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一样,也有加减乘除的方法

标签：常用,String,int,System,javaAPI,println,public,out
来源： https://blog.csdn.net/weixin_55768623/article/details/121594779