Java API

最新推荐文章于 2024-09-24 09:19:59 发布

Geollan

最新推荐文章于 2024-09-24 09:19:59 发布

阅读量133

点赞数

分类专栏： Java Learning 文章标签： java

本文链接：https://blog.csdn.net/weixin_46755489/article/details/107730628

版权

Java Learning 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

API

概述

API(Application Programming Interface), 应用程序编程接口。Java API是一本程序员的字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查阅API的方式，来学习Java提供的类，并得知如何使用它们。

API使用步骤

打开帮助文档。
点击显示，找到索引，看到输入框。
在输入框里输入，然后回车。
看包。java.lang下的类不需要导包，其他需要。
看类的解释和说明。
学习构造方法。
使用成员方法。

Scanner 类

什么是Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。

例如，以下代码使用户能够从System.in中读取一个数：
```
Scanner input = new Scanner(System.in);
int i = input.nextInt();
```
备注：System.in系统输入值的是通过键盘录入数据。

引用类型使用步骤

导包

使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。

格式：
```
import 包名.类名;
```
创建
```
类名称 对象名 = new 类名称();
```
使用
```
对象名.成员方法名();
```

/*
Scanner类的功能，可以实现键盘键入数据，到程序当中。

引用类型的一般使用步骤：

1.导包
import 包路径.类名称;
如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
只有java.lang包下的内容不需要导包，其他的包都需要import语句。

2.创建
类名称 对象名 = new 类名称();

3.使用
对象名.成员方法名()

获取键盘输入的一个int数字：int num = input.nextInt();
获取键盘输入的一个字符串：String str = input.next();
*/

import java.util.Scanner; //导包

public class ScannerExample
{
    public static void main(String[] args)
    {
        //创建
        //System.in代表从键盘进行输入
        Scanner input = new Scanner(System.in);
        
        //获取键盘输入的int数字
        int num = input.nextInt();
        System.out.println("输入的数字是：" + num);
        
        //获取键盘输入的字符串
        String str = input.next();
        System.out.println("输入的字符串是：" + str);
    }
}

匿名类

class Person
{
    String name;
    
    public void showName()
    {
        System.out.println("我叫" + name);
    }
}

/*
创建对象的标准格式：
类名称 对象名 = new 类名称();

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
new 类名称();

注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名变量。
*/

public class AnonymousExample01
{
    public static void main(String[] args)
    {
        //左边的one就是对象的名字
        Person one = new Person();
        one.name = "Geollan";
        one.showName();
        System.out.println("==============");
        
        //匿名对象
        new Person().name = "George";
        new Person().showName(); //我叫null
    }
}

import java.util.Scanner;

public class AnonymousExample02
{
    public static void main(String[] args)
    {
        //普通使用方式
        //Scanner input = new Scanner(System.in);
        //int num = input.nextInt();
        
        //匿名对象的方式
        //int num = new Scanner(System.in).nextInt();
        //System.out.println("输入的是：" + num);
        
        //使用一般写法传入参数
        //Scanner input = new Scanner(System.in);
        //methodParam(input);
        
        //使用匿名对象进行传参
        //methodParam(new Scanner(System.in));
        
        Scanner input = methodReturn();
        int num = input.next();
        System.out.println("输入的是：" + num);
    }
    
    public static void methodParam(Scanner input)
    {
        int num = input.nextInt();
        System.out.println("输入的是：" + num);
    }
    
    public static Scanner methodReturn()
    {
        //Scanner input = new Scanner(System.in);
        //return input;
        
        return new Scanner(System.in);
    }
}

Random 类

/*
Random类用来生成随机数字。使用起来也是三个步骤：

1.导包
import java.util.Random;

2.创建
Random r = new Random(); //小括号当中留空即可

3.使用
获取一个随机的int数字（范围是int所有范围，有正负），int num = r.nextInt()
获取一个随机的int数字（参数代表了范围，左闭右开），int num = r.nextInt(3)
实际上代表的含义是：[0, 3), 也就是0 ~ 2    
*/

public class RandomExample
{
    Random r = new Random();
    
    int num = r.nextInt();
    System.out.println("随机数是：" + num);
}

ArrayList

什么是ArrayList类

java.util.ArrayList是大小可变的数组的实现，存储在内的数据成为元素。此类提供一些方法来操作内部存储的元素。ArrayList中可不断添加元素，其大小也自动增长。
ArrayList使用步骤
- 查看类
  
  java.util.ArrayList : 该类需要import导入后使用
  
  , 表示一种指定的数据类型，叫做泛型。E，取自Element（元素）的首字母。在出现E的地方，我们使用一种引用数据类型将其替换即可，表示我们将存储哪种类型的元素。代码如下：
```
ArrayList<String>, ArrayList<Student>
```
- 查看构造方法
  
  public ArrayList(): 构造一个内容为空的集合。
  
  基本格式：
```
ArrayList<String> list = new ArrayList<String>();
```

/*
数组的长度不可改变
但是ArrayList集合的长度是可以随意变化的。

对于ArrayList来说，有一个尖括号<E>代表泛型。
泛型，也就是装在集合当中的所有元素，全都是同意的什么类型。
注意：泛型只能是引用类型，不能是基本类型。

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

publi class ArrayListExample
{
    public static void main(String[] args)
    {
        //创建了一个ArrayList集合，集合的名称是list，里面装的全都是String字符串类型的数据
        //备注：从JDK1.7+开始，右侧的尖括号内部都可以不写内容，但是<>本身还是要写的。
        ArrayList<String> list = new ArrayList<>();
        System.out.println();
        
        //像集合当中添加一些数据，需要用到add方法。
        list.add("Geollan");
        System.out.println(list); //[Geollan]
        
        list.add("George");
        list.add("Ingram");
        list.add("Kobe");
        System.out.println(list); //[Geollan, George, Ingram, Kobe]
    }
}

/*
ArrayList当中常用方法

public boolean add(E e)：向集合中添加元素，参数的类型和泛型一致。
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
但对于其他集合来说，add添加不一定成功。

public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。

public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。

public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。

*/

public class ArrayListMethod
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list); //[]
        
        //向集合中添加元素：add
        boolean success = list.add("Geollan");
        System.out.println(list); //[Geollan]
        System.out.println("添加的动作是否成功：" + success); //true
        
        list.add("George");
        list.add("Ingram");
        list.add("Tucker");
        list.add("Bonga");
        System.out.println(list); // [Geollan, George, Ingram, Tucker, Bonga]
        
        //从集合中获取元素：get。索引值从0开始
        String name = list.get(2);
        System.out.println("第二号索引位置：" + name);
        
        //从集合中删除元素：remove。索引值从0开始。
        String whoRemoved = list.remove(3);
        System.out.println("被删除的人是：" + whoRemoved); //Tucker
        
        //获取集合的长度尺寸，也就是其中元素的个数
        int size = list.size();
        System.out.println("集合的长度是：" + size);
        
        
        //遍历集合
        for(int i = 0; i < list.size(); i++)
        {
            System.out.println(list.get(i));
        }
    }
}

import java.util.ArrayList;

/*
如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。

基本类型		包装类（引用类型，包装类都位于java.lang包下）
byte		   Byte
short		   Short
int			   Integer			【特殊】
long		   Long
float		   Float
double		   Double
char		   Character		【特殊】
boolean		   Boolean

从JDK 1.5+开始，支持自动装箱、自动拆箱。

自动装箱：基本类型 --> 包装类型
自动拆箱：包装类型 --> 基本类型
*/

public class ArrayListBasic
{
    public static void main(Strnig[] args)
    {
        ArrayList<String> listA = new ArrayList<>();
        //错误写法！泛型只能是引用类型，不能是基本类型
        //ArrayList<int> listB = new ArrayList<>();
        
        ArrayList<Integer> listC = new ArrayList<>();
        listC.add(100);
        listC.add(200);
        System.out.println(listC);//[100, 200]
        
        int num = listC.get(1);
        System.out.println("The first number is " + num);
        
    }
}

String 类

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

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

创建字符串的常见3+1种方式
三种构造方法：
public String():创建一个空白字符串，不含任何内容。
public String(char[] array)，根据字符数组的内容，来创建对应的字符串。
public String(byte[] array)，根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = "Hello"; //右边直接用双引号

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

public class StringExample
{
    public static void main(String[] args)
    {
        //使用空参构造
        String str1 = new String(); //小括号留空，说明字符串什么内容都没有。
        System.out.println("The first string is " + str1);
        
        //根据字符数组创建字符串
        char[] charArray = {'A', 'B', 'C'};
        String str2 = new String(charArray);
        System.out.println("The second string is " + str2);
        
        //根据字节数组创建字符
        byte[] byteArray = {97, 98, 99};
        String str3 = new String(byteArray);
        System.out.println("The third string is " + str3);
        
        //直接创建
        String str1 = "Hello"; 
        System.out.println("The fourth string is " + str4);
    }
}

/*
字符串常量池，程序当中直接写上的双引号字符串，就在字符串常量池中

对于基本类型来说，==是进行数值的比较。
对于引用类型来说，==是进行地址值的比较。
*/

public class StringPool
{
    public static void main(String[] args)
    {
        String str1 = "abc";
        String str2 = "abc";
        
        char[] charArray = {'a', 'b', 'c'};
        String str3 = new String(charArray);
        
        System.out.println(str1 == str2); //true
        System.out.println(str1 == str3); //false
        System.out.println(str3 == str2); //false
        
        //双引号直接写的字符串在常量池当中，new的不在池当中。
    }
}

/*
==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

public boolean equals(Object obj), 参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。

注意事项：
1. 任何对象都能用Object进行接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
推荐："Hello".equals(str)		不推荐：str.equals("Hello")

public boolean equalsIgnoreCase(String str),忽略大小写，进行内容比较。
*/

public class StringEquals
{
   public static void main(String[] args)
   {
       String str1 = "Hello";
       String str2 = "Hello";
       char[] charArray = {'H', 'e', 'l', 'l', 'o'};
       String str3 = new String(charArray);
       
       System.out.println(str1.equals(str2)); //true
       System.out.println(str1.equals(str3)); //true
       System.out.println(str2.equals(str3)); //true
       System.out.println("Hello".equals(str2)); //true
       
       String str4 = "hello";
       System.out.println(str1.equals(str4)); //false
       
       String str5 = null;
       System.out.println("Hello".equals(str5)); //推荐，false
       System.out.println(str5.equals("Hello")); //不推荐，报错，空指针异常NullPointerException
       
       String strA = "Java";
       String strB = "java";
       System.out.println(strA.equals(strA)); //false，严格区分大小写
       System.out.println(strA.equalsIgnoreCase(strB)); //true, 忽略大小写
       
       //注意，只有英文字母区分大小写，其他都不区分大小写
       System.out.println("abc一".equalsIgnoreCase("abc壹")); //false
   }
}

/*
String当中与获取相关的常用方法有：

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


public class StringGet
{
    public static void main(String[] args)
    {
        //获取字符串的长度
        int length = "asdfg".length();
        System.out.println("字符串的长度是：" + length); //5
        
        //拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(st2);
        System.out.println(str1); //原封不动
        System.out.println(str2); //原封不动
        System.out.println(str3); //HelloWorld, 新的字符串
  
        //获取指定索引位置的单个字符串
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是：" + ch);
        
        //查找参数字符串在本来字符串当中出现第一次的索引位置
        //如果根本没有，返回-1值
        String original = "HelloWorldHelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次索引值是：" + index); //2
        
        System.out.println("HelloWorld".indexOf("abc")); //-1
         
    }
}

/*
字符串的截取方法：

public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。
备注：[begin, end)，包含左边，不包含右边。
*/

publilc class SubString
{
    public static void main(String[] args)
    {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1); //HelloWorld，原封不动
        System.out.println(str2); //World, 新字符串
        
        String str3 = str1.substring(4, 7);
        System.out.println(str3); //oWo
        
        //下面这种写法，字符串的内容仍然是没有改变的
        //下面有两个字符串："Hello", "Jaav"
        //strA当中保存的是地址值
        //本来地址值是Hello的0xABC
        //后来地址值变成了Java的0xCBA
        String strA = "Hello";
        System.out.println(strA); //Hello
        strA = "Java";
        System.out.println(strA); //Java
    }
}

/*
String当中与转换相关的常用方法有:

public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString)：
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
备注：CharSequence意思就是说可以接受字符串类型。
*/
public class Convert
{
    public static void main(String[] args)
    {
        //转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); //H
        System.out.println(char.length); //5
        
        //转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for(int i = 0; i < bytes.lenth; i++)
            System.out.print(bytes[i] + " ");
        //97 98 99
        
        //字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1); //How do you do?
        System.out.println(str2); //H*w d* y*u d*?
        
        String lang1 = "会不会玩呀！你大爷的！ "; 
        String lang2 = lang1.replace("你大爷的", "****");
        System.out.println(lang1); //会不会玩呀！你大爷的！
        System.out.println(lang2); //会不会玩呀！****
    }
}

/*
分割字符串的方法
public String[] split(String regex)：按照参数的规则，将字符串切分为若干部分。

注意事项：
split方法的参数其实是一个“正则表达式”。
如果按照英文句点"."进行切分，必须写“\\."（两个反斜杠）
*/


public class Split
{
    public static void main(String[] args)
    {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        
        for(int i = 0; i < array1.length; i++)
            System.out.print(array1[i] + " ");
        //aaa bbb ccc
        
        String str2 = "aaa bbb ccc"
        String[] array2 = str1.split(" ");
        
        for(int i = 0; i < array2.length; i++)
            System.out.print(array2[i] + " ");
        //aaa bbb ccc
        
        
        //String切不出来
        String str3 = "aaa.bbb.ccc"
        String[] array3 = str1.split(".");
        System.out.println(arrray3.length); //0
        for(int i = 0; i < array3.length; i++)
            System.out.print(array3[i] + " ");
        
    }
}

static类

/*
静态代码块的格式是：

public class 类名称
{
    static 
    {
        //静态代码块的内容
    }
}

特点：当第一次用到本类是，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法优先执行。

静态代码块的典型用途：
用来一次性地对静态成员变量执行赋值。
*/

public class Static
{
    public static void main(String[] args)
    {
        Person one = new Person();
        Person two = new Person();
    }
}

class Person
{
    static 
    {
        System.out.println("静态代码块执行！");
    }
    
    public Person()
    {
        System.out.println("构造方法执行！");
    }
}

Arrays 类

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

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

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

public class Arrays
{
    pubilc static void main(String[] args)
    {
        int[] intArray = {10, 20, 30};
        //将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); //[10, 20, 30]
        
        int[] array1 = {2, 1, 3, 10, 6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); //[1, 2, 3, 6, 10]
        
        String[] array2 = {"aaa", "bbb", "ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }
}

Math类

/*
java.util.Math类是数学相关的工具类，里面提供类大量的静态方法，完成与数学运算相关的操作。

public static double abs(double num)：获取绝对值
public static double ceil(double num)：向上取整
public static double floor(double num)：向下取整
public static long round(double num)：四舍五入

Math.PI 代表近似的圆周率常量（double）
*/

public class Math
{
    public static void main(String[] args)
    {
        //获取绝对值
        System.out.println(Math.abs(3.14)); //3.14
        System.out.println(Math.abs(0)); //0
        System.out.println(Math.abs(-2.4)); //2.4
        
        //向上取整
        System.out.println(Math.ceil(3.9)); //3.9
        System.out.println(Math.ceil(3.1)); //3.1
        System.out.println(Math.ceil(3.0)); //3.0
        
        //向下取整，抹零
        System.out.println(Math.floor(20.9)); //20
        System.out.println(Math.floor(3.1)); //3.0
        System.out.println(Math.floor(3.0)); //3.0
        
        //四舍五入
        System.out.println(Math.round(20.9)); //21
        System.out.println(Math.round(3.1)); //3
        
    }
}