目录
一、Collection 接口
Collection接口是层次结构中的根接口。构成Collection的单位称为元素。Collection接口通常不能直接使用，但该接口提供了添加元素、删除元素、管理数据的方法。由于List接口与Set接口都继承了Collection接口，因此这些方法对List集合与Set集合是通用的。常用方法如表：
| 方 法 | 功 能 描 述 |
| add（E e） | 将指定对象添加到该集合中 |
| remove(Object o) | 将指定的对象从该集合中删除 |
| isEmpty() | 返回boolean值，用于判断当前集合是否为空 |
| iterator() | 返回在此Collection的元素上进行迭代的迭代器。用于遍历集合中的对象 |
| size() | 返回int型值，获取该集合中元素的个数 |
如何遍历集合中的每个元素呢？
通常遍历集合，都是通过迭代器（Iterator)来实现。Collection接口中的iterator（）方法可以返回在此Collection进行迭代的迭代器。
在项目中创建类Muster，在主方法中实例化集合对象，并向集合中添加元素，最后将集合中的对象以String形式输出。
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator; //插入java.util包，其他实例都要添加该语句
public class Muster { //创建类Muster
public static void main(String[] args) {
Collection<String>list = new ArrayList<>(); //实例化集合类对象
list.add("a"); //向集合添加数据
list.add("b");
list.add("c");
lterator<String>it = (lterator<String>) list.iterator();//创建迭代器
while (((Iterator<?>) it).hasNext()){ //判断是否有下一个元素
String str = (String) ((Iterator<?>) it).next();//获取集合中的元素
System.out.println(str);
}
}
}注意：Iterator的next()方法返回的是 Object。
二、List集合
1、List接口
List接口继承了Collection接口，因此包含Collection中的所有方法。此外，List接口还定义了以下两个非常重要的方法。
- get（int index）：获得指定索引位置的元素
- set（int index，Object obj）：将集合中指定索引位置的对象修改为指定对象。
2、List接口的实现类
List接口的常用实现类有ArrayList与LinkedList。
ArrayList类实现了可变的数组，允许保存所有元素，包括null，并可以根据索引位置对集合进行快速的随机访问；缺点是向指定的索引位置插入对象或删除对象的速度较慢。
LinkedList类采用链表结构保存对象。这种结构的优点是便于向集合中插入和删除对象，需要问集合中的对象，使用LinkedList类实现List集合的效率较低。
使用List集合时通常声明为List类型，可通过不同的实现类来实例化集合。
分别通过ArrayList、LinkedList类实例化List集合。
List<E>list = new ArrayList<>();
List<E>listw = new LinkedList<>()；在上面的代码中，E可以是合法的Java数据类型。例如，如果集合中的元素为字符串类型，那么E可以修改为String。
在项目中创建类Gather，在主方法中创建集合对象，通过Math类的random()方法随机获取集合中的某个元素，然后移除数组中索引位置是“2”的元素，最后遍历数组。
import java.util.ArrayList;
import java.util.List;
public class Gather { //创建类Gather
public static void main(String[] args) { //主方法
List<String>list = new ArrayList<>(); //创建集合类对象
list.add("a"); //向集合添加元素
list.add("b");
list.add("c");
int i = (int)(Math.random()*list.size());//获得0~2之间的随机数
System.out.println("随机获取数组中的元素："+list.get(i));
list.remove(2); //将指定索引位置的元素从集合中移除
System.out.println("将索引是‘2’的元素从数组移除后，数组中的元素是：");
for (int j = 0;j < list.size();j++){ //循环遍历集合
System.out.println(list.get(j));
}
}
}
如上，Math类的random()方法可以获得一个0.0~1.0之间的随机数。
三、Set集合
Set集合中的对象不按特定的方式排序，只是简单的把对象加入集合中，但Set集合中不能包含重复对象。Set集合由Set接口和Set接口的实现类组成。Set接口继承了Collection接口，因此包含Collection接口的所有方法。
注意:Set的构造有一个约束条件，传入的Collection对象不能有重复值，必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true，则会出现一些问题。
Set常用的实现类有HashSet类与TreeSet类。
HashSet类实现Set接口，由哈希表（实际上是一个HashMap示例）支持。它不保证Set的迭代顺序，特别是它不保证该顺序恒久不变。此类允许使用null元素。
TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口，因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序，也可以按照指定比较器递增排序，即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。TreeSet类新增的方法如表：
| 方 法 | 功 能 描 述 |
| first() | 返回此Set中当前第一个（最低）元素 |
| last() | 返回此Set中当前最后一个（最高）元素 |
| comparator() | 返回对此Set中的元素进行排序的比较器。如果此Set使用自然顺序，则返回nuill |
| headSet(E toElement) | 返回一个新的Set集合，新集合时toElement（不包含）之前的所有对象 |
| subSet(E fromElement,E fromElement) | 返回一个新的Set集合，是fromElement（包含）对象与fromElement（不包含）对象之间的所有对象 |
| tailSet(E fromElement) | 返回一个新的Set集合，新集合包含对象fromElement（包含）之后的所有对象 |
中
在项目中创建类UpdateStu，实现Comparable接口，重写该接口中的compareTo()方法。在主方法中创建UpdateStu，创建集合，并将UpdateStu对象添加到集合中。遍历该集合中的全部元素，以及通过headSet()、subSet()方法获得部分集合。
import java.util.Iterator;
import java.util.TreeSet;
public class UpdateStu implements Comparable<Object>{ //创建类实现Comparable接口
String name;
long id;
public UpdateStu(String name,long id){ //构造方法
this.name = name;
this.id = id;
}
@Override
public int compareTo(Object o) {
UpdateStu upstu = (UpdateStu) o;
int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);//参照代码说明
return result;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public static void main(String[] args) {
UpdateStu stu1 = new UpdateStu("李",01011);
UpdateStu stu2 = new UpdateStu("王",01021); //创建UpdateStu对象
UpdateStu stu3 = new UpdateStu("欧阳",01031);
UpdateStu stu4 = new UpdateStu("上官",01041);
TreeSet<UpdateStu>tree = new TreeSet<>();
tree.add(stu1); //向集合添加对象
tree.add(stu2);
tree.add(stu3);
tree.add(stu4);
Iterator<UpdateStu> it = tree.iterator(); //Set集合中的所有对象的迭代器
System.out.println("Set集合中的所有元素:");
while (it.hasNext()){ //遍历集合
UpdateStu stu = (UpdateStu)it.next();
System.out.println(stu.getId()+""+stu.getName());
}
it = tree.headSet(stu2).iterator(); //截取排在stu2对象之前的对象
System.out.println("截取前面部分的集合:");
while (it.hasNext()){ //遍历集合
UpdateStu stu = (UpdateStu)it.next();
System.out.println(stu.getId()+""+stu.getName());
}
it = tree.subSet(stu2,stu3).iterator(); //截取排在stu2与stu3之间的对象
System.out.println("截取中间部分的集合:");
while (it.hasNext()){ //遍历集合
UpdateStu stu = (UpdateStu) it.next();
System.out.println(stu.getId()+""+stu.getName());
}
}
}
代码说明：存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的compareTo(Object o)方法比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、0或正整数。
技巧：headSet ()、subSet ()、tailSet ()方法截取对象生成新集合时是否包含指定的参数，可通过如下方法来判别：如果指定参数位于新集合的起始位置，则包含该对象，如subSet()方法的第一个参数和 tailSet()方法的参数；如果指定参数是新集合的终止位置，则不包含该参数，如headSet()方法的入口参数和 subSet ()方法的第二个入口参数。
四、Map集合
Map 集合没有继承 Collection 接口，其提供的是 key 到 value 的映射。 Map 中不能包含相同的 key 每个 key 只能映射一个 value 。 key 还决定了存储对象在映射中的存储位置，但不是由 key 对象本身决定的，而是通过一种“散列技术”进行处理，产生一个散列码的整数值。散列码通常用作一个偏移量该偏移量对应分配给映射的内存区域的起始位置，从而确定存储对象在映射中的存储位置。 Map 集台包括 Map 接ロ以及 Map 接口的所有实现类。
1、Map接口
Map 接口提供了将 key 映射到值的对象。一个映射不能包含重复的 key ，每个 key 最多只能映射到一个值。 Map 接口中同样提供了集合的常用方法，
| 方 法 | 功 能 描 述 |
| put (K key,V value) | 向集合中添加指定的 key 与 value 的映射关系 |
| containsKey (Object key) | 如果此映射包含指定 key 的映射关系，则返回 true |
| containsValue (Object value) | 如果此映射将一个或多个 key 映射到指定值，则返回 true |
| get (Object key) | 如果存在指定的 key 对象，则返回该对象对应的值，否则返回 nul |
| keySet() | 返回该集合中的所有 key 对象形成的 Set 集合 |
| value() | 返回该集合中所有值对象形成的 Colection 集合 |
在项目中创建类Updatestu，在主方法中创建Map集合，并获取Map集合中所有key对象的集合和所有values值的集合，最后遍历集合。
import java.util.*;
public class UpdateStu {
public static void main(String[] args) {
Map<String,String>map = new HashMap<>(); //创建Map实例
map.put("01","Li"); //向集合中添加对象
map.put("02","Wang");
Set<String>set = map.keySet(); //构建Map集合中所有key对象的集合
Iterator<String>it = set.iterator(); //创建集合迭代器
System.out.println("key集合中的元素：");
while (it.hasNext()){ //遍历集合
System.out.println(it.next());
}
Collection<String>coll = map.values(); //构建Map集合中所有values的值
it = coll.iterator();
System.out.println("values集合中的所有元素：");
while (it.hasNext()){ //遍历集合
System.out.println(it.next());
}
}
}说明：Map 集合中允许值对象是 nul ，而且没有个数限制。例如，可通过“ map . put ("05", null );”语句向集合中添加对象
2、Map接口的实现类
Map 接口常用的实现类有 HashMap 和 TreeMap 。建议使用 HashMap 类实现 Map 集合，因为由 HashMap 实现的 Map 集合添加和删除映射关系效率更高。 HashMap 是基于哈希表的 Map 接口的实现，HashMap 通过哈希码对其内部的映射关系进行快速查找；而 TreeMap 中的映射关系存在一定的顺序，如果希望 Map 集合中的对象也存在一定的顺序，应该使用 TreeMap 类实现 Map 集合。
HashMap 类是基于哈希表的 Map 接口的实现，此实现提供所有可选的映射操作，并允许使用null 值和 null 键，但必须保证键的唯一性。 HashMap 通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
TreeMap 类不仅实现了 Map 接口，还实现了 java . util . SortedMap 接口，因此，集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系时， TreeMap 类比 HashMap 类性能稍差。由于 TreeMap 类实现的 Map 集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是 null 。
可以通过 HashMap 类创建 Map 集合，当需要顺序输出时，再创建一个完成相同映射关系的 TreeMap 类实例。
通过HashMap类实例化Map集合，并遍历该Map集合，然后创建TreeMap实例化将集合中的元素顺序输出。
public class Emp {
private String e_id;
private String e_name;
public Emp(String e_id,String e_name){
this.e_id = e_id;
this.e_name = e_name;
}
public String getE_id() {
return e_id;
}
public void setE_id(String e_id) {
this.e_id = e_id;
}
public String getE_name() {
return e_name;
}
public void setE_name(String e_name) {
this.e_name = e_name;
}
}import java.util.*;
//创建类MapText
public class MapText {
//主方法
public static void main(String[] args) {
//由HashMap实现的Map对象
Map<String,String>map = new HashMap<>();
//创建Emp对象
Emp emp = new Emp("159","张三");
Emp emp2 = new Emp("365","李四");
Emp emp3 = new Emp("475","王五");
Emp emp4 = new Emp("968","赵六");
Emp emp5 = new Emp("567","黄七");
//将对象添加到集合中
map.put(emp4.getE_id(),emp4.getE_name());
map.put(emp5.getE_id(),emp5.getE_name());
map.put(emp.getE_id(),emp.getE_name());
map.put(emp2.getE_id(),emp2.getE_name());
map.put(emp3.getE_id(),emp3.getE_name());
//获取Map集合中的key对象集合
Set<String>set = map.keySet();
Iterator<String>it = set.iterator();
System.out.println("HashMap类实现的Map集合，无序：");
//遍历Map集合
while (it.hasNext()){
String str = (String) it.next();
String name = (String) map.get(str);
System.out.println(str+""+name);
}
//创建TreeMap集合对象，向集合中添加对象
TreeMap<String,String>treeMap = new TreeMap<>();
treeMap.putAll(map);
Iterator<String>iter = treeMap.keySet().iterator();
System.out.println("TreeMap类实现的Map集合，键对象升序：");
//遍历TreeMap集合对象，获取集合中所有的key对象，获取集合中所有values值
while (iter.hasNext()){
String str = (String) iter.next();
String name = (String) treeMap.get(str);
System.out.println(str+""+name);
}
}
}
281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
