1.API
概述
API(Application Programming Interface),应用程序编程接口。Java API是一本程序员的 字典 ,是JDK中提供给 我们使用的类的说明文档。这些类将底层的代码实现封装了起来,我们不需要关心这些类是如何实现的,只需要学 习这些类如何使用即可。所以我们可以通过查询API的方式,来学习Java提供的类,并得知如何使用它们。
API使用步骤
- 打开帮助文档。
- 点击显示,找到索引,看到输入框。
- 你要找谁?在输入框里输入,然后回车。
- 看包。java.lang下的类不需要导包,其他需要。
- 看类的解释和说明。
- 学习构造方法。
- 使用成员方法。
2.Scanner类
2.1 什么是Scanner类
一个可以解析基本类型和字符串的简单文本扫描器。 例如,以下代码使用户能够从 System.in 中读取一个数:
备注:System.in 系统输入指的是通过键盘录入数据。
2.2 引用类型使用步骤
1.导包
import包路径.类的名称;
如果需要使用的目标类,和当前的类位置在一个包下,则可以省略导包语句;
(只有java.lang包下的可以不需要导包语句,其他包都需要import语句)
//举例:
import java.util.Scanner;//1.导包
2.创建对象
类名称 对象名=new 类名称(参数列表)
//举例
Scanner sc = new Scanner(System.in);
3.调用方法
对象名.成员方法名称()
//举例
int i = sc.nextInt(); // 接收一个键盘录入的整数
获取键盘输入的一个int类型的数字:int num=sc.nextInt();
获取键盘输入的一个String类型的字符串:String str=sc.next();
2.3 Scanner使用步骤
查看类
- java.util.Scanner :该类需要import导入后使用。
查看构造方法
- public Scanner(InputStream source) : 构造一个新的 Scanner,它生成的值是从指定的输入流扫描的。
查看成员方法
- public int nextInt() :将输入信息的下一个标记扫描为一个 int 值。
使用Scanner类,完成接收键盘录入数据的操作,代码如下:
package com.itmei.day07.demo01;
import java.util.Scanner;//1.导包
/**
* Scanner类的功能:可以实现键盘输入数据,到程序当中
*
* 引用类型的一般使用步骤:
* 1.导包
* import包路径.类的名称;
* 如果需要使用的目标类,和当前的类位置在一个包下,则可以省略导包语句;(只有java.lang包下的可以不需要导包语句,其他包都需要import语句)
* 2.创建
* 类名称 对象名=new 类名称()
* 3.使用
* 对象名.成员方法名称()
*
* 获取键盘输入的一个int类型的数字:int num=sc.nextInt();
* 获取键盘输入的一个String类型的字:String str=sc.next();
*
*/
public class Demo01Scanner {
public static void main(String[] args) {
//2.创建
//System.in表示从键盘输入
Scanner sc=new Scanner(System.in);
//3.获取键盘输入的数字
int sum = sc.nextInt();
System.out.println("输入的int数字是:"+sum);
//4.获取键盘输入的字
String str=sc.next();
System.out.println("输入的字符串是:"+str);
}
}
2.4 练习
2.4.1 求和
键盘输入两个int数字,并且求出和值。
package com.itmei.day07.demo01;
import java.util.Scanner;
/**
* 题目:
* 键盘输入两个int数字,并且求出和值。
*
* 思路:
* 1. 既然需要键盘输入,那么就用Scanner
* 2. Scanner的三个步骤:导包、创建、使用
* 3. 需要的是两个数字,所以要调用两次nextInt方法
* 4. 得到了两个数字,就需要加在一起。
* 5. 将结果打印输出。
*/
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 sum=a+b;
System.out.println("你输入的2个数字和为:"+sum);
}
}
2.4.2取最值
键盘录入三个数据并获取最大值,代码如下:
package com.itmei.day07.demo01;
import java.util.Scanner;
/**
* 题目:
* 键盘输入三个int数字,然后求出其中的最大值。
*
* 思路:
* 1. 既然是键盘输入,肯定需要用到Scanner
* 2. Scanner三个步骤:导包、创建、使用nextInt()方法
* 3. 既然是三个数字,那么调用三次nextInt()方法,得到三个int变量
* 4. 无法同时判断三个数字谁最大,应该转换成为两个步骤:
* 4.1 首先判断前两个当中谁最大,拿到前两个的最大值
* 4.2 拿着前两个中的最大值,再和第三个数字比较,得到三个数字当中的最大值
* 5. 打印最终结果
*/
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;
int max;
if(a>b){
temp=a;
}else{
temp=b;
}if (temp>c){
max=temp;
}else {
max=c;
}*/
//首先达到前面2个数字当中的最大值(使用三元运算)
int temp=a>b ? a:b;
int max=c>temp?c:temp;
System.out.println("输入的三个数字最大值为:"+max);
}
}
2.5 匿名对象
概念
创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法,但是应用 场景非常有限。
- 匿名对象 :没有变量名的对象。
格式:
new 类名(参数列表);
举例:
new Scanner(System.in);
应用场景
- 创建匿名对象直接调用方法,没有变量名。
new Scanner(System.in).nextInt();
- 一旦调用两次方法,就是创建了两个对象,造成浪费,请看如下代码。
new Scanner(System.in).nextInt();
new Scanner(System.in).nextInt();
提示:一个匿名对象,只能使用一次。
3. 匿名对象可以作为方法的参数和返回值
- 作为参数:
public class Demo02Anonymous {
public static void main(String[] args) {
//普通使用方式
Scanner sc=new Scanner(System.in);
methodParam(sc);
//使用匿名的写法传入参数
methodParam(new Scanner(System.in));
}
public static void methodParam(Scanner scanner){
int sum=scanner.nextInt();
System.out.println("输入的是:"+sum);
}
}
- 作为返回值
public class Demo02Anonymous {
public static void main(String[] args) {
//普通使用方式
Scanner sc = methodReturn();
int sum = sc.nextInt();
System.out.println("输入的是:"+sum);
}
public static Scanner methodReturn(){
//普通方式
// Scanner sc=new Scanner(System.in);
// return sc;
//匿名对象作为方法返回值
return new Scanner(System.in);
}
}
3. Random类
3.1 什么是Random类
此类的实例用于生成伪随机数。
例如,以下代码使用户能够得到一个随机数:
Random r = new Random();
int i = r.nextInt();
3.2 Random使用步骤
查看类
- java.util.Random :该类需要 import导入使后使用。
查看构造方法
- public Random() :创建一个新的随机数生成器。
查看成员方法
- public int nextInt(int n) :返回一个伪随机数,范围在 0 (包括)和 指定值 n (不包括)之间的 int 值。
使用Random类,完成生成3个10以内的随机整数的操作,代码如下:
import java.util.Random;//1.导包
/**
* 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 demo01Random {
public static void main(String[] args) {
//2. 创建键盘录入数据的对象
Random r=new Random();
for (int i=0;i<3;i++){
//3. 随机生成一个数据
int num = r.nextInt(3);
//4. 输出数据
System.out.println("随机数:"+num);//随机数:0~2
}
}
}
备注:创建一个 Random 对象,每次调用 nextInt() 方法,都会生成一个随机数。
3.3 练习
3.3.1获取随机数
获取1-n之间的随机数,包含n,代码如下:
package com.itmei.day07.demo03;
import java.util.Random;
/**
* 题目要求:
* 根据int变量n的值,来获取随机数字,范围是[1,n],可以取到1也可以取到n。
*
* 思路:
* 1. 定义一个int变量n,随意赋值
* 2. 要使用Random:三个步骤,导包、创建、使用
* 3. 如果写10,那么就是0~9,然而想要的是1~10,可以发现:整体+1即可。
* 4. 打印随机数字
*/
public class demo03Random {
public static void main(String[] args) {
random(10);
}
//普通的方法
public static void random(int n){
Random r=new Random();
for (int i=0;i<100;i++){
int num= r.nextInt(n)+1;//本来随机数是范围是[0,n),整体+1之后变成了[1,n+1),已经是[1,n]
System.out.println("随机数"+i+"的值:"+num);
}
}
}
3.3.2猜数字小游戏
游戏开始时,会随机生成一个1-100之间的整数 randomNum。玩家猜测一个数字 guessNum,会与 randomNum作比 较,系统提示大了或者小了,直到玩家猜中,游戏结束。(设置了5次没猜对游戏结束!)
package com.itmei.day07.demo03;
import java.util.Random;
import java.util.Scanner;
/**
* 题目:
* 用代码模拟猜数字的小游戏。
*
* 思路:
* 1. 首先需要产生一个随机数字,并且一旦产生不再变化。用Random的nextInt方法
* 2. 需要键盘输入,所以用到了Scanner
* 3. 获取键盘输入的数字,用Scanner当中的nextInt方法
* 4. 已经得到了两个数字,判断(if)一下:
* 如果太大了,提示太大,并且重试;
* 如果太小了,提示太小,并且重试;
* 如果猜中了,游戏结束。
* 5. 重试就是再来一次,循环次数不确定,用while(true)。
*/
public class Demo04RandomGame {
public static void main(String[] args) {
//猜谜的次数
int i=0;//循环了几次
int sum=5; //只能猜5次
//1.创建随机数对象
Random r=new Random();
//1.1随机数范围1-100
int randomNum=r.nextInt(100)+1;//[1,100]
//2.创建键盘输入对象
Scanner sc=new Scanner(System.in);
System.out.println("请输入你的猜测数字:"+"剩余次数:"+(sum-i)+","+randomNum);
//3.不知道要循环多少次用while(true)才会运行false不会运行
//当循环的次数不等于猜的次数那么为true,就会运行,如果循环次数等于猜的次数那么为false,while不会运行
while (i!=sum){
int guessNum=sc.nextInt();//键盘输入的猜测数字
if(guessNum>randomNum){
System.out.println("太大了,请重试!"+"剩余次数:"+(sum-i-1));
}else if(guessNum<randomNum){
System.out.println("太小了,请重试!"+"剩余次数:"+(sum-i-1));
}else{
System.out.println("恭喜你猜对了!");
break;//如果猜对了,退出循环
}
i++;
}
System.out.println("游戏结束!");
}
}
运行结果:
4. ArrayList类
4.1 引入——对象数组
创建Person实体类,用于存放3个人:
package com.itmei.day07.demo04;
public class Person {
private String name; //姓名
private int age;//年龄
public Person() {
}
public Person(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;
}
}
package com.itmei.day07.demo04;
/**
* 题目:
* 定义一个数组,用来存储3个Person对象。
*
* 数组有一个缺点:一旦创建,程序运行期间长度不可以发生改变。
*/
public class Demo01Array {
public static void main(String[] args) {
// 首先创建一个长度为3的数组,里面用来存放Person类型的对象
Person[] array = new Person[3];
Person one =new Person("高圆圆",25);
Person two =new Person("古力娜扎",20);
Person three =new Person("刘备",35);
//将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());//古力娜扎
}
}
到目前为止,我们想存储对象数据,选择的容器,只有对象数组。而数组的长度是固定的,无法适应数据变化的需 求。为了解决这个问题,Java提供了另一个容器 java.util.ArrayList 集合类,让我们可以更便捷的存储和操作对 象数据。
4.2 什么是ArrayList类
- java.util.ArrayList 是大小可变的数组的实现,存储在内的数据称为元素。此类提供一些方法来操作内部存储 的元素。ArrayList 中可不断添加元素,其大小也自动增长。
4.3 ArrayList使用步骤
查看类
- java.util.ArrayList :该类需要 import导入使后使用。
< E> ,表示一种指定的数据类型,叫做泛型。 E ,取自Element(元素)的首字母。在出现 E 的地方,我们使 用一种引用数据类型将其替换即可,表示我们将存储哪种引用类型的元素。代码如下:
ArrayList< String>,ArrayList< Person>
查看构造方法
- public ArrayList() :构造一个内容为空的集合。
基本格式:
ArrayList< String> list = new ArrayList< String>();
在JDK 7后,右侧泛型的尖括号之内可以留空,但是<>仍然要写。简化格式
ArrayList<String> list = new ArrayList<>();
查看成员方法
- public boolean add(E e) : 将指定的元素添加到此集合的尾部。
参数 E e ,在构造ArrayList对象时, 指定了什么数据类型,那么 add(E e) 方法中,只能添加什么数据
类型的对象。
使用ArrayList类,存储三个字符串元素,代码如下:
package com.itmei.day07.demo04;
import java.util.ArrayList;
/**
* 数组的长度不可以发生改变。
* 但是ArrayList集合的长度是可以随意变化的。
*
* 对于ArrayList来说,有一个尖括号<E>代表泛型。
* 泛型:也就是装在集合当中的所有元素,全都是统一的什么类型。
* 注意:泛型只能是引用类型,不能是基本类型。
*
* 注意事项:
* 对于ArrayList集合来说,直接打印得到的不是地址值,而是内容。
* 如果内容是空,得到的是空的中括号:[]
*/
public class demo02ArrayList {
public static void main(String[] args) {
// 创建了一个ArrayList集合,集合的名称是list,里面装的全都是String字符串类型的数据
// 备注:从JDK 1.7+开始,右侧的尖括号内部可以不写内容,但是<>本身还是要写的。
ArrayList<String> list = new ArrayList<String>();
System.out.println(list); // []
//创建字符串对象
String s1="M";
String s2="J";
//向集合当中添加数据,使用add方法
list.add(s1);
list.add(s2);
System.out.println(list);//[M, J]
//list.add(100)//这是错误的写法,因为泛型已经定义成了String字符串类型,添加的元素必须都是字符串才可以
}
}
4.4 常用方法和遍历
对于元素的操作,基本体现在——增、删、查。常用的方法有:
public boolean add(E e) :将指定的元素添加到此集合的尾部。
public E remove(int index) :移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index) :返回此集合中指定位置上的元素。返回获取的元素。
public int size() :返回此集合中的元素数。遍历集合时,可以控制索引范围,防止越界。
这些都是最基本的方法,操作非常简单,代码如下:
package com.itmei.day07.demo04;
import java.util.ArrayList;
public class Demo03ArrayListMethod {
public static void main(String[] args) {
//创建对象
ArrayList<String> list=new ArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//public E get(int index) :返回指定位置上的元素。返回获取的元素。
System.out.println("get获取元素为:"+list.get(0));
System.out.println("get获取元素为:"+list.get(1));
System.out.println("get获取元素为:"+list.get(2));
//public int size() :返回此集合中的个数。遍历集合时,可以控制索引范围,防止越界。
System.out.println("size数组长度为:"+list.size());
//public E remove(int index) :移除此集合中指定位置上的元素。返回被删除的元素。
System.out.println("remove删除的是:"+list.remove(0));
//遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.println("集合下标"+i+"的值:"+list.get(i));
}
}
}
运行效果:
4.5 如何存储基本数据类型
注意:ArrayList对象不能存储基本类型,只能存储引用类型的数据。类似 不能写,但是存储基本数据类型对应的 包装类型是可以的。所以,想要存储基本类型数据, <> 中的数据类型,必须转换后才能编写,转换写法如下:
我们发现,只有 Integer 和 Character 需要特殊记忆,其他基本类型只是首字母大写即可。那么存储基本类型数 据,代码如下:
package com.itmei.day07.demo04;
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 Demo05ArrayListBasic {
public static void main(String[] args) {
//创建对象
ArrayList<String> listA = new ArrayList<String>();
// 错误写法!泛型只能是引用类型,不能是基本类型
//ArrayList<int> listB = new ArrayList<>();
ArrayList<Integer> listC = new ArrayList<Integer>();
listC.add(100);
listC.add(200);
System.out.println(listC); // [100, 200]
int num = listC.get(1);
System.out.println("第1号元素是:" + num);
}
}
4.6 ArrayList练习
4.6.1 数值添加到集合
生成6个1~33之间的随机整数,添加到集合,并遍历
package com.itmei.day07.demo5;
import java.util.ArrayList;
import java.util.Random;
/**
* 题目:
* 生成6个1~33之间的随机整数,添加到集合,并遍历集合。
*
* 思路:
* 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 Demo01ArrayListRandom {
public static void main(String[] args) {
//创建集合对象
ArrayList<Integer> list=new ArrayList<Integer>();
//创建随机数对象
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));
}
}
}
运行效果:
4.6.2对象添加到集合
自定义4个学生对象,添加到集合,并遍历:
创建student实体类:成员属性,成员方法,构造方法
package com.itmei.day07.demo5;
public class Student {
private String name;//姓名
private int age;//年龄
public Student() {
}
public Student(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;
}
}
package com.itmei.day07.demo5;
import java.util.ArrayList;
/**
* 题目:
* 自定义4个学生对象,添加到集合,并遍历。
*
* 思路:
* 1. 自定义Student学生类,四个部分。
* 2. 创建一个集合,用来存储学生对象。泛型:<Student>
* 3. 根据类,创建4个学生对象。
* 4. 将4个学生对象添加到集合中:add
* 5. 遍历集合:for、size、get
*/
public class Demo02ArrayListStudent {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> list=new ArrayList<Student>();
//创建学生(使用全参构造)
Student s1=new Student("小米",10);
Student s2=new Student("小王",20);
Student s3=new Student("赵丽颖",25);
Student s4=new Student("高圆圆",28);
//把学生对象作为元素添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
//遍历集合
for (int i = 0; i < list.size(); i++) {
Student student = list.get(i);//通过get获取第i个元素的值
System.out.println(student.getName()+"------"+student.getAge());
}
}
}
运行结果:
4.6.3打印集合方法
定义以指定格式打印集合的方法(ArrayList类型作为参数),使用{}扩起集合,使用@分隔每个元素。格式参照 {元素 @元素@元素}。
package com.itmei.day07.demo5;
import java.util.ArrayList;
/**
* 题目:
* 定义以指定格式打印集合的方法(ArrayList类型作为参数),使用{}扩起集合,使用@分隔每个元素。
* 格式参照 {元素@元素@元素}。
*
* System.out.println(list); [10, 20, 30]
* printArrayList(list); {10@20@30}
*/
public class Demo03ArrayListPrint {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("张三丰");
list.add("宋远桥");
list.add("张无忌");
list.add("张翠山");
System.out.println(list); // [张三丰, 宋远桥, 张无忌, 张翠山]
printArrayList(list);
}
/**
* 定义方法的三要素
* 返回值类型:只是进行打印而已,没有运算,没有结果;所以用void
* 方法名称:printArrayList
* 参数列表:ArrayList
*
*/
private static void printArrayList(ArrayList<String> list) {
// {10@20@30}
System.out.print("{");
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.print(name+"@");
}
}
}
}
运行结果:
4.6.4获取集合方法
定义获取所有偶数元素集合的方法(ArrayList类型作为返回值)
package com.itmei.day07.demo5;
import java.util.ArrayList;
import java.util.Random;
/**
* 题目:
* 用一个大集合存入20个随机数字,然后筛选其中的偶数元素,放到小集合当中。
* 要求使用自定义的方法来实现筛选。
*
* 分析:
* 1. 需要创建一个大集合,用来存储int数字:<Integer>
* 2. 随机数字就用Random nextInt
* 3. 循环20次,把随机数字放入大集合:for循环、add方法
* 4. 定义一个方法,用来进行筛选。
* 筛选:根据大集合,筛选符合要求的元素,得到小集合。
* 三要素
* 返回值类型:ArrayList小集合(里面元素个数不确定)
* 方法名称:getSmallList
* 参数列表:ArrayList大集合(装着20个随机数字)
* 5. 判断(if)是偶数:num % 2 == 0
* 6. 如果是偶数,就放到小集合当中,否则不放。
*/
public class Demo05ArrayListReturn {
public static void main(String[] args) {
// 创建Random 对象
Random r = new Random();
// 创建ArrayList 对象
ArrayList<Integer> list = new ArrayList<Integer>();
//循环20次,把随机数字放入大集合:for循环、add方法
for (int i=0;i<20;i++){
int n= r.nextInt(1000)+1;
list.add(n);
}
// 调用偶数集合的方法
ArrayList<Integer> smallList = getSmallList(list);
System.out.println(smallList);
}
public static ArrayList<Integer> getSmallList(ArrayList<Integer> list){
//创建小集合,用于保存偶数
ArrayList<Integer> smallList=new ArrayList<Integer>();
//遍历集合
for (int i = 0; i < list.size(); i++) {
//获取list元素
int num=list.get(i);
//判断为偶数,添加到集合中
if (num % 2==0){
//偶数
smallList.add(num);
}
}
//返回小集合
return smallList ;
}
}
4.7增强for循环的使用
增强型for循环定义如下:
for(ElementType element: arrayName){};
简单理解for(元素类型 元素名称:集合名称){}
元素类型取决于 集合对象的类型
普通for循环遍历:
//定义一个数组
int[] num={1,2,3,4,5};
//使用普通的for循环遍历
for (int i=0;i<num.length;i++){
//获取每一个元素
int n = num[i];
System.out.print(n);
}
使用增强for循环:
//定义一个数组
int[] num={1,2,3,4,5};
//使用增强for循环
for (Integer n:num){
System.out.print(n);
}
使用增强for循环遍历集合对象
//创建集合
ArrayList< Student> lists=new ArrayList< Student>();
for (Student list:lists){
System.out.println(list);//这个打印的是地址值
System.out.println(list.getName());//打印学生姓名
}
从这里可以看出我们创建的ArrayList的泛型是Student类,集合名称为lists,那么我们通过for增强就可以知道他的元素类型是Student ,元素名称可以随意写,如果我们直接打印元素名称,那么我们获取到的是元素的地址值,我们获取元素的信息,那么就需要调用元素的对应成员方法
总结:相对于普通的for循环而言
1.写起来简单
2.遍历集合、容器简单
对象添加集合并且for增强打印
package com.itmei.day07.demo5;
import java.util.ArrayList;
public class Demo06ArrayListFor {
public static void main(String[] args) {
//创建集合对象,泛型为Student
ArrayList<Student> list=new ArrayList<Student>();
//通过全参构造创建学生信息
Student s1=new Student("高圆圆",20);
Student s2=new Student("赵丽颖",20);
//添加学生到集合中
list.add(s1);
list.add(s2);
enhanceFor(list);
}
//增强for循环的方法
public static void enhanceFor(ArrayList<Student> students){
//使用增强for循环
for (Student student:students){
//打印学生姓名
System.out.println(student.getName());
}
}
}
运行结果: