java常用API 1（系统类、随机数、数组、超类、时间类、基本类型与包装类）

最新推荐文章于 2022-11-04 22:18:26 发布

BeanInJ

最新推荐文章于 2022-11-04 22:18:26 发布

阅读量240

点赞数 2

分类专栏： java系列文章标签： java jdk 字符串

@BeanInJ

本文链接：https://blog.csdn.net/a__int__/article/details/113269683

版权

java系列专栏收录该内容

100 篇文章 4 订阅

订阅专栏

文章目录

java常用API

java常用API

官方中文API文档下载地址：

jdk1.6的：链接：https://pan.baidu.com/s/1TxmXzyFdf8JP-Z-2jI6JGQ 提取码：0523

到目前官方只出了1.6的中文官方文档，如果想看1.8的可以参考其他人翻译的

我们在日常使用过程中，只有java.lang下的类不需要导包，其他的api都需要import导包。

1、官方文档的使用

文档下载下来需要解除锁定才能用：
在这里插入图片描述
以String为例我们看看里面的内容

我们需要重点关注一个类的构造方法摘要、方法摘要

2、java中常用工具类

2.1、Scanner 类 (键盘输入)

我们可以通过 Scanner 类来获取用户的输入：

new Scanner(System.in);
s.next();
s.nextInt();

// 创建 Scanner 对象
Scanner sc = new Scanner(System.in);
// 获取输入的字符串对象
String s = sc.next();
// 获取输入的int对象
int i = sc.nextInt();

Scanner(System.in)输入的默认是字符串，nextInt()是强制转为int

2.2、Random 类 (随机数)

我们可以通过 Scanner 类来获取一个随机值：

new Random();
r.nextInt();
r.nextInt(3);
r.nextInt(7)+1;
r.nextDouble();

Random r = new Random();
// 获取int类型的随机数，随机范围整个int
int n1 = r.nextInt();
// 获取int类型的随机数，随机范围【0,3）
int n2 = r.nextInt(3);
// 获取int类型的随机数，随机范围【0,7】 ，适用于0~XX
int n3 = r.nextInt(7)+1;
// 除了int类型，还可以是Boolean、Bytes、Double、Float、Long
double d1 = r.nextDouble();

2.3、Array 类 (数组)

1、在1.6的API里面我们能找到两个Array，这里用的是java.lang.reflect包下的
2、Array这个类是不能够被实例化的，但是我们可以直接用基本类型加上[ ],创建对应类型的数组
3、注意数组一旦创建，长度固定，不能发生改变

public class Test_3_Array {
    public static void main(String[] args) {
        // 下面是一个int类型的数组几种写法
        // 静态赋值
        int a[] = new int[]{10,20,30};
        int[] b = new int[]{10,20,30};
        int c[] = {10,20,30};
        // 动态赋值
        int[] d = new int[3];
        d[0] = 10;
        d[1] = 20;
        d[2] = 30;

        // 下面是数组被动态初始化是，各种类型的默认值：
            //  1).byte,short,int,long类型，数组被赋值成0.
            //　2).float,double类型，数组被赋值成0.0.
            //  3).char类型，数组被赋值成“\u0000”.
            //　4).boolean类型，数组被赋值成false.
            //　5).引用类型(类，接口，数组)，数组被赋值成null.

        // 数组还可以定义成二维的
        int[][] dd = {{1, 2, 3}, {4, 5}, {6, 7, 8, 9}};
        // 也可以自定义对象数组
        NewArray[] ns = new NewArray[2];
        ns[0] = new NewArray("张三");
        ns[1] = new NewArray("李四");
        
        System.out.println(ns[0]);
        System.out.println(dd[2][1]);

        // 数组长度是不可变的，如果想要“可变”，那就用ArrayList集合
    }
}

class NewArray{
    private String name;

    NewArray(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2.4、Arrays 类 (数组工具类)

Arrays.toString(l);
Arrays.sort(l);
s.toCharArray();
String.valueOf(char1)

        // 数组工具类Arrays

        long[] l = {1,3,2};
        // 将数组变成字符串 Arrays.toString
        String s = Arrays.toString(l);
        // 排序 ,Arrays.sort升序、从小到大
        Arrays.sort(l);

        // 字符串排序       String.charAt(index)（返回值为char）    String.toCharArray()（返回值为char[]）
        // 思路：先转为char数组排序，再转为String
        String s1 = "acbed";
        // 转为char[]
        char[] c = s1.toCharArray();
        Arrays.sort(c);
        // 转为String
        System.out.println(String.valueOf(c));

2.5、ArrayList 类 (集合)

new ArrayList<>();
al.add(“张三”);
al.get(0);
al.remove(0);
int s = al.size();
for (String l : al)…

        // 数组的长度不可变，ArrayList的长度是可变的

        // ArrayList<> 可以根据<>里面的泛型定义要传入的数据类型，泛型只能是引用类型，不能是基本类型
        // jdk 1.7开始,右边的泛型可以不写
        ArrayList<String> al = new ArrayList<>();
        al.add("张三");
        al.add("李四");

        // ArrayList默认实现了序列化，直接打印ArrayList打印出来的是字符串内容
        System.out.println(al);
        // 获取其中一个元素
        System.out.println(al.get(1));
        // 删除一个,有返回值，删除的内容是什么就返回什么。
        al.remove(0);
        // 获取长度
        int s = al.size();
        // 遍历集合
        for (String l : al) { System.out.print(l);}

2.6、Math类 (数学工具类)

        // 数学工具类

        // 获取绝对值
        double m1 = Math.abs(-2.1);

        // 向上取整
        double m2 = Math.ceil(3.2);
        // 向下取整
        double m3 = Math.floor(4.7);

        // 四舍五入
        long m4 = Math.round(5.5);

        // 返回最大值、最小值
        int m5 = Math.max(5, 7);
        double m6 = Math.min(3.0, 1.22);

        // 数学中的常量
        // 圆周率 Math.PI    自然常数 Math.E

        // 另外数学方法中还有正弦、无穷大、指数、幂等相关运算

2.7、Object类 (超类)

        // 每个类都使用 Object 作为超类
        // 也就意味着 Object 类有的方法，所有类都有

        // equals 比较两个类的地址
        Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = o1;
        System.out.println(o1.equals(o2));
        System.out.println(o1.equals(o3));

        // hashCode() 返回对象内部地址转换成的整数
        System.out.println(o1.hashCode()); // 和o3一样
        System.out.println(o2.hashCode()); // 地址不一样，所以和o1、o3不一样
        System.out.println(o3.hashCode());

        // toString() 返回一个对象的字符串表示，一般没实现序列化的类返回的是类地址

        // Object 中还有一些为垃圾回收器、线程准备的方法
        // finalize() 、getClass() 、notify() 、notifyAll() 、wait()

        // Objects类 (超类工具类) ：jdk1.7后出现.提供静态方法操作对象。重写了equals、解决空指针异常问题
        boolean bs = Objects.equals(o1, o2);  // 允许o1或o2为空

2.8、Date类 (日期类)

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test_8_Date {
    public static void main(String[] args) throws ParseException {
        // java.util.Date 表示特定的瞬间，精确到毫秒

        // 概念：
        // 1、基准时间：1970年1月1日 00:00:00 GMT   为 0 毫秒
        // 2、1000毫秒 = 1 秒

        // 获取当前系统时间毫秒数（从1970到现在的毫秒数）
        // 下面两种方式都可以
        long l1 = System.currentTimeMillis();
        long l2 = new Date().getTime();

        // 获取日期 (输出格式：星期X 月份 日期 XX：XX：xx CST 年份)
        Date date1 = new Date();                // 当前日期
        Date date2 = new Date(0L);              // 1970年1月1日 00:00:00
        Date date3 = new Date(1611884139230L);  // 2020年1月19日

        // 日期格式化   java.text.SimpleDateFormat
        // y 年
        // M 月
        // d 天
        // H 小时（0-23）  k 小时（1-24）
        // m 分钟
        // s 秒   S 毫秒

        // Date转成日期字符串
        SimpleDateFormat f1 = new SimpleDateFormat("yyyy年 MM月 dd日 HH时mm分ss秒");
        String d1 = f1.format(new Date());

        // 日期字符串转成Date    parse需要抛出异常
        SimpleDateFormat f2 = new SimpleDateFormat("yyyy年 MM月 dd日 HH时mm分ss秒");
        Date d2 = f2.parse("2021年 01月 29日 10时12分23秒");
    }
}

2.9、Calendar类 (日历类)

        // Calendar 日历类

        Calendar c = Calendar.getInstance();
        // get（）
        // 获取年份
        int i = c.get(Calendar.YEAR);
        // 获取月份    西方的月份0-11   东方的月份1-12
        int i1 = c.get(Calendar.MONTH);
        // 日期
        int i2 = c.get(Calendar.DAY_OF_MONTH);
        int i3 = c.get(Calendar.DATE);
        // 时分秒 同理

        // set（）   set设置的，可以用get获取
        c.set(Calendar.YEAR,2099);  // 设置年
        c.set(Calendar.MONTH,6);    // 设置月
        c.set(Calendar.DATE,18);    // 设置日
        // 同时设置年月日
        c.set(2099,6,18);

        // 增加年、月、日、时...
        c.add(Calendar.YEAR,2);    // 增加2年
        c.add(Calendar.DATE,-3);   // 减少3月

        // 日历转为日期
        Date date = c.getTime();

2.10、System类 (系统类)

        // System类里面的都是静态方法

        // 返回系统时间毫秒 （多用来统计程序执行效率）
        long l = System.currentTimeMillis();

        // 数组复制   把i1的0-3 复制到i2中
        int[] i1 = {1,2,3,4,5} , i2 = {6,7,8,9,0} ;
        System.arraycopy(i1,0,i2,0,3);
        System.out.println(Arrays.toString(i2));

2.11、StringBuilder 类 (字符串缓存区)

        // 所有字符串都是 String 类的，它是被final修饰的不可变类型
        // 如下abc三个字符串，都是一个独立的空间。下面的相加过程总共会占用5个空间：a b c ab abc
        String s = "a"+"b"+"c";
        // 字符串转换大小写
        String s1 = "aBc123".toUpperCase();  // 转大写
        String s2 = "aBc123".toLowerCase();  // 转小写

        // 为了解决 String 浪费空间现象，我们利用StringBuilder（字符串缓冲区）提高效率
        // StringBuilder内存中是一个数组，会根据字符串长度自动扩容（初始容量为16个字符）
        StringBuilder sb1 = new StringBuilder();
        StringBuilder sb2 = new StringBuilder("aaa");
        StringBuilder sb3 = sb1.append("aaa");          // 向sb1添加内容，并赋值给sb3
        // 比较地址
        System.out.println(sb1 == sb2);
        System.out.println(sb1 == sb3);
        System.out.println(sb1.equals(sb2));
        // 添加多个值
        sb2.append("123").append("abc").append("---");
        // StringBuilder 和 String  的相互转换
        String s3 = sb2.toString();                    // StringBuilder 转 String
        StringBuilder sb4 = new StringBuilder(s2);     // String 转 StringBuilder

3、基本类型、包装类

        // 下面是java中八大基本类型 及 对应包装类
        //        基本类型　	包装器类型
        //        boolean	Boolean       布尔值
        //        char	    Character     两个字节    从0到65535，存Unicode
        //        int	    Integer       整数       32位，约-21亿到21亿
        //        byte    	Byte          一个字节    从-128到127，从0到127存ascii码
        //        short  	Short         短整数      约-3万到3万
        //        long	    Long          长整数      64位，约-90亿亿到90亿亿
        //        float  	Float         单精度浮点   32位（4个字节）
        //        double	Double        双精度浮点   64位（8个字节）

        // 基本类型 仅能存数字，他们的包装类型封装了很多方法：
        // 输出最大、最小值： MIN_VALUE、MAX_VALUE
        int i1 = Byte.MAX_VALUE;
        double i2 = Double.MIN_VALUE;

        // 装箱、拆箱（基本类型和包装类型的转换）,我们常用的是自动拆箱、装箱的方式
        Integer i3 = 2;                       // 自动装箱
        Integer i4 = new Integer(2);    // 装箱 方式1
        Integer i5 = Integer.valueOf(2);      // 装箱 方式2
        Integer i6 = Integer.valueOf("2");    // 装箱

        int i7 = i4;                          // 自动拆箱
        int i8 = i4.intValue();               // 拆箱

        // ArrayList 只能存储包装类，它的add、get可以自动装箱、拆箱
        ArrayList<Integer> l = new ArrayList<>();
        l.add(5);                              // 自动装箱
        int i9 = l.get(0);                     // 自动拆箱

        // 基本类型与String之间的转换
        // 1、基本类型转String  （三种方式）
        String s1 = 100 + "";
        String s2 = Double.toString(0.333);
        String s3 = String.valueOf(1.1);
        // 2、String转基本类型    注意：被转换的字符串内容，要符合转出去对应的基本类型，比如“a”不能转为int
        int i01 = Integer.parseInt("11");
        long l01 = Long.parseLong("202016666");

BeanInJ

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java常用API 1（系统类、随机数、数组、超类、时间类、基本类型与包装类）

文章目录java常用API1、官方文档的使用2、java.util 中常用2.1、Scanner 类 (键盘输入)2.2、Random 类 (随机数)java常用API官方中文API文档下载地址：jdk1.6的：链接：https://pan.baidu.com/s/1TxmXzyFdf8JP-Z-2jI6JGQ 提取码：0523到目前官方只出了1.6的中文官方文档，如果想看1.8的可以参考其他人翻译的我们在日常使用过程中，只有java.lang下的类不需要导包，其他的api都需要im
复制链接

扫一扫