Java课件笔记：sec3

sec3

1.Java集合框架

（1）Java中的容器（Collection）
Java中的容器是一个框架，它提供了存储和操作对象组的体系结构。对数据执行的所有操作，如搜索、排序、插入、操作、删除等等，都可以通过Java集合实现。
Java容器意味着一个对象单元，Java集合框架提供了许多接口(Set、List、Queue、Deque等)和类(ArrayList、Vector、LinkedList、PriorityQueue、HashSet、LinkedHashSet、TreeSet等)。
一个容器代表一个对象单元。
结构框架（framework）：
（i）它提供了现成的体系结构。（ii）它表示一组类和接口。（iii）它是可选的。
容器框架（Collection framework）：
集合框架表示用于存储和操作一组对象的独立体系结构。它有：（i）接口及其实现，即、类。（3）算法。
（2）容器框架（Collection Framework）的层次结构

（3）采集接口方法（Methods of Collection interface）
集合接口中声明了许多方法。它们如下：


（4）迭代器接口(Iterator Interface)
Iterator接口只提供向前方向迭代元素的功能。迭代器接口的方法迭代器接口中只有三个方法。他们是：

（5）Iterable Interface
Iterable接口是所有容器类的根接口。集合接口扩展了可迭代接口，因此集合接口的所有子类也实现了可迭代接口。它只包含一个抽象方法，即：

Iterator<T> iterator()
//它返回类型为T的元素的迭代器

详细参考：Java迭代器(iterator详解以及和for循环的区别)

（6）List接口（List Interface）
List接口是容器接口的子接口，它抑制了一个列表类型的数据结构，在这个结构中我们可以存储对象的有序集合，它可以有重复的值。List接口由ArrayList、LinkedList、Vector和Stack类实现。要实例化List接口，必须使用：

List <data-type> list1= new ArrayList();
List <data-type> list2 = new LinkedList();
List <data-type> list3 = new Vector();
List <data-type> list4 = new Stack();

List接口中有各种方法，可以用来插入、删除和访问列表中的元素。
（7）ArrayList
ArrayList类实现了List接口。它使用一个动态数组来存储不同数据类型的重复元素。ArrayList类维护插入顺序，并且是非同步的。存储在ArrayList类中的元素可以被随机访问。考虑下面的例子：

import java.util.*;
class TestJavaCollection1 {
	public static void main(String args[]){
		ArrayList<String> list=new ArrayList<String>();//Creating arraylist
		list.add("Ravi");//Adding object in arraylist
		list.add("Vijay");
		list.add("Ravi");
		list.add("Ajay");
		//Traversing list through Iterator
		Iterator itr=list.iterator();
		while(itr.hasNext()){
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Ravi
Vijay
Ravi
Ajay
*/

（8）LinkedList
LinkedList实现了容器接口，它在内部使用双链表来存储元素。它可以存储重复的元素。它维护插入顺序，并且不同步。在LinkedList中，操作非常快，因为不需要移位。考虑下面的例子：

import java.util.*;
class TestJavaCollection2 {
	public static void main(String args[])f
		LinkedList<String> al=new LinkedList<String>();
		al.add("Ravi");
		al.add("Vijay");
		al.add("Ravi");
		al.add("Ajay");
		Iterator itr=al.iterator();
		while(itr.hasNext())f
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Ravi
Vijay
Ravi
Ajay
*/

（9）Vector
Vector使用一个动态数组来存储数据元素。它类似于ArrayList。但是，它是同步的，并且包含许多不属于集合框架的方法。考虑下面的例子：

import java.util.*;
class TestJavaCollection3 {
	public static void main(String args[]){
		Vector<String> v=new Vector<String>();
		v.add("Ayush");
		v.add("Amit");
		v.add("Ashish");
		v.add("Garima");
		Iterator itr=v.iterator();
		while(itr.hasNext())f
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Ayush
Amit
Ashish
Garima
*/

（10）Stack
Vector使用一个动态数组来存储数据元素。它类似于ArrayList。但是，它是同步的，并且包含许多不属于集合框架的方法。考虑下面的例子：

import java.util.*;
class TestJavaCollection4 {
	public static void main(String args[]){
		Stack<String> stack = new Stack<String>();
		stack.push("Ayush");
		stack.push("Garvit");
		stack.push("Amit");
		stack.push("Ashish");
		stack.push("Garima");
		stack.pop();
		Iterator itr=stack.iterator();
		while(itr.hasNext()){
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Ayush
Garvit
Amit
Ashish
*/

（11）Queue接口
Queue接口维护了first-in-first-out顺序，它可以被定义为一个有序列表，用于保存将要处理的元素。有许多类，如PriorityQueue、Deque、ArrayDeque等，它们实现了队列接口。队列接口可以实例化为：

Queue<String> q1 = new PriorityQueue();
Queue<String> q2 = new ArrayDeque();

（12）PriorityQueue
PriorityQueue类实现队列接口，它保存由优先级处理的元素或对象。PriorityQueue不允许在队列中存储null值。考虑下面的例子：

import java.util.*;
class TestJavaCollection5 {
	public static void main(String args[]){
		PriorityQueue<String> queue=new PriorityQueue<String>();
		queue.add("Amit Sharma");
		queue.add("Vijay Raj");
		queue.add("JaiShankar");
		queue.add("Raj");
		System.out.println("head:"+queue.element());
		System.out.println("head:"+queue.peek());
		System.out.println("iterating the queue elements:");
		Iterator itr=queue.iterator();
		while(itr.hasNext())f
			System.out.println(itr.next());
		g
		queue.remove();
		queue.poll();
		System.out.println("after removing two elements:");
		Iterator<String> itr2=queue.iterator();
		while(itr2.hasNext()){
			System.out.println(itr2.next());
		}
	}
}

/*
Output:
head:Amit Sharma
head:Amit Sharma
iterating the queue elements:
Amit Sharma
Raj
JaiShankar
Vijay Raj
after removing two elements:
Raj
Vijay Raj
*/

（13）Deque 接口
Deque接口扩展了Queue接口，在Deque中，我们可以从两边删除和添加元素。Deque代表双端队列，它使我们能够在两端执行操作。Deque可以实例化为：

Deque d = new ArrayDeque();

（14）ArrayDeque
ArrayDeque类实现了Deque接口，它便于我们使用Deque。与Queue不同，我们可以从两端添加或删除元素。ArrayDeque比ArrayList和Stack快，没有容量限制。考虑下面的例子：

import java.util.*;
class TestJavaCollection6 {
	public static void main(String args[])f //Creating Deque and adding elements
		Deque<String> deque = new ArrayDeque<String>();
		deque.add("Gautam");
		deque.add("Karan");
		deque.add("Ajay");
		//Traversing elements
		for (String str : deque) {
			System.out.println(str);
		}
	}
}

/*
Output:
Gautam
Karan
Ajay
*/

（15）Set接口
Java中的Set接口是用java.util包表示，它扩展了容器接口。它表示不允许存储重复项的无序元素集。Set最多只能存储一个null值。Set由HashSet、LinkedHashSet和TreeSet实现。Set可以实例化为：

Set<data-type> s1 = new HashSet<data-type>();
Set<data-type> s2 = new LinkedHashSet<data-type>();
Set<data-type> s3 = new TreeSet<data-type>();

（16）HashSet
HashSet类实现Set接口，它表示使用哈希表存储的集合。散列用于存储哈希集中的元素，它包含惟一项。考虑下面的例子：

import java.util.*;
class TestJavaCollection7 {
	public static void main(String args[])f //Creating HashSet and adding elements
		HashSet<String> set=new HashSet<String>();
		set.add("Ravi");
		set.add("Vijay");
		set.add("Ravi")
		set.add("Ajay");
		//Traversing elements
		Iterator<String> itr=set.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Vijay
Ravi
Ajay
*/

（17）LinkedHashSet
LinkedHashSet类表示Set接口的LinkedList实现。它扩展了HashSet类并实现了Set接口。与HashSet一样，它也包含惟一的元素。它维护插入顺序并允许空元素。考虑下面的例子：

import java.util.*;
class TestJavaCollection8 {
	public static void main(String args[]){
		LinkedHashSet<String> set=new LinkedHashSet<String>();
		set.add("Ravi");
		set.add("Vijay");
		set.add("Ravi")
		set.add("Ajay");
		Iterator<String> itr=set.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Ravi
Vijay
Ajay
*/

（18）SortedSet 接口
SortedSet是Set接口的另一种选择，它提供了元素的总排序。SortedSet的元素按递增(升序)顺序排列。SortedSet提供了其他方法，这些方法可以抑制元素的自然顺序。SortedSet可以实例化为：

SortedSet<data-type> set = new TreeSet();

（19）TreeSet
Java TreeSet类实现了使用树存储的Set接口。与HashSet一样，TreeSet也包含独特的元素，但TreeSet的访问和检索时间非常快。TreeSet中的元素按升序存储。考虑下面的示例：

import java.util.*;
class TestJavaCollection9 {
	public static void main(String args[])f //Creating and adding elements
		TreeSet<String> set=new TreeSet<String>();
		set.add("Ravi");
		set.add("Vijay");
		set.add("Ravi")
		set.add("Ajay");
		//traversing elements
		Iterator<String> itr=set.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Ajay
Ravi
Vijay
*/

2.Java ArrayList

（1）Java ArrayList class
Java ArrayList类使用动态数组存储元素，它继承Abstract List类并实现List接口。Java ArrayList类的要点是：
（i）Java ArrayList类可以包含重复元素。
（ii）Java ArrayList类维护插入顺序。
（iii）Java ArrayList类是非同步的。
（iv）Java ArrayList允许随机访问，因为数组在索引基础上工作。
（v）在Java ArrayList类中，操作是缓慢的，因为如果从数组列表中删除了任何元素，就需要进行大量的转换。
（2）ArrayList类的层次结构

如图所示，Java ArrayList类扩展了Abstract List类，该类实现了List接口。List接口按层次顺序扩展了容器和Iterable接口。
（3）ArrayList类声明
java.util.ArrayList class的声明：

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializ

（4）Java ArrayList的构造函数

（5）ArrayList的方法


（6）Java非泛型Vs泛型容器
Java容器框架在JDK 1.5之前是非通用的，从1.5起是通用的。Java new generic集合允许在集合中只有一种类型的对象。现在它是类型安全的，所以在运行时不需要类型转换。

ArrayList al=new ArrayList();//creating old non-generic arraylist

创建java容器的新通用示例：

ArrayList<String> al=new ArrayList<String>();//creating new generic arraylist

在通用集合中，我们在angular大括号中指定类型，现在ArrayList只能有特定类型的对象。如果试图添加另一种类型的对象，它将给出编译时错误。
（7）Java ArrayList的例子

import java.util.*;
class TestCollection1 {
	public static void main(String args[]){
		ArrayList<String> list=new ArrayList<String>(); //Creating arraylist
		list.add("Ravi");//Adding object in arraylist
		list.add("Vijay");
		list.add("Ravi");
		list.add("Ajay");
		Iterator itr=list.iterator(); //Traversing list through Iterator
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Ravi
Vijay
Ravi
Ajay
*/

（8）在java中迭代集合元素的两种方法：
有两种方法可以遍历集合元素：
（i）通过迭代器接口。
（ii）for - each循环。
在上面的例子中，我们看到了迭代器遍历ArrayList。让我们看一个使用for-each循环遍历ArrayList元素的例子。
（9）通过for-each循环迭代集合

import java.util.*;
class TestCollection2 {
	public static void main(String args[]){
		ArrayList<String> al=new ArrayList<String>();
		al.add("Ravi");
		al.add("Vijay");
		al.add("Ravi");
		al.add("Ajay");
		for(String obj:al)
			System.out.println(obj);
	}
}

/*
Output:
Ravi
Vijay
Ravi
Ajay
*/

（10）Java ArrayList中的用户定义类对象
看一个在数组列表中存储Student类对象的例子：

class Student {
	int rollno;
	String name;
	int age;
	Student(int rollno,Stringname,int age) {
		this.rollno=rollno;
		this.name=name;
		this.age=age;
	}
}
import java.util.*;
class TestCollection3 {
	public static void main(String args[]){
		//Creating user-dened class objects
		Student s1=new Student(101,"Sonoo",23);
		Student s2=new Student(102,"Ravi",21);
		Student s2=new Student(103,"Hanumat",25);
		//creating arraylist
		ArrayList<Student> al=new ArrayList<Student>();
		al.add(s1); //adding Student class object
		al.add(s2);
		al.add(s3);
		//Getting Iterator
		Iterator itr=al.iterator();
		//traversing elements of ArrayList object
		while(itr.hasNext()) {
			Student st=(Student)itr.next();
			System.out.println(st.rollno+" "+st.name+" "+st.age);
		}
	}
}

/*
Output:
101 Sonoo 23
102 Ravi 21
103 Hanumat 25
*/

（11）addAll(Collection c)方法的示例

import java.util.*;
class TestCollection4 {
	public static void main(String args[]){
		ArrayList<String> al=new ArrayList<String>();
		al.add("Ravi");
		al.add("Vijay");
		al.add("Ajay");
		ArrayList<String> al2=new ArrayList<String>();
		al2.add("Sonoo");
		al2.add("Hanumat");
		al.addAll(al2); //adding second list in rst list
		Iterator itr=al.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}]
}

/*
Output:
Ravi
Vijay
Ajay
Sonoo
Hanumat

（12）removeAll()方法的示例

import java.util.*;
class TestCollection5 {
	public static void main(String args[]){
		ArrayList<String> al=new ArrayList<String>();
		al.add("Ravi");
		al.add("Vijay");
		al.add("Ajay");
		ArrayList<String> al2=new ArrayList<String>();
		al2.add("Ravi");
		al2.add("Hanumat");
		al.removeAll(al2);
		System.out.println("iterating the elements after removing the elements of al2...");
		Iterator itr=al.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

/*
Output:
iterating the elements after removing the elements of al2...
Vijay
Ajay
*/

（13）retainAll()方法的示例

import java.util.*;
class TestCollection6 {
	public static void main(String args[]){
		ArrayList<String> al=new ArrayList<String>();
		al.add("Ravi");
		al.add("Vijay");
		al.add("Ajay");
		ArrayList<String> al2=new ArrayList<String>();
		al2.add("Ravi");
		al2.add("Hanumat");
		al.retainAll(al2);
		System.out.println("iterating the elements after retaining the elements of al2");
		Iterator itr=al.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

/*
Output:
iterating the elements after retaining the elements of al2...
Ravi
*/

（14）Java ArrayList例子:Book

import java.util.*;
class Book {
	int id;
	String name,author,publisher;
	int quantity;
	public Book(int id, String name, String author, String publisher, int quantity) {
		this.id = id;
		this.name = name;
		this.author = author;
		this.publisher = publisher;
		this.quantity = quantity;
	}
}
public class ArrayListExample {
	public static void main(String[] args) {
		List<Book> list=new ArrayList<Book>(); //Creating list of Books
		Book b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8); //Creating Books
		Book b2=new Book(102,
				"Data Communications & Networking","Forouzan","Mc Graw Hill",4);
		Book b3=new Book(103,"Operating System","Galvin","Wiley",6);
		list.add(b1); //Adding Books to list
		list.add(b2);
		list.add(b3);
		for(Book b:list) { //Traversing list
			System.out.println(b.id+" "+b.name+" "+
					b.author+" "+b.publisher+" "+b.quantity);
		}
	}
}

/*
Output:
101 Let us C Yashwant Kanetkar BPB 8
102 Data Communications & Networking Forouzan Mc Graw Hill 4
103 Operating System Galvin Wiley 6
*/

3.Java LinkedList

（1）Java LinkedList class
Java LinkedList类使用双链表来存储元素。它提供了一个链表数据结构。它继承AbstractList类并实现List和Deque接口。关于Java LinkedList的要点是：
（i）Java LinkedList类可以包含重复的元素。
（ii）Java LinkedList类维护插入顺序。
（iii）Java LinkedList类是非同步的。
（iv）在Java LinkedList类中，操作非常快，因为不需要进行移位。
（v）Java LinkedList类可以用作列表、堆栈或队列。
（2）LinkedList类的层次结构

如上图所示，Java LinkedList类扩展了Abstract SequentialList类，并实现了List和Deque接口。
（3）双向链表
对于双链表，我们可以从两边添加或删除元素。

（4）LinkedList类声明
在java.util.LinkedList class中的声明：

public class LinkedList<E> extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable,

（5）Java LinkedList的构造函数

（6）Java LinkedList的方法


（7）Java LinkedList的例子
（i）

import java.util.*;
class TestCollection7 {
	public static void main(String args[]){
		LinkedList<String> al=new LinkedList<String>();
		al.add("Ravi");
		al.add("Vijay");
		al.add("Ravi");
		al.add("Ajay");
		Iterator itr=al.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Ravi
Vijay
Ravi
Ajay
*/

（ii）

import java.util.*;
class Book {
	int id;
	String name,author,publisher;
	int quantity;
	public Book(int id, String name, String author, String publisher, int quantity) {
		this.id = id;
		this.name = name;
		this.author = author;
		this.publisher = publisher;
		this.quantity = quantity;
	}
}
public class LinkedListExample {
	public static void main(String[] args) {
		List<Book> list=new LinkedList<Book>(); //Creating list of Books
		Book b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);//Creating Books
		Book b2=new Book(102,"Data Communications & Networking",
				"Forouzan","Mc Graw Hill",4);
		Book b3=new Book(103,"Operating System","Galvin","Wiley",6);
		list.add(b1); //Adding Books to list
		list.add(b2);
		list.add(b3);
		for(Book b:list) {//Traversing list
			System.out.println(b.id+" "+b.name+" "+b.author+"
					 "+b.publisher+" "+b.quantity);
		}
	}
}

/*
Output:
101 Let us C Yashwant Kanetkar BPB 8
102 Data Communications & Networking Forouzan Mc Graw Hill 4
103 Operating System Galvin Wiley 6
*/

4.ArrayList vs LinkedList

（1）ArrayList和LinkedList的区别
ArrayList和LinkedList都实现了List接口并维护插入顺序。它们都是非同步类。但是在ArrayList和LinkedList类之间有很多差异，如下所示：

（2）Java中的ArrayList和LinkedList示例

import java.util.*;
class TestArrayLinked {
	public static void main(String args[]){
		List<String> al=new ArrayList<String>();//creating arraylist
		al.add("Ravi");//adding object in arraylist
		al.add("Vijay");
		al.add("Ravi");
		al.add("Ajay");
		List<String> al2=new LinkedList<String>();//creating linkedlist
		al2.add("James");//adding object in linkedlist
		al2.add("Serena");
		al2.add("Swati");
		al2.add("Junaid");
		System.out.println("arraylist: "+al);
		System.out.println("linkedlist: "+al2);
	}
}

/*
Output:
arraylist: [Ravi,Vijay,Ravi,Ajay]
linkedlist: [James,Serena,Swati,Junaid]
*/

5.Java List 接口

（1）Java List 接口
List接口是容器的子接口，它包含在索引基础上插入和删除元素的方法，它是一个List Iterator接口的工厂。

//List Interface declaration
public interface List<E> extends Collection<E>

（2）Java List接口的方法

import java.util.*;
class ListExample {
	public static void main(String args[]){
		ArrayList<String> al=new ArrayList<String>();
		al.add("Amit");
		al.add("Vijay");
		al.add("Kumar");
		al.add(1,"Sachin");
		System.out.println("Element at 2nd position: "+al.get(2));
		for(String s:al) {
			System.out.println(s);
		}
	}
}

/*
Output:
Element at 2nd position: Vijay
Amit
Sachin
Vijay
Kumar
*/

（3）Java ListIterator接口
ListIterator接口用于向后和向前遍历元素。

//ListIterator Interface declaration
public interface ListIterator<E> extends Iterator<E>

（4）Java ListIterator接口的方法

（i）

import java.util.*;
class TestCollection8 {
	public static void main(String args[]){
		ArrayList<String> al=new ArrayList<String>();
		al.add("Amit");
		al.add("Vijay");
		al.add("Kumar");
		al.add(1,"Sachin");
		System.out.println("element at 2nd position: "+al.get(2));
		ListIterator<String> itr=al.listIterator();
		System.out.println("traversing elements in forward direction...");
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
		System.out.println("traversing elements in backward direction...");
		while(itr.hasPrevious()) {
			System.out.println(itr.previous());
		}
	}
}

/*
Output:
element at 2nd position: Vijay
traversing elements in forward direction...
Amit
Sachin
Vijay
Kumar
traversing elements in backward direction...
Kumar
Vijay
Sachin
Amit
*/

（ii）

import java.util.*;
class Book {
	int id;
	String name,author,publisher;
	int quantity;
	public Book(int id, String name, String author, String publisher, int quantity) {
		this.id = id;
		this.name = name;
		this.author = author;
		this.publisher = publisher;
		this.quantity = quantity;
	}
}
public class ListExample {
	public static void main(String[] args) {
		List<Book> list=new ArrayList<Book>(); //Creating list of Books
		Book b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);//Creating Books
		Book b2=new Book(102,"Data Communications & Networking",
				"Forouzan","Mc Graw Hill",4);
		Book b3=new Book(103,"Operating System","Galvin","Wiley",6);
		list.add(b1); //Adding Books to list
		list.add(b2);
		list.add(b3);
		for(Book b:list) f //Traversing list
			System.out.println(b.id+" "+b.name+" "+
					b.author+" "+b.publisher+" "+b.quantity);
		}
	}
}

/*
Output:
101 Let us C Yashwant Kanetkar BPB 8
102 Data Communications & Networking Forouzan Mc Graw Hill 4
103 Operating System Galvin Wiley 6
*/

6.Java HashSet

（1）Java HashSet类
Java HashSet类用于创建使用哈希表存储的集合。它继承Abstract Set类并实现Set接口。关于Java HashSet类的要点是：
（i）HashSet通过使用一种称为散列的机制存储元素。
（ii）HashSet只包含List和Set之间的惟一元素。
（iii）List可以包含重复的元素，而Set只包含唯一的元素。
（2）HashSet类的层次结构

HashSet类扩展了Abstract Set类，它实现了Set接口。容器接口按层次顺序继承容器接口和Iterable接口。

//the declaration for java.util.HashSet class.
public class HashSet<E> extends AbstractSet<E>
implements Set<E>, Cloneable, Serializable

（3）Constructors of Java HashSet class

（4）Java HashSet类的方法

（i）

import java.util.*;
class TestCollection9 {
	public static void main(String args[]) {
		HashSet<String> set=new HashSet<String>(); //Creating HashSet and adding elements
		set.add("Ravi");
		set.add("Vijay");
		set.add("Ravi");
		set.add("Ajay");
		Iterator<String> itr=set.iterator();//Traversing elements
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

/*
Output:
Ajay
Vijay
Ravi
*/

（ii）

import java.util.*;
class Book {
	int id;
	String name,author,publisher;
	int quantity;
	public Book(int id, String name, String author, String publisher, int quantity) {
		this.id = id;
		this.name = name;
		this.author = author;
		this.publisher = publisher;
		this.quantity = quantity;
	}
}
public class HashSetExample {
	public static void main(String[] args) {
		HashSet<Book> set=new HashSet<Book>(); //Creating list of Books
		Book b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);//Creating Books
		Book b2=new Book(102,"Data Communications & Networking",
				"Forouzan","Mc Graw Hill",4);
		Book b3=new Book(103,"Operating System","Galvin","Wiley",6);
		set.add(b1); //Adding Books to list
		set.add(b2);
		set.add(b3);
		for(Book b:set) f //Traversing list
			System.out.println(b.id+" "+b.name+
					" "+b.author+" "+b.publisher+" "+b.quantity);
		}
	}
}

/*
Output:
101 Let us C Yashwant Kanetkar BPB 8
102 Data Communications & Networking Forouzan Mc Graw Hill 4
103 Operating System Galvin Wiley 6
*/