Java开发Day12

最新推荐文章于 2024-09-13 21:40:38 发布

Madelana

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量135

点赞数

文章标签： java

本文链接：https://blog.csdn.net/madelana/article/details/104956905

版权

一、API概述

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

二、API的使用步骤

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

三、Scanner类

定义：Scanner类是一个可以解析基本类型和字符串的简单文本扫描器。
例如：以下代码使用户能够从System.in中读取一个数：

Scanner sc = Scanner(System.in);
int i = sc.nextInt();

备注：System.in系统输入指的是通过键盘录入的数据。

2.我们在前面的文章中讲过，数据类型分为基本数据类型和引用数据类型，首字母小写的就是基本数据类型，首字母大写的就是引用数据类型。
引用类型的使用步骤

[1] 导包
使用import关键字导包，在类的所有代码之前、包名之后导包。只有java.lang包下的类不需要导包，其他的类都需要import语句。
格式：

import 包路径.类名;
import java.util.Scanner;
//如果和当前类位于同一个包下，则可以省略不写

[2] 创建

 类名称 对象名 = new 类名称();
 Scanner sc = new Scanner(System.in);

[3] 使用

对象名.成员方法名()
获取键盘输入的一个int数字：int sum = sc.nextInt();
获取键盘输入的一个字符串：String str = sc.next();

例题1：键盘输入两个int数字，并且求和

分析：

既然需要键盘输入，那么就用Scanner
Scanner的三个步骤：导包、创建、使用
需要的是两个数字，所以要调用两次nextInt（）方法
得到了两个数字，就需要加在一起
将结果打印输出

package cn.gaomeng.day12;

import java.util.Scanner;

public class Demo02ScannerSum {
    public static void main(String[] args) {

      /*第一种写法：直接在main方法中执行
       Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        int a = sc.nextInt();
        System.out.println("请输入第二个数字：");
        int b = sc.nextInt();

        int result = a+b;
        System.out.println("结果是："+result);*/

        /**
         * 第二种方法，借助自定义方法完成求和工作
         */
        System.out.println("请输入两个整数来求和：");
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int sum = getSum(a,b);
        System.out.println("结果是："+ sum);
    }

    public static int getSum(int a, int b){
        return (a+b);
    }
}

例题2：从键盘输入三个数字，然后求出其中的最大值

分析：

既然是键盘输入，肯定需要用到Scanner

Scanner三个步骤：导包、创建、使用nextInt()

既然是三个数字，那么调用三次nextInt()方法，得到三个int变量

无法同时判断三个数字谁最大，应该转换成为两个步骤：首先判断前两个当中谁最大，拿到前两个的最大值；然后拿着前两个中的最大值，再和第三个数字比较，得到三个数字当中的最大值

打印最终结果

package cn.gaomeng.day12;

import java.util.Scanner;

public class Demo03ScannerMax {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        int a = sc.nextInt();
        System.out.println("请输入第二个数字：");
        int b = sc.nextInt();
        System.out.println("请输入第三个数字：");
        int c = sc.nextInt();

        //首先的扫前两个数字的最大值
        int temp = a > b ? a : b;
        //接着得到前两个中最大值和第三个数的最大值
        int max = temp > c ? temp : c;
        System.out.println("最大值是："+ max);
    }
}

四、匿名对象

我们使用类的时候，肯定要创建对象。
创建对象的标准格式：

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

然而，还有一种对象叫做：匿名对象

匿名对象就是只有右边的对象，没有左边的名字和赋值
格式：new 类名称( );
例如：new Person( );

new Person();
new Person().name = "李四";
new Person().showName(); //我叫null

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

/**
*输出 我叫：李四
*/
  System.out.println("我叫："+ (new Person().name = "李四"));

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

匿名对象做参数

package cn.gaomeng.day12;
import java.util.Scanner;
public class Demo02Anonymous {

    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("输入的是："+num2);

        //使用一般写法传入参数
        Scanner sc = new Scanner(System.in);
        methodScanner(sc);

        //使用匿名对象来进行传参
        methodScanner(new Scanner(System.in));
    }

    public static void methodScanner(Scanner sc){
        int num = sc.nextInt();
        System.out.println("输入的是："+num);

    }
}

匿名对象做返回值

package cn.gaomeng.day12;
import java.util.Scanner;
public class Demo02Anonymous {

    public static void main(String[] args) {
       
        Scanner sc = methodReturn();
       int num = sc.nextInt();
        System.out.println("输入的是；"+ num);

    }

    public static Scanner methodReturn(){
        //普通方式返回值
        //Scanner sc = new Scanner(System.in);
       // return sc;
        return new Scanner(System.in);
    }
}

五、Random类

Random类用来生成随机数字，使用起来也是三个步骤；

导包import java.util.Random;
创建Random r = new Random();
使用:
(1)获取一个随机的int数字（范围是int的所有范围，有正负两种,-21亿~21亿）：int num = r.nextInt();

package cn.gaomeng.day12;

import java.util.Random;

public class Demo01Random {

    public static void main(String[] args) {
        Random r = new Random();

        int num = r.nextInt();
        System.out.println("随机数是：" + num);
    }
}

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

package cn.gaomeng.day12;

import java.util.Random;

public class Demo02Random {

    public static void main(String[] args) {
        Random r = new Random();

        for(int i = 0; i<100; i++){
            int num  = r.nextInt(10);
            System.out.println("随机数是："+ num); //范围实际上是0~9
        }
    }
}

练习1：根据int变量n的值，来获取随机数字，范围是[1，n]，即既可以取到1也可以取到n

思路：

定义一个int变量n，随意赋值
要使用Random类，三个步骤：导包、创建、使用
如果写10，那么就是0_{9，然而想要的是1}10，可以发现：整体+1即可
打印随机数字

package cn.gaomeng.day12;

import java.util.Random;

public class Demo03Random {

    public static void main(String[] args) {
        int n = 5;
        Random r = new Random();
        
        for(int i = 0; i<100; i++){
/**
*注意：+1不能放在nextInt()里面
*/
            int result = r.nextInt(n) + 1;//整体加一后，就变成了[1,n]
            System.out.println("随机数是："+ result);
        }

    }
}

练习2：猜数小游戏，猜大了、猜小了都提醒你，知道你猜对，看你猜了多少次，但是要求正确的数字是随机产生的数字，数字范围在[1,100]。

思路：

首先需要产生一个随机数字，并且一旦产生就不再变化。用Random的nextInt()方法
需要键盘输入，所以用到了Scanner
获取键盘输入的数字，用Scanner当中的NextInt()方法
已经得到了两个数字，判断(if)一下，

如果太大了，提示太大，并且重试
如果太小了，提示太小，并且重试
如果猜中了，游戏结束
重试就是再来一次，循环次数不确定，用while(true)

六、对象数组

package cn.gaomeng.day13;

/**
 * 定义一个数组，用来存储3个person对象
 * 数组有一个缺点：一旦创建，程序运行期间长度不可以发生改变
 */
public class Demo01Array {

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

        Person one = new Person("迪丽热巴",18);
        Person two = new Person("古力娜扎",20);
        Person three = new Person("马尔扎哈", 38);
        //将one当中的地址值赋值到数组的0号元素位置
        array[0] = one;
        array[1] = two;
        array[2] = three;

        System.out.println(array[0]); //地址值
        System.out.println(array[1]); //地址值
        System.out.println(array[2]); //地址值

       // Person person = array[1];
        //System.out.println(person.getName());
        System.out.println(array[1].getName());

    }
}

七、ArrayList类

数组的长度不可以发生改变，但是ArrayList(集合)的长度是可以改变的
对于ArrayList来说，有一个尖括号代表泛型。
泛型：也就是装在集合当中的所有元素，全部都是统一的某种类型
注意：泛型只能是引用类型，不能是基本类型
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容为空，得到的是空的中括号
备注：从JDK1.7开始，右侧的尖括号里面可以不写内容，但是<>本身还是要写的

ArrayList<String> list = new ArrayList<>();
System.out.println(list);//打印出[ ]

向集合当中添加一些数据，需要用到add方法

list.add("张三");
list.add("李四");
System.out.println(list); //打印出：张三，李四
list.add(100);//错误，因为创建的时候尖括号泛型已经说了是String类型，所以，添加进去的元素就必须得是String类型才行

八、 ArrayList当中的常用方法

public boolean add(E e);//向集合当中添加元素，参数的类型和泛型一致。E:表示泛型
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以return返回值可写可不写，但是对于其他集合来说，add添加动作不一定成功，所以一定要写return返回值
public E get(int index); //从集合中获取元素，参数是索引编号，返回值就是对应位置的元素
public E remove(int index); //从集合当中删除元素，参数是索引编号，返回值就是被删除的元素
public int size(); //获取集合的尺寸长度，返回值是集合中包含的元素个数

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

//向集合中添加元素：add
boolean success = list.add("灵光二十二");
System.out.println(list);
System.out.println("添加的动作是否成功：" + success);

list.add("张三");
list.add("李四");
list.add("王二");
System.out.prinln(list); //灵光二十二、张三、李四、王二

//从集合中获取元素：get。索引值从0开始
String name = list.get(2);
System.out.println("第2号索引位置：" + name);//李四

//从集合中删除元素：remove。索引值从0开始
String whoRemoved = list.remove(3);
System.out.println("被删除的人是：" + whoRemoved);//王二
System.out.println(list); //灵光二十二、张三、李四

//获取集合的长度尺寸，也就是其中元素的个数
int size = list.size();
System.out.println("集合的长度是：" + size); //3
}`.

九、集合的遍历

for(int i = 0; i < list.size(); i++){
	System.out.println(list.get(i));
}

对比数组的便利：

for(int i = 0; i < array.length; i++){
	System.out.println(array[i]);
}

十、ArrayList 集合存储基本数据类型

public static void main(String[] args){
	ArrayList<String> listA = new.ArrayList<>();
	//错误写法！泛型只能是引用类型，不能是基本类型
	ArrayList<int> listB = new ArrayList<>();
}

如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。
基本数据类型对应的包装类是引用类型，而且这些包装类都位于java.lang包下，因此可以直接使用，不需要导包
从JDK1.5开始，支持自动装箱（基本类型自动变成包装类型）、自动拆箱（包装类型自动变成基本类型）
基本数据类型对应的包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
double	Double
char	Character
boolean	Boolean

ArrayList<Interger> listc = new ArrayList<>();
listc.add(100);
listc.add(200);
System.out.println(listc); //[100,200]

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

练习1. 生成6个1~33的随机整数，添加到集合，并遍历集合

分析：

需要存储6个数字，创建一个集合，< Integer >
产生随机数，需要用到Random
需要循环6次来产生6个随机数字：for循环
循环内调用 r. nextInt(int n)，参数是33，整体+1才是1~33
把数字添加到集合：add
遍历集合：for、size、get

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));
	}
}

练习2. 自定义4个学生对象，添加到集合，并遍历

分析：

自定义Student学生类，有四个部分（标准的类的写法要求）
创建一个集合，用来存储学生对象。泛型：< Student >
根据类，创建4个学生对象
将4个学生对象添加到集合中：add
遍历集合：for、size、get

//定义Student学生类
pubic class Student{
	
	private String name;
	private int age;

	public Student(){
	}

	public Studnet(String name, int age){
		this.name = name;
		this.age = 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 static void main(String[] args) {
	ArrayList<Student> list = new ArrayList<>();

	Student one = new Student("", 20);
	Student one = new Student("", 21);
	Student one = new Student("", 22);
	Student one = 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());
}
	
}

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

public static void main(String[] args){
	ArrayList<String> list = new ArrayList<>();
	list.add("张三");
	list.add("李四");
	list.add("王二");
	list.add("钱一");
	System.out.println(); //[张三，李四，王二，钱一]

	/**
	*定义方法的三要素：
	*返回值类型：只是进行打印而已，没有运算，没有结果，所以用void
	*方法名称：printArrayList
	*参数列表：ArrayList
	*/
	pubic static void printArrayList(ArrayList<String> list) {
		System.out.println("{");
		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.println(name + "@");
			}
		}

	}
}

练习4. （ArrayList类型做返回值）筛选集合中的随机数：用一个大集合存入20个随机数字，然后筛选出其中的偶数元素，放到小集合中。要求使用自定义的方法来实现筛选

分析：

需要创建一个大集合，用来存储int数字：
随机数字就用Random和nextInt
循环20次，把随机数字放入大集合：for循环、add方法
定义一个方法，用来进行筛选
筛选：根据大集合，筛选符合要求的元素，得到小集合。
三要素：
返回值类型：ArrayList小集合（里面的元素个数不确定）
方法名称：getSmallList
参数列表：ArrayList大集合（装着20个随机数字）
判断（if)是偶数：num % 2 == 0
如果是偶数，就放到小集合当中，否则不放

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; //1~100
		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);
  		}
	}
}