java学习--集合框架（1）

来源：互联网发布：python处理csv数据编辑：程序博客网时间：2024/06/06 04:41

知识点

Java集合框架支持规则集、线性表、队列和图，他们分别定义在接口Set、List、Quene和Map中。

规则集用于存储一组互不相同的元素。

线性表用于存储一个有序的元素集合。

图（Map）中存储的是键/值对。

Java集合框架中的所有实例类都实现了Cloneable和Serializable接口。所以，它们的实例都是可以复制和可序列化的。

规则集存储的是不重复的元素。若要在集合中存储重复的元素，就需要使用线性表。线性表不仅可以存储重复的元素，而且允许用户指定存储的位置。用户可以通过下标来访问线性表中的元素。

Java集合框架支持三种类型的规则集：散列集HashSet、链式散列集LinkedHashSet和树型集TreeSet。HashSet以一个不可预知的顺序存储元素；LinkedHashSet以元素被插入的顺序存储元素；TreeSet存储已排好的元素。所有方法都继承自Collection接口。

Java集合框架支持两种类型的线性表：数组线性表ArrayList和链表LinkedList。ArrayList是实现List接口的可变大小的数组。ArrayList中的所有方法都是在List接口中定义的。LinkedList是实现List接口的一个链表。除了实现List接口，该类还提供了可从线性表两端提取、插入以及删除元素的方法。

Vector类实现了List接口。Vector类和ArrayList是一样的，所不同的是它所包含的访问和修改向量的方法是同步的。Stack类扩展了Vector类，并且提供了几种对栈进行操作的方法。

Queue接口表示队列。PriorityQueue类为优先队列实现Queue接口。

Collection接口表示存储在规则集或线性表中元素的集合。Map接口将键值映射到元素，键值类似于下标。在List中，下标是整数。而在Map中，键值可以是任意类型的对象。图中不能包含重复的键值。一个键值至多可以对应一个值。Map接口提供了查询、更新、获取值集合和键值集合的方法。

Java集合框架支持三种类型的图：散列图HashMap、链式散列图LinkedHashMap和树形图TreeMap。对于定位一个值、插入一个映射和删除一个映射而言，HashMap是很高效的。LinkedHashMap支持图中的条目排序。HashMap类中的条目是没有顺序的，但LinkedHashMap中的条目可以按某种顺序来获取，该顺序既可以是它们插入图中的顺序（称为插入顺序），也可以是它们最后一次访问的时间顺序，从最早到最晚（称为访问顺序）。对于遍历排好序的键值，TreeMap是高效的。键值可以使用Comparable接口来排序，也可以使用Comparator接口来排序。

01）集合框架（概述）

02）共性方法

[java] view plaincopy

/*
* 1：add方法的参数类型都是Object。以便于接受任意类型的对象。
* 2：集合中存储的都是对象的引用（地址）。
*/
public class CollectionDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
System.out.println("---------------分割线---------------");
method_2();
}
public static void method_1(){
//创建一个容器。使用Collection接口的子类。ArrayList。
ArrayList al = new ArrayList();
//1：添加元素
al.add("Java01");
al.add("Java02");
al.add("Java03");
al.add("Java04");
//2：打印集合
sop("原集合 = " + al);
sop("原集合 = " + al.clone());
//3：判断元素。
sop("判断Java02是否存在 = " + al.contains("Java02"));
sop("判断集合是否为空 = " + al.isEmpty());
//3：删除元素
al.remove("Java03");//删除指定元素。
al.remove(1);//删除下标为1的元素。
sop("删除后 = " + al.clone());
//4：获取个数。集合长度。
sop("清空前长度 = " + al.size());
//5：清空集合。
al.clear();
sop("清空后集合 = " + al.clone());
sop("清空后长度 = " + al.size());
}
public static void method_2(){
ArrayList a = new ArrayList();
a.add("Java01");
a.add("Java02");
a.add("Java03");
a.add("Java04");
sop("改变前a = " + a);
ArrayList b = new ArrayList();
b.add("Java06");
b.add("Java05");
b.add("Java04");
b.add("Java03");
sop("改变前b = " + b);
System.out.println("---------------分割线---------------");
//取交集，a只会保留和b中相同的元素。
sop(a.retainAll(b));
sop("改变后a = " + a);
sop("改变后b = " + b);
System.out.println("---------------分割线---------------");
}
}

运行结果如下图所示：

03）迭代器——Iterator

[java] view plaincopy

public class CollectionDemo_2 {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_get();
}
public static void method_get(){
ArrayList a = new ArrayList();
a.add("Java01");//add(Object obj)
a.add("Java02");
a.add("Java03");
a.add("Java04");
Iterator it_1 = a.iterator();//获取迭代器，用于取出集合中的元素。
while(it_1.hasNext()){//如果仍有元素可以迭代，则返回 true。
sop("While: " + it_1.next());//while代码相较for而言显的更少
}
System.out.println("-----分割线-----");
for (Iterator it_2 = a.iterator(); it_2.hasNext();){
sop("For: " + it_2.next());//细节：for能尽可能的少用内存空间。
}
}
}

运行结果如下图所示：

04）List集合共性方法

[java] view plaincopy

/*
* Collection
* |--List：元素是有序的，元素可以重复。因为该集合体系有索引。
* |--Set：元素是无序，元素不可以重复。
*
* List：特有方法。凡是可以操作角标的方法都是该体系特有的方法。
*
* 增：add(index, element)：在列表的指定位置插入指定元素。
* addAll(index, Collection)：添加指定 collection 中的所有元素到此列表的结尾。
* 删：remove(index)：移除列表中指定位置的元素。
* 改：set(index, element)：用指定元素替换列表中指定位置的元素。
* 查：get(index)：返回列表中指定位置的元素。
* subList(from, to)：返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。
* listIterator();返回此列表元素的列表迭代器（按适当顺序）。
* int indexOf(obj):获取指定元素的位置。
* ListIterator listIterator()：
*
*
*/
public class ListDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
}
public static void method_1(){
ArrayList a = new ArrayList();
//添加元素。
a.add("Java01");
a.add("Java02");
a.add("Java04");
sop("原集合是： " + a);
//在指定位置添加元素。
a.add(2, "Java03");
sop("第一次修改后是： " + a);
//删除指定位置元素。
a.remove(3);
sop("第二次修改后是： " + a);
//通过下标获取元素。
sop("get(1): " + a.get(1));
System.out.println("-----分割线-----");
//获取所有元素。
for (int i = 0; i < a.size(); i++)
System.out.println("a(" + i + ") = " + a.get(i));
System.out.println("-----分割线-----");
//迭代器，获取所有元素。
Iterator it = a.iterator();
while(it.hasNext())
sop("next = " + it.next());
}
}

运行结果如下图所示：

05）ListIterator

[java] view plaincopy

/*
* List集合特有的迭代器。
* ListIterator是Iterator的子接口。
*
* 在迭代时，不可以通过集合对象的方法操作集合中的元素。
* 因为会发生ConcurrentModificationException异常。
*
* 所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，
* 只能对元素进行判断，取出，删除的操作。
* 如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
*
* 该接口只能通过List集合的listIterator方法获取。
*/
public class ListDemo_2 {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
System.out.println("----------------------分割线----------------------");
method_2();
System.out.println("----------------------分割线----------------------");
method_3();
}
public static void method_3(){
ArrayList a = new ArrayList();
//添加元素。
a.add("Java01");
a.add("Java02");
a.add("Java03");
a.add("Java04");
sop("原a = " + a);
for (ListIterator it = a.listIterator(); it.hasNext();){
sop("（前面是否有元素）hasPrevious = " + it.hasPrevious());//判断前面是否有元素。
Object obj = it.next();
if (obj.equals("Java01"))
it.add("Java添加");
if (obj.equals("Java03"))
it.set("Javahah");
sop("（打印元素）obj = " + obj);
System.out.println("------------------------------------------------");
}
sop("修改后a = " + a);
}
public static void method_2(){
ArrayList a = new ArrayList();
//添加元素。
a.add("Java01");
a.add("Java02");
a.add("Java03");
a.add("Java04");
//在迭代过程中，准备添加或者删除元素。
for (Iterator it = a.iterator(); it.hasNext();){
// sop("Next = " + it.next());
Object obj = it.next();//取出元素。
if(obj.equals("Java01"))
it.remove();//将Java01的引用在集合中删除。
sop("obj = " + obj);
}
sop("a = " + a);
}
public static void method_1(){
ArrayList a = new ArrayList();
//添加元素。
a.add("Java01");
a.add("Java02");
a.add("Java03");
a.add("Java04");
//通过indexOf获取对象的位置。
sop("indexOf = " + a.indexOf("Java03"));
//通过指定下标获取集合中的元素。
List sup = a.subList(1, 3);
sop("sup = " + sup);
}
}

运行结果如下图所示：

06）List集合具体对象的特点

[java] view plaincopy

/*
* Collection
* |--List：元素是有序的，元素可以重复。因为该集合体系有索引。
* |--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
* |--LinkedList：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
* |--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
* |--Set：元素是无序，元素不可以重复。
*/

07）Vector中的枚举

[java] view plaincopy

/*
* 枚举就是Vector特有的取出方式。
* 发现枚举和迭代器很像。其实枚举和迭代器是一样的。
*
* 因为枚举的名称以及方法的名称都过长。所以枚举被迭代器取代了。
*/
public class VectorDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
method_2();
}
public static void method_1(){
Vector v1 = new Vector();
v1.add("Java01");
v1.add("Java02");
v1.add("Java03");
v1.add("Java04");
sop("v1 = " + v1);
System.out.println("-----------------------------------------");
for (ListIterator it = v1.listIterator(); it.hasNext();){
sop("it = " + it.next());//取数据
}
System.out.println("-----------------------------------------");
}
public static void method_2(){
Vector v2 = new Vector();
v2.add("Java01");
v2.add("Java02");
v2.add("Java03");
v2.add("Java04");
sop("v2 = " + v2);
System.out.println("-----------------------------------------");
for (Enumeration<E> en = v2.elements(); en.hasMoreElements();){//早期方式。
sop("en = " + en.nextElement());
}
System.out.println("-----------------------------------------");
}
}

运行结果如下图所示：

08）LinkedList

[java] view plaincopy

/*
* LinkedList特有方法：1.6之前。
* addFirst()：将指定元素插入此列表的开头。
* addLast()：将指定元素添加到此列表的结尾。
* getFirst()：返回此列表的第一个元素。
* getLast()：返回此列表的最后一个元素。
* ：获取元素，但不删除元素。长度不变。
* ：如果集合中没有元素，会出现NoSuchElementException。
* removeFirst()：移除并返回此列表的第一个元素。
* removeLast()：移除并返回此列表的最后一个元素。
* ：获取元素，并且删除元素。
* ：如果集合中没有元素，会出现NoSuchElementException。
*
* 1.6开始出现的替代：
* offerFirst()：
* offerLast()：
* peekFirst()：
* peekLast()：
* poolFirst()：
* poolLast()：
*/
public class LinkedListDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
method_2();
}
public static void method_1(){
LinkedList link = new LinkedList();
link.addFirst("（2）Java01");
link.addLast("（3）Java02");
link.addFirst("（1）Java03");//将元素添加到此列表的开头。
link.addLast("（4）Java04");//将元素添加到此列表的尾部。
sop("add = " + link);
sop("getFirst = " + link.getFirst());
sop("getLast = " + link.getLast());
System.out.println("------------------------------------------------------------------");
}
public static void method_2(){
LinkedList link = new LinkedList();
link.offerFirst("（1）Java01");//将元素添加到此列表的开头。
link.offerFirst("（2）Java02");
link.offerFirst("（3）Java03");
link.offerFirst("（4）Java04");
sop("（原）add = " + link);
sop("remove(0) = " + link.remove(0));//获取下标为0的元素，并且删除该元素。
sop("（改）add = " + link);
System.out.println("------------------------------------------------------------------");
for(; !link.isEmpty(); ){
sop("jdk1.6 poolLast = " + link.pollLast());
}
}
}

运行结果如下图所示：