第十七天 集合-Collection&增强for&迭代器【悟空教程】

第十七天 集合-Collection&增强for&迭代器【悟空教程】

第17天 集合

第1章 集合

1.1 集合介绍

集合,集合是java中提供的一种容器,可以用来存储多个数据。

出现意义:面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。

Java中的集合: JDK为我们提供了一套完整的容器类库,这些容器可以用于存储各种类型的对象,并且长度都是可变的,我们把这些类统称为集合类,它们都位于java.util包中。

在前面的学习中,我们知道数据多了,可以使用数组存放或者使用ArrayList集合进行存放数据。那么,集合和数组既然都是容器,它们有啥区别呢?

  • 数组的长度是固定的。集合的长度是可变的。
  • 集合中存储的元素必须是引用类型数据

1.2 ArrayList集合存储元素

我们来回顾下,使用ArrayList集合存储元素并遍历的过程。

  • 练习一:ArrayList集合存储5个int类型元素

public static void main(String[] args) {

ArrayList<Integer> list = new ArrayList<Integer>();

list.add(111); //自动装箱 把基本类型 包装成 对象

list.add(222);

list.add(333);

list.add(444);

list.add(555);

for(int i=0; i<list.size(); i++){

System.out.println(list.get(i));

}

}

  • 练习二:ArrayList集合存储5个Person类型元素

public static void main(String[] args) {

ArrayList<Person> list = new ArrayList<Person>();

list.add(new Person(“小强”));

list.add(new Person(“老王”));

list.add(new Person(“小虎”));

list.add(new Person(“小泽”));

list.add(new Person(“小红”));

for(int i=0; i<list.size(); i++){

Person p = list.get(i);

System.out.println(p);

}

}

第2章 Collection

2.1 Collection接口

2.1.1 Collection概念

Collection是所有单列集合的直接或间接接口,其指定了所有集合应该具备的功能。

AbstractCollection是实现了Collection接口的抽象父类。

Collection与AbstractCollection均无法直接使用,需要使用其具体实现类。下图是强调功能的集合体系图,实线黑框为具体实现类。我们可以从中任意挑选一个以多态形式演示Collection的方法。

2.1.2 Collection通用方法

主要方法

boolean add(E e) //添加元素

boolean remove(Object o) //删除元素

void clear() //清空集合

boolean contains(Object o) //判断是否包含某元素

boolean isEmpty() //判断是否为空

int size() //获取集合长度

import java.util.ArrayList;

import java.util.Collection;

/*

* Collection 容器.

*

* 方法:

*

boolean add(E e) 确保此 collection 包含指定的元素(可选操作)。

void clear() 移除此 collection 中的所有元素(可选操作)。

boolean contains(Object o) 如果此 collection 包含指定的元素,则返回 true。

boolean isEmpty() 如果此 collection 不包含元素,则返回 true。

boolean remove(Object o) 从此 collection 中移除指定元素的单个实例,如果存在的话(可选操作)。

int size() 返回此 collection 中的元素数。

Object[] toArray() 返回包含此 collection 中所有元素的数组。

*

*/

public class Demo {

public static void main(String[] args) {

Collection c = new ArrayList<>();

System.out.println(c); // []

c.add("abc"); // 添加元素

c.add("eeee");

c.add(123);

c.add(true);

c.add(null);

c.add("abc"); // 添加元素

System.out.println(c); // [abc,eee..... ]

//c.clear(); // 清空所有元素.

//System.out.println(c); // [abc,eee..... ]

// System.out.println("是否包含: " + c.contains("abc")); //true

// System.out.println("是否包含: " + c.contains("a")); // false

// System.out.println("是否包含: " + c.contains("ee")); // false

// System.out.println("是否包含: " + c.contains(23));

// System.out.println("是否包含: " + c.contains(null));

// System.out.println("============");

// System.out.println("是否元素为空: " + c.isEmpty());

// c.clear();

// System.out.println("是否元素为空: " + c.isEmpty());

boolean remove = c.remove("abc");

System.out.println(remove);

System.out.println(c);

boolean remove2 = c.remove(222);

System.out.println(remove2);

System.out.println(c);

System.out.println("============");

Object[] array = c.toArray();

for (int i = 0; i < array.length; i++) {

System.out.println(array[i]);

}

}

}

2.2 增强for循环

增强for循环是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。增强for循环用来迭代集合或数组,:

格式:

for(元素的数据类型 变量 : Collection集合or数组){

}

它用于遍历Collection和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。

练习一:遍历数组

int[] arr = new int[]{11,22,33};

for (int n : arr) {//变量n代表被遍历到的数组元素

System.out.println(n);

}

练习二:遍历集合

Collection<String> coll = new ArrayList<String>();

coll.add("javahelp1");

coll.add("javahelp2");

coll.add("javahelp3");

coll.add("javahelp4");

for(String str : coll){//变量Str代表被遍历到的集合元素

System.out.println(str);

}

增强for循环和老式的for循环有什么区别?

注意:新for循环必须有被遍历的目标。目标只能是Collection或者是数组。

建议:遍历数组时,如果仅为遍历,可以使用增强for如果要对数组的元素进行 操作,使用老式for循环可以通过角标操作

/*

* 增强for 循环 . 简化的遍历集合操作.

*

* 格式:

* for (元素类型 变量名 : 容器名字){

* 直接使用变量名 ,就是使用元素.

* }

* for (Student student : c) {

System.out.println(student);

}

fore alt + /

*/

public class Demo {

public static void main(String[] args) {

//fun1();

//1. 创建学生对象

Student student1 = new Student("老王" , 66);

Student student2 = new Student("金莲" , 28);

Student student3 = new Student("西门" , 99);

Student student4 = new Student("大郎" , 100);

Collection<Student> c = new ArrayList<>();

// 3.添加元素

c.add(student1);

c.add(student2);

c.add(student3);

c.add(student4);

for (Student student : c) {

//c.remove(student);//ConcurrentModificationException 并发修改异常 .

student.setScore(200);

}

// Student student ;

// for (Iterator iterator = c.iterator(); iterator.hasNext(); c.remove(student))

// student = (Student)iterator.next();

System.out.println(c);

}

private static void fun1() {

Collection<String> c = new ArrayList<>();

c.add("aaa");

c.add("bbb");

c.add("ccc");

c.add("ddd");

for (String string : c) {

System.out.println(string);

}

}

}

2.3 迭代器

集合用来持有数据,一定会设计出对数据的增、删、改、查四个常用方法,而查是集合中最常用的功能。Collection接口继承了Iterable接口,具备了可迭代功能iterator方法,该方法用于迭代集合。所以,所有单列集合由于是Collection的直接或间接实现类,均具有该方法。

这里涉及到以下内容共同完成集合的迭代:

  • Collection接口的iterator方法,所以单列集合实现类均有该方法
  • iterator方法的返回值类型Iterator接口类型
  • Iterator接口的两个方法:hasNext与next方法

2.3.1 迭代常规步骤

1:通过集合获取这个集合的迭代器

2:结合使用迭代器的hashNext与next完成集合迭代

如:

ArryList<String> list = new ArryList <String>();

hs.add("i love java");

hs.add("i like java");

//返回迭代器

Iterator<String> iterator = list.iterator();

//调用hasNext与next完成集合迭代

while (iterator.hasNext()) {

String string = iterator.next();

System.out.println(string);

}

2.3.2 Collection接口的Iterator

方法声明为:

Iterator<集合中数据类型> iterator()

用来返回专属于该集合对象的迭代器对象(Iterator的子类对象)。

2.3.3 Iterator接口

该接口规定了迭代集合所需要的方法

2.3.4 Iterator接口的两个方法:hasNext与next方法

Iterator规定了两个方法,集合对象产生的迭代器对象正是通过这两个方法帮助集合进行迭代工作的。

调用迭代器的hasNext方法判断是否有下一个元素

调用迭代器的next获取下一个元素

2.3.5 迭代集合元素图解:

2.3.6 代码演示

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

/*

* Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。

*

* Iterator 就是帮你去做遍历集合操作 .

*

* iterator() 返回的就是 Iterator接口的子类对象.

*/

public class Demo2 {

public static void main(String[] args) {

Collection c = new ArrayList();

c.add("111");

c.add("222");

c.add("333");

c.add("444");

// 遍历集合. 获取其中每一个元素.

// 1.获取迭代器对象 .

Iterator iterator = c.iterator(); // Iterator 接口 指向 子类对象.

// 2.调用迭代器的方法,获取集合中的元素.

// Object next = iterator.next();

// System.out.println(next);

//

// Object next2 = iterator.next();

// System.out.println(next2);

//

// Object next3 = iterator.next();

// System.out.println(next3);

//

// Object next4 = iterator.next();

// System.out.println(next4);

//

// Object next5 = iterator.next(); //NoSuchElementException

// System.out.println(next5);

while(iterator.hasNext()){

Object next = iterator.next();

System.out.println(next);

}

}

}

2.3.7 迭代器遍历集合总结

import java.util.Collection;

import java.util.Iterator;

import java.util.ArrayList;

/*

* 1.hasNext 方法和 next方法 说明 . 遍历之前,有一个指针指向初始位置,第一个元素的前面,

* hasNext,判断是否在指针后面有元素,有返回true ,没有返回false .

* 如果有 , 就可以通过 next() 获取下一个元素了.

* 2.syso(c); 我也能看所有的元素, 那我为什么还要遍历呢?

*

* 3.toString() 在哪重写的呢? 你管的着么!! 要找找他爹,他爷爷

*

*/

public class Demo3 {

public static void main(String[] args) {

Collection c = new ArrayList<>();

c.add("aaa");

c.add("abbbbb");

c.add("cccc");

c.add("xxxx ");

// 遍历集合

// 1.获取迭代器

Iterator iterator = c.iterator();

// 2.通过迭代器获取元素 .

while (iterator.hasNext()) { // 是否有下一个.

Object next = iterator.next(); // 获取下一个元素

System.out.println(next);

}

}

}

2.3.8 保存自定义对象练习(迭代器移除元素)

public class Student {

String name; // 姓名

int score; // 分数

public Student() {

super();

// TODO Auto-generated constructor stub

}

public Student(String name, int score) {

super();

this.name = name;

this.score = score;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getScore() {

return score;

}

public void setScore(int score) {

this.score = score;

}

@Override

public String toString() {

return "学生 [姓名=" + name + ", 分数=" + score + "]";

}

}

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

/*

* 给你集合 ,保存 很多 学生对象. 学生类中, 包含了姓名和分数.

*

* 学生1 ("老王" , 66) ;

* 学生2 ("金莲" , 28) ;

* 学生3 ("西门" , 99) ;

*

* 1.把所有对象保存集合.

* 2.遍历集合,把60分以下的同学,移除掉.

* 3.再遍历的时候,只有 60分以上的同学了.

*/

public class Test {

public static void main(String[] args) {

//1. 创建学生对象

Student student1 = new Student("老王" , 66);

Student student2 = new Student("金莲" , 28);

Student student3 = new Student("西门" , 99);

Student student4 = new Student("大郎" , 100);

// 2.创建集合

Collection<Student> c = new ArrayList<>();

// 3.添加元素

c.add(student1);

c.add(student2);

c.add(student3);

c.add(student4);

System.out.println(c);

// 遍历集合,判断分数 .

//a.获取迭代器

Iterator<Student> it = c.iterator();

//b. 使用迭代器遍历

while (it.hasNext()) {

Student stu = it.next();

System.out.println(stu);

//获取分数

int score = stu.getScore();

//判断分数

if(score <60){

// 移除学生

//c.remove(stu);

it.remove(); // 移除当前迭代的元素. (迭代器移除方法可以避免并发修改异常)

}

}

// 再遍历集合

Iterator<Student> iterator = c.iterator();

while (iterator.hasNext()) {

Student student = iterator.next();

System.out.println(student.getName() +" --- "+ student.getScore());

}

}

}

2.3.9 并发修改异常

迭代的常规用法中我们要尽量避免在迭代过程中为集合添加/删除数据。否则会报错,原因是Java抛出了并发修改异常。

迭代过程中并发修改异常的原因为迭代器中”记忆”的集合长度与集合中实际长度不同,而导致出现索引与实际元素不符甚至无限循环的情况发生。

所以在使用Iterator时,避免类似操作,for循环底层为迭代器实现,所以也需要避免类似操作。

有些迭代器避免了这样的问题,如ListIterator,但该类并不通用也不常用,实际开发中很少使用,只需要简单了解。

java中提供了很多个集合,它们在存储元素时,采用的存储方式不同。我们要取出这些集合中的元素,可通过一种通用的获取方式来完成。

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

/*

* 并发修改异常:当你 遍历集合并操作集合,添加或者移除元素的使用,可能会报出并发修改异常.

* 处理方式:添加,移除 ,使用迭代器的方法. 迭代器中的remove.

* 查看异常信息: 第一行是 异常的说明 _空指针 ,角标越界, 并发.....

* 详细异常信息, 从下往上看, 能看懂哪行就是你发生异常的地方,基本上就是你写错代码.

* Iterator.next()继续迭代的时候报错, 那么我们提供一种解决方案, 可以修改,但是不再遍历集合.

*

* 解决方案:

* 1.采用 Iterator中的方法 去操作集合 -- 推荐 !

* 2.使用非Iterator中的方法操作, 那么再操作之后 ,加 break;

*

*/

public class Demo {

public static void main(String[] args) {

Collection<String> c = new ArrayList<>();

c.add("aaa");

c.add("bbb");

c.add("ccc");

c.add("ddd");

System.out.println(c);

Iterator<String> iterator = c.iterator();

while (iterator.hasNext()) {

String string = iterator.next();

// 如果存在bbb ,那么添加一个EEE

if (string.equals("bbb")) {

c.add("bbb");

break;

}

}

System.out.println(c); //java.util.ConcurrentModificationException 并发修改异常

List l = new ArrayList<>();

ListIterator listIterator = l.listIterator();

}

}

2.3.10 三种遍历集合方式对比:

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

/*

* 1.集合变成数组 .遍历数组

* 2.迭代器 -- 必须掌握

* 3.增强for -- 必须掌握

*/

public class Demo2 {

public static void main(String[] args) {

Collection<Object> c = new ArrayList<>();

c.add(111);

c.add(222);

c.add(333);

//1.变成数组

Object[] array = c.toArray();

for (int i = 0; i < array.length; i++) {

System.out.println(array[i]);

}

System.out.println("============");

//2.迭代器

Iterator<Object> iterator = c.iterator();

while (iterator.hasNext()) {

Object next = iterator.next();

System.out.println(next);

}

System.out.println("============");

//3.增强for

for (Object object : array) {

System.out.println(object);

}

}

}

第3章 集合综合案例---斗地主洗牌发牌

3.1 案例介绍与演示

按照斗地主的规则,完成洗牌发牌的动作。

具体规则:

使用54张牌打乱顺序

三个玩家参与游戏,三人交替摸牌,每人17张牌,最后三张留作底牌。

3.2 案例分析

准备牌:

牌可以设计为一个ArrayList<String>,每个字符串为一张牌。

每张牌由花色数字两部分组成,我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。

牌由Collections类的shuffle方法进行随机排序。

发牌:

将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌,剩余牌通过对3取模依次发牌。

看牌:

直接打印每个集合

//牌类

public class Card {

String huaSe;// 花色 黑桃 ,红桃 ,梅花, 方块 大 小

String dianShu; // 2 A K Q J 10 .... 3 王

// 有参构造 .

public Card(String huaSe, String dianShu) {

super();

this.huaSe = huaSe;

this.dianShu = dianShu;

}

// 黑桃A

@Override

public String toString() {

return huaSe + dianShu;

}

}

//发牌机

import java.util.ArrayList;

/*

* 发牌机类 . cardList 发牌机中的保存牌的集合.

*

* 创建发牌机 ,就同时初始化牌了.

*

*/

public class FaPaiJi {

ArrayList<Card > cardList = new ArrayList<>();// 显性初始化

// 无参构造

public FaPaiJi() {

super();

//初始化牌的操作

init();

}

/*

* 初始化牌的方法 , 创建牌对象 ,保存到cardList 中

*/

private void init() {

//添加 王牌

cardList.add(new Card("大","王"));

cardList.add(new Card("小","王"));

// 添加 52张牌 .

//循环创建牌的对象.

String[] dianShuArr = {"2","A","K","Q","J" ,"10","9","8","7","6","5","4","3"};

String[] huaSeArr = {"黑桃","红桃","梅花","方块"};

for (int i = 0; i < huaSeArr.length; i++) {

String huaSe = huaSeArr[i]; //获取花色

for (int j = 0; j < dianShuArr.length; j++) {

String dianShu = dianShuArr[j]; // 点数

cardList.add(new Card(huaSe, dianShu)); // 添加到集中

}

}

}

public ArrayList<Card> getCardList() {

return cardList;

}

public void setCardList(ArrayList<Card> cardList) {

this.cardList = cardList;

}

}

//斗地主

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

/*有牌, 洗牌 ,发牌.

* * 定义牌 类 Card

* 属性:String 花色

* String 点数

* 方法: toString

*

* 定义发牌机类: 保存54张.

* 属性:ArrayList<Card> , 创建发牌机对象, 集合就装满了54张牌.

* 方法 getCards ,获取的就是 54张牌的集合.

*

*

* 洗牌 Collections.shuffle

*

* 发牌: 大集合中牌,存到小集合(玩家)中去.

* 创建玩家的集合.

* 发牌方法: 大集合中移除元素, 添加到新的小集合中.

* 参数: 大集合, 小集合

* 返回值类型 : void

*

*/

public class DDZTest {

public static void main(String[] args) {

FaPaiJi faPaiJi = new FaPaiJi();

ArrayList<Card> cardList = faPaiJi.getCardList();

System.out.println(cardList);

// 洗牌

Collections.shuffle(cardList);

System.out.println(cardList);

//创建 玩家集合对象

ArrayList<Card> player1 = new ArrayList<>();

ArrayList<Card> player2 = new ArrayList<>();

ArrayList<Card> player3 = new ArrayList<>();

//System.out.println("玩家1 " + player1);

// 发牌方法

faPai(cardList , player1);

faPai(cardList , player2);

faPai(cardList , player3);

System.out.println("玩家1 " + player1);

System.out.println("玩家2 " + player2);

System.out.println("玩家3 " + player3);

System.out.println("底牌 " + cardList);

System.out.println(cardList.size());

}

/*

* 发牌方法: 大集合中移除元素, 添加到新的小集合中.

* 参数: 大集合, 小集合

* 返回值类型 : void

*/

private static void faPai(ArrayList<Card> cardList, ArrayList<Card> player1) {

//从大集合中获取元素,并移除 .

// 1.获取大集合迭代器

Iterator<Card> iterator = cardList.iterator();

// 2. 获取17牌

for (int i = 0; i < 17 ; i++) {

Card card = iterator.next();

//3.添加到小集合

player1.add(card);

iterator.remove();

}

}

}

utf-8改进

public class Card {

String huaSe;// 花色 黑桃 ,红桃 ,梅花, 方块 大 小

String dianShu; // 2 A K Q J 10 .... 3 王

// 有参构造 .

public Card(String huaSe, String dianShu) {

super();

this.huaSe = huaSe;

this.dianShu = dianShu;

}

// 黑桃A

@Override

public String toString() {

return huaSe + dianShu;

}

}

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import cn.javahelp_DDZ.Card;

/*����, ϴ�� ,����.

* * ������ �� Card

* ����:String ��ɫ

* String ����

* ����: toString

*

*

* ���巢�ƻ���: ����54��.

* ����:ArrayList<Card> , �������ƻ����, ���Ͼ�װ����54����.

* ���� getCards ,��ȡ�ľ��� 54���Ƶļ���.

*

*

* ϴ�� Collections.shuffle

*

* ����: �������,�浽С����(���)��ȥ.

* ������ҵļ���.

* ���Ʒ���: ������Ƴ�Ԫ��, ��ӵ��µ�С������.

* ����: ���, ����

* ����ֵ���� : void

*

* 修改编码之后,原文件中 汉字会乱码

*/

public class DDZTest {

public static void main(String[] args) {

FaPaiJi faPaiJi = new FaPaiJi();

ArrayList<Card> cardList = faPaiJi.getCardList();

System.out.println(cardList);

// ϴ��

Collections.shuffle(cardList);

System.out.println(cardList);

//���� ��Ҽ��϶���

ArrayList<Card> player1 = new ArrayList<>();

ArrayList<Card> player2 = new ArrayList<>();

ArrayList<Card> player3 = new ArrayList<>();

//System.out.println("���1 " + player1);

// ���Ʒ���

faPai(cardList , player1);

faPai(cardList , player2);

faPai(cardList , player3);

System.out.println("玩家1 " + player1);

System.out.println("玩家2 " + player2);

System.out.println("玩家3 " + player3);

System.out.println("底牌:" + cardList);

System.out.println(cardList.size());

}

/*

* ���Ʒ���: ������Ƴ�Ԫ��, ��ӵ��µ�С������.

* ����: ���, ����

* ����ֵ���� : void

*/

private static void faPai(ArrayList<Card> cardList, ArrayList<Card> player1) {

//�Ӵ���л�ȡԪ��,���Ƴ� .

// 1.��ȡ��ϵ����

Iterator<Card> iterator = cardList.iterator();

// 2. ��ȡ17��

for (int i = 0; i < 17 ; i++) {

Card card = iterator.next();

//3.��ӵ�С����

player1.add(card);

iterator.remove();

}

}

}

import java.util.ArrayList;

import cn.javahelp_DDZ.Card;

public class FaPaiJi {

ArrayList<Card > cardList = new ArrayList<>();// 显性初始化

// 无参构造

public FaPaiJi() {

super();

//初始化牌的操作

init();

}

/*

* 初始化牌的方法 , 创建牌对象 ,保存到cardList 中

*/

private void init() {

//添加 王牌

cardList.add(new Card("大","☺"));

cardList.add(new Card("小","王"));

// 添加 52张牌 .

//循环创建牌的对象.

String[] dianShuArr = {"2","A","K","Q","J" ,"10","9","8","7","6","5","4","3"};

String[] huaSeArr = {"♠","♥","♣","♦"};

for (int i = 0; i < huaSeArr.length; i++) {

String huaSe = huaSeArr[i]; //获取花色

for (int j = 0; j < dianShuArr.length; j++) {

String dianShu = dianShuArr[j]; // 点数

cardList.add(new Card(huaSe, dianShu)); // 添加到集中

}

}

}

public ArrayList<Card> getCardList() {

return cardList;

}

public void setCardList(ArrayList<Card> cardList) {

this.cardList = cardList;

}

}

第4章 本日自习作业:

4.1 知识点相关题

1:使用集合存储String或者int,并分别使用增强for循环与迭代器方式访问元素

2:完成斗地主课上案例

3:是否可以在发牌时,不使用带索引的遍历方式,转而使用增强for循环或迭代器

4:完成以下需求:

公司有多名员工,具有普涨工资的方法:查找到多名员工的工资,如果没有120000以上的月薪,则所有员工的工资普涨2000。

要求具有:公司类、员工类,员工该类集合与公司类为组合关系(员工是公司的成员变量)

5:Collection是接口还是类,ArrayList与Collection、AbstractCollection、Iterable、iterator()、List都是什么关系。

6:分别描述Iterable、Collection、List、Iterator四个接口的功能方法都有哪些

7:简单描述目前掌握的集合体系

8:预习Set集合(明日难点:Set集合如何判断元素唯一性,明日重点:认识更多的集合工具)

9:辨析集合与数组的异同点

4.2 代码题

4.2.1 模拟 饭店结账程序. 定义菜品类,属性为名称,价格,数量. 集合中添加若干菜品对象. 遍历集合,打印出集合中所有菜品名称和消费总金额.

答案:

public class Test1 {

public static void main(String[] args) {

ArrayList<Cai> al = new ArrayList<>();

Cai cai = new Cai("烤羊腿", 58, 4);

Cai cai2 = new Cai("皮蛋豆腐", 8, 1);

Cai cai3 = new Cai("烤板筋", 2, 10);

Cai cai4 = new Cai("可乐", 8, 1);

al.add(cai);

al.add(cai2);

al.add(cai3);

al.add(cai4);

System.out.println(al);

double total   =  0 ;

// 遍历 集合

for (Cai c  : al) {

// 打印

String name = c.getName();

int num = c.getNum();

System.out.println("菜名 :" + name+" -- " + num +"份");

// 计算 总价

//获取 每一个 菜的单价 .   单价 * 份数  

total += c.getPrice()*num;

}

System.out.println("总价:" +  total);

}

}

class Cai {

private String name;

private double price;

private int num = 1; // 数量,默认一份.

public Cai(String name, double price, int num) {

super();

this.name = name;

this.price = price;

this.num = num;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

public int getNum() {

return num;

}

public void setNum(int num) {

this.num = num;

}

@Override

public String toString() {

return "菜品 [名称=" + name + ", 单价=" + price + ", 数量=" + num + "]";

}

}

4.2.2 编写一个程序的模拟班级学生的成绩库, 包含多项成绩,英语,数学,Java.

实现如下功能:

1.可以修改某个学生的某项分数.

2.可以打印全班同学成绩

要求使用集合来完成.

public class Test2 {

public static void main(String[] args) {

ArrayList<Student> student_list = new ArrayList<>();

student_list.add(new Student("张三", 99, 90, 100));

student_list.add(new Student("李四", 89, 80, 100));

for (Student student : student_list) {

System.out.println(student);

}

Scanner scanner = new Scanner(System.in);

// 请输入学生姓名

System.out.println("请输入学生姓名 ");

String name = scanner.nextLine();

for (Student student : student_list) {

String n = student.getName();

if (n.equals(name)) {

// 可以继续录入, 修改

System.out.println("请输入科目 ");

String kemu = scanner.nextLine();

System.out.println("请输入分数 ");

double score = scanner.nextDouble();

// 根据不同的科目,修改不同的分数.

switch (kemu) {

case "数学":

student.setMath(score);

break;

case "英语":

student.setEnglish(score);

break;

case "java":

student.setJava(score);

break;

default:

System.out.println("查无此课, 对不起");

return ;

}

System.out.println("恭喜您, 修改成功");

System.out.println(student);

return;

}

}

System.out.println("对不起 ,查无此人");

}

}

class Student {

private double english;

private double math;

private double java;

private String name;

public Student() {

super();

}

public Student(String name, double english, double math, double java) {

super();

this.english = english;

this.math = math;

this.java = java;

this.name = name;

}

public double getEnglish() {

return english;

}

public void setEnglish(double english) {

this.english = english;

}

public double getMath() {

return math;

}

public void setMath(double math) {

this.math = math;

}

public double getJava() {

return java;

}

public void setJava(double java) {

this.java = java;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return "Student [english=" + english + ", math=" + math + ", java=" + java + ", name=" + name + "]";

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

long temp;

temp = Double.doubleToLongBits(english);

result = prime * result + (int) (temp ^ (temp >>> 32));

temp = Double.doubleToLongBits(java);

result = prime * result + (int) (temp ^ (temp >>> 32));

temp = Double.doubleToLongBits(math);

result = prime * result + (int) (temp ^ (temp >>> 32));

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Student other = (Student) obj;

if (Double.doubleToLongBits(english) != Double.doubleToLongBits(other.english))

return false;

if (Double.doubleToLongBits(java) != Double.doubleToLongBits(other.java))

return false;

if (Double.doubleToLongBits(math) != Double.doubleToLongBits(other.math))

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

}

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2018-06-01

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Java帮帮-微信公众号-技术文章全总结

第七天 自定义数据类型ArrayList集合【悟空教程】

1915
来自专栏java一日一条

JAVA集合类汇总

数组(可以存储基本数据类型)是用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知的情况下使用。 集合(只能存储对象,对象类型可以不一样)的长度可变...

1683
来自专栏猿人谷

判断单链表是否存在环

周末参加完美世界校园招聘中就有一道判断单链表是否有环的编程题。 写一个C/C++函数,来判断一个单链表是否具有环,如果存在环,则给出环的入口点。 有一个单链表,...

2049
来自专栏曾大稳的博客

c++基础语法

注意:在开发过程中,cpp或者c会被编译为dll或者so供其调用者使用,一般把public的函数定义到h文件,不然调用者都不知道有哪些函数。

1093
来自专栏Python

python2/3中 将base64数据写成图片,并将图片数据转为16进制数据的方法、bytes/string的区别

python 3中最重要的新特性可能就是将文本(text)和二进制数据做了更清晰的区分。文本总是用unicode进行编码,以str类型表示;而二进制数据以byt...

4392
来自专栏陈树义

4.Java集合总结系列:Map接口及其实现

一、Map接口 ? Map集合的特点是:通过key值找到对应的value值,key值是唯一的,value可以重复。Map中的元素是无序的,但是也有实现了排序的M...

2884
来自专栏计算机视觉与深度学习基础

java在acm中大数运算教程

import java.io.*; import java.util.*; public class Main { public static void ...

2149
来自专栏闻道于事

Java 集合补充

集合和数组不一样,数组元素可以是基本类型的值,也可以是对象(的引用变量),集合里只能保存对象(的引用变量)。

1265
来自专栏老马说编程

(30) 剖析StringBuilder / 计算机程序的思维逻辑

上节介绍了String,提到如果字符串修改操作比较频繁,应该采用StringBuilder和StringBuffer类,这两个类的方法基本是完全一样的,它们的实...

2056
来自专栏赵俊的Java专栏

最小子数组

2673

扫码关注云+社区

领取腾讯云代金券