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

刺骨的言语ヽ痛彻心扉 2023-10-08 12:41 28阅读 0赞

#### 文章目录 ####

*  java常用API
 *   *  1、官方文档的使用
     *  2、java中常用工具类
     *   *  2.1、Scanner 类 (键盘输入)
         *  2.2、Random 类 (随机数)
         *  2.3、Array 类 (数组)
         *  2.4、Arrays 类 (数组工具类)
         *  2.5、ArrayList 类 (集合)
         *  2.6、Math类 (数学工具类)
         *  2.7、Object类 (超类)
         *  2.8、Date类 (日期类)
         *  2.9、Calendar类 (日历类)
         *  2.10、System类 (系统类)
         *  2.11、StringBuilder 类 (字符串缓存区)
     *  3、基本类型、包装类

## java常用API ##

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

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

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

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

### 1、官方文档的使用 ###

文档下载下来需要解除锁定才能用：  
![在这里插入图片描述][20210127203031296.png]  
以String为例我们看看里面的内容  
![在这里插入图片描述][20210127203922146.png]  
我们需要重点关注一个类的构造方法摘要 、方法摘要  
![在这里插入图片描述][20210127204208260.png]

### 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");

[20210127203031296.png]: https://img-blog.csdnimg.cn/20210127203031296.png
[20210127203922146.png]: https://img-blog.csdnimg.cn/20210127203922146.png
[20210127204208260.png]: https://img-blog.csdnimg.cn/20210127204208260.png