Java集合框架
文章目录
前言
集合的概念
对象的容器,定义了多个对象进行操作的的常用方法。可实现数组。
数组长度固定,可以存放基本类型和引用类型
位置:java.util.*
集合的框架
1.总体分为两个体系,collection和Map。collection体系都实现了Iterator接口
2.collection分别被List和Set、Queue继承,主要还是List和Set
3.List的实现类有ArrayList,LinkList和VectorList
4.Set的实现类有HashSet和TreeSet
5.Map有两个比较常用的实现类TreeMap和HashMap
Iterator迭代器
是用来遍历集合的(Map除外),有三个方法常用方法
public static void main(String [] args){
Collection<String> lin = new ArrayList<>();
lin.add("小鸟");//添加元素
lin.add("乌龟");
lin.add("螃蟹");
System.out.println(lin.size());//计算集合大小
System.out.println(lin);
Iterator<String> it = lin.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
//运行结果:
//3
//[小鸟, 乌龟, 螃蟹]
//小鸟
//乌龟
//螃蟹
一、collection体系
Collection接口
特点:无序(插入和取出顺序不一定相同),无下标,可重复
方法
- boolean add(E e)
确保此集合包含指定的元素(可选操作)。 - boolean addAll(Collection<? extends E> c)
将指定集合中的所有元素添加到此集合(可选操作)。 - void clear()
从此集合中删除所有元素(可选操作)。 - boolean contains(Object o)
如果此集合包含指定的元素,则返回 true 。 - boolean containsAll(Collection<?> c)
如果此集合包含指定 集合中的所有元素,则返回true。 - boolean equals(Object o)
将指定的对象与此集合进行比较以获得相等性。 - int hashCode()
返回此集合的哈希码值。 - boolean isEmpty()
如果此集合不包含元素,则返回 true 。 - Iterator iterator()
返回此集合中的元素的迭代器。 - default Stream parallelStream()
返回可能并行的 Stream与此集合作为其来源。 - boolean remove(Object o)
从该集合中删除指定元素的单个实例(如果存在)(可选操作)。 - boolean removeAll(Collection<?> c)
删除指定集合中包含的所有此集合的元素(可选操作)。 - default boolean removeIf(Predicate<? super E> filter)
删除满足给定谓词的此集合的所有元素。 - boolean retainAll(Collection<?> c)
仅保留此集合中包含在指定集合中的元素(可选操作)。 - int size()
返回此集合中的元素数。 - default Spliterator spliterator()
创建一个Spliterator在这个集合中的元素。 - default Stream stream()
返回以此集合作为源的顺序 Stream 。 - Object[] toArray()
返回一个包含此集合中所有元素的数组。 - T[] toArray(T[] a)
返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
将对比较常用的方法进行代码演示
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class test1 {
public static void main(String [] args){
Collection<String> lin1 = new ArrayList<>();//Collection是接口只能new实现类,这里用ArrayList
Collection<String> lin2 = new ArrayList<>();
lin1.add("小鸟");//向集合添加元素
lin1.add("乌龟");
lin1.add("螃蟹");
System.out.println(lin1.size());//输出集合元素个数
System.out.println(lin1);//掉用toString方法,因为String已近重写了toString方法,所以若其他是需要重写toString方法的
lin2.add("皮皮虾");
lin2.add("小猴");
lin1.addAll(lin2);//向集合添加lin2整个集合
System.out.println(lin1.size());
System.out.println(lin1);
/* 3
[小鸟, 乌龟, 螃蟹]
5
[小鸟, 乌龟, 螃蟹, 皮皮虾, 小猴]
*/
System.out.println(lin2.size());
lin2.clear();//清空集合的元素,
System.out.println(lin2.size());
/*2
0
*/
if(lin1.contains("皮皮虾"))//若集合含有皮皮虾,则返回true,否则返回flash
System.out.println("我有皮皮虾");
else
System.out.println("唉,我没有皮皮虾");
if(lin1.contains("小姐鱼"))
System.out.println("我有小姐鱼");
else
System.out.println("唉,我没有小姐鱼");
/*
我有皮皮虾
唉,我没有小姐鱼
*/
System.out.println(lin1.isEmpty());//若元素为空则放回true,否则放回flash
System.out.println(lin2.isEmpty());
/* flash
true
*/
lin1.remove("皮皮虾");//删除皮皮虾元素
// lin1.removeAll(lin2);删除lin1中包含lin2的全部元素
// lin1.retainAll(lin2);保留lin1和lin2共有的元素,类似于求交集
Iterator<String> it = lin1.iterator();//返回一个迭代器,用来遍历集合
while(it.hasNext()){
System.out.println(it.next());
}
//迭代器遍历
for(String a:lin1){
System.out.println(a);
}
//增强for遍历
}
}
List接口
特点:有序(插入元素与取出元素相同),要下标,可重复
方法
继承自Collection接口,拥有Collection接口的全部方法;也有新加的方法
- void add(int index, E element)
将指定的元素插入此列表中的指定位置(可选操作)。 - boolean addAll(int index, Collection<? extends E> c)
将指定集合中的所有元素插入到此列表中的指定位置(可选操作)。 - E get(int index)
返回此列表中指定位置的元素。 - int indexOf(Object o)
返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。 - int lastIndexOf(Object o)
返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。 - ListIterator listIterator()//这个的返回值是ListIterator
返回列表中的列表迭代器(按适当的顺序)。 - ListIterator listIterator(int index)//这个的返回值是ListIterator
从列表中的指定位置开始,返回列表中的元素(按正确顺序)的列表迭代器。 - E remove(int index)
删除该列表中指定位置的元素(可选操作)。 - E set(int index, E element)
用指定的元素(可选操作)替换此列表中指定位置的元素。
上代码前先解释一下ListIterator,这个也是一个迭代器,他的继承至Iterator,他拥有更强的功能,在之后代码遍历是会用一下,以下是他的方法
- void add(E e)
将指定的元素插入列表(可选操作)。 - boolean hasNext()
返回 true如果遍历正向列表,列表迭代器有多个元素。 - boolean hasPrevious()
返回 true如果遍历反向列表,列表迭代器有多个元素。 - E next()
返回列表中的下一个元素,并且前进光标位置。 - int nextIndex()
返回随后调用 next()返回的元素的索引。 - E previous()
返回列表中的上一个元素,并向后移动光标位置。 - int previousIndex()
返回由后续调用 previous()返回的元素的索引。 - void remove()
从列表中删除由 next()或 previous()返回的最后一个元素(可选操作)。 - void set(E e)
用 指定的元素替换由 next()或 previous()返回的最后一个元素(可选操作)。
上代码
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class test2 {
public static void main(String [] args){
List<String> li1 = new ArrayList<>();
List<String> li2 = new ArrayList<>();
li1.add("苹果");
li1.add("荔枝");
li1.add("香蕉");
li1.add("苹果");
li2.add("西瓜");
li2.add("哈密瓜");
System.out.println("li:"+li1);
li1.add(3,"火龙果");//在特定位置插入元素
System.out.println("li:"+li1);
/*
li1:[苹果, 荔枝, 香蕉, 苹果]
li1:[苹果, 荔枝, 香蕉, 火龙果, 苹果]
*/
System.out.println("li2:"+li2);
li1.addAll(2,li2);//在特定位置插入整个集合
System.out.println("li:"+li1);
/*
li2:[西瓜, 哈密瓜]
li1:[苹果, 荔枝, 西瓜, 哈密瓜, 香蕉, 火龙果, 苹果]
*/
System.out.println(li1.get(2));//获取指定位置的元素
//西瓜
System.out.println(li1.indexOf("西瓜"));//重头开始查找,即从第一个元素开始查找
System.out.println(li1.lastIndexOf("西瓜"));//从最后一个元素开始查找
/*
2
2
*/
System.out.println("li1:"+li1);
li1.remove(2);//删除指定位置上的元素
System.out.println("li1:"+li1);
li1.set(2,"梨子");//把指定位置上的元素代替掉
System.out.println("li1:"+li1);
/*
li1:[苹果, 荔枝, 西瓜, 哈密瓜, 香蕉, 火龙果, 苹果]
li1:[苹果, 荔枝, 哈密瓜, 香蕉, 火龙果, 苹果]
li1:[苹果, 荔枝, 梨子, 香蕉, 火龙果, 苹果]
*/
//开始遍历,因为有下标所以可以用普通的for进行遍历
for(int i=0;i<li1.size();i++) {
System.out.print(li1.get(i)+" ");
}
System.out.println();
for(String a:li1){
System.out.print(a+" ");
}
ListIterator<String> lit = li1.listIterator();
while(lit.hasNext()){//正向遍历
System.out.println(lit.next());
}
while(lit.hasPrevious()){
//反向遍历,用之前指针要指向后面,因为上面正常遍历了一次,指针已经到最后,如果需要可调用listIterator(int index)函数
System.out.println(lit.previous());
}
}
}
List实现类
- ArrayList类:底层采用数组实现,查询快,增删慢,线程不安全
如果未向集合添加元素,容量为0,添加1个元素后容量为10,之后以1.5倍空间增长空间。
构造方法
public ArrayList(int initialCapacity)
构造具有指定初始容量的空列表。
public ArrayList()
构造一个初始容量为十的空列表。
public ArrayList(Collection<? extends E> c)
构造一个包含指定集合的元素的列表,按照它们由集合的迭代器返回的顺序。
import java.util.ArrayList;
import java.util.ListIterator;
public class test3 {
public static void main(String []args){
ArrayList<String> ali = new ArrayList<>();
ali.add("椅子");
ali.add("桌子");
ali.add("床");
ali.add("沙发");
System.out.println("ali:"+ali);
ali.remove(3);
System.out.println("ali:"+ali);
//遍历
for(int i=0;i<ali.size();i++){
System.out.print(ali.get(i)+" ");
}
System.out.println();
for(String a:ali){
System.out.print(a+" ");
}
System.out.println();
ListIterator<String> lit = ali.listIterator();
while(lit.hasNext()){
System.out.print(lit.next()+" ");
}
System.out.println();
while(lit.hasPrevious()){
System.out.print(lit.previous()+" ");
}
}
}
/*
ali:[椅子, 桌子, 床, 沙发]
ali:[椅子, 桌子, 床]
椅子 桌子 床
椅子 桌子 床
椅子 桌子 床
床 桌子 椅子
*/
- LinkedList类:底层采用链表实现,查询慢,增删快,线程不安全
构造方法:
LinkedList()
构造一个空列表。
LinkedList(Collection<? extends E> c)
构造一个包含指定集合的元素的列表,按照它们由集合的迭代器返回的顺序。
新增的方法
void addFirst(E e)
在该列表开头插入指定的元素。
void addLast(E e)
将指定的元素追加到此列表的末尾。
E getFirst()
返回此列表中的第一个元素。
E getLast()
返回此列表中的最后一个元素。
E peek()
检索但不删除此列表的头(第一个元素)。
E peekFirst()
检索但不删除此列表的第一个元素,如果此列表为空,则返回 null 。
E peekLast()
检索但不删除此列表的最后一个元素,如果此列表为空,则返回 null 。
E poll()
检索并删除此列表的头(第一个元素)。
E pollFirst()
检索并删除此列表的第一个元素,如果此列表为空,则返回 null 。
E pollLast()
检索并删除此列表的最后一个元素,如果此列表为空,则返回 null 。
E pop()
从此列表表示的堆栈中弹出一个元素。与removeFirst一样,实际上它就是removeFirst
void push(E e)
将元素推送到由此列表表示的堆栈上。与addFirst一样,实际上它就是addFirst
E remove()
检索并删除此列表的头(第一个元素)。
E remove(int index)
删除该列表中指定位置的元素。
boolean remove(Object o)
从列表中删除指定元素的第一个出现(如果存在)。
E removeFirst()
从此列表中删除并返回第一个元素。
boolean removeFirstOccurrence(Object o)
删除此列表中指定元素的第一个出现(从头到尾遍历列表时)。
E removeLast()
从此列表中删除并返回最后一个元素。
import java.util.LinkedList;
public class test4 {
public static void main(String []args){
LinkedList<String> linkList = new LinkedList<>();
linkList.add("two");
linkList.add("three");//在尾部添加元素
System.out.println(linkList);
//[two, three]
linkList.addFirst("one");//在头部插入元素
linkList.addLast("four");//在尾部插入元素
//[one, two, three, four]
System.out.println(linkList);
linkList.add(4,"five");
System.out.println(linkList);
//[one, two, three, four, five]
linkList.remove();//删除第一个元素
System.out.println(linkList);
//[two, three, four, five]
linkList.removeFirst();//删除第一个元素
linkList.removeLast();//删除最后一个元素
System.out.println(linkList);
//[three, four]
linkList.remove(0);
linkList.remove("four");
System.out.println(linkList);
//[]
linkList.add("one");
linkList.add("two");
linkList.add("three");
linkList.add("four");
linkList.add("five");
linkList.add("six");
System.out.println(linkList);
System.out.println("get(index): " + linkList.get(3));//获取下表为3的元素
System.out.println("getFirst: " + linkList.getFirst());//获取第一个元素
System.out.println("getLast: " + linkList.getLast());//获取最后一个元素
/*
[one, two, three, four, five, six]
get(index): four
getFirst: one
getLast: six
*/
linkList.clear();//清空集合
linkList.push("one");//在头部插入元素
linkList.push("two");
linkList.push("three");
linkList.push("four");
linkList.push("five");
linkList.push("six");
System.out.println(linkList);
System.out.println("pop: " + linkList.pop());//删除最后一个元素
System.out.println("after pop: " + linkList);
/*
[six, five, four, three, two, one]
pop: six
after pop: [five, four, three, two, one]
*/
System.out.println("poll: " + linkList.poll());//检索第一个元素并删除
System.out.println("after poll: " + linkList);
/*
poll: five
after poll: [four, three, two, one]
*/
System.out.println("peek: " + linkList.peek());//检索第一个元素不删除
System.out.println("after peek: " + linkList);
/*
peek: four
after peek: [four, three, two, one]
*/
}
}
- Vector类(不太常用,用ArrayList较多):底层采用数组实现,查询快,增删慢,线程安全,已2倍扩展。比较少用,需要直接看下面方法。
方法
boolean add(E e)
将指定的元素追加到此Vector的末尾。
void add(int index, E element)
在此Vector中的指定位置插入指定的元素。
boolean addAll(Collection<? extends E> c)
将指定集合中的所有元素追加到该向量的末尾,按照它们由指定集合的迭代器返回的顺序。
boolean addAll(int index, Collection<? extends E> c)
将指定集合中的所有元素插入到此向量中的指定位置。
void addElement(E obj)
将指定的组件添加到此向量的末尾,将其大小增加1。
int capacity()
返回此向量的当前容量。
void clear()
从此Vector中删除所有元素。
Object clone()
返回此向量的克隆。
boolean contains(Object o)
如果此向量包含指定的元素,则返回 true 。
boolean containsAll(Collection<?> c)
如果此向量包含指定集合中的所有元素,则返回true。
void copyInto(Object[] anArray)
将此向量的组件复制到指定的数组中。
E elementAt(int index)
返回指定索引处的组件。
Enumeration elements()
返回此向量的组件的枚举。
void ensureCapacity(int minCapacity)
如果需要,增加此向量的容量,以确保它可以至少保存最小容量参数指定的组件数。
boolean equals(Object o)
将指定的对象与此向量进行比较以获得相等性。
E firstElement()
返回此向量的第一个组件(索引号为 0的项目)。
void forEach(Consumer<? super E> action)
对 Iterable的每个元素执行给定的操作,直到所有元素都被处理或动作引发异常。
E get(int index)
返回此向量中指定位置的元素。
int hashCode()
返回此Vector的哈希码值。
int indexOf(Object o)
返回此向量中指定元素的第一次出现的索引,如果此向量不包含元素,则返回-1。
int indexOf(Object o, int index)
返回此向量中指定元素的第一次出现的索引,从 index向前 index ,如果未找到该元素,则返回-1。
void insertElementAt(E obj, int index)
在指定的index插入指定对象作为该向量中的一个 index 。
boolean isEmpty()
测试此矢量是否没有组件。
Iterator iterator()
以正确的顺序返回该列表中的元素的迭代器。
E lastElement()
返回向量的最后一个组件。
int lastIndexOf(Object o)
返回此向量中指定元素的最后一次出现的索引,如果此向量不包含元素,则返回-1。
int lastIndexOf(Object o, int index)
返回此向量中指定元素的最后一次出现的索引,从 index ,如果未找到元素,则返回-1。
ListIterator listIterator()
返回列表中的列表迭代器(按适当的顺序)。
ListIterator listIterator(int index)
从列表中的指定位置开始,返回列表中的元素(按正确顺序)的列表迭代器。
E remove(int index)
删除此向量中指定位置的元素。
boolean remove(Object o)
删除此向量中指定元素的第一个出现如果Vector不包含元素,则它不会更改。
boolean removeAll(Collection<?> c)
从此Vector中删除指定集合中包含的所有元素。
void removeAllElements()
从该向量中删除所有组件,并将其大小设置为零。
boolean removeElement(Object obj)
从此向量中删除参数的第一个(最低索引)出现次数。
void removeElementAt(int index)
删除指定索引处的组件。
boolean removeIf(Predicate<? super E> filter)
删除满足给定谓词的此集合的所有元素。
protected void removeRange(int fromIndex, int toIndex)
从此列表中删除所有索引为 fromIndex (含)和 toIndex之间的元素。
void replaceAll(UnaryOperator operator)
将该列表的每个元素替换为将该运算符应用于该元素的结果。
boolean retainAll(Collection<?> c)
仅保留此向量中包含在指定集合中的元素。
E set(int index, E element)
用指定的元素替换此Vector中指定位置的元素。
void setElementAt(E obj, int index)
设置在指定的组件 index此向量的要指定的对象。
void setSize(int newSize)
设置此向量的大小。
int size()
返回此向量中的组件数。
void sort(Comparator<? super E> c)
使用提供的 Comparator对此列表进行排序以比较元素。
Spliterator spliterator()
在此列表中的元素上创建late-binding和故障切换 Spliterator 。
List subList(int fromIndex, int toIndex)
返回此列表之间的fromIndex(包括)和toIndex之间的独占视图。
Object[] toArray()
以正确的顺序返回一个包含此Vector中所有元素的数组。
T[] toArray(T[] a)
以正确的顺序返回一个包含此Vector中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
String toString()
返回此Vector的字符串表示形式,其中包含每个元素的String表示形式。
void trimToSize()
修改该向量的容量成为向量的当前大小。
Set接口
特点:无序(插入顺序和取出顺序不一定相同),无下标,不可重复
方法:继承至Collection接口,方法类似
这两个方法要注意,存储位置和这两个函数有关,后面讲解
int hashCode()
返回此集合的哈希码值。
boolean equals(Object o)
将指定的对象与此集合进行比较以实现相等。
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class test5 {
public static void main(String []args){
Set<String> s = new HashSet<>();
//增
s.add("one");
s.add("two");
s.add("three");
s.add("four");
s.add("four");//不可重复
System.out.println(s);
//[four, one, two, three]
//删
s.remove("four");
System.out.println(s);
//[one, two, three]
//遍历
for(String a : s){
System.out.println(a);
}
Iterator it = s.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
Set实现类
- HashSet
底层采用哈希表(数组+链表+红黑树)实现。
构造方法:
HashSet()
构造一个新的空集合; 背景HashMap实例具有默认初始容量(16)和负载因子(0.75)。
HashSet(Collection<? extends E> c)
构造一个包含指定集合中的元素的新集合。
HashSet(int initialCapacity)
构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子(0.75)。
HashSet(int initialCapacity, float loadFactor)
构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子。
这里解释一下负载因子:比如说当前的容器容量是16,负载因子是0.75,16*0.75=12,当容量达到了12的时候就会进行扩容操作。
方法
import java.util.HashSet;
import java.util.Iterator;
public class test6 {
public static void main(String []args){
HashSet<String> hs = new HashSet<>();
hs.add("松树");
hs.add("柳树");
hs.add("槐树");
hs.add("葵树");
System.out.println(hs);
hs.remove("葵树");
System.out.println(hs);
//[柳树, 槐树, 葵树, 松树]
//[柳树, 槐树, 松树]
Iterator<String> it = hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
for(String a:hs){
System.out.println(a);
}
}
}
最后再说一下HashSet的存储方式,要插入元素是先调用 hashCode()来决定存储的位置,在调用equals方法来比较是否要存储
- TreeSet:
特点: TreeSet的底层数据结构是红黑树,特点:唯一且有序, TreeSet集合会自动对元素进行排序,默认是升序排序。要改变排序方式可通过改变比较器。
构造方法:
TreeSet()
构造一个新的,空的树组,根据其元素的自然排序进行排序。
TreeSet(Collection<? extends E> c)
构造一个包含指定集合中的元素的新树集,根据其元素的 自然排序进行排序 。
TreeSet(Comparator<? super E> comparator)
构造一个新的,空的树集,根据指定的比较器进行排序。
TreeSet(SortedSet s)
构造一个包含相同元素的新树,并使用与指定排序集相同的顺序。
主要了解下面这个方法:
Comparator<? super E> comparator()
返回用于对该集合中的元素进行排序的比较器,或null,如果此集合使用其元素的natural ordering 。
import java.util.Comparator;
import java.util.Objects;
public class Students implements Comparator<Students>{
String name;
int id;
Students(){}
Students(String n,int i){
name = n;
id = i;
}
public String toString() {//重写toString方法
return "{" +
"name='" + name + '\'' +
", id=" + id +
'}';
}
public boolean equals(Students o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if(o.id == this.id){
return false;
}
else{
return true;
}
}
public int hashCode() {
return Objects.hash(name, id);
}
public int compare(Students o1, Students o2) {
if(o1.id == o2.id){
return o2.name.compareTo(o1.name);
}
else if(o1.id<o2.id){
return 1;
}
else {
return -1;
}
}
}
import java.util.Objects;
public class People implements Comparable<People>{
String name;
int id;
People(String name,int id){
this.name=name;
this.id=id;
}
public String toString() {//重写toString方法
return "{" +
"name='" + name + '\'' +
", id=" + id +
'}';
}
public boolean equals(People o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if(o.id == this.id){
return false;
}
else{
return true;
}
}
public int hashCode() {
return Objects.hash(name, id);
}
public int compareTo(People o) {
if(this.id == o.id){
return o.name.compareTo(this.name);
}
else if(this.id>o.id){
return 1;
}
else {
return -1;
}
}
}
import java.util.Iterator;
import java.util.TreeSet;
public class test7 {
public static void main(String []args){
TreeSet<Students> ts =new TreeSet<>(new Students());
ts.add(new Students("刘德华",1));
ts.add(new Students("周润发",2));
ts.add(new Students("周星驰",3));
ts.add(new Students("彭于晏",4));
ts.add(new Students("陈冠希",5));
ts.add(new Students("刘德华",6));
System.out.println(ts);
//[{name='刘德华', id=6}, {name='陈冠希', id=5}, {name='彭于晏', id=4}, {name='周星驰', id=3}, {name='周润发', id=2}, {name='刘德华', id=1}]
TreeSet<People> ts1 =new TreeSet<>();
ts1.add(new People("刘德华",1));
ts1.add(new People("周润发",2));
ts1.add(new People("周星驰",3));
ts1.add(new People("彭于晏",4));
ts1.add(new People("陈冠希",5));
ts1.add(new People("刘德华",6));
System.out.println(ts1);
//[{name='刘德华', id=1}, {name='周润发', id=2}, {name='周星驰', id=3}, {name='彭于晏', id=4}, {name='陈冠希', id=5}, {name='刘德华', id=6}]
//遍历
Iterator<People> it = ts1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//{name='刘德华', id=1}
//{name='周润发', id=2}
//{name='周星驰', id=3}
//{name='彭于晏', id=4}
//{name='陈冠希', id=5}
//{name='刘德华', id=6}
}
}
让元素自身具备比较排序功能,具备比较排序功能的元素只需要实现Comparable 接口。覆盖接口中CompareTo方法。(People类,采用id升序)
让集合自身具备比较功能,定义一个类实现Comparator接口,覆盖compare方法。(Students类采用id降序)
两种方法都要实现Comparable接口
二、Map体系
Map接口
特点:Map集合是键值对形式存储值的,Map中的集合不能包含重复的键,值可以重复。每个键只能对应一个值。
常用方法
int size();
返回此映射中的键-值映射关系数。
boolean isEmpty();
如果此映射未包含键-值映射关系,则返回 true。
boolean containsKey(Object key);
如果此映射包含指定键的映射关系,则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值,则返回 true。
V get(Object key);
根据key查找对应value数据,如果没有,则返回 null。
V put(K key, V value);
向集合保存数据可选操作)。
V remove(Object key);
如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
void putAll(Map<? extends K, ? extends V> m);
从指定映射中将所有映射关系复制到此映射中(可选操作)。
void clear();
从此映射中移除所有映射关系(可选操作)。
interface Entry<K, V> {
K getKey();
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
}
Set KeySet();
返取出全部key。
Collection values();
返回此映射中包含的值的 Collection 视图。
Set<Map, Entry<K, V>> entrySet();
即将Map集合转化为Set集合。
以下重点掌握遍历方法
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class test8 {
public static void main(String[] args){
Map<Integer,String> m1 = new HashMap<>();
m1.put(11,"郭富城");
m1.put(12,"黎明");
Map<Integer,String> m = new HashMap<>();
m.put(1,"刘德华");
m.put(2,"彭于晏");
m.put(3,"吴彦祖");
m.put(4,"周星驰");
m.put(5,"成龙");
System.out.println(m.size());//5
System.out.println(m);//{1=刘德华, 2=彭于晏, 3=吴彦祖, 4=周星驰, 5=成龙}
System.out.println(m.isEmpty());//false
System.out.println(m.containsKey(1));//true
System.out.println(m.containsValue("刘德华"));//true
System.out.println(m.get(1));//刘德华
m.remove(1);
System.out.println(m);//{2=彭于晏, 3=吴彦祖, 4=周星驰, 5=成龙}
m.putAll(m1);
System.out.println(m);//{2=彭于晏, 3=吴彦祖, 4=周星驰, 5=成龙, 11=工程, 12=黎明}
//Map遍历
//方法一
Iterator<Map.Entry<Integer,String>> it1 = m.entrySet().iterator();
while(it1.hasNext()){
Map.Entry<Integer,String> a = it1.next();
System.out.println("key="+a.getKey()+" valus="+a.getValue());
}
//方法二
Iterator<Integer> i = m.keySet().iterator();
while(i.hasNext()){
int a = i.next();
System.out.println("key="+a+" valus="+m.get(a));
}
//方法三
for(Map.Entry<Integer,String> a : m.entrySet()){
System.out.println("key="+a.getKey()+" valus="+a.getValue());
}
//方法四
for(int a:m.keySet()){
System.out.println("key="+a+" valus="+m.get(a));
}
}
}
HashMap实现类
构造方法:
HashMap()
构造一个空的 HashMap ,默认初始容量(16)和默认负载系数(0.75)。
HashMap(int initialCapacity)
构造一个空的 HashMap具有指定的初始容量和默认负载因子(0.75)。
HashMap(int initialCapacity, float loadFactor)
构造一个空的 HashMap具有指定的初始容量和负载因子。
HashMap(Map<? extends K,? extends V> m)
构造一个新的 HashMap与指定的相同的映射 Map 。
底层采用哈希表实现,方法使用和Map接口类似
TreeMap实现类
构造方法
TreeMap()
使用其键的自然排序构造一个新的空树状图。
TreeMap(Comparator<? super K> comparator)
构造一个新的,空的树图,按照给定的比较器排序。
TreeMap(Map<? extends K,? extends V> m)
构造一个新的树状图,其中包含与给定地图相同的映射,根据其键的 自然顺序进行排序 。
TreeMap(SortedMap<K,? extends V> m)
构造一个包含相同映射并使用与指定排序映射相同顺序的新树映射。
底层采用树实现,方法使用和Map接口类似
HashMap与TreeMap的比较
1、HashMap基于哈希表实现。TreeMap基于树实现。
2、HashMap可以通过调优初始容量和负载因子,优化HashMap空间的使用。
TreeMap没有调优选项,因为该树总处于平衡状态
3、HashMap性能优于TreeMap。