JavaSE學習總結（七）—— 集合
目錄
- 一、為什麽需要集合
- 二、Java常用集合類型
- 三、List與ArrayList
- 3.0、Collection常用方法
- 3.0.1、添加功能
- 3.0.2、刪除功能
- 3.0.3、判斷功能
- 3.0.4、遍歷功能
- 3.0.5、長度功能
- 3.0.6、交集功能
- 3.0.7、把集合轉換成數組
- 3.1、List接口
- 3.2、ArrayList
- 3.2.1、List基本操作
- 3.2.2、LIST操作二
- 四、Map與HashMap
- 4.1、HashMap
- 4.1.1、Map基本操作
- 4.1.2、Map操作二
- 4.2、TreeMap
- 4.3、HashTable
- 五、Set與HashSet
- 六、總結
- 七、DVD租賃系統
- 7.1、功能需求
- 7.2、技術指導
- 7.3、第二次指導
- 7.4、第三次DVD指導
- 八、視頻示例下載
- 九、面試題
一、為什麽需要集合
如果要將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]：
八、視頻示例下載
本章內容在線視頻觀看：b站
九、面試題
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商店
JavaSE學習總結（七）—— 集合