文章目录
1、集合概述
集合的作用
对多个对象进行存储
Java容器
集合、数组都是对多个数据进行存储操作的结构,简称Java容器。
说明;此时的存储,主要是指能存层面的存储,不涉及到持久化的存储(.txt,.jpg,.avi,数据库中)
数组在存储多个数据方面的特点:
- 一旦初始化以后,其长度就不可修改。
- 数组中提供的方法非常有限,对于添加、删除、插入数据等操作,非常不便,同时效率不高。
- 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用
- 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求,不能满足。
集合涉及到的API
- 集合框架 = Collection +Map
- Collection接口:单列集合,用于存储一个一个的对象
- List接口:存储有序、可重复的数据(动态数组)
- 实现类:ArrayList 、LinkedList 、Vector
- Set接口:存储无序 、不可重复的数据(高中讲的“集合”)
- 实现类:HashSet 、LinkedHashSet 、TreeSet
- List接口:存储有序、可重复的数据(动态数组)
- Map接口:双列集合,用于存储一对一对(key - value)的数据(类似于 y = f(x))
- 实现类:HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
Collection接口继承树
Map接口继承树
2、Collection接口
2.1、概述
- Collection 接口是List、Set 和Queue 接口的父接口,该接口里定义的方法可用于操作Set 集合、List集合 、Queue 集合。
- JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List)实现。
- 在Java5 之前,Java 集合会丢失容器中所有对象的数据类型,把所有对象都当成Object 类型处理;从JDK 5.0 增加了泛型以后,Java 集合可以记住容器中对象的数据类型。
2.2、Collection常用方法
名称 | 作用 |
---|---|
add( object x ) | 将x添加到集合中 |
size() | 获取集合元素的个数 |
addAll( Collection A ) | 将集合A中的所有元素添加到d当前集合中 |
isEmpty() | 判断集合是否为空(评判标准:size == 0) |
clear() | 清空集合元素 |
contains(object x) | 判断x是否包含在集合中 |
containsAll(Collection A) | 判断a中的元素是否全都在集合中 |
remove(object x) | 在集合中移除x |
removeAll(Collection A) | 移除集合中与集合A相同的所有元素 |
retainAll(Collection A) | 移除不与A相同的元素(相当于将当前集合变得与集合A一样) |
equals( object a ) | 判断集合与a是否相等 |
hashCode() | 返回当前对象的hash值(JDK根据对象的地址或属性计算出对应的int整数) |
toArray() | 集合转化为数组 |
Arrays.asList( arr ) | 将数组arr转化成集合 |
iterator() | 返回Iterator接口的实例,用于遍历集合的元素(限于Collection) |
package test5;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
public class CollectionWay1 {
public static void main(String[] args){
//JDK无提供Collection接口直接实现类
Collection<Integer> coll=new ArrayList<>();
Collection<Integer> coll2=new ArrayList<>();
Collection<Integer> coll3=new ArrayList<>();
//add(object x),将x添加到集合中
coll.add(15);
coll.add(26);
coll.add(8);
coll2.add(77);
coll2.add(88);
Iterator<Integer> it= coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//size() 获取集合元素的个数
int num=coll.size();
System.out.println(num);//3
System.out.println("*******************");
//addAll( Collection A) 将集合A中的所有元素添加到本集合中
coll.addAll(coll2);
Iterator it2=coll.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
//isEmpty() 判断集合是否为空(评判标准:size == 0)
System.out.println(coll.isEmpty());//false
System.out.println(coll3.isEmpty());//true
//clear():清空集合元素
System.out.println(coll2.isEmpty());
// coll2.clear();
System.out.println(coll2.isEmpty());
System.out.println("*******************");
//contains(object x) 判断x是否包含在集合中
System.out.println(coll.contains(15));//true
System.out.println(coll.contains(14));//false
//containsAll(Collection a) 判断a中的元素是否全都在集合中
System.out.println(coll.containsAll(coll2));//true
//remove(object x) 在集合中移除x
coll.remove(26);
Iterator<Integer> it4=coll.iterator();
while(it4.hasNext()){
System.out.println(it4.next());
}
System.out.println("*******************");
//removeAll(Collection a) 移除集合中与集合a相同的所有元素
coll.removeAll(coll2);
Iterator<Integer> it3=coll.iterator();
while(it3.hasNext()){
System.out.println(it3.next());
}
System.out.println("*******************");
//retainALl(Collection a) 移除不与a相同的元素
// coll.retainAll(coll3);
Iterator it5=coll.iterator();
while(it5.hasNext()){
System.out.println(it5.next());
}
//toArray() 集合转化为数组
Object[] arr=coll.toArray();
for(Object i: arr){
System.out.println(i);
}
//数组转化成集合
Collection coll4= Arrays.asList(arr);
for(Object obj: coll4){
System.out.println(obj);
}
}
}
- 向Collection接口的实现类的对象中添加数据obj时,要求obj所在类要重写equals().
Iterator接口
iterator()遍历操作:
Iterator it=coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
- Iterator对象称为迭代器(设计模式的一种),主要用于遍历Collection 集合中的元素。
- Iterator 不是个容器,是个迭代器
- 集合对象每次调用 iterator()都会得到一个新的迭代器对象,默认游标在集合第一个元素之前(初始化)
- 内部定义了remove(),删除当前对象 it . remove ()
- 在remove()之后,没有next()的情况下会报错(ilegalStateException)
- Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
- 执行原理
Iterator 调用remove()
package test5;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class iteratorTest {
public static void main(String[] args){
Collection coll=new ArrayList();
coll.add(123);
coll.add("ABC");
coll.add("abc");
Iterator it=coll.iterator();
while(it.hasNext()){
if(it.next().equals("ABC")){
System.out.println();
it.remove();
}
}
Iterator it2=coll.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
}
}
foreach
- Java 5.0 提供了foreach循环迭代访问Collection和数组。
- 遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。
- 遍历集合的底层调用Iterator完成操作。
- foreach还可以用来遍历数组。
3、List接口
- 鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组
- List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
- JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。
List接口常用实现类对比
- ArrayList:作为List接口的主要实现类;线程不安全的,效率高;底层使用Object[ ] elementData存储
- LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表存储
- Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储
ArrayList的源码分析
- ArrayList是List 接口的典型实现类、主要实现类
- 本质上,ArrayList是对象引用的一个”变长”数组
ArrayList的源码分析:
jdk 7情况下
ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
list.add(123);//elementData[0] = new Integer(123);
...
list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容。
默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。
结论:建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity)//指定创建capacity个长度的数组
jdk 8中ArrayList的变化:
ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
list.add(123);//第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]
...
后续的添加和扩容操作与jdk 7 无异。
小结:jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象
的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。
LinkedList的源码分析
- 对于频繁的插入或删除元素的操作,建议使用LinkedList类,效率较高
- LinkedList:双向链表,内部没有声明数组,而是定义了Node类型的first和last,用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基本结构。
LinkedList的源码分析:
LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性,默认值为null
list.add(123);//将123封装到Node中,创建了Node对象。
其中,Node定义为:体现了LinkedList的双向链表的说法
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next; //next变量记录下一个元素的位置
this.prev = prev; //prev变量记录前一个元素的位置
}
}
Vector的源码分析
- Vector 是一个古老的集合,JDK1.0就有了。大多数操作与ArrayList相同,区别之处在于Vector是线程安全的。
- 在各种list中,最好把ArrayList作为缺省选择。当插入、删除频繁时,使用LinkedList;Vector总是比ArrayList慢,所以尽量避免使用
- 源码分析:
- 创建对象时创建长度为10的数组,默认扩容为原来的2倍
List常用方法
名称 | 作用 |
---|---|
void add(int index , object x) | 在index中插入x |
boolean addAll( int index ,Collection A) | 从index开始,A中所有元素添加进来 |
Object get( int index ) | 获取index位置上的元素 |
int indexOf( Object a ) | 返回a在集合中首次出现的位置 |
int LastIndexOf( Object a ) | 返回a在集合中最后一次出现的位置 |
Object remove( int index ) | 移除index位置上的元素并返回 |
Object set( int index,Object a) | 在index位置上的元素改成a |
List subList( int from ,int end ) | 返回从from到end的子集合【from,end) |
- 总结
- 增:add(object obj)
- 删:object remove(int index)、boolean remove(Object obj)
- 改:set(int index,object obj)
- 查:get(int index)
- 插:add(int index,object obj)
- 遍历:
- Iterator
- foreach
- for
- coll . foreach (System.out :: println)
例题
* 请问ArrayList/LinkedList/Vector的异同?谈谈你的理解?
* ArrayList底层是什么?扩容机制?Vector和ArrayList的最大区别?
*
* ArrayList和LinkedList的异同二者都线程不安全,相对线程安全的Vector,执行效率高。
* 此外,ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
* 对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。
* 对于新增和删除操作add(特指插入)和remove,LinkedList比较占优势,因为ArrayList要移动数据。
*
* ArrayList和Vector的区别Vector和ArrayList几乎是完全相同的,
* 唯一的区别在于Vector是同步类(synchronized),属于强同步类。
* 因此开销就比ArrayList要大,访问要慢。正常情况下,
* 大多数的Java程序员使用ArrayList而不是Vector,
* 因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间,
* 而ArrayList是1.5倍。Vector还有一个子类Stack。
4、Set接口
- Set接口是Collection的子接口,set接口没有提供额外的方法,只能使用Collection声明的方法
- Set接口存储无序的、不可重复的(用equals()判断,不是用“==”)的数据
- 常用实现类HashSet、LinkedSet、TreeSet
- 向Set添加数据时。其所在的类(自定义类)一定要重写hashCode()和equals()(TreeSet不用重写)
- 重写的hashCode()和equals() 需要保持一致性,相同的元素必须有相同的hash值
无序性、不可重复性的理解
- 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定的。
- 不可重复性:保证添加的元素按照equals()判断时,不能返回true.即:相同的元素只能添加一个。
Set常用实现类对比
- HashSet:Set接口的主要实现类;线程不安全;可以存储null值;不能保证元素顺序(不是根据添加顺序输出,而是根据hash值)
- LinkedHashSet:是HashSet的子类;使用双向链表存储,添加数据时,还维护了两个引用,用于记录当前数据的前一个与后一个的值
- TreeSet:可以按照指定对象进行排序;添加的对象必须相同类;涉及到两种排序方式:自然排序(comparable),定制排序(comparator)
HashSet
- HashSet是Set 接口的典型实现,大多数时候使用Set 集合时都使用这个实现类。
- HashSet按 Hash 算法 来存储集合中的元素,因此具有很好的存取、查找、删除性能。
- HashSet具有以下特点:不能保证元素的排列顺序
- HashSet不是线程安全的
- 集合元素可以是null
- 底层也是数组,初始容量为16,当如果使用率超过0.75,(16*0.75=12)就会扩大容量为原来的2倍。(16扩容为32,依次为64,128…等)
- HashSet 集合判断两个元素相等的标准:两个对象通过hashCode() 方法比较相等,并且两个对象的equals()方法返回值也相等。
- 对于存放在Set容器中的对象,对应的类一定要重写 equals() 和 hashCode(Object obj) 方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。(一般IDEA中Alt+Ins自动重写)
Set接口添加元素过程
* 添加元素的过程:以HashSet为例:
* 我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,
* 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置),判断
* 数组此位置上是否已经有元素:
* 如果此位置上没有其他元素,则元素a添加成功。 --->情况1
* 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hash值:
* 如果hash值不相同,则元素a添加成功。--->情况2
* 如果hash值相同,进而需要调用元素a所在类的equals()方法:
* equals()返回true,元素a添加失败
* equals()返回false,则元素a添加成功。--->情况2
添加元素的过程
- jdk 7 :元素2放到数组中,指向原来的元素。
- jdk 8 :原来的元素在数组中,指向元素2
- HashSet底层:数组+链表的结构
LinkedHashSet
- LinkedHashSet是HashSet的子类
- LinkedHashSet根据元素的hashCode值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
- LinkedHashSet插入性能略低于HashSet,但在遍历Set 里的全部元素时有很好的性能。
- LinkedHashSet不允许集合元素重复。
TreeSet
- TreeSet 是 SortedSet 接口的实现类,TreeSet可以确保集合元素处于排序状态。
- TreeSet底层使用红黑树结构存储数据
- TreeSet两种排序方法:自然排序和定制排序。默认情况下,TreeSet采用自然排序。
- 特点:有序,查询速度比List快
- 自然排序:TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列。
- 如果试图把一个对象添加到TreeSet时,则该对象的类必须实现Comparable 接口
- 向TreeSet中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较。
- 因为只有相同类的两个实例才会比较大小,所以向TreeSet中添加的应该是同一个类的对象。
- 对于TreeSet集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过compareTo(Object obj)方法比较返回值。
- 当需要把一个对象放入TreeSet中,重写该对象对应的equals()方法时,应保证该方法与compareTo(Object obj) 方法有一致的结果:如果两个对象通过equals()方法比较返回true,则通过compareTo(Object obj)方法比较应返回0。否则,让人难以理解。
- 自然排序中,比较两个对象是否相同的标准为:compareTo()返回0.不再是equals().
- 定制排序中,比较两个对象是否相同的标准为:compare()返回0.不再是equals().
红黑树
自然排序
package test5;
public class Person implements Comparable {
private String name;
private int age;
private int score;
public Person(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
if (getAge() != person.getAge()) return false;
if (getScore() != person.getScore()) return false;
return getName() != null ? getName().equals(person.getName()) : person.getName() == null;
}
@Override
public int hashCode() {
int result = getName() != null ? getName().hashCode() : 0;
result = 31 * result + getAge();
result = 31 * result + getScore();
return result;
}
@Override
public int compareTo(Object o) {
if(o instanceof Person){
Person p=(Person)o;
int n1 = p.name.compareTo(this.name);
if(n1 != 0){
return n1;
}else{
int n2=Integer.compare(this.score,p.score);//成绩从小到大排序
if(n2 != 0){
return n2;
}else
return -Integer.compare(this.age,p.age);//年龄从大到小
}
}
throw new RuntimeException("错误");
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
package test5;
import java.util.Iterator;
import java.util.TreeSet;
public class PersonTest {
public static void main(String[] args){
TreeSet tree=new TreeSet();
tree.add(new Person("Tom",15,80));
tree.add(new Person("Jack",20,75));
tree.add(new Person("Ben",21,66));
tree.add(new Person("Smith",21,75));
tree.add(new Person("Tom",10,79));
Iterator it= tree.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
定制排序
package test5;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class PersonTest2 {
public static void main(String[] args){
Comparator com=new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Person && o2 instanceof Person){
Person p1=(Person)o1;
Person p2=(Person)o2;
int num1=p1.getName().compareTo(p2.getName());
if(num1 != 0){
return num1;
}else{
return Integer.compare(p1.getScore(),p2.getScore());
}
}
throw new RuntimeException("错误!");
}
};
TreeSet tree=new TreeSet(com);
tree.add(new Person("Tom",15,80));
tree.add(new Person("Jack",20,75));
tree.add(new Person("Tom",21,66));
tree.add(new Person("Smith",21,75));
tree.add(new Person("Tom",10,79));
Iterator iterator =tree.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
5、Map接口
- 双列数据,存储key-value对的数据
实现类
- HashMap:作为Map的主要实现类;线程不安全的,效率高;存储null的key和value
- 底层:
- 数组+链表(JDK8之前)
- 数组+链表+红黑树(JDK8)
- 底层:
- LinkedHashMap:HashMap的子类;保证在遍历map元素时,可以按照添加的顺序实现遍历。
- 原因:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。对于频繁的遍历操作,此类执行效率高于HashMap。(双向链表)
- TreeMap:保证按照添加的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序底层使用红黑树
- Hashtable:作为古老的实现类;线程安全的,效率低;不能存储null的key和value
- Properties:常用来处理配置文件。key和value都是String类型
Map中存储的key-value的特点
- Map与Collection并列存在。用于保存具有映射关系的数据:key-value
- Map中的 key 和 value 都可以是任何引用类型的数据
- 一个键值对 key-value = 一个 Entry 对象
- Map中的key是用Set存储,其对象所在的类需重写hashCode()、equals()
- Map中的value用Collection存储,其对象所在的类需重写equals()
- key 和 value 之间存在单向一对一关系,即通过指定的key总能找到唯一的、确定的value
HashMap
- HashMap是Map接口使用频率最高的实现类。
- 允许使用 null键 和 null 值,与HashSet一样,不保证映射的顺序。
- 所有的key构成的集合是Set:无序的、不可重复的。所以,key所在的类要重写:equals()和hashCode()
- 所有的value构成的集合是Collection:无序的、可以重复的。所以,value所在的类要重写:equals()
- 所有的 entry 构成的集合是Set:无序的、不可重复的
- HashMap判断两个key相等的标准是:两个key通过equals()方法返回true,hashCode值也相等。
- HashMap判断两个value相等的标准是:两个value 通过equals()方法返回true。
HashMap底层源码分析
数组+链表(JDK8之前)
数组+链表+红黑树(JDK8)
//底层源码
//JDK7
HashMap map=new HashMap();//创建长度为16的Entry[] table数组
map.put(key1,value1);//调用key1.hashCode()计算存储的位置
//如果无其他元素则添加成功,否则
//用key1的hash值逐个比较,若不同,则添加成功,否则
//调用key1.equals(key2)//key2:与key1hash值相同的元素
//若返回true,则value1替换value2
//若返回false,则添加成功
//JDK8 相较于 JDK7
//new HashMap()时没有创建长度为16的数组,而是首次调用put()时才创建
//创建的数组为Node[],而非Entry[]
//JDK7底层:数组+链表
//JDk8底层:数组+链表+红黑树
//当某一位置以链表形式存在个数 >8 且当前数组长度 >64时,所有索引位置上的数据改为红黑树结构
扩容问题
当超出临界值(16*0.75=12),且要放的位置非空,默认扩容为2倍
LinkedHashMap
- LinkedHashMap是HashMap的子类
- 在HashMap存储结构的基础上,使用了一对双向链表来记录添加元素的顺序
- 与LinkedHashSet类似,LinkedHashMap可以维护Map 的迭代顺序:迭代顺序与Key-Value 对的插入顺序一致
Map的常用方法
增、删、改、查
名称 | 作用 |
---|---|
Object put( object key , objetc value ) | 将指定key-value放到当前map对象中(修改对应key的value值) |
void putAll(map M) | 将集合M中的所有的key-value对放到当前map中 |
Objetc remove( object key ) | 删除指定key-value对,并返回value值 |
void clear() | 清空map中所有数据 |
Object get( object key ) | 获取key对应的value |
boolean containskey ( object key ) | 判读是否包含key |
boolean containsvalue(object value) | 判断是否包含value |
int size() | 返回map中key-value对的个数 |
boolean isEmpty() | 判断map是否为空 |
boolean equals(object obj) | 判断map中和obj是否相等 |
元视图操作
名称 | 作用 |
---|---|
Set keySet() | 返回所有key构成的Set集合 |
Collection() values() | 返回所有value构成的集合 |
Set entrySet() | 返回所有key-value对构成的Set集合 |
TreeMap
- TreeMap存储Key-Value 对时,需要根据key-value对进行排序。TreeMap可以保证所有的Key-Value 对处于有序状态。
- TreeSet底层使用红黑树结构存储数据
- TreeMap判断两个key相等的标准:两个key通过compareTo()方法或者compare()方法返回0。
- TreeMap的Key的排序:
- 自然排序:TreeMap的所有的Key 必须实现Comparable接口,而且所有的Key应该是同一个类的对象,否则将会抛出ClasssCastException
- 定制排序:创建TreeMap时,传入一个Comparator 对象,该对象负责对TreeMap中的所有key 进行排序。此时不需要Map 的Key实现Comparable 接口
public class treemaptest {
public static void main(String[] args){
Comparator<Dog> com=new Comparator<Dog>() {
@Override
public int compare(Dog o1, Dog o2) {
int num=o1.getName().compareTo(o2.getName());
if(num != 0){
return num;
}else{
return o1.getDesc().compareTo(o2.getDesc());
}
}
};
TreeMap<Dog,Integer> tree=new TreeMap<>(com);
tree.put(new Dog("哈士奇","傻狗"),2000);
tree.put(new Dog("哈士奇","大傻狗"),1500);
tree.put(new Dog("金毛","暖狗"),2000);
Set entry=tree.entrySet();
Iterator<Map.Entry<Dog,Integer>> it=entry.iterator();
while(it.hasNext()){
Map.Entry<Dog,Integer> en=it.next();
System.out.println(en.getKey()+"->"+en.getValue());
}
}
}
Hashtable
- Hashtable是个古老的Map 实现类,JDK1.0就提供了。不同于HashMap,Hashtable是线程安全的。
- Hashtable实现原理和HashMap相同,功能相同。底层都使用哈希表结构,查询速度快,很多情况下可以互用。
- 与HashMap不同,Hashtable不允许使用null 作为key和value
- 与HashMap一样,Hashtable也不能保证其中Key-Value 对的顺序
Properties
- Properties 类是Hashtable的子类,该对象用于处理属性文件
- 由于属性文件里的key、value都是字符串类型,所以Properties 里的key和value都是字符串类型创建文件
- 1、new—》Resource Bundle—》name
- 2、new—》File—》name.Properties(后缀)
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class PropertiesTest {
//Properties:常用来处理配置文件。key和value都是String类型
public static void main(String[] args){
//快捷键:ALT+Shift+Z
FileInputStream fis = null;
try {
Properties pros = new Properties();
fis = new FileInputStream("jdbc.properties");
pros.load(fis); //加载流对应文件
String name = pros.getProperty("name");
String password = pros.getProperty("password");
System.out.println("name = " + name + ",password = " + password);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
6、Collections工具类
- Collections 是一个操作Set、List和Map 等集合的工具类
- Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
名称 | 作用 |
---|---|
reverse(List) | 反转 List 中元素的顺序 |
shuffle(List) | 对 List 集合元素进行随机排序 |
sort(List) | 根据元素的自然顺序对指定 List 集合元素按升序排序 |
sort(List,Comparator) | 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序 |
wap(List,int, int) | 将指定 list 集合中的 i 处元素和 j 处元素进行交换 |
Object max(Collection) | 根据元素的自然顺序,返回给定集合中的最大元素 |
Object max(Collection,Comparator) | 根据 Comparator 指定的顺序,返回给定集合中的最大元素 |
Object min(Collection) | 根据元素的自然顺序,返回给定集合中的最小元素 |
Object min(Collection,Comparator) | 根据 Comparator 指定的顺序,返回给定集合中的最小元素 |
int frequency(Collection,Object) | 返回指定集合中指定元素的出现次数 |
void copy(List dest,List src) | 将src中的内容复制到dest中 |
boolean replaceAll(List list,Object oldVal,Object newVal) | 使用新值替换 List 对象的所有旧值 |