黑马程序员——集合概述一、集合概述二、List集合添加add(index,element);addAll(index,Collection);删除remove(index);修改set(index,element);查询get(index)；subList(from,to);listIterator();int indexOf(obj):获取指定元素的位置。ListIterator listIterator();List集合特有的迭代器：ListIterator是Iterator的子接口。在迭

60 阅读 0 评论 40 点赞

我是靠谱客的博主耍酷龙猫，最近开发中收集的这篇文章主要介绍黑马程序员——集合概述一、集合概述二、List集合添加add(index,element);addAll(index,Collection);删除remove(index);修改set(index,element);查询get(index)；subList(from,to);listIterator();int indexOf(obj):获取指定元素的位置。ListIterator listIterator();List集合特有的迭代器：ListIterator是Iterator的子接口。在迭，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

------- android培训、 java培训、期待与您交流！ ----------

一、集合概述

为什么出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作

就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同是容器，二者区别

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储

基本数据类型，集合只能存储对象。

集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

Collection接口

一个独立的元素的序列，这些元素服从一条或多条规则。

Collection接口下主要分为List集合和Set集合。

List集合的特点是元素有序、允许有重复元素。

Set集合的特点是元素无存储顺序、不允许有重复元素。

Collection定义了集合框架的共性功能。

添加

add(e);

addAll(collection);

删除

remove(e);

removeAll(collection);

clear();

判断

contains(e);

isEmpty();

获取

iterator();

size();

获取交集。

retainAll();

集合变数组。

toArray();

注意：

(1).add方法的参数类型是Object。以便于接收任意类型对象。

(2).集合中存储的都是对象的引用(地址)。

迭代概述

迭代是取出集合中元素的一种方式。

对于集合的元素取出这个动作：

当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。就把取出

方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。

而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容：判断和取出。那么就可

以将这些共性抽取。

那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。通过一个对外提供的方

法： iterator(); ，来获取集合的取出对象。

因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

迭代的常见操作

hasNext();//有下一个元素，返回真

next();//取出下一个元素

remove();//移除

注意：在迭代时循环中next调用一次，就要hasNext判断一次。

使用：

ArrayList a=newArrayList();//创建一个集合

Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。

第一种打印方式：

for(Iterator iter = a.iterator();iter.hasNext(); )

{

System.out.println(iter.next());

}

第二种打印方式：

Iteratoriter = a.iterator();

while(iter.hasNext())

{

System.out.println(iter.next());

}

迭代注意事项

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。

迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

迭代器的next方法返回值类型是Object，所以要记得类型转换。

二、List集合

添加

add(index,element);

addAll(index,Collection);

删除

remove(index);

修改

set(index,element);

查询

get(index)；

subList(from,to);

listIterator();

int indexOf(obj):获取指定元素的位置。

ListIterator listIterator();

List集合特有的迭代器：ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异

常。所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出、删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的listIterator方法获取。

枚举Enumeration

就是Vector特有的取出方式。Vector有三种取出方式。

其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

特有方法：

addElement(obj);//添加元素，相当于add(obj)。

Enumerationelements();//Vector特有取出方式(枚举)。

hasMoreElements();//相当于Iterator的hasNext()方法。

nextElements();//相当于Iterator的next()方法。
示例代码

public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}

LinkedList

特有方法：

addFirst();

addLast();

getFirst();

getLast();获取元素，但不删除元素。如果集合中没有元素，则抛出异常。

removeFirst();

removeLast();获取元素，但是元素被删除，如果集合中没有元素，则抛出异常。

在JDK 1.6出现了替代方法:

offerFirst();

offerLast();

peekFirst();

peekLast();获取元素，但不删除元素。如果集合中没有元素，返回null。

pollFirst();

pollLast();获取元素，但是元素被删除，如果集合中没有元素，则返回null。

练习：使用LinkedList模拟一个堆栈或者队列数据结构。

class DuiLie
{
private LinkedList link;
DuiLie()
{
link = new LinkedList();
}
public void myAdd(Object obj)//添加元素进入队列
{
link.addFirst(obj);
}
public Object myGet()//拿出元素，并移除这个元素
{
return link.removeFirst();
}
public boolean isNull()//判断队列中是否有元素
{
return link.isEmpty();
}
}
class
LinkedListTest
{
public static void main(String[] args)
{
DuiLie dl = new DuiLie();//初始化并添加元素
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while(!dl.isNull())//如果队列不为空，则取出元素
{
System.out.println(dl.myGet());
}
}
}

练习：去除ArrayList集合中的重复元素。

class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();//初始化一个ArrayList对象
al.add("java01");//并添加元素
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
sop(al);//打印原集合
al = singleElement(al);
sop(al);//打印去掉重复元素的集合
}
public static ArrayList singleElement(ArrayList al)
{
//定义一个临时容器。
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();//遍历原集合
while(it.hasNext())
{
Object obj = it.next();
if(!newAl.contains(obj))//如果新集合不包含这个元素则存入新集合
newAl.add(obj);
}
return newAl;
}
}

三、Set集合

Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。

HashSet：底层数据结构是哈希表。是线程不安全的。不同步。

HashSet保证元素的唯一性：

是通过元素的两个方法，hashCode和equals来完成。

如果元素的HashCode值相同，才会判断equals是否为true。

如果元素的hashcode值不同，不会调用equals。

对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

Set集合的功能和Collection是一致的。

练习：往hashSet集合中存入自定对象姓名和年龄相同为同一个人，重复元素。

class HashSetTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs = new HashSet();//定义一个HashSet
//向这个集合中添加自定义元素
hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
//遍历这个集合
Iterator it = hs.iterator();
//打印集合中的内容
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person
{
private String name;//人的属性
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
//覆盖hashCode值和equals方法
public int hashCode()
{
System.out.println(this.name+"....hashCode");
return name.hashCode()+age*37;
}
//如果姓名和年龄相同就为同一个人
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"...equals.."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}

TreeSet集合

可以对Set集合中的元素进行排序。底层数据结构是二叉树。

保证元素唯一性的依据：compareTo方法return 0.

TreeSet排序的第一种方式：自然排序

让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也成为元素的自然

顺序，或者叫做默认顺序。

TreeSet的第二种排序方式：比较器

当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始

化时，就有了比较方式。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时，以比较器排序为主。

练习：按字符串长度排序

class
TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StrLenComparator());//创建一个TreeSet，并传入一个比较器
ts.add("abcd");//添加元素
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator it = ts.iterator();//遍历打印这个集合，查看排序结果
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenComparator implements Comparator
{
public int compare(Object o1,Object o2)//覆盖compare方法
{
String s1 = (String)o1;
String s2 = (String)o2;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));//字符串按长度从短到长排序
if(num==0)
return s1.compareTo(s2);
return num;
}
}

四、Map集合

Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。

Map操作：

添加

put(K key, V value); //添加元素，如果出现相同的键，那么后添加的值会覆盖原有键对应值，且put方法返回被覆盖的值。

putAll(Map<? extends K, ? extends V> m);

删除

clear();

remove(Object key);

判断

containsValue(Object value);

containsKey(Object key);

isEmpty();

获取

get(Object key); //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断

size();

values();

map集合的两种取出方式：

(1).Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。

所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

(2).Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型

就是：Map.Entry

Entry其实就是Map中的一个static内部接口。

为什么要定义在内部？因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的

一个内部事物。而且该事物在直接访问Map集合中的元素。

Map取出示例代码

class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("01","zhangsan1");
map.put("04","zhangsan4");
//将Map集合中的映射关系取出。存入到Set集合中。
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+":"+value);
}
/*
//先获取map集合的所有键的Set集合,keySet();
Set<String> keySet = map.keySet();
//有了Set集合。就可以获取其迭代器。
Iterator<String> it = keySet.iterator();
while(it.hasNext())
{
String key = it.next();
//有了键可以通过map集合的get方法获取其对应的值。
String value
= map.get(key);
System.out.println("key:"+key+",value:"+value);
}
*/
}
}