【API、匿名对象、ArrayList类】

【API、匿名对象、ArrayList类】

API的概述及使用步骤

**API：**Application Programming Interface.应用程序编程接口。Java API是一本程序员的字典，是JDK 中提供给我们使用的类的说明文档，这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。

API使用步骤

• 1.打开帮助文档；
• 2.点击显示，找到索引，看到输入框；
• 3.你要找谁？在输入框里输入，然后回车；
• 4.看包。Java.lang下的类不需要导包，其他需要；
• 5.看类的解释和说明；
• 6.学习构造方法；
• 7.使用成品方法。

Scanner类的概述及其使用步骤

引用数据类型一般使用步骤：

• 1.导包
  • import 包名称.类名称;
    • 如果需要使用的目标类，和当前类位于同一包下，则可以省略导包语句不写；
    • 只有java.lang包下的内容不需要导包，其他的包都需要import语句。
• 2.创建
  • 类名称 对象名 = new 类名称（参数（如有））;
• 3.使用
  • 对象名.成员方法名（）;

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

例如：以下代码使用能够从 System.in 中读取一个数：

import java.util.Scanner;//1.导包

public class MyScanner {
    public static void main(String[] args) {
        //2.创建Scanner类的实例对象sc
        Scanner sc = new Scanner(System.in);//System.in系统输入指的是通过键盘录入数据
        //3.获取键盘输入的int数字
        int l = sc.nextInt();//使用，赋值调用
        System.out.println("输入的数字是"+num);
        //4.获取键盘输入的字符串
        String str = sc.next();//使用，赋值调用
        System.out.println("输入的字符串是"+str);
    }
}

tips：sc.next()相当于把输入的字符串直接作为返回值，sc.nextInt()相当于把输入的字符串转化为int数据类型然后作为返回值。

匿名对象的说明

创建对象的标准格式：

类名称 对象名 = new 类名称（）；

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符：

new 类名称（）；

注意事项：匿名对象只能使用唯一的一次，下次再用不得不创建一个新对象。

使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。

public class Person {
    private String name;

    public String getName() {
        return name;
    }

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

    public void showName() {
        System.out.println("我叫" + getName());
    }
}

public class Annoymous {
    public static void main(String[] args) {
        //左边的one就是对象的名字
        Person one = new Person();
        one.setName("高圆圆");
        one.showName();
        System.out.println("----------");

        //匿名对象
        new Person().setName("赵又廷");
        new Person().showName();
         //我叫高圆圆
		//----------
		//我叫null
    }
}

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

import java.util.Scanner;

public class Annoymous {
    public static void main(String[] args) {
        //普通使用方法：
//        Scanner sc = new Scanner(System.in);
//        int num = sc.nextInt();
        //匿名对象使用方法：
//        int num = new Scanner(System.in).nextInt();
//        System.out.println("输入的是"+num);
//        使用一般写法传入参数
//        Scanner sc = new Scanner(System.in);
//        method(sc);
//        匿名写法传入参数
        method(new Scanner(System.in));

        Scanner s = methodReturn();
        int num = s.nextInt();
        System.out.println("输入的是"+num);

    }
    public static void method(Scanner scanner){
        int num = scanner.nextInt();
        System.out.println("输入的是"+num);
    }
    public static Scanner methodReturn(){
        return new Scanner(System.in);
    }
}

Random类的概述和基本使用

Ramdon类用来生成随机数字。使用起来也是三个步骤：导包、创建、使用。

获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt();

获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(4);

实际上代表的是：[0,3)，也就是0-2；

import java.util.Random;

public class MyRandom {
    public static void main(String[] args) {
        Random r = new Random();
        int num1 = r.nextInt();
        System.out.println("随机数是" + num1);
        for (int i = 0; i < 10; i++) {
            int num = r.nextInt(10);//实际上是0-9
            System.out.println(num);
        }
        //获取1-10的10个随机数：
        for (int i = 0; i < 10; i++) {
            int result = r.nextInt(10) + 1;//整体加一，就是1——10
            System.out.println(result);

        }
    }
}

猜数字的小游戏

可以一直玩下去，直到猜对：

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

public class GuessRandomNum {
    public static void main(String[] args) {
        System.out.println("猜数字小游戏！");
        System.out.println("------------------------");
        int num = new Random().nextInt(100) + 1;//获取1-100之间的随机数
        System.out.println("这个数字是1——100之间的数字（包含1和100），请你猜一猜：");
        while (true) {
            int num_guess = new Scanner(System.in).nextInt();//获取键盘输入
            if (num_guess < 1 || num_guess > 100) {
                System.out.println("输入有误，请重新输入！");
                System.out.println("这个数字是1——100之间的数字（包含1和100），请你猜一猜：");
                continue;
            } else if (num_guess > num) {
                System.out.println("太大了，请重新输入：");
            } else if (num_guess < num) {
                System.out.println("太小了，请重新输入：");
            } else {
                System.out.println("你猜对了！");
                break;
            }
        }
    }
}

可以猜五次，猜不对就输：

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

public class GuessNum5Times {
    public static void main(String[] args) {
        System.out.println("猜数字小游戏！");
        System.out.println("------------------");
        System.out.println("请在5次内猜中这个1-100之间的数！");
        int random = new Random().nextInt(100) + 1;
        for (int i = 0; i < 5; i++) {
            System.out.println("请输入你猜的数，你还有" + (5 - i) + "次机会");
            int guessNum = new Scanner(System.in).nextInt();
            if (guessNum < 1 || guessNum > 100) {
                if (i == 4) {
                    System.out.println("很遗憾，你没猜对！游戏结束！" );
                    break;
                }
                System.out.println("输入有误，请重新输入！");
                System.out.println("这个数字是1——100之间的数字（包含1和100），请你猜一猜：");
                continue;
            } else if (guessNum > random) {
                if (i == 4) {
                    System.out.println("很遗憾，你没猜对！游戏结束！" );
                    break;
                }
                System.out.println("太大了，请重新输入：");
            } else if (guessNum < random) {
                if (i == 4) {
                    System.out.println("很遗憾，你没猜对！游戏结束！" );
                    break;
                }
                System.out.println("太小了，请重新输入：");
            } else {
                System.out.println("你猜对了！游戏结束！");
                break;
            }
        }
    }
}

对象数组

定义一个数组，用来存储3个Person的对象。

数组可以存储任何数据类型。

但是数组有一个缺点：一旦创建，程序运行期间数组长度不可以发生改变。

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

public class Array {
    public static void main(String[] args) {
        //首先创建一个长度为3的数组，里面用来存储Person类的对象
        Person[] personArray = new Person[3];
        System.out.println(personArray[0]);//null
        System.out.println(personArray[1]);//null
        System.out.println(personArray[2]);//null

        Person one =new Person("迪丽热巴",18);
        Person two =new Person("古力娜扎",28);
        Person three =new Person("玛尔扎哈",38);

        //将三个对象的地址值赋值给数组的三个位置
        personArray[0] = one;
        personArray[1] = two;
        personArray[2] = three;

        System.out.println(personArray[1].getName());//古力娜扎
    }
}

ArrayList类集合

数组的长度不可以发生改变，但是ArrayList集合的长度是可以随意变化的。

对于ArrayList来说，有一个尖括号代表泛型。

**泛型：**也就是装在集合当中的所有元素，全都是统一的什么类型。

**注意：**泛型只能用引用类型，不能是基本类型。

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

import java.util.ArrayList;

public class MyArrayList {
    public static void main(String[] args) {
        //创建了一个ArrayList集合，集合的名称是List，里面装的全都是String字符串类型的数据
        //备注：从JDK1.7+开始，右侧的<>内部可以不写内容，但是<>本身还是要写的
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);//[]

        //向集合当中添加一个数据，需要用到add方法。
        list.add("James");
        System.out.println(list);//[James]
        list.add("Kobe");
        System.out.println(list);//[James,Kobe]
    }
}

ArrayList集合常用方法

ArrayList的常用方法：

方法	含义	调用
public boolean add(E a)	向集合中添加元素，元素类型需和泛型一致	.add(E a);
public E get(int index)	从集合当中获取元素，参数是索引编号，返回值是对应位置的元素	.get(int index )
public E remove(int index)	从集合当中删除元素，参数是索引编号，返回只就是被删除的元素	.remove(int index)
public int size()	获取集合的尺寸长度，返回值就是集合中包含的元素个数	.size()

备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。

​ 但是对于其他集合（今后学习）来说，add添加动作不一定成功。

import java.util.ArrayList;

public class ArrayListMethod {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);//[]

        //向集合当中添加元素：add,接受其返回值
        boolean success = list.add("James");
        System.out.println(list);//James
        System.out.println("添加元素是否成功："+success);//添加元素是否成功：true

        list.add("Kobe");
        list.add("Magic");
        list.add("O'Neal");
        list.add("T-mac");
        System.out.println(list);//[James, Kobe, Magic, O'Neal, T-mac]

        //从集合中获取元素，get，索引值从0开始
        String center = list.get(3);
        System.out.println("第3号索引位置是"+center);//第3号索引位置是O'Neal

        //从集合中删除元素，remove，索引值从0开始
        String whoIsNotLakers = list.remove(4);
        System.out.println(whoIsNotLakers+"不是湖人球员");//T-mac不是湖人球员
        System.out.println("湖人传奇："+list);//湖人传奇：[James, Kobe, Magic, O'Neal]

        //获取集合的长度尺寸，也就是其中的元素个数
        int size = list.size();
        System.out.println("有"+size+"个湖人球员");//有4个湖人球员

        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            if (i == 0){
                System.out.print("有"+list.size()+"个湖人球员，分别是"+list.get(i)+"、");
            }else if (i == 3){
                System.out.println(list.get(i)+"，欢迎他们！");
            }else {
                System.out.print(list.get(i)+"、");
            }
        }
    }//有4个湖人球员，分别是James、Kobe、Magic、O'Neal，欢迎他们！
}

ArrayList集合存储基本数据类型

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

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

import java.util.ArrayList;

public class ArrayListBasic {
    public static void main(String[] args) {
        ArrayList<Integer> listInt = new ArrayList<>();
        listInt.add(100);
        listInt.add(200);
        System.out.println(listInt);//[100,200]

        int num = listInt.get(1);
        System.out.println("第1号元素是"+num);

    }
}

ArrayList练习

1.产生6个随机数字，存储到ArrayList中并遍历

import java.util.Random;

public class ArrayListRandom {
    public static void main(String[] args) {
        ArrayList<Integer> listInt = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 6; i++) {
            listInt.add(r.nextInt(33)+1);
        }
        for (int i = 0; i < listInt.size(); i++) {
            System.out.println("第"+i+"位置的元素是"+listInt.get(i));
        }
    }
}

2.存储自定义对象添加到集合并遍历

public class ArrayListPerson {
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();

        Person person1 = new Person("洪七公", 20);
        Person person2 = new Person("欧阳锋", 21);
        Person person3 = new Person("黄药师", 28);
        Person person4 = new Person("段智兴", 33);

        list.add(person1);
        list.add(person2);
        list.add(person3);
        list.add(person4);

        for (int i = 0; i < list.size(); i++) {
            System.out.println("姓名：" + list.get(i).getName() + "，年龄" + list.get(i).getAge());
        }
    }
}

3.打印集合方法

定义以指定格式打印集合的方法（ArrayList类型作为参数），使用{}扩起集合，使用@分隔每个元素。格式参照：

{元素@元素@元素}

import java.util.ArrayList;

public class ArrayListPrint {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        arrayListPrint(list);//{10@20@30}

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

4.筛选集合

用一个大集合来存储20个随机数字，然后筛选其中的偶数元素，当如小集合中。

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

public class ArrayListReturn {
    public static void main(String[] args) {
        ArrayList<Integer> list = myList();
        System.out.println(list);
        ArrayList<Integer> evenList = arrayListReturn(list);
        System.out.print("偶数总共有"+evenList.size()+"个：");
        for (int i = 0; i < evenList.size(); i++) {
            System.out.print(evenList.get(i)+" ");

        }
    }
    public static ArrayList<Integer> myList(){
        Random r = new Random();
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            list.add(r.nextInt(100));
        }
        return list;
    }
    public static ArrayList<Integer> arrayListReturn(ArrayList<Integer> list) {
        ArrayList<Integer> newList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i)%2==0){
                newList.add(list.get(i));
            }
        }
        return newList;
    }
}