一、为什么需要集合
如果要将100个学生成绩存放到程序中，怎么做？
首先想到是数组
int[] scores=new int[100];
然而，长度是固定的，比如是101个学生成绩，这个数组就不能用了，越界。
另外如果只使用了10个，则另外90个都被浪费了。
总之：集合是数组的升级，长度是动态的，无需预定义
package com.zhangguo.chapter8.d1;
import java.util.ArrayList;
import java.util.List;
public class C1 {
public static void main(String[] args) {
//数组
int[] scores=new int[100];
//scores[200]=99;
//泛型集合
List<Integer> marks1=new ArrayList<Integer>();
marks1.add(98);
marks1.add(89);
marks1.add(59);
System.out.println(marks1.get(2)+1);
//....
//非泛型类型
List marks2=new ArrayList();
marks2.add(98);
marks2.add(9.8);
marks2.add("九十九");
//非泛型有安全隐患
System.out.println(Integer.parseInt(marks2.get(2)+"")+1);
}
}
使用Array（数组）存储对象方面具有一些弊端，需要提前对数组进行容量大小的设定，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中，不要提前设置容量大小，存多少个就是多少个，无需提前定义。
数组是很常用的一种的数据结构，我们用它可以满足很多的功能，但是，有时我们会遇到如下这样的问题：
1、我们需要该容器的长度是不确定的。
2、我们需要它能自动排序。
3、我们需要存储以键值对方式存在的数据。
Java是一种面向对象语言，如果我们要针对多个对象进行操作，就必须对多个对象进行存储。而数组长度固定，不能满足变化的要求。所以，java提供了集合。
特点
1. 长度可以发生改变
2. 只能存储对象
3. 可以存储多种类型对象
二、Java常用集合类型
Collection 接口存储一组不唯一，无序的对象
List 接口存储一组不唯一，有序（插入顺序）的对象，类似数组
Set 接口存储一组唯一，无序的对象
Map接口存储一组键值对象，提供key到value的映射，Key不允许重复
List 允许重复，有序
set 不允许重复，无序
map value可重复，key不可重复，无序
三、List与ArrayList
3.0、Collection常用方法
3.0.1、添加功能
boolean add(Object obj):向集合中添加一个元素
boolean addAll(Collection c)：向集合中添加一个集合的元素
3.0.2、删除功能
void clear()：删除集合中的所有元素
boolean remove(Object obj)：从集合中删除指定的元素
boolean removeAll(Collection c):从集合中删除一个指定的集合元素
3.0.3、判断功能
boolean isEmpty()：判断集合是否为空。
boolean contains(Object obj)：判断集合中是否存在指定的元素。
boolean containsAll(Collection c)：判断集合中是否存在指定的一个集合中的元素。
3.0.4、遍历功能
Iterator iterator():就是用来获取集合中每一个元素。
3.0.5、长度功能
int size():获取集合中的元素个数
3.0.6、交集功能
boolean retainAll(Collection c):判断两个集合中是否有相同的元素
3.0.7、把集合转换成数组
Object[] toArray():把集合变成数组。
3.1、List接口
List接口为Collection直接接口。List所代表的是有序的Collection，即它用某种特定的插入顺序来维护元素顺序。用户可以对列表中每个元素的插入位置进行精确地控制，同时可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。实现List接口的集合主要有：ArrayList、LinkedList、Vector、Stack。
add方法用于添加一个元素到当前列表的末尾，也可以通过其重载形式指定添加的位置；
addAll方法用于添加一个集合到当前列表的末尾，主要用于批量添加；
remove方法用于删除列表中的一个元素，可以将需要删除的元素作为参数进行指定，也可以指定需要删除元素的下标；
removeAll方法用于一次删除多个元素，参数为集合，集合中包含需要删除的元素；
get 方法用于通过下标获取对应下标的元素；
set 方法用于修改对应下标的元素；
size 方法用于获得集合的长度；
另外，还有几个类似的方法：
clear 方法用于清除现有所有的元素；
contains 方法用来查找某个对象在不在列表之中；
3.2、ArrayList
ArrayList是一个动态数组，也是我们最常用的集合。它允许任何符合规则的元素插入甚至包括null。每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。随着容器中的元素不断增加，容器的大小也会随着增加。在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作。所以如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。
size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间运行，也就是说，添加 n 个元素需要 O(n) 时间（由于要考虑到扩容，所以这不只是添加元素会带来分摊固定时间开销那样简单）。
ArrayList擅长于随机访问，ArrayList是非同步的。
示例：
package com.zhangguo.chapter8.d1;
import java.util.*;
public class ListDemo1 {
public static void main(String[] args) {
//定义list1集合，指定存放的数据类型，只能是引用类型
List<Integer> list1=new ArrayList();
//添加单个元素
Integer n=88;
list1.add(98);
list1.add(99);
list1.add(60);
list1.add(n);
//获得单个元素
int e1=list1.get(0); //98
System.out.println("list1的第2个元素值为："+list1.get(1));
//获得集合长度
System.out.println("长度为："+list1.size());
//遍历1
for (Integer item : list1) {
System.out.println("遍历："+item);
}
//遍历2
for (int i = 0; i < list1.size(); i++) {
System.out.println(i+"="+list1.get(i));
}
//移除
//将下标为0的元素移除，当前面的元素移除时后面补上
list1.remove(0);
System.out.println("list1的第1个元素值为："+list1.get(0));
//指定要移除的对象，把集合中的60移除
list1.remove(n);
//移除所有
list1.clear();
//获得集合长度
System.out.println("长度为："+list1.size());
}
}
结果：
3.2.1、List基本操作
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("Tom");
arrayList.add("Jerry");
arrayList.add("Micky");
// 使用Iterator遍历元素
Iterator<String> it = arrayList.iterator();
while (it.hasNext()) {
String str = it.next();
System.out.println(str);
}
// 在指定位置插入元素
arrayList.add(2, "Kate");
// 通过索引直接访问元素
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
List<String> subList = new ArrayList<String>();
subList.add("Mike");
// addAll(Collection<? extends String> c)添加所给集合中的所有元素
arrayList.addAll(subList);
// 判断是否包含某个元素
if (arrayList.contains("Mike")) {
System.out.println("Mike is include in the list");
}
LinkedList<String> linkedList = new LinkedList<String>();
linkedList.addAll(arrayList);
// 获取指定元素
System.out.println(linkedList.get(4));
// 获取第一个元素
System.out.println(linkedList.getFirst());
// 获取最后一个元素
System.out.println(linkedList.getLast());
// 获取并删除第一个元素
System.out.println(linkedList.pollFirst());
// 获取，但不移除第一个元素
System.out.println(linkedList.peekFirst());
3.2.2、LIST操作二
package com.zhangguo.chapter8139.d1;
import java.util.*;
public class Collection01 {
public static void main(String[] args) {
//定义一个集合，只能存Integer
List<Integer> marks=new ArrayList<Integer>();
Integer k=75;
//添加
marks.add(10); //0
marks.add(90); //1
marks.add(37);
marks.add(k);
marks.add(58);
marks.add(77);
//取值
System.out.println(marks.get(1));
//长度
System.out.println("个数："+marks.size());
//遍历
System.out.println("遍历：");
for (Integer n : marks) {
System.out.println(n);
}
//根据索引删除
marks.remove(3);
//根据对象删除
marks.remove(k);
Integer d=null;
for (Integer j : marks) {
if(j==90){
d=j;
break;
}
}
marks.remove(d);
//修改
marks.set(0, 9); //将下标0对应的值修改为9
//循环
System.out.println("循环：");
for (int i = 0; i < marks.size(); i++) {
System.out.println(marks.get(i));
}
//删除所有
marks.clear();
System.out.println("个数："+marks.size());
}
}
结果：
90
个数：6
遍历：
10
90
37
75
58
77
循环：
9
37
58
77
个数：0
四、Map与HashMap
Map与List、Set接口不同，它是由一系列键值对组成的集合，提供了key到Value的映射。同时它也没有继承Collection。在Map中它保证了key与value之间的一一对应关系。也就是说一个key对应一个value，所以它不能存在相同的key值，当然value值可以相同。实现map的有：HashMap、TreeMap、HashTable、Properties、EnumMap。字典（Dictionary）
4.1、HashMap
以哈希表数据结构实现，查找对象时通过哈希函数计算其位置，它是为快速查询而设计的，其内部定义了一个hash表数组（Entry[] table），元素会通过哈希转换函数将元素的哈希地址转换成数组中存放的索引，如果有冲突，则使用散列链表的形式将所有相同哈希地址的元素串起来，可能通过查看HashMap.Entry的源码它是一个单链表结构。
key：键，唯一，钥匙，关键的
4.1.1、Map基本操作
HashMap<String, Integer> map = new HashMap<String, Integer>();
// 向Map中添加元素
map.put("Tom", 26);
map.put("Jack", 18);
map.put("Micky", 17);
map.put("Kate", 15);
// 根据Key获取Value
System.out.println("Jack is " + map.get("Jack") + " years old");
// 移除
map.remove("Micky");
// 遍历Map
for (Entry<String, Integer> entry : map.entrySet()) {
System.out.println("name:" + entry.getKey() + " age:"
+ entry.getValue());
}
// Key相同的元素将被覆盖
map.put("Jack", 19);
// 根据Key获取Value
System.out.println("Jack is " + map.get("Jack") + " years old");
// 判断是否包含某个Key
if (map.containsKey("Tom")) {
System.out.println(map.get("Tom"));
}
// 判断是否包含某个Value
if (map.containsValue(26)) {
System.out.println("The map include the value 26");
}
// 判断map是否为空
if (!map.isEmpty()) {
// 获取map大小
System.out.println("The map‘s size=" + map.size());
}
// 获取Key的集合
for (String str : map.keySet()) {
System.out.println(str);
}
TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
treeMap.putAll(map);
// 输出内容按照key值排序
for (Entry<String, Integer> entry : treeMap.entrySet()) {
System.out.println("name:" + entry.getKey() + " age:"
+ entry.getValue());
// name:Jack age:19
// name:Kate age:15
// name:Tom age:26
}
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
// 向Map中添加元素
linkedHashMap.put("Tom", 26);
linkedHashMap.put("Jack", 18);
linkedHashMap.put("Micky", 17);
linkedHashMap.put("Kate", 15);
// 保持了插入的顺序
for (Entry<String, Integer> entry : linkedHashMap.entrySet()) {
System.out.println("name:" + entry.getKey() + " age:"
+ entry.getValue());
// name:Tom age:26
// name:Jack age:18
// name:Micky age:17
// name:Kate age:15
}
//包
package com.zhangguo.chapter8.d2;
import java.util.HashMap;
import java.util.Map;
//类
public class StudentClient {
//方法 主方法 静态 数组
public static void main(String[] args) {
Stu s1=new Stu("201701","张学友","男");
Stu s2=new Stu("201702","张汇美","女");
Stu s3=new Stu("201703","张卫健","男");
//创建一个Map集合 <>泛型 集合中只能存放学生对象
//键是字符类型，值是Stu类型
Map<String,Stu> students=new HashMap();
//添加对象
students.put(s1.no,s1);
students.put(s2.no,s2);
students.put("201703",s3);
//取集合中key对应的元素
students.get("201703").show();
//遍历key
for (String key : students.keySet()) {
System.out.println("key："+key);
}
//移除
students.remove("201702");
//遍历Value
for (Stu s : students.values()) {
s.show();
}
//移除所有
students.clear();
System.out.println("总个数："+students.size());
}
}
/**学生*/
class Stu
{
//构造方法
public Stu(String no,String name,String sex) {
this.no=no;
this.name=name;
this.sex=sex;
}
//属性
public String no; //学号
public String name; //姓名
public String sex; //性别
//方法
public void show(){
System.out.println("学号："+no+" 姓名："+name+" 性别："+sex);
}
}
4.1.2、Map操作二
Student类
package com.zhangguo.chapter8139.d1;
/**学生类**/
public class Student {
//构造方法
public Student(String _no,String _name,String _sex,int _score) {
this.no=_no;
this.name=_name;
this.sex=_sex;
this.score=_score;
}
public Student() {
}
public String no;//学号
public String name; //姓名
public String sex; //性别
public int score; //成绩
@Override
public String toString() {
return "学号："+no+"\\t姓名："+name+"\\t性别："+sex+"\\t成绩："+score;
}
}
Map操作类
package com.zhangguo.chapter8139.d1;
import java.util.HashMap;
import java.util.Map;
public class Collection02 {
public static void main(String[] args) {
Student tom = new Student("201701", "张学友", "男", 98);
//System.out.println(tom);
Student rose = new Student("201702", "张汇美", "女", 69);
//System.out.println(rose);
//定义一个map，字典，key->String,value->Student
Map<String,Student> stus=new HashMap<>();
//添加
stus.put(tom.no, tom);
stus.put("201702", rose);
stus.put("201703", new Student("201703","张国立","男",78));
stus.put("201704", new Student("201704","张娜啦","女",60));
stus.put("201709", new Student("201709","张铁林","男",35));
//取值，引用类型传地址
System.out.println(stus.get("201702"));
Student jack=stus.get("201709");
jack.score=36;
//长度
System.out.println("个数："+stus.size());
//遍历,所有key
System.err.println("\\n所有key：");
for (String key : stus.keySet()) {
System.out.println(key+"："+stus.get(key));
}
//是否存在某个对象
System.out.println("是否存在key201702："+stus.containsKey("201702"));
//删除
//根据key
stus.remove("201702");
//修改
stus.put("201709", new Student("201709","张林铁","女",37));
//遍历,所有value
System.err.println("\\n所有value：");
for (Student v : stus.values()) {
System.out.println(v);
}
//删除所有
stus.clear();
//长度
System.out.println("个数："+stus.size());
}
}
运行结果：
学号：201702 姓名：张汇美 性别：女 成绩：69
所有key：
个数：5
201709：学号：201709 姓名：张铁林 性别：男 成绩：36
201704：学号：201704 姓名：张娜啦 性别：女 成绩：60
201703：学号：201703 姓名：张国立 性别：男 成绩：78
201702：学号：201702 姓名：张汇美 性别：女 成绩：69
201701：学号：201701 姓名：张学友 性别：男 成绩：98
是否存在key201702：true
所有value：
学号：201709 姓名：张林铁 性别：女 成绩：37
学号：201704 姓名：张娜啦 性别：女 成绩：60
学号：201703 姓名：张国立 性别：男 成绩：78
学号：201701 姓名：张学友 性别：男 成绩：98
个数：0
4.2、TreeMap
键以某种排序规则排序，内部以red-black（红-黑）树数据结构实现，实现了SortedMap接口
4.3、HashTable
也是以哈希表数据结构实现的，解决冲突时与HashMap也一样也是采用了散列链表的形式，不过性能比HashMap要低
五、Set与HashSet
Set是一种不包括重复元素的Collection。它维持它自己的内部排序，所以随机访问没有任何意义。与List一样，它同样运行null的存在但是仅有一个。由于Set接口的特殊性，所有传入Set集合中的元素都必须不同，同时要注意任何可变对象，如果在对集合中元素进行操作时，导致e1.equals(e2)==true，则必定会产生某些问题。实现了Set接口的集合有：EnumSet、HashSet、TreeSet。
3.1、EnumSet
是枚举的专用Set。所有的元素都是枚举类型。
3.2、HashSet
HashSet堪称查询速度最快的集合，因为其内部是以HashCode来实现的。它内部元素的顺序是由哈希码来决定的，所以它不保证set 的迭代顺序；特别是它不保证该顺序恒久不变。
3.2.1、Set基础操作
List<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(4);
HashSet<Integer> hashSet = new HashSet<Integer>();
hashSet.add(1);
hashSet.add(3);
hashSet.add(2);
hashSet.add(6);
// 重复元素将不能被添加
hashSet.add(3);
// 只要有元素被添加就返回true
if (hashSet.addAll(list)) {
System.out.println("Add success");
}
// 判断是否存在某个集合
if (hashSet.containsAll(list)) {
System.out.println("The hashSet is contain 3 and 4");
}
Iterator<Integer> it = hashSet.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");
// 1 2 3 4 6
// 看结果是被排序了，HashSet按照Hash函数排序，Integer值的HashCode就是其int值
}
// 换转成数组
Object[] integers = hashSet.toArray();
for (int i = 0; i < integers.length; i++) {
System.out.print((Integer) integers[i]);
}
//移除元素
hashSet.remove(3);
TreeSet<String> treeSet = new TreeSet<String>();
treeSet.add("C");
treeSet.add("A");
treeSet.add("D");
treeSet.add("B");
for (Iterator<String> strIt = treeSet.iterator(); strIt.hasNext();) {
System.out.print(strIt.next());
// ABCD 按照字母顺序
}
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
linkedHashSet.add("C");
linkedHashSet.add("A");
linkedHashSet.add("D");
linkedHashSet.add("B");
for (Iterator<String> linkedIt = linkedHashSet.iterator(); linkedIt
.hasNext();) {
System.out.print(linkedIt.next());
// CADB 按照插入顺序
}
3.3、TreeSet
基于TreeMap，生成一个总是处于排序状态的set，内部以TreeMap来实现。它是使用元素的自然顺序对元素进行排序，或者根据创建Set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
六、总结
七、DVD租赁系统
7.1、功能需求
a)、添加dvd
b)、查看所有dvd
c)、删除dvd，使用编号或名称
d)、借出dvd，使用编号或名称
e)、归还dvd
f)、退出
7.2、技术指导
退出：
public class Test {
public static void main(String[] args) {
System.out.println("Hello");
System.exit(0);
System.out.println("World");
}
}
Hello
定义DVD类：
package miniDVD;
/**DVD类*/
public class DVD {
public DVD() {
}
public DVD(String name, double price, boolean isRent) {
this.name = name;
this.price = price;
this.isRent = isRent;
}
public DVD(String name, double price) {
this.name = name;
this.price = price;
}
/**名称*/
private String name;
/**价格*/
private double price;
/**是否被借出*/
private boolean isRent;
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 boolean isRent() {
return isRent;
}
public void setRent(boolean isRent) {
this.isRent = isRent;
}
@Override
public String toString() {
return this.getName()+" ￥："+this.getPrice()+" "+this.isRent();
}
}
定义DVD管理类：
package miniDVD;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**DVD管理类*/
public class DVDMgr {
//输入器
private Scanner input=new Scanner(System.in);
//dvd集合
private List<DVD> dvds=new ArrayList();
/**初始化*/
public void init(){
dvds.clear();
DVD d1=new DVD("从海底出击",89.5);
DVD d2=new DVD("生死狙击",35.8);
DVD d3=new DVD("偷天换日",9.9);
dvds.add(d1);
dvds.add(d2);
dvds.add(d3);
}
/**开始运行*/
public void start(){
init();
search();
}
/**显示菜单*/
public void menu(){
}
/**查询，列出所有的dvd*/
public void search()
{
for (DVD dvd : dvds) {
$(dvd);
}
}
/**添加*/
public void add()
{
}
/**工具方法，输出*/
public void $(Object str)
{
System.out.println(str);
}
public void $$(Object str)
{
System.out.print(str);
}
//....
}
测试类：
package miniDVD;
public class Client {
public static void main(String[] args) {
DVDMgr dm=new DVDMgr();
dm.start();
}
}
运行结果：
7.3、第二次指导
View Code
DVD类：
package com.zhangguo.chapter8.d3;
/**光碟*/
public class DVD {
/**构造*/
public DVD(String name, double price, boolean isRent) {
this.name = name;
this.price = price;
this.isRent = isRent;
}
/**名称*/
public String name;
/**价格*/
public double price;
/**是否被借出*/
public boolean isRent;
@Override
public String toString() {
return name+"\\t\\t"+price+"\\t\\t"+(isRent?"已借出":"未借出");
}
}
DVD测试类：
package com.zhangguo.chapter8.d3;
public class DVDClient {
public static void main(String[] args) {
/**商店对象*/
DVDStore store=new DVDStore();
store.menu();
}
}
DVDStore商店类：
package com.zhangguo.chapter8.d3;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
/**DVD出租商店*/
public class DVDStore {
/**构造*/
public DVDStore() {
init();
}
/**所有的DVD集合*/
public Map<String, DVD> dvds=new HashMap();
/**输入器*/
Scanner input=new Scanner(System.in);
/**初始化*/
public void init(){
DVD d1=new DVD("兵临城下", 99.7, false);
DVD d2=new DVD("生死狙击", 19.1, false);
DVD d3=new DVD("生化危机", 23.5, false);
DVD d4=new DVD("极限特工", 87.1, false);
dvds.put(d1.name, d1);
dvds.put(d2.name, d2);
dvds.put(d3.name, d3);
dvds.put(d4.name, d4);
dvds.put("饥饿游戏",new DVD("饥饿游戏",67.8, true));
}
/**菜单*/
public void menu(){
$("\\n");
$("********************★☆★☆★☆DVD商店欢迎您★☆★☆★☆********************");
$("1、显示所有DVD");
$("2、借出DVD");
$("3、归还DVD");
$("4、添加新DVD");
$("5、删除DVD");
$("6、退出");
$("7、回主菜单");
$("********************★☆★☆★☆DVD商店欢迎您★☆★☆★☆********************");
int item=0;
$$("请输入[1-7]选择功能：");
item=input.nextInt();
/*
do {
$$("请输入[1-7]选择功能：");
item=input.nextInt();
} while (item<1||item>7); //如果小于1大于7则继续输入
*/
switch (item) {
case 1:
list();
menu();
break;
case 2:
break;
case 3:
break;
case 4:
add();
menu();
break;
case 5:
remove();
list();
menu();
break;
case 6:
$("欢迎您下次光临，再见！");
System.exit(0);
break;
case 7:
menu();
break;
default:
$("输入错误，请重新选择！");
menu();
break;
}
}
/**删除DVD**/
private void remove() {
$("\\n*****开始删除DVD*****");
$$("名称：");
String name=input.next();
//从集合中根据key移除对象
dvds.remove(name);
}
/**添加DVD*/
private void add() {
$("\\n*****开始添加DVD*****");
$$("名称：");
String name=input.next();
$$("价格：");
double price=input.nextDouble();
$$("是否借出[0/1]：");
String isRent=input.next();
//向dvds集合中添加新的DVD
dvds.put(name,new DVD(name,price, isRent.equals("1")));
}
/**遍历所有的DVD*/
public void list(){
$("\\n本店所有DVD列表：");
for (DVD dvd : dvds.values()) {
$(dvd);
$("****************************************");
}
}
/**工具方法**/
//换行
public void $(Object o){
System.out.println(o);
}
//不换行
public void $$(Object o){
System.out.print(o);
}
}
运行结果：
7.4、第三次DVD指导
1、DVD实体 DVD.java
package com.zhangguo.chapter8139.d2;
/**光碟 实体 模型*/
public class DVD {
/**构造方法*/
public DVD(int _id,String _name,double _price,boolean _isRent) {
this.id=_id;
this.name=_name;
this.price=_price;
this.isRent=_isRent;
}
/**编号*/
public int id;
/**名称*/
public String name;
/**价格*/
public double price;
/**是否被借出*/
public boolean isRent;
@Override
public String toString() {
return ("编号："+this.id+"\\t\\t"+"名称："+this.name+"\\t\\t"+"价格："+this.price+"\\t\\t"+"借出："+(this.isRent?"是":"否"));
}
}
2、DVDService
package com.zhangguo.chapter8139.d2;
import java.util.HashMap;
import java.util.Map;
/** 服务 DVD管理 DVD业务 */
public class DVDService {
/** 构造 */
public DVDService() {
init();
}
/** DVD集合 */
public Map<Integer, DVD> dvds = new HashMap<Integer, DVD>();
/** 初始化 */
public void init() {
DVD d1 = new DVD(2017001, "功夫", 17.3, true);
DVD d2 = new DVD(2017002, "寒战", 25.6, false);
DVD d3 = new DVD(2017003, "超体", 11.9, true);
DVD d4 = new DVD(2017004, "异型", 88.8, false);
DVD d5 = new DVD(2017005, "龙猫", 64.1, true);
dvds.put(d1.id, d1);
dvds.put(d2.id, d2);
dvds.put(d3.id, d3);
dvds.put(d4.id, d4);
dvds.put(d5.id, d5);
}
/** 添加DVD */
public void add(DVD dvd) {
dvds.put(dvd.id, dvd);
}
/**删除DVD*/
public void del(int id) {
dvds.remove(id);
}
/**显示DVD*/
public String list(){
String result="";
/**遍历*/
for (DVD dvd : dvds.values()) {
result+=dvd+"\\n";
}
return result;
}
/**修改DVD借出状态*/
public void modify(int id,boolean _isRent){
DVD dvd=dvds.get(id);
dvd.isRent=_isRent;
}
}
3、DVDUI.java
package com.zhangguo.chapter8139.d2;
import java.util.Scanner;
/** 界面 */
public class DVDUI {
// write once only once
public static final String line = "**********";
Scanner input = new Scanner(System.in);
DVDService ds = new DVDService();
int id;
public void menu() {
String myline = r(line, 3) + "欢迎光临DVD小店" + r(line, 3);
$("\\n" + myline);
$("1、显示DVD");
$("2、借出DVD");
$("3、归还DVD");
$("4、添加DVD");
$("5、删除DVD");
$("6、刷新界面");
$("7、退出系统");
$(myline + "\\n");
int n = 0;
do {
$$("请选择功能[1-7]：");
n = input.nextInt();
} while (n < 1 || n > 7);
switch (n) {
case 1:
$(ds.list());
menu();
break;
case 2:
$$("请输入借出DVD的编号：");
id = input.nextInt();
ds.modify(id, true);
menu();
break;
case 3:
$$("请输入归还DVD的编号：");
id = input.nextInt();
ds.modify(id, false);
menu();
break;
case 4:
$("请录入您要添加的DVD信息");
$$("编号：");
id = input.nextInt();
$$("名称：");
String _name = input.next();
$$("价格：");
double _price = input.nextDouble();
DVD dvd=new DVD(id, _name, _price, false);
ds.add(dvd);
menu();
break;
case 5:
$$("请输入删除的DVD编号：");
id = input.nextInt();
ds.del(id);
$("删除成功");
menu();
break;
case 6:
menu();
break;
case 7:
System.exit(0);
break;
default:
$("该功能未实现");
menu();
break;
}
}
/** 输出换行 */
public void $(Object o) {
System.out.println(o);
}
/** 重复字符串 */
public String r(Object o, int n) {
String r = "";
for (int i = 1; i <= n; i++) {
r += o + "";
}
return r;
}
/** 输出不换行 */
public void $$(Object o) {
System.out.print(o);
}
}
4、DVDClient.java
package com.zhangguo.chapter8139.d2;
/** DVD客户端 */
public class DVDClient {
public static void main(String[] args) {
DVDUI dvdui = new DVDUI();
dvdui.menu();
}
}
运行结果：
******************************欢迎光临DVD小店******************************
1、显示DVD
2、借出DVD
3、归还DVD
4、添加DVD
5、删除DVD
6、刷新界面
7、退出系统
******************************欢迎光临DVD小店******************************
请选择功能[1-7]：8
请选择功能[1-7]：1
编号：2017003 名称：超体 价格：11.9 借出：是
编号：2017002 名称：寒战 价格：25.6 借出：否
编号：2017001 名称：功夫 价格：17.3 借出：是
编号：2017005 名称：龙猫 价格：64.1 借出：是
编号：2017004 名称：异型 价格：88.8 借出：否
******************************欢迎光临DVD小店******************************
1、显示DVD
2、借出DVD
3、归还DVD
4、添加DVD
5、删除DVD
6、刷新界面
7、退出系统
******************************欢迎光临DVD小店******************************
请选择功能[1-7]：
八、视频示例下载
九、面试题
8.1、接口的特点是什么？
interface IX{}
interface IY{}
/**
* 接口不能实例化
* */
interface Ieatable
{
/**public static final*/
double PI=3.14;
/**无方法体*/
/**只能是public,不修饰默认也是公有的*/
void eat();
}
/**实现类必须实现未实现的方法*/
class Duck implements Ieatable,IX,IY{
@Override
public void eat() {
System.out.println("吃蚯蚓"+PI);
}
/**接口允许多实现，弥补继承的单根性*/
}
8.2、定义Car类，定义List集合，完成，添加，删除，获得单个元素，遍历，修改操作。
车牌NO，颜色Color，价格Price
8.3、定义Animal类，定义Map集合，完成，添加，删除，获得单个元素，遍历，修改操作。
编号Id，名称name，重量Weight，颜色Color
8.4、完成DVD商店