一 . 概述
1. 集合定义
集合也称容器，用来存储数据（变量/对象）。相对于数组，集合类实现了动态存储、删除数据，并各有特点，我们根据具体的实际应用来选择实现集合。
二 . 集合类
1. 集合接口&实现类
-
（1）Collection<>（接口）
- 1）List<>（接口）
- |ArrayList（子类）
- |LinkedList（子类）
- 2）Set<>（接口）
- |HashSet（子类）
- 3）Queue<>（接口）
- 4）Stack（实现类）
- 1）List<>（接口）
-
（2）Map<>（接口）
- 1）HashMap（子类）
- 2）HashTable（子类）
- 3）TreeMap（子类）
2. Collection 概述
Collection<>:存储多个单一对象
1.List<>接口（线性表）
实现List接口的集合是有序序列，元素间具有线性（前驱后继）关系，可以对序列的
每个元素位置进行精确控制，根据元素索引下标访问元素，List接口中的元素可以重复
（1）ArrayList：（线性表—顺序存储）
特点：底层是用数组实现，但大小可动态改变；查找快，插入、删除慢
（2）LinkedList：（线性表-链式存储）
特点：底层是链表，实现了Queue接口，插入、删除快，查找慢
2.Set<>接口 （集合）
不包含重复元素的 collection，元素间不具有线性关系，基于Map（映射）的特殊结构，实现set接口的集合是无序序列，不能通过索引下标访问数据元素，
该序列元素不能重复
（1）HashSet:（集合-哈希函数）
由哈希表（实际上是一个 HashMap 实例）支持。
它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素
特点：元素逻辑地址不相邻，通过哈希函数指向其存储地址
（2）TreeSet：（集合-树）
基于 TreeMap 的 NavigableSet 实现。
使用元素的自然顺序对元素进行排序，或者根据创建 set 时
提供的 Comparator 进行排序，具体取决于使用的构造方法
特点：具有排序功能
3.Queue<>接口（队列）：
一端删除、另一端插入的【线性表】；先入先出；实现类：（例）LinkedList
4.Stack实现类（堆栈）：
只在一端插入、删除的【线性表】；先入后出；实现了List接口
3. Collection 方法
（1）add(E e) -boolean
向集合（尾部）添加元素
（2）addAll(Collection<? extends E> c) -boolean
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）
（3）clear() -void
移除此 collection 中的所有元素（可选操作)
（4）contains(Object o) -boolean
如果此 collection 包含指定的元素，则返回 true
（5）containsAll(Collection<?> c) -boolean
如果此 collection 包含指定 collection 中的所有元素，则返回 true
（6）equals(Object o) -boolean
比较此 collection 与指定对象内容（而非地址）是否相等
（7）hashCode() -int
返回此 collection 的哈希码值
（8）isEmpty() -boolean
如果此 collection 不包含元素，则返回 true
（9）iterator() -Iterator<E>
返回在此 collection 的元素上进行迭代的迭代器
（10)remove(Object o) -boolean
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）
（11）removeAll(Collection<?> c) -boolean
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）
（12）retainAll(Collection<?> c) -boolean
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）
（13）size() -int
返回此 collection 中的元素数
（14） toArray() -Object[]
返回包含此 collection 中所有元素的数组
（15） toArray(T[] a) -<T> T[]
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组
的运行时类型相同
4. Collection — 实现类 方法
继承父类Collection(),并实现了更多个性化()
1.List<>
（0）clone() -Object
返回此List实例的浅表副本
（1）get(int index) - E
返回列表中指定位置的元素
（2）indexOf(Object o) - int
返回此列表中第一次出现的指定元素的索引；
如果此列表不包含该元素，则返回 -1
（3）lastIndexOf(Object o) - int
返回此列表中最后出现的指定元素的索引；
如果列表不包含此元素，则返回 -1
（4）listIterator() -ListIterator<E>
返回此列表元素的列表迭代器（按适当顺序）
（5）set(int index, E element) -E
用指定元素替换列表中指定位置的元素（可选操作）
（6）toArray() - Object[]
返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）
|ArrayList
（1）ArrayList()
构造一个初始容量为 10 的空列表
（2）ArrayList(int initialCapacity)
构造一个具有指定初始容量的空列表
|LinkedList
（1）LinkedList()
构造一个空列表
（2）add(int index, E element) -void
在此列表中指定的位置插入指定的元素
（3）addFirst(E e) -void
将指定元素插入此列表的开头。
（4）addLast(E e) -void
将指定元素添加到此列表的结尾
（5）peek() -E
获取但不移除此列表的头（第一个元素）
（6）poll() -E
获取并移除此列表的头（第一个元素）
（7）pop() -void
从此列表所表示的堆栈处弹出一个元素
（8）push(E e) -void
将元素推入此列表所表示的堆栈
2.Set<>
（1）iterator() -Iterator<E>
返回对此 set 中元素进行迭代的迭代器
————补充说明：
Iterator<E>：{
hasNext() -boolean
如果仍有元素可以迭代，则返回 true
next() -E
返回迭代的下一个元素。
remove() -void
从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
}
|HashSet
|TreeSet
（1）TreeSet()
构造一个新的空 set，该 set 根据其元素的自然顺序进行排序
（2）TreeSet(Comparator<? super E> comparator)
构造一个新的空 TreeSet，它根据指定比较器进行排序
（3）ceiling(E e) -E
返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null
（4）comparator() - Comparator<? super E>
返回对此 set 中的元素进行排序的比较器；
如果此 set 使用其元素的自然顺序，则返回 null
（5）first() -E
返回此 set 中当前第一个（最低）元素
（6）floor(E e) -E
返回此 set 中小于等于给定元素的最大元素；
如果不存在这样的元素，则返回 null
（7）higher(E e) -E
返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null
（8）last() -E
返回此 set 中当前最后一个（最高）元素
（9）lower(E e) -E
返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null
3.Queue<>
（1）peek() -E
获取但不移除此队列的头；如果此队列为空，则返回 null
（2）poll() -E
获取并移除此队列的头，如果此队列为空，则返回 null
4.Stack
（1）Stack()
创建一个空堆栈
（2）peek() -E
查看堆栈顶部的对象，但不从堆栈中移除它
（3）pop() -E
移除堆栈顶部的对象，并作为此函数的值返回该对象
（4）push(E item) -E
把项压入堆栈顶部
（5）search(Object o) -int
返回对象在堆栈中的位置，以 1 为基数
5. Map 概述
Map<K,V>接口:（映射）
存储多个成对（键值对）的对象，一个集合中不能由重复键，每个键唯一对应一个值
1.HashMap<K,V>（实现类）：
基于哈希表的 Map 接口的实现；
此实现提供所有可选的映射操作，并允许使用 null 值和 null 键；
此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）
2.HashTable<K,V>（实现类）：
此类实现一个哈希表，该哈希表将键映射到相应的值。
任何非 null 对象都可以用作键或值。
为了成功地在哈希表中存储和获取对象，
用作键的对象必须实现 hashCode 方法和 equals 方法。
3.TreeMap<K,V>（实现类）：
基于红黑树（Red-Black tree）的 NavigableMap 实现。
该映射根据其键的自然顺序进行排序，或者根据创建映射时
提供的 Comparator 进行排序，具体取决于使用的构造方法
6. Map 方法
1.Map<K,V>
（1）clear() -void
从此映射中移除所有映射关系（可选操作）
（2）clone() -Object
返回Map实现类实例的浅表副本
（2）equals(Object o) -boolean
比较指定的对象与此映射是否相等
（3）get(Object key) -V
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
（4）isEmpty() -boolean
如果此映射不包含键-值映射关系，则返回 true
（5）put(K key, V value) -V
将指定的值与此映射中的指定键关联（可选操作）
（6）remove(Object key) -V
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）
（7）size() -int
返回此映射中的键-值映射关系数
7. Map实现类 方法
1.HashMap
（1）HashMap()
构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
（2）HashMap(int initialCapacity)
构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap
2.HashTable
（1）Hashtable()
用默认的初始容量 (11) 和加载因子 (0.75) 构造一个新的空哈希表。
（2）Hashtable(int initialCapacity)
用指定初始容量和默认的加载因子 (0.75) 构造一个新的空哈希表
（3）contains(Object value) -boolean
测试此映射表中是否存在与指定值关联的键
（4）containsKey(Object key) -boolean
测试指定对象是否为此哈希表中的键。
（5）containsValue(Object value) -boolean
如果此 Hashtable 将一个或多个键映射到此值，则返回 true
（6）hashCode()
按照 Map 接口的定义，返回此 Map 的哈希码值
3.TreeMap
（1）TreeMap()
使用键的自然顺序构造一个新的、空的树映射。
（2）TreeMap(Comparator<? super K> comparator)
构造一个新的、空的树映射，该映射根据给定比较器进行排序
（3）ceilingEntry(K key) -Map.Entry<K,V>
返回一个键-值映射关系，它与大于等于给定键的最小键关联；
如果不存在这样的键，则返回 null。
（4）ceilingKey(K key) -K
返回大于等于给定键的最小键；如果不存在这样的键，则返回 null
（5）comparator() -Comparator<? super K>
返回对此映射中的键进行排序的比较器；
如果此映射使用键的自然顺序，则返回 null
（6）containsKey(Object key)
如果此映射包含指定键的映射关系，则返回 true。
（7）containsValue(Object value) -boolean
如果此映射为指定值映射一个或多个键，则返回 true
7. 集合辅助类&接口
- | Collections（类）
概述： 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容
- | Compareble（接口）
概述： 强行对某个对象 collection 进行整体排序 的比较函数
8. 集合辅助类&接口 方法
1. Collections（类）
（1）copy(List1, List2) -void
将所有元素从一个列表复制到另一个列表
（2）fill(List-list, T obj) -void
使用指定元素替换指定列表中的所有元素
（3）max(Collection coll) -T
根据元素的自然顺序，返回给定 collection 的最大元素
（4）min(Collection coll) -T
根据元素的自然顺序 返回给定 collection 的最小元素
（5）reverse(List<?> list)
反转指定列表中元素的顺序
2.Compareble（接口）
（1）compare(T o1, T o2) -int
比较用来排序的两个参数。
equals(Object obj) -boolean
（2）指示某个其他对象是否"等于"此 Comparator
三 . 代码实例
1.数组
public class Test_Array implements Comparable {
String name;
int age;
public static void main(String[] args) {
Test_Array stu1 = new Test_Array("顾一"); // 学生被创建的时候就有名字
Test_Array stu2 = new Test_Array("王二");
Test_Array stu3 = new Test_Array("李三");
Test_Array stu4 = new Test_Array("杨四");
// 定义 存储学生的数组
Test_Array[] stus = new Test_Array[3]; // 0,1,2
stus[0] = stu1;
// stus[3] = stu4; 数组下标越界异常Arrayoutofbounds
// stus =new Test_Array[10000]; 我们不能去通过定义一个足够大的数组来保证足够的存储空间
}
// 构造方法：将学生姓名传给对象
public Test_Array(String name) {
this.name = name;
}
// 重写 toString
public String toString() {
return name;
}
// 重写 equals
public boolean equals(Object obj) {
// 判断 obj 是不是空的
if (obj == null) {
return false;
} else {
// 判断 obj 和 当前对象是不是一个类型
if (this.getClass() == obj.getClass()) {
// 比较
// 强转
Test_Array stu = (Test_Array) obj;
if (this.name.equals(stu.name)) {
return true;
}
}
}
return false;
}
public int hashCode() {
return age;
}
public int compareTo(Object o) {
return 0;
}
}
2.List
import java.util.ArrayList;
import java.util.List;
public class Test_List {
String name;
public static void main(String[] args) {
Test_List stu1 = new Test_List("顾一");// 学生被创建的时候就有名字
Test_List stu2 = new Test_List("王二");
Test_List stu3 = new Test_List("李三");
Test_List stu4 = new Test_List("杨四");
Test_List stu5 = new Test_List("杨四");
// 用集合存对象
List l = new ArrayList();// 父类引用指向子类对象
l.add(stu1);
l.add(stu2);
l.add(stu3);
l.add(stu4);
l.add(stu5);
System.out.println(l);
for (int i = 0; i < l.size(); i++) {
System.out.println(l.get(i));
}
}
// 构造方法：将学生姓名传给对象
public Test_List(String name) {
this.name = name;
}
public String toString() {
return name;
}
}
3.Set
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test_Set {
String name;
public static void main(String[] args) {
Test_Set stu1 = new Test_Set("顾一");// 学生被创建的时候就有名字
Test_Set stu2 = new Test_Set("王二");
Test_Set stu3 = new Test_Set("李三");
Test_Set stu4 = new Test_Set("杨四");
Test_Set stu5 = new Test_Set("杨四");
System.out.println(stu4.equals(stu5));
System.out.println(stu4.hashCode());
System.out.println(stu5.hashCode());
// 创建set 对象
Set s = new HashSet();
s.add(stu1);
s.add(stu2);
s.add(stu3);
s.add(stu4);
s.add(stu5);
System.out.println(s);
// 遍历
Iterator it = s.iterator();
while (it.hasNext()) {
Object obj = it.next();
System.out.print(obj + " ");
}
Set ss = new HashSet();
ss.add("aa");
ss.add("ab");
ss.add("ac");
ss.add("aa");
ss.add("ad");
Iterator it1 = ss.iterator();
while (it1.hasNext()) {
System.out.print(it1.next() + " ");
}
}
// 构造方法：将学生姓名传给对象
public Test_Set(String name) {
this.name = name;
}
public String toString() {
return name;
}
}
4.Map
public class Test_Map {
public static void main(String[] args) {
Map m = new HashMap();
m.put(new Integer(1), "abc");
m.put(2, "abc");
m.put(3, "efg");
// 遍历
Set s = m.keySet();
Iterator it = s.iterator();
while (it.hasNext()) {
Object key = it.next();
Object value = m.get(key);
System.out.println(key + ":" + value);
}
}
}
5. Collections
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Test_Collections {
public static void main(String[] args) {
List<String> l = new ArrayList<String>();
for (int i = 1; i <= 10; i++) {
l.add("a" + i);
}
System.out.println(l);
Collections.reverse(l);
System.out.println(l);
Collections.sort(l);
System.out.println(l);
Collections.shuffle(l);
System.out.println(l);
Collections.sort(l);
int i = Collections.binarySearch(l, "a5");
System.out.println(i);
}
}
6. 泛型&集合
import java.util.ArrayList;
import java.util.List;
//泛型：避免类型转换带来的风险
public class Test_Genericity {
public static void main(String[] args) {
Var<String> v=new Var<String>();
Var<Integer> v2=new Var<Integer>();
Var<Number> v3=new Var<Number>();
Var<Object> v4=new Var<Object>();
// v.setValue(1);
v.setValue("aa");
// v.setValue(v);
v.m(v2);
v.m(null);
//v.m(v);// v 不 是 Number的子类
v.m1(v3);
v.m1(v4);
List<Integer> l =new ArrayList<Integer>();
Var1 v1 =new Var1();
v1.setValue(1);
}
}
class Var<T>{ // T 就是 type 的缩写
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
private T value;
// 泛型的通配符
public void m(Var<? extends Number> v){}// ？ 这个参数 是Number的子类
public void m1(Var<? super Number> v){}// ？ 这个参数 是Number的父类
public void m2(Var<T> v){}
}
class Var1{
private int value;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
扫一扫
5400
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
