位于java.util包中
集合中的元素全部是对象，即Object类的实例
特征：存储一组不唯一、无序的对象
集合方法的好处：在程序运行时不知道会需要多少对象，或者需要更复杂方式存储对象，可以使用Java集合框架。
缺点：（1）数组长度固定不变
（2）不便存储具有映射关系的数据
（3）数据变更效率低下
一、Collection接口
Collection 接口存储一组不唯一，无序的对象
Collection接口是List、Set接口的父接口
接口里定义的方法即可用于操作Set集合，也可用于操作List集合
常用方法:
| 方法名 | 详情 |
| boolenan add(Object o) | 用于向集合中添加一个元素 如果集合不允许重复且已包含了指定元素，则返回false |
| boolean addAll(Collection c) | 将集合c里所有元素添加到指定集合里。添加成功返回true |
| void clear() | 清除集合中所有元素，将集合长度变为为0 |
| boolean contains(Object o) | 判断集合中是否包含指定元素 |
| boolean containsAll(Collection c) | 判断集合中是否包含集合c里所有的元素 |
| boolean remove(Object o) | 删除集合中的指定元素o。当集合中包含了一个或多个元素o时，这些元素将被删除。删除成功，返回true |
| int size() | 返回集合里元素的个数 |
| boolean retainAll(Collection c) | 从集合中删除集合c里不包含的元素（相当于把调用该方法的集合变成该集合和集合c的交集） 如果该操作改变了调用该方法的集合，则返回true |
| boolean removeAll(Collection c) | 从集合中删除集合c里包含的所有元素 如果删除了一个或一个以上的元素，则返回true |
| boolean isEmpty() | 如果此集合中不包含任何元素，则返回true |
| Object[] toArray() | 该方法把集合转换成一个数组，所有的集合元素变成对应的数组元素 |
Collection接口示例
import java.util.Collection;
import java.util.ArrayList;
public class asd {
public static void main(String[] args){
Collection fruitList1 = new ArrayList();
System.out.println("********添加元素add()**********");//存储信息
fruitList1.add("java") ;
fruitList1.add("java");
System.out.println("********获取元素个数size()**********"); //获取总数
System.out.println("第1个集合一共添加了"+fruitList1.size()+"类信息。");
System.out.println("********删除元素remove()**********"); //删除指定数据
fruitList1.remove(5);
System.out.println("第1个集合里的元素："+fruitList1);
System.out.println("********判断集合是否包含指定元素contains()**********"); //判断集合中是否包含指定数据
System.out.println("第1个集合中是否包含Java？"+fruitList1.contains("Java"));
Collection fruitList1 = new ArrayList(); //输出全部信息
//省略添加元素的代码
System.out.println("********判断集合包含关系containsAll()**********");
Collection fruitList2 = new HashSet();
//省略添加元素的代码
System.out.println("第2个集合是否包含第1个集合？" + fruitList2.containsAll(fruitList1));
System.out.println("********删除集合2全部元素clear()**********"); //清空集合
fruitList2.clear();
}
}
二、集合遍历
（1）迭代器Iterator
Iterator对象也被称为迭代器
获取Iterator ：Collection 接口的iterator()方法
Iterator接口定义的方法
| 方法 | 描述 |
| boolean hasNext() | 是否存在下一个迭代元素，存在则返回true |
| Object next() | 返回迭代的下一个元素 |
| void remove() | 删除集合里上一次next()方法返回的元素 |
使用Iterator对象遍历集合案例
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class asd {
public static void main(String[] args){
public class Fruit {
private String brand;
private double price;
//省略setter/getter()方法
public Fruit() {}
public Fruit(String brand, double price) {
this.brand = brand;
this.price = price;
}
//输出信息
public void show() {
System.out.println(this.brand+",每斤"+this.price+"元。");
}
}
//省略创建一个集合对象，添加集合元素的代码
Iterator it = fruitList.iterator();
while(it.hasNext()) {
Fruit fruit = (Fruit)it.next();
fruit.show();
}
}
}Iterator的使用必依赖于Collection对象
Iterator仅用于遍历集合，并不提供储存数据的功能
使用Iterator迭代访问Collection集合时，可调用Iterator的remove()方法删除集合元素
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class asd {
public static void main(String[] args){
Iterator it = fruitList.iterator();
while(it.hasNext()) {
Fruit fruit = (Fruit)it.next();
if(fruit.brand.equals("java")) {
it.remove();
} else {
fruit.show();
}
}
}
}（2）foreach循环
可用于遍历集合和数组
语法：
for(数据类型type 迭代变量名value:迭代对象object) {
//引用迭代变量value的语句
}
案例：
public class asd {
public static void main(String[] args){
for(Object obj:fruits) {
Fruit fruit = (Fruit)obj;
fruit.show();
}
}
}与Iterator接口类似，foreach循环中迭代变量也不是集合元素本身，系统只是依次把集合元素的值赋给迭代变量。因此，在foreach循环中修改迭代变量的值也没有任何实际意义
三、List接口
a.继承Collection接口，存储一组可重复的有序对象
b.元素顺序以元素插入的次序来放置元素，不会重新排序
c.通过索引访问数组元素，索引从0开始
索引操作集合元素的方法:
| 方法 | 描述 |
| void add(int index,Object element) | 将元素(element)插入到List的指定位置（index）处 |
| boolean addAll(intindex,Collection c) | 将集合c所包含的所有元素都插入List集合指定位置（index）处 |
| Object get(int index) | 返回集合index索引处的元素 |
| int indexOf(Object o) | 返回对象o在List集合中第一次出现的位置索引 |
| int lastIndexOf(Object o) | 返回对象o在List集合中最后一次出现的位置索引 |
| Object remove(int index) | 从集合中删除指定位置的元素 |
| boolean remove(Object o) | 从集合中删除指定对象 |
| Object set(int index,Object element) | 将index索引处的元素替换成element对象，返回新元素 |
| List subList(int fromIndex,int toIndex) | 返回从索引fromIndex（包含）到索引toIndex（不包含）处所有集合元素组成的子集合 |
List集合
是List接口所有实现类组成的集合
1.ArrayList类实现长度可变的数组
在内存中分配连续的空间
2.LinkedList类采用双向链表存储方式
插入、删除元素时效率比较高
每个节点中都有两个指针
（1）ArrayList类
import java.util.ArrayList;
public class asd {
public static void main(String[] args){
List fruits = new ArrayList(); //创建集合和元素对象
Fruit fruit1 = new Fruit("java1",2.5);
Fruit fruit2 = new Fruit("java2",2.0);
Fruit fruit3 = new Fruit("java3",3.5);
Fruit fruit4 = new Fruit("java4",3.0);
System.out.println("*******向集合中存储信息********");
fruits.add(fruit1);
fruits.add(fruit2);
fruits.add(fruit3);
showData(fruits);
/* public static void showData(List list) {
for(int i=0;i<list.size();i++) {
Fruit fruit = (Fruit)list.get(i);
fruit.show();
}
*/
}
}
注意事项
1.可以使用索引访问List集合元素
2.可以使用for循环遍历List集合
3.List集合中存放的都是Object类对象
4.add(Object o)方法的参数是Object类对象
5.调用set(int index,Object o)方法改变List集合指定索引的元素时，指定的索引必须是List集合的有效索引
6.set(int index,Object o)方法不会改变List集合的长度
（2）LinkedList类
具有双向链表结构，更加方便实现添加和删除操作
除了具有List接口扩展的方法外，还提供了实现链表操作的方法
| 方法 | 描述 |
| void addFirst(Object o) | 在链表的首部添加元素 |
| void addLast(Object o) | 在链表的末尾添加元素 |
| Object getFirst() | 返回链表中第一个元素 |
| Object getLast() | 返回链表中最后一个元素 |
| Object removeFirst() | 删除并返回链表中的第一个元素 |
| Object removeLast() | 删除并返回链表中的最后一个元素 |
import java.util.LinkedList;
public class asd {
public static void main(String[] args){
LinkedList fruits = new LinkedList(); //新建集合及元素对象
Fruit fruit1 = new Fruit("1号", 2.5);
Fruit fruit2 = new Fruit("2号", 2.0);
Fruit fruit3 = new Fruit("3号", 3.5);
Fruit fruit4 = new Fruit("4号", 3.0);
fruits.add(fruit1); //向集合中添加元素对象
fruits.add(fruit2);
fruits.add(fruit3);
fruits.add(fruit4);
System.out.println("集合中包含信息如下：");
showData(fruits);
/* public static void showData(List list) {
for(int i=0;i<list.size();i++) {
Fruit fruit = (Fruit)list.get(i);
fruit.show();
}*/
Fruit firstFruit = (Fruit) ((LinkedList) fruits).getFirst(); //查看集合中第一条信息
System.out.println("集合中第一类："+firstFruit.getBrand());
Fruit lastFruit = (Fruit) ((LinkedList) fruits).getLast(); //查看集合中最后一条信息
System.out.println("集合中最后一类："+lastFruit.getBrand());
fruits.removeFirst(); //删除集合中第一条和最后一条信息
fruits.removeLast();
System.out.println("删除部分信息后还有"+fruits.size()+"条信息。如下：");
showData(fruits);
}
}（3）ArrayList类和LinkedList类对比
ArrayList类和LinkedList类的共同点
1.可以容纳所有类型的元素对象，包括null
2.元素值可以重复
3.元素按顺序存储
ArrayList类特点
底层是数组
优点：基于数组实现，读取操作效率高
缺点：不适合频繁进行插入和删除操作，因为每次执行该类操作都需要频繁移动其中的元素
LinkedList类特点
由双向链表实现，任意一个节点都可以方便地访问它的前驱节点和后继节点
优点：增加、删除操作只需修改链表节点指针，不需进行频繁的移动
缺点：遍历效率较低
四、Set接口
特征：继承Collection接口，存储一组唯一、无序的对象
继承关系：
（1）HashSet类
特征
1.不允许存储重复的元素
2.没有索引，没有包含索引的方法，不能使用索引遍历
3.无序集合，存储元素和取出元素的顺序可能不一致
import java.util.HashSet;
public class asd {
public static void main(String[] args){
//创建一个HashSet集合和多条数据
Set fruits = new HashSet();
Fruit fruit1 = new Fruit("苹果", 2.5);
Fruit fruit2 = new Fruit("香蕉", 2.0);
//向集合中添加元素
fruits.add(fruit1);
fruits.add(fruit2);
System.out.println("添加重复元素，是否成功："+fruits.add(fruit1));
//遍历集合
for(Object o:fruits) {
Fruit fruit = (Fruit)o;
fruit.show();
}
}
}
五、Map接口
特征：存储一组成对的键-值对象，提供key到value的映射
Key：不要求有序，不允许重复
Value：不要求有序，但允许重复
与Collection接口不存在继承关系
常用方法：
| 方法 | 描述 |
| Object put(Object key,Object value) | 以“键-值对”的方式进行存储 |
| Object get（Object key） | 返回指定键所对应的值。如果不存在指定的键，返回null |
| int size() | 返回元素个数 |
| boolean remove(Object key) | 删除指定的键映射的“键-值对” |
| Set keyset() | 返回键的集合 |
| Collection values() | 返回值的集合 |
| boolean containsKey(Object key) | 如果存在指定的键映射的“键-值对”，则返回true |
| Set entrySet() | 返回“键-值对”集合 |
| boolean isEmpty() | 若不存在“键-值对”元素，则返回true |
| void clear() | 删除该Map对象中的所有“键-值对” |
关系：
import java.util.*;
public class asd {
public static void main(String[] args){
//省略代码 创建对象
Fruit fruit1 = new Fruit("梨",2.5);
Fruit fruit2 = new Fruit("苹果",2.0);
Fruit fruit3 = new Fruit("香蕉",3.5);
Fruit fruit4 = new Fruit("西瓜",3.0);
Map fruitMap = new HashMap(); //创建Map集合对象并添加水果元素
fruitMap.put(fruit1.getBrand(),fruit1);
fruitMap.put(fruit2.getBrand(),fruit2);
fruitMap.put(fruit3.getBrand(),fruit3);
fruitMap.put(fruit4.getBrand(),fruit4);
System.out.println("所有水果数据如下："); //通过迭代器依次输出集合中所有的水果信息
Set keys = fruitMap.keySet();
Iterator it = keys.iterator();
while(it.hasNext()) {
String key = (String)it.next();
Fruit fruit = (Fruit)fruitMap.get(key);
fruit.show();
}
}
}
（1）Map.Entry接口
特征：用于保存“键-值对”元素
运用Map.Entry接口遍历集合
1.通过entrySet()方法获取所有“键-值”对元素的集合
2.遍历集合中每个元素，进行键和值的分离
| 方法 | 描述 |
| Object getKey() | 取得此“键-值对”对应的key值 |
| Object getValue() | 取得此“键-值对”相对应的value值 |
| int hashCode() | 返回该“键-值对”的哈希码值 |
| Object setValue(Object value) | 用指定的值替换该“键-值对”的value值 |
Set allSet = fruitMap.entrySet(); //获取键值对集合 Map.Entry对象集合
Iterator it = allSet.iterator();
while(it.hasNext()){
Map.Entry me = (Map.Entry)it.next();
System.out.println(me.getKey()+" "+((Fruit)me.getValue()).getPrice());
}
（2）Hashtable类
与HashMap类具有相似的特征，也可以存储“键-值对”元素
Map接口实现类
Hashtable类和HashMap类之间存在的区别
| HashtableHashtable | HashMap |
| 继承自Dictionary类 | Java1.2引进的Map interface的一个实现 |
| 比HashMap要古老 | 是Hashtable的轻量级实现 |
| 线程安全 | 线程不安全 |
| 不允许有null的键和值 | 允许有null的键和值 |
| 效率稍低 | 效率稍高 |
六、泛型集合
特征：1.约束集合的元素类型
2.从集合中取出数据无需进行类型转换
语法：
List<E>
Map<K,V>
案例：
import java.util.*;
public class asd {
public static void main(String[] args){
List<Fruit> fruits = new ArrayList<Fruit>(); //限制元素类型
Fruit fruit1 = new Fruit("香水梨",2.5);
Fruit fruit2 = new Fruit("苹果梨",2.0);
Fruit fruit3 = new Fruit("富士苹果",3.5);
Fruit fruit4 = new Fruit("金帅苹果",3.0);
//添加元素
fruits.add(fruit1);
fruits.add(fruit2);
fruits.add(fruit3);
fruits.add(fruit4);
//循环迭代
Iterator it = fruits.iterator();
for(int i=0;i<fruits.size();i++){
Fruit fruit = fruits.get(i); //无需强制转换
fruit.show();
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
