黑马程序员——java的集合类
2015-06-28 15:31
441 查看
------- android培训、java培训、期待与您交流! ----------
前言:通过观看毕向东老师的java基础视频,查漏补缺,将一些自己掌握的还不牢固的知识写出来,希望和大家交流分享。
1.集合框架
1.集合类的出现原因:为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。
2.java集合框架的构成,由于数据结构的不同,有不同的集合,也叫容器。如下图:
3.与数组相比,集合的优势: 数组虽然也可以存储对象,但长度是固定的;集合长度是可变的。数组中可以存储基本数据类型,集合只能存储对象。
2.Collection类
1.Collection的结构:
Collection
|--List//元素是有序的,元素可以重复。因为该集合体系有索引。
|--Set//元素是无序的,元素不可以重复。
2.Collection接口中常见方法
1)add(Object obj); //添加元素,add方法的参数类型是Object。以便于接收任意类型对象。
2) 删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3)判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4)size();//获取个数,集合长度
5) retainAll(另一集合);//调用者只保留两集合的共性元素。
注:集合中存储的都是对象的引用(地址)。
3.迭代
1) 迭代是取出集合中元素的一种方式。
2)Iterator规则:对于集合的元素取出这个动作被定义成了内部类,可以直接访问集合内部的元素。对每一个容器的数据结构不同,所以取出的动作细节也不一样。
但是都具有共性内容: 判断和取出。那么就可以将这些共性抽取。 那么这些内部类都符合一个规则(或者说都抽取出来一个规则)。该规则就是Iterator。
通过一个对外提供的方法:iterator();,来获取集合的取出对象。因为Collection中有iterator方法,所以每一个子类集合对象都具备迭代器。
3)三个方法:
hasNext();//有下一个元素,返回真
next();//取出下一个元素
remove();//移除
注:在迭代时循环中next调用一次,就要hasNext判断一次
如:
迭代器在Collcection接口中是通用的,它替代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素,要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object,所以要记得类型转换。
3.List类
1.list的组成结构
List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。
2.List的特有方法:
凡是可以操作角标的方法都是该体系特有的方法。
1)增
boolean add(index,element);//指定位置添加元素
Boolean addAll(index,Collection);//在指定位置增加给定集合中的所有元素,若省略位置参数,则在当前集合的后面依次添加元素
2)删
Boolean remove(index);//删除指定位置的元素
3)改
set(index,element);//修改指定位置的元素。
4)查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5)其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置,如果没有则返回-1
注:List集合判断元素是否相同,移除等操作,依据的是元素的equals方法。
3.ListIterator 是List集合特有的迭代器,是Iterator的子接口,对Iterator进行了扩展。
ListIterator特有的方法:
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
4.Vector中的枚举Enumeration
1、枚举就是Vector特有的取出方式
2、发现枚举和迭代器很像。
3、其实枚举和迭代是一样的,因为枚举的名称以及方法的名称都过长,所以被迭代器取代了
5.LinkedList
它底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
特有方法:
1、增
addFirst();
addLast();
2、获取
//获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后,出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素,但是不删除。如果集合中没有元素,会返回null。
peekFirst();
peekLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
LinkedList代码示例:
1.Set的组成结构
Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。
|--HashSet:底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理:判断元素的hashCode值是否相同。如果相同,还会继续判断元素的equals方法,是否为true。
|--TreeSet:可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据:compareTo方法return 0。
Set集合的功能和Collection是一致的。
2.HashSet
1)HashSet:线程不安全,存取速度快。
2)可以通过元素的两个方法,hashCode和equals来完成保证元素唯一性。
如果元素的HashCode值相同,才会判断equals是否为true。如果元素的hashCode值不同,不会调用equals。
3)HashSet对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals方法。
代码示例:
分析:重复元素去重。
3.TreeSet
1) 底层的数据结构为二叉树结构(红黑树结构)
2)可对Set集合中的元素进行排序,是因为:TreeSet类实现了Comparable接口,该接口强制让增加到集合中的对象进行了比较,需要复写compareTo方法,才能让对象按指定需求(如人的年龄大小比较等)进行排序,并加入集合。
3) java中的很多类都具备比较性,其实就是实现了Comparable接口。
4)排序时,当主要条件相同时,按次要条件排序。
5)保证数据的唯一性的依据:通过compareTo方法的返回值,是正整数、负整数或零,则两个对象较大、较小或相同。相等时则不会存入。
6)Tree排序的两种方式
1、方式一,自然排序:让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也被称为元素的自然顺序,或者叫做默认顺序。
代码示例:
2、方式二,比较器:当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。定义一个比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式:定义一个类,实现Comparator接口,覆盖compare方法。
当两种排序都存在时,以比较器为主。
代码示例:
5.Map集合
1. Map<K,V>集合是一个接口,和List集合及Set集合不同的是,它是双列集合,并且可以给对象加上名字,即键(Key)
2.该集合存储键值对,一对一对往里存。要保证键的唯一性。
3.Map的组成结构
Map
|--Hashtable:底层是哈希表数据结构,不可以存入null键 null值。该集合是线程同步的。JDK1.0,效率低。
|--HashMap:底层是哈希表数据结构。允许使用null键null值,该集合是不同步的。JDK1.2,效率高。
|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
4.Map集合常用方法
1、添加
V put(K key,V value);//添加元素,如果出现添加时,相同的键,那么后添加的值会覆盖原有键对应值,并put方法会返回被覆盖的值。
void putAll(Map <? extends K,? extends V> m);//添加一个集合
2、删除
clear();//清空
V remove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
V get(Object key);//通过键获取对应的值
size();//获取集合的长度
Collection<V>value();//获取Map集合中所以得值,返回一个Collection集合
还有两个取出方法,接下来会逐个讲解:
Set<Map.Entry<K,V>> entrySet();
Set<K> keySet();
注:HashMap集合可以通过get()方法的返回值来判断一个键是否存在,通过返回null来判断。
5.Map集合的两种取出方式
Map集合的取出原理:将Map集合转成Set集合。再通过迭代器取出。
1、Set<K> keySet():将Map中所以的键存入到Set集合。因为Set具备迭代器。先通过迭代方式取出所以键的值,再通过get方法。获取每一个键对应的值。
代码示例:
2、Set<Map.Entry<K,V>> entrySet():将Map集合中的映射关系存入到Set集合中,而这个关系的数据类型就是:Map.Entry 其实,Entry也是一个接口,它是Map接口中的一个内部接口。关系如下:
5.Entry是一个接口,它是Map的子接口中的一个内部接口,就相当于是类中有内部类一样。为何要定义在其内部呢?
原因:a、Map集合中村的是映射关系这样的两个数据,是先有Map这个集合,才可有映射关系的存在,而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员,所以定义在内部。
6.当量数据之间存在着映射关系的时候,就应该想到使用Map集合。
‘如: 获取该字符串中的字母出现的次数,如:"sjokafjoilnvoaxllvkasjdfns";希望打印的结果是:a(3)c(0).....
通过结果发现,每个字母都有对应的次数,说明字母和次数之间有映射关系。
代码示例:
运行结果:
------- android培训、java培训、期待与您交流! ----------
前言:通过观看毕向东老师的java基础视频,查漏补缺,将一些自己掌握的还不牢固的知识写出来,希望和大家交流分享。
1.集合框架
1.集合类的出现原因:为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。
2.java集合框架的构成,由于数据结构的不同,有不同的集合,也叫容器。如下图:
3.与数组相比,集合的优势: 数组虽然也可以存储对象,但长度是固定的;集合长度是可变的。数组中可以存储基本数据类型,集合只能存储对象。
2.Collection类
1.Collection的结构:
Collection
|--List//元素是有序的,元素可以重复。因为该集合体系有索引。
|--Set//元素是无序的,元素不可以重复。
2.Collection接口中常见方法
1)add(Object obj); //添加元素,add方法的参数类型是Object。以便于接收任意类型对象。
2) 删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3)判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4)size();//获取个数,集合长度
5) retainAll(另一集合);//调用者只保留两集合的共性元素。
注:集合中存储的都是对象的引用(地址)。
3.迭代
1) 迭代是取出集合中元素的一种方式。
2)Iterator规则:对于集合的元素取出这个动作被定义成了内部类,可以直接访问集合内部的元素。对每一个容器的数据结构不同,所以取出的动作细节也不一样。
但是都具有共性内容: 判断和取出。那么就可以将这些共性抽取。 那么这些内部类都符合一个规则(或者说都抽取出来一个规则)。该规则就是Iterator。
通过一个对外提供的方法:iterator();,来获取集合的取出对象。因为Collection中有iterator方法,所以每一个子类集合对象都具备迭代器。
3)三个方法:
hasNext();//有下一个元素,返回真
next();//取出下一个元素
remove();//移除
注:在迭代时循环中next调用一次,就要hasNext判断一次
如:
ArrayList a=newArrayList();//创建一个集合 Iteratorit=a.iterator();//获取一个迭代器,用于取出集合中的元素。 //第一种打印方式: for(Iterator iter = a.iterator();iter.hasNext();){ System.out.println(iter.next()); } //第二种打印方式: Iterator iter = a.iterator(); while(iter.hasNext()){ System.out.println(iter.next()); }4)注意事项:
迭代器在Collcection接口中是通用的,它替代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素,要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object,所以要记得类型转换。
3.List类
1.list的组成结构
List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。
2.List的特有方法:
凡是可以操作角标的方法都是该体系特有的方法。
1)增
boolean add(index,element);//指定位置添加元素
Boolean addAll(index,Collection);//在指定位置增加给定集合中的所有元素,若省略位置参数,则在当前集合的后面依次添加元素
2)删
Boolean remove(index);//删除指定位置的元素
3)改
set(index,element);//修改指定位置的元素。
4)查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5)其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置,如果没有则返回-1
注:List集合判断元素是否相同,移除等操作,依据的是元素的equals方法。
3.ListIterator 是List集合特有的迭代器,是Iterator的子接口,对Iterator进行了扩展。
ListIterator特有的方法:
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
4.Vector中的枚举Enumeration
1、枚举就是Vector特有的取出方式
2、发现枚举和迭代器很像。
3、其实枚举和迭代是一样的,因为枚举的名称以及方法的名称都过长,所以被迭代器取代了
5.LinkedList
它底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
特有方法:
1、增
addFirst();
addLast();
2、获取
//获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后,出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素,但是不删除。如果集合中没有元素,会返回null。
peekFirst();
peekLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
LinkedList代码示例:
package collection; import java.util.LinkedList; /** * 使用LinkedList模拟一个堆栈或者队列数据结构。 * 堆栈:先进后出 如同一个杯子。 * 队列:先进先出 FIFO 如同一个水管。 * @author songwenju * */ public class LinkedListDemo { //模拟栈 public static void stack(LinkedList<String> list){ while (!list.isEmpty()) { System.out.println(l 4000 ist.removeFirst()); } } //模拟队列 public static void queue(LinkedList<String> list){ while (!list.isEmpty()) { System.out.println(list.removeLast()); } } public static void main(String[] args) { LinkedList<String> list = new LinkedList<String>(); list.addFirst("java01"); list.addFirst("java02"); list.addFirst("java03"); list.addFirst("java04"); list.addFirst("java05"); //堆栈输出 //stack(list); //队列输出 queue(list); } }4.Set类
1.Set的组成结构
Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。
|--HashSet:底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理:判断元素的hashCode值是否相同。如果相同,还会继续判断元素的equals方法,是否为true。
|--TreeSet:可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据:compareTo方法return 0。
Set集合的功能和Collection是一致的。
2.HashSet
1)HashSet:线程不安全,存取速度快。
2)可以通过元素的两个方法,hashCode和equals来完成保证元素唯一性。
如果元素的HashCode值相同,才会判断equals是否为true。如果元素的hashCode值不同,不会调用equals。
3)HashSet对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals方法。
代码示例:
package collection; import java.util.HashSet; /** * 往hashSet集合中存入自定义对象 * 姓名和年龄相同为同一个人,重复元素。去除重复元素 * 思路: * 1、对人描述,将人的一些属性等封装进对象 * 2、定义一个HashSet容器,存储人对象 * 3、取出 * @author songwenju * */ class Person{ private String name; private int age; public Person() {} public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } //以下hashCode和equals是由eclipse生成的代码。 /* (non-Javadoc) * @see java.lang.Object#hashCode() */ @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } /* (non-Javadoc) * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!(obj instanceof Person)) { return false; } Person other = (Person) obj; if (age != other.age) { return false; } if (name == null) { if (other.name != null) { return false; } } else if (!name.equals(other.name)) { return false; } return true; } } public class HashSetDemo { public static void main(String[] args) { HashSet<Person> h = new HashSet<Person>(); h.add(new Person("stu1", 10)); h.add(new Person("stu2", 6)); h.add(new Person("stu3", 30)); h.add(new Person("stu1", 10)); h.add(new Person("stu4", 10)); for (Person p : h) { System.out.println(p.getName()+"-->"+p.getAge()); } } }运行结果:
分析:重复元素去重。
3.TreeSet
1) 底层的数据结构为二叉树结构(红黑树结构)
2)可对Set集合中的元素进行排序,是因为:TreeSet类实现了Comparable接口,该接口强制让增加到集合中的对象进行了比较,需要复写compareTo方法,才能让对象按指定需求(如人的年龄大小比较等)进行排序,并加入集合。
3) java中的很多类都具备比较性,其实就是实现了Comparable接口。
4)排序时,当主要条件相同时,按次要条件排序。
5)保证数据的唯一性的依据:通过compareTo方法的返回值,是正整数、负整数或零,则两个对象较大、较小或相同。相等时则不会存入。
6)Tree排序的两种方式
1、方式一,自然排序:让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也被称为元素的自然顺序,或者叫做默认顺序。
代码示例:
package collection; import java.util.TreeSet; /** * 自然排序 * @author songwenju * */ //这里要实现Compare接口,否则会报collection.Student cannot be cast to java.lang.Comparable错误 class Student implements Comparable<Student>{ private String name; private int age; public Student() {} public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } //覆写compareTo @Override public int compareTo(Student student) { if (this.age == student.age) { return this.name.compareTo(student.name); } return this.age - student.age; } } public class TreeSetDemo { public static void main(String[] args) { TreeSet<Student> t = new TreeSet<Student>(); t.add(new Student("stu1", 12)); t.add(new Student("stusj", 2)); t.add(new Student("stu1swj", 12)); t.add(new Student("stu6ds", 12)); t.add(new Student("stu", 22)); for (Student p : t) { System.out.println(p.getName()+"-->"+p.getAge()); } } }运行结果:
2、方式二,比较器:当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。定义一个比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式:定义一个类,实现Comparator接口,覆盖compare方法。
当两种排序都存在时,以比较器为主。
代码示例:
package collection; import java.util.Comparator; import java.util.TreeSet; /** * 往TreeSet集合中存储自定义对象学生。 * 想按照学生的年龄进行排序。 * @author songwenju * */ //这里要实现Compare接口,否则会报collection.Student cannot be cast to java.lang.Comparable错误 class Student implements Comparable<Student>{ private String name; private int age; public Student() {} public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } //覆写compareTo @Override public int compareTo(Student student) { if (this.age == student.age) { return this.name.compareTo(student.name); } return this.age - student.age; } } //定义一个比较器 class LenCompare implements Comparator<Student>{ @Override public int compare(Student s1, Student s2) { int num = new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length())); if (num == 0) { return new Integer(s1.getAge()).compareTo(s2.getAge()); } return 0; } } public class TreeSetDemo { public static void main(String[] args) { TreeSet<Student> t = new TreeSet<Student>(); t.add(new Student("stu1", 12)); t.add(new Student("stu1", 12)); t.add(new Student("stusj", 2)); t.add(new Student("stu1swj", 12)); t.add(new Student("stu6ds", 12)); t.add(new Student("stu", 22)); for (Student p : t) { System.out.println(p.getName()+"-->"+p.getAge()); } } }运行结果:
5.Map集合
1. Map<K,V>集合是一个接口,和List集合及Set集合不同的是,它是双列集合,并且可以给对象加上名字,即键(Key)
2.该集合存储键值对,一对一对往里存。要保证键的唯一性。
3.Map的组成结构
Map
|--Hashtable:底层是哈希表数据结构,不可以存入null键 null值。该集合是线程同步的。JDK1.0,效率低。
|--HashMap:底层是哈希表数据结构。允许使用null键null值,该集合是不同步的。JDK1.2,效率高。
|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
4.Map集合常用方法
1、添加
V put(K key,V value);//添加元素,如果出现添加时,相同的键,那么后添加的值会覆盖原有键对应值,并put方法会返回被覆盖的值。
void putAll(Map <? extends K,? extends V> m);//添加一个集合
2、删除
clear();//清空
V remove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
V get(Object key);//通过键获取对应的值
size();//获取集合的长度
Collection<V>value();//获取Map集合中所以得值,返回一个Collection集合
还有两个取出方法,接下来会逐个讲解:
Set<Map.Entry<K,V>> entrySet();
Set<K> keySet();
注:HashMap集合可以通过get()方法的返回值来判断一个键是否存在,通过返回null来判断。
5.Map集合的两种取出方式
Map集合的取出原理:将Map集合转成Set集合。再通过迭代器取出。
1、Set<K> keySet():将Map中所以的键存入到Set集合。因为Set具备迭代器。先通过迭代方式取出所以键的值,再通过get方法。获取每一个键对应的值。
代码示例:
package collection; import java.util.HashMap; /** * 对Map进行遍历输出 * @author songwenju * */ public class MapDemo { public static void main(String[] args) { HashMap<String, String> map = new HashMap<String, String>(); map.put("河南", "郑州"); map.put("河北", "石家庄"); map.put("湖南", "长沙"); map.put("湖北", "武汉"); //对keyset进行遍历,得到每一个key再得到对于的value。 for (String k : map.keySet()) { System.out.print(k + "-->"); System.out.println(map.get(k)); } } }运行结果:
2、Set<Map.Entry<K,V>> entrySet():将Map集合中的映射关系存入到Set集合中,而这个关系的数据类型就是:Map.Entry 其实,Entry也是一个接口,它是Map接口中的一个内部接口。关系如下:
interface Map { public static interface Entry{ public abstract Object getKey(); public abstract Object getValue(); } }代码示例:
package collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; /** * 对Map进行遍历输出 * @author songwenju * */ public class MapEntryDemo { public static void main(String[] args) { HashMap<String, String> map = new HashMap<String, String>(); map.put("河南", "郑州"); map.put("河北", "石家庄"); map.put("湖南", "长沙"); map.put("湖北", "武汉"); /* * 用for each实现 */ //对keyset进行遍历,得到每一个key再得到对于的value。 Set<Map.Entry<String, String>> entries = map.entrySet(); for (Entry<String, String> k : entries) { System.out.print(k.getKey() + "-->"); System.out.println(k.getValue()); } System.out.println("----------------------"); /* * 用Iterator迭代实现 */ Iterator<Map.Entry<String, String>> it = map.entrySet().iterator(); while (it.hasNext()) { Map.Entry<String, String> me = it.next(); System.out.print(me.getKey() + "-->"); System.out.println(me.getValue()); } } }运行结果:
5.Entry是一个接口,它是Map的子接口中的一个内部接口,就相当于是类中有内部类一样。为何要定义在其内部呢?
原因:a、Map集合中村的是映射关系这样的两个数据,是先有Map这个集合,才可有映射关系的存在,而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员,所以定义在内部。
6.当量数据之间存在着映射关系的时候,就应该想到使用Map集合。
‘如: 获取该字符串中的字母出现的次数,如:"sjokafjoilnvoaxllvkasjdfns";希望打印的结果是:a(3)c(0).....
通过结果发现,每个字母都有对应的次数,说明字母和次数之间有映射关系。
代码示例:
package collection; import java.util.Map.Entry; import java.util.TreeMap; /** * 需求: 获取该字符串中的字母出现的次数,如:"sjokafjoilnvoaxllvkasjdfns";希望打印的结果是:a(3)c(1)..... * 思路: * 1、将字符串转换为字符数组 * 2、定义一个TreeMap集合,用于存储字母和字母出现的次数 * 3、用数组去遍历集合,如果集合中有该字母则次数加1,如果集合中没有则存入 * 4、将TreeMap集合中的元素转换为字符串 * @author songwenju * */ public class CharCount { public static void main(String[] args) { String s = "agk;sjaksd;gsa"; System.out.println("s中各字母出现的个数:"+charCount(s)); } public static String charCount(String str) { char[] chs = str.toCharArray();//转化为字符数组 //定义一个TreeMap集合,因为TreeMap集合会给键自动排序 TreeMap<Character, Integer> map = new TreeMap<Character, Integer>(); int count = 0;//定义计数变量 for (int i = 0; i < chs.length; i++) { if (!(chs[i]>='a' && chs[i]<= 'z'||chs[i]>='A' && chs[i]<= 'Z')) { continue;//如果字符串中非字母,则不计数 }else { Integer value = map.get(chs[i]);//获取集合中的值 if (value != null) {//如果集合中没有该字母,则存入 count = value; } a1d9 count++; map.put(chs[i], count); count = 0; } } StringBuilder sBuilder = new StringBuilder(); for (Entry<Character, Integer> c : map.entrySet()) { sBuilder.append(c.getKey()+"("+c.getValue()+")"); } return sBuilder.toString(); } }
运行结果:
------- android培训、java培训、期待与您交流! ----------
相关文章推荐
- java对世界各个时区(TimeZone)的通用转换处理方法(转载)
- java-注解annotation
- java-模拟tomcat服务器
- java-用HttpURLConnection发送Http请求.
- java-WEB中的监听器Lisener
- Android IPC进程间通讯机制
- Android Native 绘图方法
- Android java 与 javascript互访(相互调用)的方法例子
- 介绍一款信息管理系统的开源框架---jeecg
- 聚类算法之kmeans算法java版本
- java实现 PageRank算法
- PropertyChangeListener简单理解
- 插入排序
- 冒泡排序
- 堆排序
- 快速排序
- 二叉查找树
- [原创]java局域网聊天系统