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 iterator()
//它返回类型为T的元素的迭代器
详细参考：Java迭代器(iterator详解以及和for循环的区别)
（6）List接口（List Interface）
List接口是容器接口的子接口，它抑制了一个列表类型的数据结构，在这个结构中我们可以存储对象的有序集合，它可以有重复的值。List接口由ArrayList、LinkedList、Vector和Stack类实现。要实例化List接口，必须使用：
List list1= new ArrayList();
List list2 = new LinkedList();
List list3 = new Vector();
List list4 = new Stack();
List接口中有各种方法，可以用来插入、删除和访问列表中的元素。
（7）ArrayList
ArrayList类实现了List接口。它使用一个动态数组来存储不同数据类型的重复元素。ArrayList类维护插入顺序，并且是非同步的。存储在ArrayList类中的元素可以被随机访问。考虑下面的例子：
import java.util.*;
class TestJavaCollection1 {public static void main(String args[]){ArrayList list=new ArrayList();//Creating arraylistlist.add("Ravi");//Adding object in arraylistlist.add("Vijay");list.add("Ravi");list.add("Ajay");//Traversing list through IteratorIterator 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[])fLinkedList al=new LinkedList();al.add("Ravi");al.add("Vijay");al.add("Ravi");al.add("Ajay");Iterator itr=al.iterator();while(itr.hasNext())fSystem.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 v=new Vector();v.add("Ayush");v.add("Amit");v.add("Ashish");v.add("Garima");Iterator itr=v.iterator();while(itr.hasNext())fSystem.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 stack = new Stack();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 q1 = new PriorityQueue();
Queue q2 = new ArrayDeque();
（12）PriorityQueue
PriorityQueue类实现队列接口，它保存由优先级处理的元素或对象。PriorityQueue不允许在队列中存储null值。考虑下面的例子：
import java.util.*;
class TestJavaCollection5 {public static void main(String args[]){PriorityQueue queue=new PriorityQueue();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())fSystem.out.println(itr.next());gqueue.remove();queue.poll();System.out.println("after removing two elements:");Iterator 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 elementsDeque deque = new ArrayDeque();deque.add("Gautam");deque.add("Karan");deque.add("Ajay");//Traversing elementsfor (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 s1 = new HashSet();
Set s2 = new LinkedHashSet();
Set s3 = new TreeSet();
（16）HashSet
HashSet类实现Set接口，它表示使用哈希表存储的集合。散列用于存储哈希集中的元素，它包含惟一项。考虑下面的例子：
import java.util.*;
class TestJavaCollection7 {public static void main(String args[])f //Creating HashSet and adding elementsHashSet set=new HashSet();set.add("Ravi");set.add("Vijay");set.add("Ravi")set.add("Ajay");//Traversing elementsIterator 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 set=new LinkedHashSet();set.add("Ravi");set.add("Vijay");set.add("Ravi")set.add("Ajay");Iterator itr=set.iterator();while(itr.hasNext()) {System.out.println(itr.next());}}
}/*
Output:
Ravi
Vijay
Ajay
*/
（18）SortedSet 接口
SortedSet是Set接口的另一种选择，它提供了元素的总排序。SortedSet的元素按递增(升序)顺序排列。SortedSet提供了其他方法，这些方法可以抑制元素的自然顺序。SortedSet可以实例化为：
SortedSet 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 elementsTreeSet set=new TreeSet();set.add("Ravi");set.add("Vijay");set.add("Ravi")set.add("Ajay");//traversing elementsIterator 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 extends AbstractList
implements List, 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 al=new ArrayList();//creating new generic arraylist
在通用集合中，我们在angular大括号中指定类型，现在ArrayList只能有特定类型的对象。如果试图添加另一种类型的对象，它将给出编译时错误。
（7）Java ArrayList的例子
import java.util.*;
class TestCollection1 {public static void main(String args[]){ArrayList list=new ArrayList(); //Creating arraylistlist.add("Ravi");//Adding object in arraylistlist.add("Vijay");list.add("Ravi");list.add("Ajay");Iterator itr=list.iterator(); //Traversing list through Iteratorwhile(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 al=new ArrayList();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-dened class objectsStudent s1=new Student(101,"Sonoo",23);Student s2=new Student(102,"Ravi",21);Student s2=new Student(103,"Hanumat",25);//creating arraylistArrayList al=new ArrayList();al.add(s1); //adding Student class objectal.add(s2);al.add(s3);//Getting IteratorIterator itr=al.iterator();//traversing elements of ArrayList objectwhile(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 al=new ArrayList();al.add("Ravi");al.add("Vijay");al.add("Ajay");ArrayList al2=new ArrayList();al2.add("Sonoo");al2.add("Hanumat");al.addAll(al2); //adding second list in rst listIterator 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 al=new ArrayList();al.add("Ravi");al.add("Vijay");al.add("Ajay");ArrayList al2=new ArrayList();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 al=new ArrayList();al.add("Ravi");al.add("Vijay");al.add("Ajay");ArrayList al2=new ArrayList();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 list=new ArrayList(); //Creating list of BooksBook b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8); //Creating BooksBook 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 listlist.add(b2);list.add(b3);for(Book b:list) { //Traversing listSystem.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 extends AbstractSequentialList
implements List, Deque, Cloneable,
（5）Java LinkedList的构造函数
（6）Java LinkedList的方法
（7）Java LinkedList的例子
（i）
import java.util.*;
class TestCollection7 {public static void main(String args[]){LinkedList al=new LinkedList();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 list=new LinkedList(); //Creating list of BooksBook b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);//Creating BooksBook 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 listlist.add(b2);list.add(b3);for(Book b:list) {//Traversing listSystem.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 al=new ArrayList();//creating arraylistal.add("Ravi");//adding object in arraylistal.add("Vijay");al.add("Ravi");al.add("Ajay");List al2=new LinkedList();//creating linkedlistal2.add("James");//adding object in linkedlistal2.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 extends Collection
（2）Java List接口的方法
import java.util.*;
class ListExample {public static void main(String args[]){ArrayList al=new ArrayList();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 extends Iterator
（4）Java ListIterator接口的方法
（i）
import java.util.*;
class TestCollection8 {public static void main(String args[]){ArrayList al=new ArrayList();al.add("Amit");al.add("Vijay");al.add("Kumar");al.add(1,"Sachin");System.out.println("element at 2nd position: "+al.get(2));ListIterator 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 list=new ArrayList(); //Creating list of BooksBook b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);//Creating BooksBook 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 listlist.add(b2);list.add(b3);for(Book b:list) f //Traversing listSystem.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 extends AbstractSet
implements Set, Cloneable, Serializable
（3）Constructors of Java HashSet class
（4）Java HashSet类的方法
（i）
import java.util.*;
class TestCollection9 {public static void main(String args[]) {HashSet set=new HashSet(); //Creating HashSet and adding elementsset.add("Ravi");set.add("Vijay");set.add("Ravi");set.add("Ajay");Iterator itr=set.iterator();//Traversing elementswhile(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 set=new HashSet(); //Creating list of BooksBook b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);//Creating BooksBook 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 listset.add(b2);set.add(b3);for(Book b:set) f //Traversing listSystem.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
*/
标签：
相关文章
-
无相关信息