API

概述

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

API 使用步骤

打开帮助文档。
点击显示，找到索引，看到输入框。
你要找谁？在输入框里输入，然后回车。
看包->java.lang下的类不需要导包，其他需要。（Java.lang指的是“Java Language”的缩写）
看类的解释和说明。
学习构造方法。（构造方法和方法摘要）

Scanner

·Scanner的首字母是大写的，说明它是一个类。

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

使用步骤

1.导包

import 包路径.类名称;

如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。

（注：只有java.lang包下的内容不需要导包，其他的包都需要import语句）

2.创建

类名称对象名 = new 类名称();

3.使用

对象名.成员方法名();

(现阶段，1和2可以理解为死格式记下。)

package Day07;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 4:08
 */
//1.导包
import java.util.Scanner;
public class DemoScanner01 {
    public static void main(String[] args) {
//        2.创建。System.in可以理解为从键盘输入。
        Scanner sc = new Scanner(System.in);
//        现阶段，1和2可以理解为死格式记下。
//        获取键盘输入的一个int数字: int num = sc.nextInt();
//        获取键盘输入的一个字符串: String str = sc.next();
        System.out.println("Please enter a number:");
        int num = sc.nextInt();
        System.out.println("The number you enter is : " + num);
        System.out.println("Please enter a word:");
        String str = sc.next();
        System.out.println("The word you enter is : " + num);

    }
}

Eg：

package Day07;
import java.util.Scanner;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 4:55
 */
public class DemoScannerMax {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Please enter the first number:");
        int a = sc.nextInt();
        System.out.println("Please enter the second number:");
        int b = sc.nextInt();
        System.out.println("Please enter the third number:");
        int c = sc.nextInt();
        int temp = Math.max(a, b);//可以考虑三元关系式，
        int n = Math.max(temp,c);//可以考虑三元关系式，
        System.out.println("The Max number is "+ n);
    }
}

匿名对象

1.创建对象的标准格式；

类名称对象名 = new 类名称();

2.匿名对象：

只有标准格式的右边的对象，没有左边的名字和赋值运算符。格式为：

new 类名称();

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

package Day07.AnonymousObject;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 5:27
 */
public class DemoAnonymous01 {
    public static void main(String[] args) {
//        标准格式创建对象
        Person p = new Person();
        p.name = "成果果";
        p.ShowName();
//        匿名对象
        new Person().name = "成果锅";
        new Person().ShowName();//应该叫“成果锅”，结果是“我是null”
//        注意事项。匿名对象只能使用唯一的一次。下次再用不得不再创建一个新对象。
//        使用建议:如果确定有一个对象只需要使用唯-的一次，就可以用匿名对象。
    }
}

匿名对象作为方法的参数和返回值

普通使用方式

·Scanner sc = new Scanner(System.in);

·int num = sc.nextInt();

匿名对象的方式

·int num2 = new Scanner(System.in).nextInt();

·System.out.println("输入的是: " + num);

使用一般写法传入参数

·Scanner sc2 = new Scanner(System.in);

·methodParam(sc);

使用一般方法传回返回值

·Scanner sc = methodReturn();
int num = sc.nextInt();
System.out.println("The number is " + num);

package Day07.AnonymousObject;
import java.util.Scanner;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 6:03
 */
public class DemoAnonymous02 {
    public static void main(String[] args) {
//        普通使用方式
//        Scanner sc = new Scanner(System.in);
//        int num = sc.nextInt();
//        匿名对象的方式
//        int num2 = new Scanner(System.in).nextInt();
//        System.out.println("输入的是: " + num);
//        使用一般写法传入参数
//        Scanner sc2 = new Scanner(System.in);
//        methodParam(sc);
//        使用匿名对象来进行传参
//        methodParam(new Scanner(System.in));
        Scanner sc = methodReturn();
        int num = sc.nextInt();
        System.out.println("The number is " + num);
    }
    public static void methodParam(Scanner sc){
        int num = sc.nextInt();
        System.out.println("输入的是: " + num);
    }
    public static Scanner methodReturn(){
//        int num = sc.nextInt();
//        return num;
        return new Scanner(System.in);
    }
}

Random

Random类

Random类用于生成随机数。

使用流程

1.导包
import java.util.Random;
2.创建
Random r = new Random(); 小括号为空即可
3.使用

获取一个随机的int数字(范围是正负int极限）：int num = r.nextInt();
获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt();
左闭右开区间：[0,3)->0,1,2,无3。

Eg:

package Day07.DemoRandom;
import java.util.Random;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 7:01
 1.导包
 import java.util.Random;
 2.创建
 Random r = new Random(); 小括号为空即可
 3.使用
 获取一个随机的int数字(范围是正负int极限）：r.nextInt()
 */
public class DemoRandom01 {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt();
        System.out.println("The random number is " + num);
    }
}

左闭右开区间实验：

package Day07.DemoRandom;
import java.util.Random;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 7:11
 */
public class DemoRandom02 {
    public static void main(String[] args) {
        Random r = new Random();
        for (int num = 0; num < 77; num++) {
            int num1 = r.nextInt(10);//限制范围为0~9
            System.out.println(num1);
        }
    }
}

在这里插入图片描述

Random参数范围练习

Random问题1：int一个n，使随机数字的范围是[1,n]
思路。
1.定义一个int变量n.随意赋值
2.要使用Random:三个步骤，导包、创建、使用
3.如果写10.那么就是0_{9,然而想要的是1}10,可以发现:整体+1即可。
4.打印随机数字

package Day07.DemoRandom;
import java.util.Random;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 7:19
 Random问题1：int一个n，使随机数字的范围是[1,n]
思路。
1.定义一个int变量n.随意赋值
2.要使用Random:三个步骤，导包、创建、使用
3.如果写10.那么就是0~9,然而想要的是1~10,可以发现:整体+1即可。
4.打印随机数字
 */
public class DemoRandom03 {
    public static void main(String[] args) {
        int n = 5;
        Random r = new Random();
        int result = r.nextInt(n)+1;//范围是1-5
        System.out.println(result);
        int result1 = r.nextInt(n+1);//范围是0-4
        System.out.println(result1);
    }
}

Random问题2：猜数字小游戏

思路：
1.首先需要产生一个随机数字，并且产生后不再变化。用Random的nextInt();
2.获取用户从键盘输入的数字，即Scanner中的nextInt();
3.得到的一个Random和Scanner比较，使用if判断：
（1）如果太小了，给与提示，并重试。
（2）如果太大了，给与提示，并重试。
（3）如果猜中了，结束游戏。
4.重试的过程需要循环，切次数不确定，需要while循环。

package Day07.DemoRandom;

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

/**
 * @author Edwin D
 * @date 2020.4.9 下午 7:39
 题目：猜数字小游戏

 思路：
 1.首先需要产生一个随机数字，并且产生后不再变化。用Random的nextInt();
 2.获取用户从键盘输入的数字，即Scanner中的nextInt();
 3.得到的一个Random和Scanner比较，使用if判断：
 （1）如果太小了，给与提示，并重试。
 （2）如果太大了，给与提示，并重试。
 （3）如果猜中了，结束游戏。
 4.重试的过程需要循环，切次数不确定，需要while循环。
 */
public class DemoRandom04 {
    public static void main(String[] args) {
        Random r = new Random();
        int RandomNum = r.nextInt(100)+1;
        Scanner sc = new Scanner(System.in);

        while (true){
            System.out.println("Please enter a number:");
            int GuessNum = sc.nextInt();
            if (GuessNum>RandomNum)
                System.out.println("Too large!");
            else if(GuessNum<RandomNum)
                System.out.println("Too small!");
            else
                System.out.println("You Win!");
        }
    }
}

对象数组

用数组承装对象

数组的长度不可以发生改变。
但是Arraylist集合的长度是可以随意变化的。
对于ArrayList来说，有一个尖括号代表泛型。
泛型:也就是装在集合当中的所有元素，全都是统一的什么类型。
注意:泛型只能是引用类型，不能是基本类型。
注意事项:
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空，得到的是空的中括号: []

package Day07.ObjectArray;
import java.util.ArrayList;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 8:03
数组的长度不可以发生改变。
但是Arraylist集合的长度是可以随意变化的。
对于ArrayList来说，有一个尖括号<E>代表泛型。
泛型:也就是装在集合当中的所有元素，全都是统一的什么类型。
注意:泛型只能是引用类型，不能是基本类型。
注意事项:
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空，得到的是空的中括号: []
 */
public class DemoArrayList01 {
    public static void main(String[] args) {
        //创建了一个ArrayList集合， 集合的名称是List, 里面装的全都是String字符串类型的数据
        //备注:从JDK 1.7+开始。右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
        //向集合中添加一些数据，需要用到add方法
        list.add("Alita");
        System.out.println(list);
        list.add("吴倩");
        System.out.println(list);
        list.add("成果果");
        System.out.println(list);
//        list.add(177);错误，int型与之前的String冲突。
    }
}

ArrayList当中的常用方法有:

ArrayList当中的常用
public boolean add(E e):向集合当中添加元素，参数的类型和泛型一致.
注：对于ArrayList来讲，add动作一定会成功，返回值可以不用。
但是对于其他集合（今后讨论学习），add添加动作不一定成功。
public E get(int index): 从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int_ index): 从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size(): 获取集合的尺寸长度，返回值是集合中包含的元素个数。

package Day07.ObjectArray;
import java.util.ArrayList;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 8:23
ArrayList当中的常用方法有:
public boolean add(E e):向集合当中添加元素，参数的类型和泛型一致.
注：对于ArrayList来讲，add动作一定会成功，返回值可以不用。
    但是对于其他集合（今后讨论学习），add添加动作不一定成功。
public E get(int index): 从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int_ index): 从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size(): 获取集合的尺寸长度，返回值是集合中包含的元素个数。
 */
public class DemoArrayListMethod {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
//        向集合中添加元素，add
        boolean success = list.add("Alita");
        System.out.println(list);
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
        System.out.println(list);
//        从集合中获取一个元素：get.索引值（从零开始）
        String name = list.get(2);
        System.out.println("The second is " + name);
//        从集合中删除一个元素：remove.(索引值）
        String whoRemoved = list.remove(4);
        System.out.println("The one who is removed is " + whoRemoved);
        System.out.println(list);
//        获取集合的长度：得到长度
        int size = list.size();
        System.out.println("The length of the array is " + size);
    }
}

ArrayList的遍历

package Day07.ObjectArray;
import java.util.ArrayList;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 10:29
 */
public class DemoArrayListMethod2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Alita");
        list.add("Ali");
        list.add("成果果");
//        遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

ArrayList的基本储存类型

如果想要往集合ArrayList中存储基本类型的数据，必须使用基本类型对应的“包装类”

基本类型包装类（引用类型，包装类都位于java.lang下，无需打包）
byte Byte
short Short
int Integer 【特殊】
long Long
float Float
double Double
char Character【特殊】
boolean Boolean
从JDK1.5开始，支持自动装箱，拆箱。
自动装箱：基本类型–> 包装类型
自动拆箱:包装类型–> 基本类型

package Day07.ObjectArray;

import java.util.ArrayList;

/**
 * @author Edwin D
 * @date 2020.4.9 下午 10:32
 如果想要往集合ArrayList中存储基本类型的数据，必须使用基本类型对应的“包装类”

 基本类型           包装类（引用类型，包装类都位于java.lang下，无需打包）
 byte               Byte
 short              Short
 int                Integer 【特殊】
 long               Long
 float              Float
 double             Double
 char               Character【特殊】
 boolean            Boolean
从JDK1.5开始，支持自动装箱，拆箱。
自动装箱：基本类型--> 包装类型
自动拆箱:包装类型-->  基本类型
 */
public class DemoArrayListBasic {
    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        //        ArrayList<int> listB = new ArrayList<>();
        ArrayList<Integer> listC = new ArrayList<>();
        listC.add(177);
        listC.add(277);
        System.out.println(listC);
        int num = listC.get(1);
        System.out.println("The First one is " + num);
    }
}

ArrayList练习题

1.题目:
生成6个1~33之间的随机整数，添加到集合，并遍历集合。

package Day07.ObjectArray;
import java.util.ArrayList;
import java.util.Random;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 10:47
思路:
1.需要存储6个数字，创建一个集合，<Integer>
2.产生随机数，需要用到Random
3.用循环6次，来产生6个随机数字。for循环
4.循环内调用r. nextInt(int n)，参数是33. 0-32, 整体+1才是1~33
5.把数字添加到集合中。add !
6.遍历集合。for. size. get
 */
public class DemoExercise1 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 6; i++) {
            int num = random.nextInt();
            list.add(num);
        }
        System.out.println(list);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

2.题目:
自定义4个学生对象，添加到集合，并遍历。

package Day07.ObjectArray;
import java.util.ArrayList;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 11:03
思路: 
1.自定义student学生类， 四个部分。
2.创建一个集合，用来存储学生对象。泛型: <Student>
3.根据类，创建4个学生对象。
4.将4个学生对象添加到集合中:add
5. 通历集合: for. size. get
 */
public class DemoExercise2 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student one = new Student("Alita",17);
        Student two = new Student("Ali",177);
        Student three = new Student("成果果",25);
        Student four = new Student("成果菓",26);
        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("Name: " + stu.getName() + ", age: " + stu.getAge());
        }
    }
}

3.题目:
定义以指定格式打印集合的方法(Arraylist类型作为参数)，使用{}扩起集合，使用@分隔每个元素。
格式参照{元素@元素@元素}.

package Day07.ObjectArray;
import com.sun.org.apache.bcel.internal.generic.ALOAD;
import java.util.ArrayList;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 11:12
System. out. println(list);
[1e, 20, 30]
printArrayList(list);
{10@20@30}
 */
public class DemoExercise3 {
    public static void main(String[] args) {
        ArrayList<String > list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        System.out.println(list);
//        定义方法的三要素
//        返回值类型:只是进行打印而已，没有运算，没有结果:所以用void
//        方法名称。printArraylist
//        参数列表: Arraylist
        printArrayList(list);
    }
    public 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.print(name + "}");
            }
            else {
                System.out.print(name + "@");
            }
        }
    }
}

4.题目。
用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中。
要求使用自定义的方法来实现筛选。

package Day07.ObjectArray;
import com.sun.org.apache.bcel.internal.generic.ALOAD;
import sun.text.bidi.BidiLine;
import java.util.ArrayList;
import java.util.Random;
/**
 * @author Edwin D
 * @date 2020.4.9 下午 11:20
分析:
1.需要创建一个大集合，用来存储int数字，<Integer>
2.随机数字就用Random nextInt
3.循环20次，把随机数字放入大集合: for循环、add方法
4.定义一个方法，用来进行筛选。
筛选。根据大集合，筛选符合要求的元素，得到小集合。
三要素
返回值类型: Arraylist小集合 (里面元素个数不确定)
方法名称: getSmalllist
参数列表。Arraylist大集合(装着20个随机数字)
5.判断(if)是偶数:num%2==0
6.如果是偶数。就放到小集合当中，否则不放。
 */
public class DemoArrayListReturn {
    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("Total is " + smallList.size());
        for (int i = 0; i < smallList.size(); i++) {
            System.out.println(smallList.get(i));
        }
    }
//    接受大叔集合，返回小集合结果。
    private 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;
    }
}

参考文献：

《黑马Java基础班视频》

《黑马Java基础教材笔记》

2020.04.09

Edwin D

原创文章 18 获赞 19 访问量 463

关注私信

JavaSe-Day7-API&Scanner&Random&ArrayList

API

概述