黑马程序员_集合学习之Map,Collections,Arrays与高级for
2013-04-07 22:44
507 查看
------- android培训、java培训、期待与您交流! ----------
Map集合
该集合存储键值对。一对一对往里存,而且要保证键的唯一性(与Set集合保证元素唯一性一致)。一个映射不能包含重复的键。每个键最多只能映射到一个值。
Collection是单列对象集合,而Map是键值对集合。
添加,删除,判断,获取元素。
clear
从此映射中移除所有映射关系(可选操作)。
remove
如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
Containskey()
ContainsValue()
判断键和值是否在集合中存在。
get
返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回
values
返回此映射中包含的值的
添加
put
将指定的值与此映射中的指定键关联(可选操作)。
putAll
从指定映射中将所有映射关系复制到此映射中(可选操作)。
Map集合中常见的三个子类对象
HashMap:底层是哈希表数据结构,线程不同步。允许使用null值和null键,效率高
HashTable:线程同步。不允许存入null值和null键,效率低
为了成功的在哈希表中存储和获取对象,用作键的对象必须实现hashCode方法和equals方法。
TreeMap:底层是二叉树数据结构,线程不同步,给键排序是它的主要特点。
其实Set底层就是使用了Map集合。
当Map仅存入一个键值的 时候,就是Set。
下边具体写一个例子来使用上述方法
在Map中不能通过迭代器的方式去取出所有的元素,只用Collection体系下的集合才能使用Iterator去迭代取出。
有两种方式
keySet
返回此映射中包含的键的
将map中所有的键存入到Set集合中,由于Set具备迭代器,所以可以使用迭代方式取出所有的键,在根据get方法,获取每一个键对应的值。
例如
entrySet
返回此映射中包含的映射关系的
Map集合的取出原理,将Map集合转成Set集合,再通过迭代器取出。
在Map集合的子类中实现了Map.entry,对应集合的特定取出方式。跟迭代器原理一样。
上边的Map.entry类型其实就是关系类型。每一个键值对组成了一个关系。
Map集合的练习:
下边,我们来看一个关于Map集合的高级应用。
需求:
一个公司的名字叫WDB,底下有很多的部门,比如说有财务部,信息部。
每个部下边又有很多的人。现在用集合中嵌套集合的方式来实现这个需求。
下边来讲解集合中的两个工具类:Collections,Arrays
Collections
作用:专门用来对集合进行操作的类,如对List集合排序sort();
sort(List<T>list)
根据元素的自然顺序 对指定列表按升序进行排序。
sort(List<T>list, Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序。
例子
输出为:
[1, 111, 3, 4]
[1, 3, 4, 111]
介绍其中几个比较重要的方法
public static<T> Comparator<T> reverseOrder()
返回一个比较器,它强行逆转实现了 Comparable 接口的对象 Collection 的自然顺序。
如下:
public static<T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器,它强行逆转指定比较器的顺序。
例如:
Arrays
用于操作数组的工具类
1. 对基本数据类型的折半查找的方法。
例如
binarySearch(byte[]a, bytekey)
使用二分搜索法来搜索指定的 byte 型数组,以获得指定的值。
2.对数组的复制
copyOf(boolean[]original, int newLength)
复制指定的数组,截取或用 false 填充(如有必要),以使副本具有指定的长度。
最重要的方法,将数组变成List集合
使用Arrays.asList();
为什么将数组变为集合?
可以使用集合的思想和方法来操作数组中的元素。
数组是一个对象,但是它的功能比较少,而集合的方法很多。
注意:将数组变成集合,不可以使用集合的增删方法
因为数组的长度是固定的。
如果使用增删,会发生UnsupportedOperationException
注意当使用
打印的不是元素,而是这个数组地址值。。
它是将arr作为一个集合的元素存在,而这个集合的类型就是int[]
所以当使用泛型的时候,应该这样去定义
List<int[]> list = Arrays.asList(arr);
如果数组中的元素都是对象,变成集合时候,数组中的元素就直接转成集合中的元素
比如说String,如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
当我们这样定义时候
结果为[1, 33, 3, 4, 5]
上述是数组变成集合使用Arrays中的asList方法。
当集合变为数组的时候,就用到了Collection接口中的toArray方法。
输出为 [1, 2, 3]
这里指定类型的数组要定义多长呢?当指定类型数组小于集合的size,那么该方法内部会创建一个新的数组,长度为集合的size,当指定类型的数组长度大于了集合的size,就不会新创建数组,而是使用传递进来的数组。
所以应该这样创建。String [] arr=al.toArray(new String[al.size()]);
为什么要将集合变成数组?
是为了限定对元素的操作。当返回一个集合时候,使用者对这个集合依然可以使用增删的方法对集合进行修改。当返回一个数组的时候,就不能改变其集合的大小了,限定了对使用着的操作。
高级for循环,方便对集合进行操作。
前提:只有继承自Iterable接口的集合接口才能使用foreach(高级for循环),比如Collection,而Map集合不能使用这个高级for循环。
格式
for(数据类型 变量名 :被遍历的集合(Collection)或者数组)
{
}
这个遍历的局限性:只能对集合中的元素进行取出,而不能做修改动作。
迭代器至少有remove,如果使用列表迭代器的话,增删改查都行。
例子:
还可以对数组进行遍历,例子:
传统for循环和高级for循环的区别:高级for有一个局限性。必须有被遍历的目标。
对HashMap进行高级for循环遍历的例子:
由于Map不能使用高级for循环,所以必须将Map转成Set后,再使用高级for循环。
Map集合
该集合存储键值对。一对一对往里存,而且要保证键的唯一性(与Set集合保证元素唯一性一致)。一个映射不能包含重复的键。每个键最多只能映射到一个值。
Collection是单列对象集合,而Map是键值对集合。
添加,删除,判断,获取元素。
clear
()
从此映射中移除所有映射关系(可选操作)。
remove
(Object
key)
如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
Containskey()
ContainsValue()
判断键和值是否在集合中存在。
get
(Object
key)
返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回
null。
values
()
返回此映射中包含的值的
Collection视图。
添加
put
(K
key,V
value)
将指定的值与此映射中的指定键关联(可选操作)。
putAll
(Map
<? extendsK
,?extendsV
>m)
从指定映射中将所有映射关系复制到此映射中(可选操作)。
Map集合中常见的三个子类对象
HashMap:底层是哈希表数据结构,线程不同步。允许使用null值和null键,效率高
HashTable:线程同步。不允许存入null值和null键,效率低
为了成功的在哈希表中存储和获取对象,用作键的对象必须实现hashCode方法和equals方法。
TreeMap:底层是二叉树数据结构,线程不同步,给键排序是它的主要特点。
其实Set底层就是使用了Map集合。
当Map仅存入一个键值的 时候,就是Set。
下边具体写一个例子来使用上述方法
import java.util.*; public class MapDemo { public static void main(String[] args) { Map<String,String> mp = new HashMap<String,String>(); System.out.println(mp.put("01","001")); System.out.println(mp.put("01","0001")); //在Map中存入一个键相同的值后,新的值会替换旧的值,这与set集合不同。 //旧的值通过put方法返回 mp.put("02", "002"); mp.put("03","003"); mp.put("04","004"); System.out.println(mp.containsKey("02")); System.out.println(mp.remove("01")); //当remove删除键在集合中不存在时候,返回null //当remove删除的键在集合中存在时,返回这个键所对应的值 System.out.println(mp); String s = mp.get("04"); //通过键去得到键所对应的值 System.out.println(s); mp.put(null,null); //HashMap中能存null键与null值 //获取map中所有的值 Collection<String> c = mp.values(); System.out.println(c); c.remove("002"); System.out.println(c); System.out.println(mp); } }
在Map中不能通过迭代器的方式去取出所有的元素,只用Collection体系下的集合才能使用Iterator去迭代取出。
有两种方式
keySet
()
返回此映射中包含的键的
Set视图。
将map中所有的键存入到Set集合中,由于Set具备迭代器,所以可以使用迭代方式取出所有的键,在根据get方法,获取每一个键对应的值。
例如
Map<String,String> mp = new HashMap<String,String>(); mp.put("02", "002"); mp.put("03","003"); mp.put("04","004"); Set<String> set = mp.keySet(); Iterator<String> it = set.iterator(); while(it.hasNext()) { String key = it.next(); System.out.println(key+"...."+mp.get(key)); }
entrySet
()
返回此映射中包含的映射关系的
Set视图。
Map<String,String> mp = new HashMap<String,String>(); mp.put("02", "002"); mp.put("03","003"); mp.put("04","004"); Set<Map.Entry<String,String>> set = mp.entrySet(); Iterator<Map.Entry<String,String>> it = set.iterator(); while(it.hasNext()) { Map.Entry<String,String> mpe = it.next(); System.out.println(mpe.getKey()+".."+mpe.getValue()); }
Map集合的取出原理,将Map集合转成Set集合,再通过迭代器取出。
在Map集合的子类中实现了Map.entry,对应集合的特定取出方式。跟迭代器原理一样。
上边的Map.entry类型其实就是关系类型。每一个键值对组成了一个关系。
Map集合的练习:
import java.util.*; public class Test { public static void main(String[] args) { Map<Student,String> mp = new HashMap<Student,String>(); mp.put(new Student("01",9),"0001"); mp.put(new Student("02",10),"0002"); mp.put(new Student("01",10),"0001"); mp.put(new Student("001",9),"0001"); mp.put(new Student("001",9),"002"); //第一种取出方式 keySet Set<Student> set = mp.keySet(); Iterator<Student> it = set.iterator(); while(it.hasNext()) { Student s = it.next(); System.out.println(s+"......."+mp.get(s)); } //第二种取出方式entrySet Set<Map.Entry<Student,String>> setMapEntry = mp.entrySet(); Iterator<Map.Entry<Student,String>> itEntry = setMapEntry.iterator(); while(itEntry.hasNext()) { Map.Entry<Student,String> me = itEntry.next(); System.out.println(me.getKey()+"...."+me.getValue()); } } } class Student implements Comparable<Student> { private String name; private int age; public Student(String name,int age) { this.name = name; this.age = age; } @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; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) 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; } @Override public String toString() { return "{"+this.name+"."+this.age+"}"; } @Override public int compareTo(Student o) { int num = this.name.compareTo(o.name); if(num==0) { return this.age-o.age; } return num; } }
下边,我们来看一个关于Map集合的高级应用。
需求:
一个公司的名字叫WDB,底下有很多的部门,比如说有财务部,信息部。
每个部下边又有很多的人。现在用集合中嵌套集合的方式来实现这个需求。
import java.util.*; public class JJ { public static void main(String[] args) { HashMap<String,List<Person1>> WDB = new HashMap<String,List<Person1>>(); //创建了一个公司 ArrayList<Person1> caiwu = new ArrayList<Person1>(); ArrayList<Person1> xinxi = new ArrayList<Person1>(); //创建了两个部门 //给两个部门分别添加各自的员工。 caiwu.add(new Person1("wangdbain",10)); caiwu.add(new Person1("wangdbain1",11)); xinxi.add(new Person1("zhaojianrun",10)); xinxi.add(new Person1("wangfangfang",20)); //给公司添加部门 WDB.put("caiwu",caiwu); WDB.put("xinxi",xinxi); //这里使用迭代器去分别去取公司每个部门的员工 Set<Map.Entry<String,List<Person1>>> set = WDB.entrySet(); Iterator<Map.Entry<String,List<Person1>>> it = set.iterator(); while(it.hasNext()) { Map.Entry<String,List<Person1>> me = it.next(); System.out.println(me.getKey());//得到部门的名称 List<Person1> li = me.getValue();//得到部门员工的集合 Iterator<Person1> it1 = li.iterator(); while(it1.hasNext()) { System.out.println(it1.next()); //得到一个部门的所有员工 } } } } class Person1 { private String name; private int age; public Person1(String name,int age) { this.name = name; this.age = age; } 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 String toString() { return this.name+"..."+this.age; } }
下边来讲解集合中的两个工具类:Collections,Arrays
Collections
作用:专门用来对集合进行操作的类,如对List集合排序sort();
sort(List<T>list)
根据元素的自然顺序 对指定列表按升序进行排序。
sort(List<T>list, Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序。
例子
public class CollectionsDemo { public static void main(String[] args) { ArrayList<String> al = new ArrayList<String>(); al.add("4"); al.add("111"); al.add("1"); al.add("3"); Collections.sort(al); System.out.println(al); Collections.sort(al,new Mycom2()); System.out.println(al); } } class Mycom2 implements Comparator<String> { public int compare(String o1, String o2) { int num = o1.length()-o2.length(); if(num==0) { return o1.compareTo(o2); } return num; } }
输出为:
[1, 111, 3, 4]
[1, 3, 4, 111]
介绍其中几个比较重要的方法
public static<T> Comparator<T> reverseOrder()
返回一个比较器,它强行逆转实现了 Comparable 接口的对象 Collection 的自然顺序。
如下:
TreeSet<String> ts = new TreeSet<String>(); ts.add("2"); ts.add("1"); ts.add("4"); ts.add("8"); System.out.println(ts); //输出 1,2,3,8 TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder()); ts.add("2"); ts.add("1"); ts.add("4"); ts.add("8"); System.out.println(ts); 则//输出 8,3,2,1
public static<T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器,它强行逆转指定比较器的顺序。
例如:
public class Collectionnn { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>(new Mycom()); ts.add("2"); ts.add("11"); ts.add("422"); ts.add("8888"); System.out.println(ts); //得到 [2, 11, 422, 8888] TreeSet<String> ts = new TreeSet<String>(Collections. reverseOrder(new Mycom())); ts.add("2"); ts.add("11"); ts.add("422"); ts.add("8888"); System.out.println(ts); //得到 [ 8888,422,11,2] } } class Mycom implements Comparator<String> { public int compare(String o1, String o2) { return o1.length()-o2.length(); } }
Arrays
用于操作数组的工具类
1. 对基本数据类型的折半查找的方法。
例如
binarySearch(byte[]a, bytekey)
使用二分搜索法来搜索指定的 byte 型数组,以获得指定的值。
2.对数组的复制
copyOf(boolean[]original, int newLength)
复制指定的数组,截取或用 false 填充(如有必要),以使副本具有指定的长度。
最重要的方法,将数组变成List集合
使用Arrays.asList();
String [] arre={"11","23","22"}; List<String> list = Arrays.asList(arre); System.out.println(list); //结果为 [11, 23, 22]
为什么将数组变为集合?
可以使用集合的思想和方法来操作数组中的元素。
数组是一个对象,但是它的功能比较少,而集合的方法很多。
注意:将数组变成集合,不可以使用集合的增删方法
因为数组的长度是固定的。
如果使用增删,会发生UnsupportedOperationException
注意当使用
int []arr ={1,33,3,4,5}; List list =Arrays.asList(arr); System.out.println(list);
打印的不是元素,而是这个数组地址值。。
它是将arr作为一个集合的元素存在,而这个集合的类型就是int[]
所以当使用泛型的时候,应该这样去定义
List<int[]> list = Arrays.asList(arr);
如果数组中的元素都是对象,变成集合时候,数组中的元素就直接转成集合中的元素
比如说String,如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
当我们这样定义时候
Integer []arr = {1,33,3,4,5}; List<Integer> list= Arrays.asList(arr); System.out.println(list);
结果为[1, 33, 3, 4, 5]
上述是数组变成集合使用Arrays中的asList方法。
当集合变为数组的时候,就用到了Collection接口中的toArray方法。
ArrayList<String> al = new ArrayList<String>(); al.add("1"); al.add("2"); al.add("3"); String [] arr=al.toArray(new String[0]); System.out.println(Arrays.toString(arr));
输出为 [1, 2, 3]
这里指定类型的数组要定义多长呢?当指定类型数组小于集合的size,那么该方法内部会创建一个新的数组,长度为集合的size,当指定类型的数组长度大于了集合的size,就不会新创建数组,而是使用传递进来的数组。
所以应该这样创建。String [] arr=al.toArray(new String[al.size()]);
为什么要将集合变成数组?
是为了限定对元素的操作。当返回一个集合时候,使用者对这个集合依然可以使用增删的方法对集合进行修改。当返回一个数组的时候,就不能改变其集合的大小了,限定了对使用着的操作。
高级for循环,方便对集合进行操作。
前提:只有继承自Iterable接口的集合接口才能使用foreach(高级for循环),比如Collection,而Map集合不能使用这个高级for循环。
格式
for(数据类型 变量名 :被遍历的集合(Collection)或者数组)
{
}
这个遍历的局限性:只能对集合中的元素进行取出,而不能做修改动作。
迭代器至少有remove,如果使用列表迭代器的话,增删改查都行。
例子:
ArrayList<Integer> al = new ArrayList<Integer>(); al.add(1); al.add(31); for(int a:al) { System.out.println(a); }
还可以对数组进行遍历,例子:
int[] arr = {1,2,3,4,5}; for(int num:arr) { System.out.println(num); }
传统for循环和高级for循环的区别:高级for有一个局限性。必须有被遍历的目标。
对HashMap进行高级for循环遍历的例子:
由于Map不能使用高级for循环,所以必须将Map转成Set后,再使用高级for循环。
HashMap<String,String> hm = new HashMap<String,String>(); hm.put("1","2"); hm.put("2", "3"); Set<Map.Entry<String,String>> set = hm.entrySet(); for(Map.Entry<String,String> me:set) { System.out.println(me.getKey()+"....."+me.getValue()); }
相关文章推荐
- 黑马程序员_学习笔记:10) 集合框架2:Set(HashSet、TreeSet)、Map(Hashtable、HashMap、TreeMap)、Collections、Arrays
- 黑马程序员---集合框架工具类Collections,数组工具类Arrays常见方法以及1.5版本新特性(高级for,可变参数和静态导入)
- 黑马程序员_温习 集合六 (个人笔记)摘要(Collections集合工具类-----Arrays数组工具类-----高级for----可变参数----静态导入)
- 黑马程序员—java基础学习--Map集合、Collections,Arrays工具类
- Java学习日记(九)Collection、泛型、Map集合、Collections&Arrays、增强for语句、可变参数、静态导入
- 黑马程序员------集合(No.2)(Collections、Arrays、集合与数组转换、高级for、可变参数、静态导入)
- 黑马程序员_集合3(HashMap,HashTable,TreeMap,Arrays,Collections,高级for,可变参数,静态导入,Date,Calendar,Math,System等)
- JAVA基础学习之 Map集合、集合框架工具类Collections,Arrays、可变参数、List和Set集合框架什么时候使用等(4)
- 黑马程序员_java_集合_Map_Collections_Arrays_TreeMap
- 黑马程序员——JAVA基础——集合---概述、Collection中共性方法、List、Map、工具类Collections和Arrays
- 黑马程序员——6.集合类(String/StringBuffer、List、Set、Map、Collections工具类、Arrays工具类 )
- 黑马程序员_Java第17天知识总结_集合框架的工具类_Collections_Arrays_将数组变成list集合_集合变数组_高级for循环_可变参数
- Map集合,Collections,Arrays,增强for
- 黑马程序员——Java基础---集合<二>Map,Arrays,Collections
- 黑马程序员_毕向东JAVA基础_集合(3)Map&Collections&Arrays&增强for循环
- 黑马程序员--------java Collections、Arrays、高级for、可变参数、静态导入、System、Runtime、Math、Date、Calendar
- 【17】集合4_Collections,Arrays工具类,高级For,可变参数,静态成员导入
- 黑马程序员_(集合框架(Map,Collections,Arrays))
- 集合二(set及其子类、Map、Collections、Arrays、增强for)
- 黑马程序员--集合框架(map集合,Collections,Arrays)