常用API

最新推荐文章于 2021-12-01 14:02:37 发布

hello嗨

最新推荐文章于 2021-12-01 14:02:37 发布

阅读量297

点赞数 1

分类专栏： Java语言高级

本文链接：https://blog.csdn.net/LRFlrf_/article/details/90444860

版权

Java语言高级专栏收录该内容

37 篇文章 0 订阅

订阅专栏

应用程序编程接口，Java API是一本程序员使用的字典。

Scanner的功能

可以实现键盘输入，到程序当中。
引用类型的一般使用步骤。
1. 导包
import 包路径.类名称；
如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
只有java.lang包下的内容不需要导包，其他的包都需要import语句。
2. 创建
类名称对象名 = new 类名称（）；
3. 使用
对象名.成员方法名（）；

Random的功能

Random类用来生成随机数字。使用起来也是三个步骤。
1. 导包
import java.util.Random；
2. 创建
Random r = new Random（）；
3. 使用
获取一个随机的int数字（范围是int所有范围，有正负两种）——nextInt。
int num = r.nextInt();
获取一个随机的int数字（参数代表了范围，左闭右开区间）
int num =r.nextInt(3);
实际上代表的含义是[0,3),也就是0~2。

Random练习一——————生成1-n之间的数

import java.util.Random;

/**
 * 题目要求
 * 根据int变量n的值，来获取随机数字，范围是[1,n],可以取到1也可以取到n。
 */
public class Demo03Random {
    public static void main(String[] args) {
        int n = 5;
        Random r = new Random();
        for (int i = 0; i < 100; i++) {
            int result = r.nextInt(n) + 1;
            System.out.println(result);
        }
    }
}

Random练习二——————猜数字小游戏

import java.util.Random;
import java.util.Scanner;

/**
 * 用代码模拟猜数字小游戏
 */
public class Demo04RandomGame {
    public static void main(String[] args) {
        Random r = new Random();
        int randomNum = r.nextInt(100) + 1;//[1,100)
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请输入你猜测的数字：");
            int guessNum = sc.nextInt();//键盘输入的猜测数字

            if (guessNum > randomNum) {
                System.out.println("太大了，请重试。");
            } else if (guessNum < randomNum) {
                System.out.println("太小了，请重试。");
            } else {
                System.out.println("恭喜你，猜中了！！！");
                break;//如果猜中，不再重试
            }
        }

    }
}

在这里插入图片描述

ArrayList集合

数组有一个缺点——一旦创建，程序运行期间的长度不可以发生改变。
ArrayList集合的长度可以随时改变。
对于ArrayList来说，有一个尖括号代表泛型。
泛型——也就是装在集合当中的所有元素，全部都是统一的什么类型。
注意——泛型只能是引用数据类型，不能是基本类型

注意事项
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空，得到的是空的中括号[ ]。

ArrayList集合常用方法

public boolean add（E e）——像集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
对于集合来说，add添加动作一定是成功的。所以返回值可用可不用。
但对于其他集合来说，add添加动作不一定成功。
public E get(int index)——像集合当中获取元素，参数是索引编号，返回值就是对应位置得元素。
public E remove(int index)——从集合当中删除元素，参数是索引编号，返回值就是被删除的元素。
public int size（）——获取集合尺寸的长度，返回值是集合中包含的元素个数。

如果希望向集合ArrayList当中存储基本数据类型，必须使用基本类型对应的“包装类”。
基本类型——包装类—（引用类型，包装类都位于java.lang包下）
byte—————Byte
short—————Short
int——————Integer——【特殊】
long—————Long
float—————Float
double————Double
char—————Character——【特殊】
boolean————Boolean
从JDK1.5+开始，支持自动装箱、自动拆箱。
自动装箱——基本类型–>包装类型
自动拆箱——包装类型–>基本类型

ArrayList练习一——————存储随机数

import java.util.ArrayList;
import java.util.Random;

/**
 * 题目
 * 生成6个1~33之间的随机整数，添加到集合，并遍历集合。
 */
public class Demo01ArrayListRandom {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 6; i++) {
            int num = r.nextInt(33) + 1;
            list.add(num);
        }
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

在这里插入图片描述

ArrayList练习二——————存储自定义对象

import java.util.ArrayList;

/**
 * 题目
 * 自定义4个学生对象，添加到集合，并遍历。
 */
public class Demo02ArrayListStudent {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student one = new Student("洪七公",20);
        Student two = new Student("欧阳锋",21);
        Student three = new Student("黄药师",22);
        Student four = new Student("段志心",23);
        list.add(one);
        list.add(two);
        list.add(three);
        list.add(four);
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println("姓名:"+stu.getName()+"年龄："+stu.getAge());
        }
    }
}

在这里插入图片描述

ArrayList练习三——————按指定格式打印集合

import java.util.ArrayList;

/**
 * 题目
 * 定义以指定格式打印集合的方法（ArrayList类型作为参数），
 * 使用{}扩起集合，使用@分隔每个元素。
 * 格式参照{元素@元素@元素}
 */
public class Demo03ArrayListPrint {
    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("宋远桥");
        list.add("张无忌");
        list.add("张翠山");
        System.out.println(list);
        printArrayList(list);
    }

    private static void printArrayList(ArrayList<String> list) {
        System.out.print("{");
        for (int i = 0; i < list.size(); i++) {
            String name = list.get(i);
            if(i==list.size()-1){
                System.out.println(name+"}");
            }else {
                System.out.print(name + "@");
            }
        }
    }
}

在这里插入图片描述

ArrayList练习四——————筛选集合


import java.util.ArrayList;
import java.util.Random;

/**
 * 题目
 * 用一个大集合存入20个随机数字，
 * 然后筛选其中的偶数元素，放到小集合当中。
 * 要求使用自定义的方法来实现筛选。
 */
public class Demo04ArrayListReturn {
    public static void main(String[] args) {
        ArrayList<Integer> bigList = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100) + 1;
            bigList.add(num);
        }
        ArrayList<Integer> smallList = getSmallList(bigList);
        System.out.println("偶数总共有多少个："+smallList.size());
        for (int i = 0; i < smallList.size(); i++) {
            System.out.println(smallList.get(i));
        }
    }

    //这个方法，接收大集合参数，返回小集合结果
    public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) {
        //创建一个小集合，用来装偶数结果
        ArrayList<Integer> smallList = new ArrayList<>();
        for (int i = 0; i < bigList.size(); i++) {
            int num = bigList.get(i);
            if (num % 2 == 0) {
                smallList.add(num);
            }
        }
        return smallList;
    }
}

在这里插入图片描述

String类

java.lang.String类代表字符串。
API当中说：Java程序中所有的字符串字面值（如“abc”）都作为此类的实例实现。
其实就是说——程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是）。
字符串的特点

字符串的内容永不改变。【重点】
正是因为字符串不可改变，所以字符串是可以共享使用的。
字符串效果上相当于char[ ]字符数组，但是底层原理是byte[ ]字节数组。

创建字符串的常见3+1种方式

三种构造方法

public String（）：创建一个空白字符串，不含有任何内容。
public String（char[ ] array）：根据字符数组的内容，来创建对应字符串。
public String（byte[ ] array）：根据字节数组的内容，来创建对应字符串。

一种直接创建

String str = “Hello”;//右边直接用双引号。

注意
直接写上双引号，就是字符串对象。

练习——————创建字符串

public class Demo01String {
    public static void main(String[] args) {
        //使用空参搞糟
        String str1 = new String();
        System.out.println("第一个字符串：" + str1);
        //根据字符数组创建字符串
        char[] charArray = {'A', 'B', 'C'};
        String str2 = new String(charArray);
        System.out.println("第二个字符串：" + str2);
        //根据字节数组创建字符串
        byte[] byteArray = {97, 98, 99};
        String str3 = new String(byteArray);
        System.out.println("第三个字符串：" + str3);
        //直接创建
        String str4 = "Hello";
        System.out.println("第四个字符串："+str4);
    }
}

在这里插入图片描述

字符串常量池

程序当中直接写上的双引号字符串，就在字符串常量池中。
对于基本类型来说，==是进行数值的比较。
对于引用类型来说，==是进行【地址值】的比较。
在这里插入图片描述

String当中与比较相关的常用方法

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法。
public boolean equals(Object obj);参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
注意事项

任何对象都能用Object进行接收。
equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
推荐——“abc".equals(str)
不推荐——str.equals(“abc")
public boolean equalsIgnoreCase(String str);忽略大小写，进行内容比较。

String当中与获取相关的常用方法

public int length()——获取字符串当中含有的字符个数，拿到字符串长度。
public String concat (String str)——将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index)——获取指定索引位置的单个字符。
public int indextOf(String str)——查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

字符串的截取方法

public String substring(int index)——截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin，int end)——截取begin开始，一直到end结束，中间的字符串。

备注：[begin,end),包含左边，不包含右边。

String当中与转换相关的常用方法

public char[ ] toCharArray()——将当前字符串拆分成为字符数组作为返回值。
public byte[ ] getByte()——获得当前字符串底层的自己数组。
public String replace(CharAequence oldString,CharAequence ewString)——将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
备注：CharAequence 意思就是说可以接收字符串类型。

分割字符串的方法

public String[ ]split (String regex)——按照参数的规则，将字符串切分成为若干部分。
注意事项
split 方法的参数其实是一个”正则表达式“
如果按照英文句点”.“进行切分，必须写“\\.”(两个反斜杠)

练习——————按指定格式拼接字符


/**
 * 题目
 * 定义一个方法，把数组{1，2，3}按照指定格式拼接成一个字符串。
 * 格式参照如[word1#word2#word3]。
 */
public class Demo06StringPractise {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        String result =fromArrayToString(array);
        System.out.println(result);
    }

    public static String fromArrayToString(int[] array) {
        String str = "[";
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                str += "word" + array[i] + "]";
            } else {
                str += "word" + array[i] + "#";

            }
        }
        return str;
    }
}

在这里插入图片描述

练习——————统计输入的字符串中

import java.util.Scanner;

/**
 * 题目
 * 键盘输入一个字符串，并且统计其中各种字符出现的次数。
 * 种类有：大写字母、小写字母、数字、其他。
 */
public class Demo07StringCount {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String input = sc.next();//获取键盘输入的一个字符串
        int countUpper = 0;//大写字母
        int countLower = 0;//小写字母
        int countNumber = 0;//数字
        int countOther = 0;//其他字符
        char[] charArray = input.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i];//当前单个字符
            if ('A'<=ch&&ch<='Z'){
                countUpper++;
            }else if ('a'<=ch&&ch<='z'){
                countLower++;
            }else if ('0'<=ch&&ch<='9'){
                countNumber++;
            }else {
                countOther++;
            }
        }
        System.out.println("大写字母："+countUpper);
        System.out.println("小写字母："+countLower);
        System.out.println("数字："+countNumber);
        System.out.println("其他字符："+countOther);
    }

}

在这里插入图片描述

数组工具类Arrays

java.util,Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作。

public static String toString(数组)——将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3…]）。
public static void sort(数组)——按照默认升序（从小到大）对数组的元素进行排序。

备注

如果时数值，sort默认按照升序从小到大
如果是字符串，sort默认按照字母升序
如果是自定义的类型，那么这个自定义的类需要有Comparator 或者Comparator接口的支持。

Arrays练习——————字符串倒序

import java.util.Arrays;

/**
 * 题目
 * 请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
 */
public class Demo02ArraysPractise {
    public static void main(String[] args) {
        String str = "asv76agfqwdfvasdfvjh";
        //如何进行升序排列：sort
        //必须是一个数组，才能用Arrays.sort方法
        //String-->数组，用toCharArray
        char[] chars = str.toCharArray();
        Arrays.sort(chars);//对字符数组进行升序排列
        System.out.println(chars);
        //需要倒序
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }
    }
}

在这里插入图片描述

数学工具类Math

java.util.Math类时数学相关工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
pubic static double abs(double num)——获取绝对值。有多种重载。
pubic static double ceil(double num)——向上取整。
pubic static double floor(double num)——向下取整，抹零。
pubic static Long round(double num)——四舍五入。
Math.PI代表近似的圆周率常量（double ）。

Math练习——————小学数学真题

/**
 * 题目
 * 计算-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
 */
public class Demo02MathPractise {
    public static void main(String[] args) {
        int count = 0;
        double min = -10.8;
        double max = 5.9;
            //这样处理，变量i就是区间之内所有的整数
        for (int i = (int) min; i < max; i++) {
            int abs = Math.abs(i);
            if (abs > 6 || abs < 2.1) {
                System.out.println(i);
                count++;
            }
        }
        System.out.println("总共有："+count);
    }
}

在这里插入图片描述

Object类

java.lang.Object类是Java语言中的根类，即所有类的父类。它类中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

Date类

java.util.Data——表示日期和时间的类。
类Data表示特定的瞬间，精确到毫秒。
毫秒——千分之一秒1000毫秒=1秒
特定的瞬间——一个时间点，一刹那时间
2088-08-08 09：55：33：333瞬间
2088-08-08 09：55：33：334瞬间
2088-08-08 09：55：33：334瞬间
…
毫秒值的作用——可以对时间和日期进行计算。
2099-01-03到2088-01-01中间一共多少天。
可以日期转换为毫秒进行计算，计算完毕，再把毫秒转换为日期。
把日期转换为毫秒
当前日期2088-01-01
时间原点（0毫秒）——1970年1月1日00：00：00（英国格林威治）
就是计算当前日期到时间原点之间一共经历了多少毫秒。
把毫秒转换为日期
1天=24×60×50=86400秒=86400×1000=86400000毫秒
注意
中国属于东八区，会把时间增加8小时
1970年1月1日08：00：00
Date类的空参数构造方法
Data()——获取当前系统的日期和时间。
Date类的带参数构造方法
Data(long data)——传递毫秒值，把毫秒值转换为Data日期。
long getTime()把日期转换为毫秒值（相当于System.currentTimeMillis（）方法）
返回自1970年1月1日00：00：00GMT以来次Data对象表示的毫秒数。

DateFormat类

java.text.DateFormat是日期/时间格式化子类的抽象类。

DateFormat类作用

我们通过这个类可以帮我们完成日期和文本之间的转换，也就是可以在Data对象与String对象之间进行来回转换。

DateFormat类成员方法

**String format(Date date)**按照指定的模式，把Date日期，格式化为符合模式的字符串。
**Date parse(String source)**把符合模式的字符串，解析为Date日期。

DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat类的子类。
java.text.SimpleDateFormat extends DateFormat
构造方法

SimpleDateFormat（String pattern）

用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
参数——String pattern——传递指定的模式
模式——区分大小写的

y——年
M——月
d——日
H——时
m——分
s——秒

写对应的模式，会把模式替换为对应的日期和时间
“yyyy-MM-dd HH-mm-ss”
注意
模式中的字母不能更改，连接模式的符号可以改变
“yyyy年MM月dd日 HH时mm分ss秒”
使用DateFormat类中的方法parse，把文本解析为日期
使用步骤

创建SimpleDateFormat对象，构造方法中传递指定的模式
调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串，解析为Date日期。注意

public Date parse (String source)throw ParseException
parse方法声明了一个异常叫ParseException
如果字符串和构造方法的模式不一样，那么程序就会抛出异常
调用一个抛出异常的方法，就必须处理这个异常，那么throw继续抛出这个异常，要么try catch自己处理。
使用DateFormat类中的方法farmot，把日期解析为文本
使用步骤

创建SimpleDateFormat对象，把日期格式化为文本
调用SimpleDateFormat对象中的方法farmot，按照构造方法中的指定模式，把Date日期格式化为符合模式的字符串（文本）。

练习——————计算出一个人已经出生了几天

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

/**
 * 练习：
 * 请使用日期时间相关的API，计算一个人已经出生了多少天。
 */
public class Demo02Test {
    public static void main(String[] args) throws ParseException {
        //1.使用Scanner类中的方法next，获取出生日期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的出生日期，格式：yyyy-MM-dd");
        String birthDayDateString = sc.next();
        //2。使用DateFormat类中的方法parse，把字符串的出生日期，解析为Date格式的出生日期
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        Date birthDayDate = sdf.parse(birthDayDateString);
        System.out.println(birthDayDate);
        //3.把Date格式的出生日期转换为毫秒值
        long birthDayDateTime = birthDayDate.getTime();
        //4.获取当前的日期，转换为毫秒值
        long todayTime =new Date().getTime();
        //5.使用当前日期的毫秒值-出生日期的毫秒值
        long time =todayTime-birthDayDateTime;
        //6.把毫秒差值转换为天（s/1000/60/60/24）
        System.out.println(time/1000/60/60/24);
    }
}

在这里插入图片描述

Calendar类

java.util.calendar类——日历类
Calendar类时一个抽象类，里边提供了很多操作日历字段的方法（YEAR、MONTH、DAY_OF_MONTH、HOUR）
Calendar类无法直接创建对象使用，里边有一个静态方法叫getInstance(),方法返回了Calendar类的子类对象。
static Calendar getInstance()使用默认时区和语言环境获得了一个日历。
Calendar类常用成员方法

public int get（int field）————————————返回给定字段的值。
public void set（int field,int value）———————将给定的日历字段设置给定值。
public abstract void add（int field,int amount）——根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime（）————————————返回一个表示时间值（从历元到现在的毫秒偏移量）的Date对象。

成员方法的参数

int field——日历类的字段，可以使用Calendar类的静态成员变量获取
public static final int YEAR=1；——————————年
public static final int MONTH=2；—————————月
public static final int DATE=5；——————————月中的某一天
public static final int DAY_OF_MONTH=5；—————月中的某一天
public static final int HOUR=10；—————————时
public static final int MINUTE =12；————————分
public static final int SECOND=13；————————分秒

System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关得信息或系统级操作，在System类的API文档中，常用的方法有——

public static long currentTimeMillis()——返回以毫秒为单位的当前时间。
public static void arraycopy(Object src,int srcPos,Object dest,int desPos,int desPos,ine length)——将数组中指定的数据拷贝到另一个数组中。

参数：

src————————源数组
srcPos——————源数组中的起始位置
dest———————目标数组
destPos——————目标数组中的起始位置
length———————要复制的数组元素的数量

StringBuider类

在这里插入图片描述
java.lang.StringBuilder类——————字符串缓冲区，可以提高字符串的效率。
构造方法

StringBuilder()———————————构造一个不带任何字符的字符串生成器，并初始容量为16个字符。
StringBuilder(String str)———————构造一个字符串生成器，并初始化为特定的字符串内容。

StringBuilder常用的方法

public StringBuilder append(…)———添加任意类型数据的字符串形式，并返回当前对象自身。

StringBuilder 和String可以相互转换

String–>StringBuilder ———————可以使用StringBuilder的构造方法————StringBuilder(String str）
StringBuilder–>StringBuilde————可以使用StringBuilder中的toString方法
public String toString()———————将当前StringBuilder对象转换为String对象。

包装类

在这里插入图片描述
装箱——把基本数据类型的数据，包装到包装类中（基本类型数据–>包装类）
构造方法

Integer(int value)构造一个新分配的Integer对象，它表示指定的int值。
Integer(String s)构造一个新分配的Integer对象，它表示String 参数所指示的int值。

传递的字符串，必须是基本类型的字符串，否则会抛出异常“100”正确“a”抛异常
静态方法

static Integer valueOf(int i)————返回一个表示指定Int值的Integer实例。
static Integer valueOf(String s)——返回一保存指定String的值的Integer对象。

拆箱*——在包装类中取出基本数据类型的数据（包装类–>基本类型数据）
成员方法

int intvaule()—————————以int类型返回Integer 的值。

自动装箱与自动拆箱————基本数据类型的数据和包装类之间可以自动的相互转换。
JDK1.5之后出现的新特性。
基本类型与字符串之间的相互转换
基本类型–>字符串（String）
1.基本类型的值+“”最简单的方法（工作中常用）。
2.包装类的静态方法toString(参数)，不是Object类的toString（）是重载

static String toString(int i)——返回一个表示指定整数的String对象。

3.String类的静态方法vauleOf(参数)

static String vauleOf(int i)——返回int参数的字符串表示形式。

字符串（String）–>基本类型
使用包装类的静态方法parseXXX(“字符串”);

Integer 类 ————————static int parseInt(String s)
Double类 —————————static double parseDouble(String s)

hello嗨

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用API

应用程序编程接口，Java API是一本程序员使用的字典。Scanner的功能可以实现键盘输入，到程序当中。引用类型的一般使用步骤1. 导包import 包路径.类名称；如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。只有java.lang包下的内容不需要导包，其他的包都需要import语句。2. 创建类名称对象名 = new 类名称（）；3. 使用对...
复制链接

扫一扫

专栏目录