API基础和集合基础 (非常详细）

文章目录

1. API概述和使用步骤

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

API的使用步骤：

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

通俗理解：

所谓的API就是好多类好多方法，jdk提供了一些现成的类，可以直接俄拿过来使用，这些类是现成提供给我们，直接拿来使用的类，他们都叫做API。
API文档：告诉我们到底只有哪些类是现成的，到底有哪些方法具有各自怎样的功能，这个样的一份说明说就叫做API文档。
提示： string 关键字都是小写的， String是一个类，这个是jdk的作者写的。

看看三点内容：

看包路径：java.long 这个是类所在的一个包路径，jdk提供好的各式各样的类也是在一个一个的包当中的，java这个包里面，lang这个包里面有一个String类。long是语言的缩写。
看构造方法摘要：一个类通常情况下不能直接使用，要想使用，要根据它new一个对象，new就是在调用构造方法。用哪个查哪个，
看方法摘要：返回值类型，方法名称，参数。可以点方法名称可以跳转到更加详细的说明。

2. Scanner的使用步骤

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

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

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

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

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

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

代码如下：

import java.util.Scanner;

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

2.1 举栗一（键盘输入两个数字求和）

题目：
键盘输入两个int数字，并且求出和值

思路：

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

代码如下：


import java.util.Scanner;
public class Demo02ScannerSum{
    
    
	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();
		
		int result = a + b;
		System.out.println("结果是：" + result);
	}
}

2.2 举栗二（键盘输入三个数字求最大值）

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

思路：

既然是键盘输入，肯定需要用到Scanner
Scanner三个步骤：导包、创建、使用nextInt()方法
既然是三个数字，那么调用三次nextInt()方法，得到三个int变量
无法同时判断三个数字谁最大，应该转换成为两个步骤：
4.1首先判断前两个当中谁最大，拿到前两个的最大值
4.2拿着前两个中的最大值，再和第三个数字比较，得到三个数组当中的最大值
打印最终结果

代码如下：

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

3. 匿名对象的说明

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

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
new 类名称();
注意事项：匿名对象只能使用唯一的一次，下次再用不得不在创建一个新的对象
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。

当我们创建对象的时候，总是要起一个名字，有些情况下这个名字可以省略掉，没有名字的对象就叫做匿名对象，
注意： 几个new就创建了几个对象。
有一个对象，只想通过它的名称点一次，就这一次，只是用唯一的一次，如果再取一个名字就有些多余了，再这种情况下，直接new个对象，想用谁点谁，
但是匿名对象要用只能用一次，反过来说，有的对象只用一次，就可以用匿名对象。


public class Demo01Anoymous{
    
    
	public static void main(String[] args){
    
    
		Person one = new Person();
		one.name = "高圆圆";
		one.showName();//我叫高圆圆
		System.out.println("==========================");
		
		//匿名对象
		new Person().name = "赵又廷";
		new Person().showName();//我叫，nall
	}
}

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

import java.util.Scanner;

public class Demo02Anonymous{
    
    
	
	public static void main(String[] args){
    
    
		// 使用普通的方式
		// Scanner sc = new Scanner(System.in);
		// int num = sc.nexInt();
		
		//匿名对象的方式
		//int num = new Scanner(System.in).nextInt();
		//System.out.println("输入的是："+num);
		
		// 使用一般写法传入参数
		// Scanner sc = new Scanner(System.in);
		// methodParam(sc);
		
		// 使用匿名对象来进行传参
		// methodParam(new Scanner(System.in));
		
		Scanner sc = methodReturn();
		int num = sc.nextInt();
		System.out.println("我输入的是：" + num);
		
	}
	
	public static void methodParam(Scanner sc){
    
    
		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);
	}
}

4. Random概述和基本使用

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

导包
import java.util.Random
创建
Random r = new Random;//小括号当中留空即可
使用
（1）获取一个随机的int数字（范围是int所有范围，有正负了两种），int num = r.nextInt()
（2）获取一个随机的int数字（参数代表了的范围，左闭右开区间），int num = r.nextInt(3)
实际上代表的含义是：[0,3),也就是0-2

public class Demo01Random{
    
    
	public static void main(String[] args){
    
    
		// 没有参数的
		Random r = new Random();
		int num  = r.nextInt();
		System.out.println("随机数是：" + num);
		
		// 带参数的,循环10次
		
		for(int i = 0; i < 10; i++){
    
    
			int a = r.nextInt(2);
			System.out.println(a);
		}
	}
}

4.1 举栗一（生成1-n之间的随机数）

题目要求：
根据int变量n的值，来获取随机数字，范围是[1,n],可以取到1也可以取到n

思路：
1.定义一个int变量
2. 要使用Random，单个步骤，导包、创建、使用
3.如果写10，那么就是0-9，然而想要的是1-9，可以发现，整体+1即可。
4. 打印随机数字

public class Demo02Random{
    
    
	public static void main(String[] args){
    
    
		int n = 5 ;
		Random r = new Random();
		
		// 带参数的,循环10次
		
		for(int i = 0; i < 10; i++){
    
    
			int num = r.nextInt(n) + 1 ;
			System.out.println(num);
		}
	}
}

4.2 举栗二（猜数字小游戏）

题目：用代码模拟猜数字游戏

思路：

首先需要产生一个随机数字，并且一旦产生不再变化，用Random的nextInt方法
需要键盘输入，所以用到了Scanner
获取键盘输入的数字，用Scnaner方法中的nextInt方法
已经获得了两个数字，判断（if）一下
如果太大了，提示太大，并且重试
如果太小了，提示太小，并且重试
如果猜中了，游戏结束
重试就是再来一次，循环次数不确定，用while（true）。

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

public class Demo03RandomGame{
    
    
	public static void main(String[] args){
    
    
		Random r = new Random();
		int randomunm = r.nextInt(100) + 1; // [1,100]
		Scanner sc = new Scanner(System.in);
		
		while(true){
    
    
			System.out.println("请输入你猜测的数字");
			int guessNum = sc.nextInt(); // 键盘输入猜测的数字
		
			if(guessNum > randomunm){
    
    
				System.out.println("太大了，请重试");
			}else if(guessNum < randomunm){
    
    
				System.out.println("太小了，请重试");
			}else{
    
    
				System.out.println("恭喜你，猜中了");
				break;
			}
		}
	}
}

5. 对象数组

题目：定义一个数组，用来储存3个Person对象
数组有一个缺点，一旦创建，程序运行期间，长度不可以发生改变

public class Persons{
    
    
	
	private String name;
	private int age;
	
	public Persons(){
    
    
		
	}
	public Persons(String name,int age){
    
    
		this.name = name;
		this.age = age ;
	}
	
	public void setName(String name){
    
    
		this.name = name;
		
	}
	public String getName(){
    
    
		return name;
	}
	public void setAge(int age){
    
    
		this.age = age;
	}
	public int getAge(){
    
    
		return age;
	}
}

public class Demo04Array{
    
    
	public static void main(String[] args){
    
    
		// 首先创建一个长度为3的数组，里面用来存放Person类型的对象
		Persons[] array = new Persons[3];
		
		Persons one = new Persons("迪丽热巴",18);
		Persons two = new Persons("古力娜扎",20);
		Persons three = new Persons("马儿扎哈",30);
		
		//将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]);
		
		System.out.println(array[0].getName() + "的年龄："+ array[0].getAge() + "岁");//迪丽热巴
		
	}
}

6. ArrayList集合概述和基本使用

java.util.ArrayList <E>: 该类需要import导入以后使用
,表示一种指定的数据类型，叫做泛型。E,取自Element（元素）的首字母。再出现E的地方，我们使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。
尖括号当中是泛型

ArrayList也能存储多个数据，这个数据都是统一的什么类型，这个类型就在尖括号中写着那。
最常用的就是无参构造

为什么返回的不是一个地址值那？
写ArrayList的这个人对ArrayList类进行了特殊处理怎么对他特殊处理那？之后会学习tostring方法。

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

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

注意事项：

对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容是空，得到的是空的中括号[ ]。
但是当一个集合作为一个方法参数的时候所接收到的参数就是一个地址值，然后就可以拿这个地址值进行操作了。

代码如下：

import java.util.ArrayList;
public class Demo05ArrayList{
    
    
	public static void main(String[] args){
    
    
		//创建了一个ArrayList集合，集合的名称是list,里面装的全都是String字符串类型的数据
		//备注：从JDK 1.7开始，右侧的尖括号内部可以不写内容，但是<>本省还是要写的。
		
		ArrayList<String> list = new ArrayList<>();
		System.out.println(list);
		
		// 向集合当中添加一些数据，需要用到add方法
		list.add("赵丽颖");
		System.out.println(list);
		list.add("迪丽热巴");
		list.add("古力娜扎");
		list.add("马儿扎哈");
		System.out.println(list);
//		list.add(100);//错误写法 因为创建的时候尖括号泛型已经说了是字符串，添加进去的元素就必须都是字符串才行

6.1 ArrayList集合的常用方法和遍历

数组 array.length
集合 list.size()
list.fori = for(int i = 0 ; i < list.size() ; i++){}
sout

ArrayList当中的常用方法有：

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

public E get(int index):从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int index):从集合当中删除元素，参数是索引编号，返回值就是被删除的元素。
public int size(): 获取集合的尺寸长度，返回值是集合中包含的元素个数。

举个栗子：

import java.util.ArrayList;

public class Demo06ArrayListMethod{
    
    
	public static void main(String[] args){
    
    
		ArrayList<String> list = new ArrayList<>();
		System.out.println(list); // []
		
		boolean success = list.add("柳岩");
		System.out.println(list);
		System.out.println("添加的动作是否成功：" + success);
		
		list.add("高圆圆");
		list.add("赵又廷");
		list.add("李小璐");
		list.add("贾乃亮");
		System.out.println(list);//[柳岩,高圆圆,赵又廷,李小璐,贾乃亮]
		
		//从集合中获取元素，get。索引值从0开始
		System.out.println("======================");
		String name = list.get(2);
		System.out.println("第二号索引位置：" + name);
		
		//从集合中删除元素，remove。索引值从0开始。
		System.out.println("======================");
		String whoRemoved = list.remove(3);
		System.out.println("被删除的人是谁：" + whoRemoved);
		System.out.println(list);
		
		//获取集合的长度尺寸，也就是其中元素的个数
		System.out.println("======================");
		int size = list.size();
		System.out.println("集合的长度是：" + size);
		
		//遍历集合
		System.out.println("======================");
		System.out.println("遍历集合：");
		for(int i = 0; i < size; i++){
    
    
			System.out.println(list.get(i));
		}
	}
}

6.2 ArrayList集合存储基本数据类型

为什么不能是基本类型那？？ 集合里面保存的都是地址值，但是基本类型的数据，没有地址值，所以你要想往里面存储一个int是不允许的。
有解决方案：

如果希望像集合ArrayList当汇总存储基本类型数据，必须使用基本类型对应"包装类"

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

小提示：
从JDK 1.5开始，支持自动装箱、自动拆箱。

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

这个过程不需要人工干预的，是自动完成的。

示例代码如下:

import java.util.ArrayList;

public class Demo07ArrayListBsic{
    
    
	public static void main(String[] args){
    
    
		//错误写法！泛型只能是引用类型，不能是基本类型
	    // ArrayList<int> listC = 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("第1号元素是：" + num);
	}
}

6.3 举栗一（存储随机数字）

题目：产生6个1-33之间的随机整数，添加到集合，并遍历集合

思路：

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

代码如下：

import java.util.Random;
import java.util.ArrayList;
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));
		}
	}
}

IDEA快捷操作：

6.fori = for(int i = 0 ; i < 6 ; i++)
list.fori = for (int i = 0 ; i < list.size ; i++)
biglist.fori = for (int i = 0 ; i < biglist.size; i++)
alt + 回车键（local）

6.4 举栗二（存储自定义对象）

题目：
自定义4个学生对象，添加到集合，并遍历
思路：

自定义Student学生类，四个部分
创建一个集合，用来储存学生对象，泛型：
根据类，创建四个学生对象
将4个学生添加到集合中，add
遍历集合：for 、 size 、get

代码如下：

public class  Student{
    
    
	private String name;
	private int age;
	
	public Student(){
    
    
		
	}
	
	public Student(String name , int age ){
    
    
		this.name = name;
		this.age = age;
	}
	
	public void setName(String name){
    
    
		this.name = name;
	}
	
	public String getName(){
    
    
		return name;
		
	}
	public void setAge(int age){
    
    
		this.name = name;
		
	}
	public int getAge(){
    
    
		return age;
	}
}

import java.util.ArrayList;

public class Demo01ArrayListStudent{
    
    
	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("郭靖",23);
		Student four = new Student("段誉",25);
		
		list.add(one);
		list.add(two);
		list.add(three);
		list.add(four);
		System.out.println(list); //输出的是地址值
		for(int i = 0; i < list.size(); i++){
    
    
			Student stu = list.get(i);
			System.out.println("姓名：" + stu.getName() + ", 年龄" + stu.getAge());
		}
	}
}

6.5 举栗三（按指定格式遍历集合字符串）

当一个集合作为一个方法参数的时候，所接收到的参数就是一个地址值，然后就可以拿这个地址值进行操作了。

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

举例：
System.out.println(list); [10,20,30]
printArray(list); {10@20@30}

代码如下：

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

6.6 举栗四（筛选集合中的随机数）

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

分析：

需要创建一个大集合，用来储存int数字，
随机数字就用Random nextInt
循环20次，把随机数字放入大集合，for循环、add方法
定义一个方法，用来就行筛选
筛选：根据大集合，筛选符合要求的元素，得到小集合。
判断（if）是否是偶数：num % 2 == 0
如果是偶数，就放到小集合当中，否则不放

方法三要素：

返回值类型：ArrayList小集合（里面元素个数不确定）
方法名称：getSmallList
参数列表：ArrayList大集合（装着20个随机数字）

代码如下：

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

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; // [1,100]
			biglist.add(num);
		}
		// System.out.println(biglist);
		
		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++){
    
    
			if(biglist.get(i)%2 == 0){
    
    
				smalllist.add(biglist.get(i));
			}
		}
		return smalllist;
	}
}