Table of Contents
Java集合框架
1:基本概念
集合是包含多个对象的简单对象,所包含的对象称为元素。集合的典型应用是用来处理多种类型的对象,这些类型必须有共同的父类。
“集合框架”由一组用来操作对象的接口组成。不同接口描述不同类型的组。在很大程度上,一旦你理解了接口,就理解了框架。
虽然总要创建接口特定的实现,但访问实际集合的方法应该限制在接口方法的使用上;因此,允许更改基本的数据结构而不必改变其它代码。框架接口层次结构如下图所示。
2:Conllection接口
在 Collection 接口中声明了适用于 Java 集合(只包含 Set 和 List)的通用方法。
3:List(列表)
与集合父类重复的不再赘述
void add(E e) | 将指定元素加在列表的末尾 |
void add (int index,E.element) | 向list中指定位置插入元素 |
boolean addAll (Collection c) | 将指定集合的所有元素都加载改集合末尾 |
E get(int index) | 返回列表中指定元素 |
int indexOf(Object o) | 返回列表中第一次出现元素的位置 |
int lastIndexOf() | 返回列表中最后一次出现元素的位置 |
E remove(int index) | 移除列表中指定位置的元素 |
E set(int index,E element) | 用指定元素替换指定位置的元素 |
List<E> subList(int fromIndex,int toIndex) | 返回列表中指定的 fromIndex(包括)和 toIndex(不包括)之间的部分视图 |
4:Set(集)
set的方法基本和list没有区别,只不过set是无序的
boolean add(E e) | 如果 set 中尚未存在指定的元素,则添加此元素 |
boolean contains(Object o) | 如果 set 包含指定的元素,则返回 true |
Iterator iterator() | 返回在此 set 中的元素上进行迭代的迭代器 |
boolean remove(Object o) | 如果 set 中存在指定的元素,则将其移除 |
Object[] toArray() | 返回一个包含 set 中所有元素的数组 |
遍历set,利用迭代器Iterator
public class TestMain {
public static void main(String[] args) {
Set<String> set = new TreeSet<>();
//获取迭代器
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
System.out.println("遍历的值:"+iterator.next());
}
}
}
5:Map
Map(映射)是一种把键对象和值对象进行映射的集合,它的每一个元素都包含一对键对象和值对象,而值对象仍可以是Map类型,以此类推,这样就形成了多级映射。向Map集合中加入元素时,必须提供一对键对象和值对象,从 Map 集合中检索元素时,只要给出键对象,就会返回对应的值对象。
JDK中API的方法
方法 | 说明 |
void clear() | 从此映射中移除所有映射关系 |
boolean containsKey(Object key) | 如果此映射包含指定键的映射关系,则返回 true |
boolean containsValue(Object value) | 如果此映射将一个或者多个见映射到此值上,返回true |
Set<Map.Entry> entrySet() | 返回此映射中包含的映射关系的 Set 视图 |
boolean equals(Object o) | 比较指定的对象与此映射是否相等 |
V get(Object key) | 通过键值(key)来得到相应的value值,如果没有这个key,那么返回null |
boolean isEmpty() | 判断该映射关系是否为空 |
Set<K> keySet() | 返回该映射(map)所有key组成的set |
V put(K key,V value) | 为此map添加关系映射 |
void putAll(Map m) | 将指定映射中的所有映射关系复制到此映射 |
V remove(Object key) | 删除此映射中对应key的关系 |
int size() | 返回这个映射中的key-value的对数 |
Collection values() | 返回此映射中包含的值(value)的 Collection 视图 |
6:List的实现类
6.1:ArrayList(线性集合)
ArrayList 是一种线性数据结构,它的底层是用数组实现的,相当于动态数组。
6.2:LinkedList 底层原理
LinkedList 底层是通过一个双向链表实现。
所以linkedlist的寻找元素很快
7:Set接口的实现
7.1:HashSet 的底层原理
HashSet 类按照哈希算法来存取集合中的对象,具有很好的存取和查找性能。当向集合中加入一个对象时,HashSet 会调用对象的 hashCode()方法来获得哈希码,然后根据这个哈希码进一步计算出对象在集合中的存放位置。
在 Object 类中定义了 hashCode()和 equals()方法,Object 类的 equals()方法按照内存地址比较对象是否相等,因此如果 object1.equals(object2)为 true,则表明object1 和 object2 变量实际上引用同一个对象,那么两个对象的哈希码也肯定相等。
7.2:TreeSet 底层原理
TreeSet 底层使用平衡二叉树(红黑树)实现。
8:排序:
8.1:自然排序---Comparable
他在java.lang包下
Comparable可以认为是一个内比较器,实现了Comparable接口的类有一个特点,就是这些 类是可以和自己比较的,至于具体和另一个实现了Comparable接口的类如何比较,则依赖compareTo方法的实现,compareTo方法也被称为自然比较方法。
对于表达式x.compareTo(y),如果返回值为 0,则表示 x 和 y相等,如果返回值大于0,则表示 x 大于 y,如果返回值小于 0,则表示 x 小于 y。
在JDK类库中,有一部分类实现Comparable接口,如Integer、Double和String等。Comparable 接口有一个 compareTo(Object o)方法,它返回整数类型。所以这些都是可以直接排序比较的;
如何使用:
//定义一个实体类,这个类自己实现了Comparable接口
public class Person implements Comparable<Person> {
String name;
int age;
//重写排序方法
@Override
public int compareTo(Person o) {
int i = 0;
i = name.compareTo(o.name); // 使用字符串的比较
if (i == 0) { // 如果名字一样,比较年龄, 返回比较年龄结果
return age - o.age;
} else {
return i; // 名字不一样, 返回比较名字的结果.
}
}
}
8.2:客户化排序---Comparator
他在java.util包下
Comparator 是在集合外部实现的排序,所以,如想实现排序,就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。
用 Comparator 是策略模式(strategy design pattern),就是不改变对象自身,而用一个策略对象(strategy object)来改变它的行为。
比如:你想对整数采用绝对值大小来排序,Integer 是不符合要求的,你不需要去修改 Integer 类(实际上你也不能这么做)去改变它的排序行为,只要使用一个实现了 Comparator 接口的对象来实现控制它的排序就行了。
//定义一个实体类
public class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
第一中方式:定义外部比较器;
//在类的外部自定义比较器
public class MyConparator implements Comparator<Person> {
@Override
public int compare(Person one, Person two) {
int i = 0;
i = one.name.compareTo(two.name); // 使用字符串的比较
if(i == 0) { // 如果名字一样,比较年龄,返回比较年龄结果
return one.age - two.age;
} else {
return i; // 名字不一样, 返回比较名字的结果.
}
}
}
第二种,直接使用匿名内部类
public class TestMain {
public static void main(String[] args) {
Person p1 = new Person("张三",12);
Person p2 = new Person("张三",16);
Person p3 = new Person("李四",12);
List<Person> plist = new ArrayList<>();
plist.add(p2);
plist.add(p3);
plist.add(p1);
System.out.println(""+ plist);
Collections.sort(plist, new Comparator<Person>() {
@Override
public int compare(Person one, Person two) {
int i = 0;
i = one.name.compareTo(two.name); // 使用字符串的比较
if(i == 0) { // 如果名字一样,比较年龄,返回比较年龄结果
return one.age - two.age;
} else {
return i; // 名字不一样, 返回比较名字的结果.
}
}
});
System.out.println(""+ plist);
}
}
8:Map接口的实现
如果 Set 中的元素是由两个值组合成的对象,那么就是 Map 了。
实际上 HashSet 的实现都是通过封装了一个 HashMap 的成员变量来实现的。TreeSet 也不例外。
9:泛型
1:集合中的元素,可以是任意类型的元素;(如果是对象,就是对象的引用)
2:泛型则是规定了某一个集合只可以存放特定类型的对象,设置了泛型的集合会在编译期间进行类型检查,可以按特定类型获取集合元素
List<String> list = new ArrayList<>();
String s = list.get(0);
10:Collections 工具类
Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化,是一个工具类,服务于 Java 的 Collection 框架
10.1:排序
public static <T extends Comparable<? super T>> void sort(List<T>
list)
【排序】根据元素的自然顺序对指定列表按升序进行排序。返回集合
10.2:最小元素
public static <T extends Object & Comparable<? super T>> T min (Collection<? extends T> coll)
【最小元素】
根据元素的自然顺序返回给定 Collection 的最小元素,Collection 中的所有元素必须实现 Comparable 接口,也可传入外置比较器,此外,collection 中的所有元素都必须是可相互比较的。
10.3:最大元素
public static <T extends Object & Comparable<? super T>> T max (Collection<? extends T> coll)
【最大元素】根据元素的自然顺序,返回给定 collection 的最大元素
10.4:没有交集
public static boolean disjoint(Collection<?> c1,Collection<?> c2)
【没有交集】如果两个指定 collection 中没有相同的元素,则返回 true
10.5:翻转
public static void reverse(List<?> list)
【反转】反转指定列表中元素的顺序。
10.6:交换
public static void swap(List<?> list,int i ,int j)
【交换】在指定列表的指定位置处交换元素。
10.7:替换
public static <T> void fill(List<? super T> list,T obj)
【填充】使用指定元素替换指定列表中的所有元素。
10.8:复制
public static <T> void copy(List<? super T> dest,List<? extendsT> src)
【复制】将所有元素从一个列表复制到另一个列表。执行此操作后,目标列表中每个已复制元素的索引将等同于源列表中该元素的索引,目标列表的长度至少必须等于源列表。
10.9:统计次数
public static int frequency(Collection<?> c,Object o)
【次数】返回指定 collection 中等于指定对象的元素数。指定 object o 在 c 中出现的次数。
10:以前的历史集合