--------------------- android培训、java培训、java学习型技术博客、期待与您交流! -------------------
Map
集合特点一次存入一堆元素,以键值对的形式存在,必须保证健的唯一性
Map集合和Collection集合的区别?
Map中一次存储是键值对。Map的存储使用的put方法。Map的取出,是讲Map转成Set,在使用迭代器取出。
Collection中一次存储是单个元素。Collection存储使用的是add方法。 Collection取出,使用就是迭代器。
如果元素存在着映射关系,可以优先考虑使用Map存储或者用数组,
如果没有映射关系,可以使用Collection存储。
共性方法
添加 put(key,value)返回的是被覆盖的value,如果没有覆盖返回为空
删除 remove(key)移除与此键相关的映射关系 clear()移除所有映射关系
获取 get(key)通过key获取value,该key不存在时返回null
因为在hashMap中可以存入null健null值所以当返回为null时需要注意hashMap中存入的键所对应的值是否为null
判断 boolean countainsKey(key)该健是否存在
boolean countains Value(value)该值是否存在
boolean isEmpty()判断是否有元素。
长度 int size()返回集合元素个数
取出:
原理将map集合转换为Set集合后再通过迭代取出
Set<k> keyset();将map集合中的所有键提取出来存入set集合中,通过set集合取出键后,再通过map集合的get方法提取对应的值
KeySet图解
Set<Map.Eentry<k,v>> entrySet();将map集合中的键值映射关系打包成一个对象Map.Entry对象再存入set集合中,通过set集合的方法取出Map.Entry后,再通过Map.Entry的getKey和getVlaue方法取出
entrySet图解
接口Map.Entry<K,V>
接口Map<K,V>
这两个接口的泛型定义有两个,是因为在其接口内部都封装了另外一个接口。
Collection<v> values()获取所有值存入一个Collection中
values取出代码示例
class MapDemo
{
public static void main(String[] args)
{
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(8,"zhaoliu");
map.put(2,"zhaoliu");
map.put(7,"xiaoqiang");
map.put(6,"wangcai");
Collection<String> values = map.values();
Iterator<String> it = values.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
HashMap 底层是哈希表数据结构,允许使用null值和null键,是不同步的,效率高
HashMap KeySet取出代码示例
class HashMapDemo
{
public static void main(String[] args)
{
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("lisi",38),"北京");
hm.put(new Student("zhaoliu",24),"上海");
hm.put(new Student("xiaoqiang",31),"沈阳");
hm.put(new Student("wangcai",28),"大连");
hm.put(new Student("zhaoliu",24),"铁岭");
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator();
Iterator<Student> it = hm.keySet().iterator();
while(it.hasNext()){
Student key = it.next();
String value = hm.get(key);
System.out.println(key.getName()+":"+key.getAge()+"---"+value);
}
}
Hashtable底层是哈希表数据结构,不可以存入null键null值,该集合是线程同步的,被HashMap取代
TreeMap底层是二叉树结构,线程不同步,可以用于给Map集合中的键进行排序。
其实Set集合底层调用的就是Map集合
class TreeMapDemo
{
public static void main(String[] args)
{
TreeMap<Student,String>tm=
new TreeMap<Student,String>(new ComparatorByName());
tm.put(new Student("lisi",38),"北京");
tm.put(new Student("zhaoliu",24),"上海");
tm.put(new Student("xiaoqiang",31),"沈阳");
tm.put(new Student("wangcai",28),"大连");
tm.put(new Student("zhaoliu",24),"铁岭");
Iterator<Map.Entry<Student, String>> it = tm.entrySet().iterator();
while(it.hasNext()){
Map.Entry<Student,String> me = it.next();
Student key = me.getKey();
String value = me.getValue();
System.out.println(key.getName()+":"+key.getAge()+"---"+value);
}
}
}
练习
"fdgavcbsacdfs" 获取该字符串中,每一个字母出现的次数。
代码示例
class MapTest
{
public static void main(String[] args)
{
String str = "fdg+avAdc bs5dDa9c-dfs";
String s = getCharCount(str);
System.out.println(s);
}
public static String getCharCount(String str) {
//将字符串变成字符数组
char[] chs = str.toCharArray();
//定义map集合表。
Map<Character,Integer> map = new TreeMap<Character,Integer>();
for (int i = 0; i < chs.length; i++) {
if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z'))
if(!(Character.toLowerCase(chs[i])>='a' && Character.toLowerCase(chs[i])<='z'))
continue;
//将数组中的字母作为键去查map表。
Integer value = map.get(chs[i]);
int count = 1;
//判断值是否为null.
if(value!=null){
count = value+1;
}
count++;
map.put(chs[i], count);
if(value==null){
map.put(chs[i], 1);
}else{
map.put(chs[i], value+1);
}
}
return mapToString(map);
}
private static String mapToString(Map<Character, Integer> map) {
StringBuilder sb = new StringBuilder();
Iterator<Character> it = map.keySet().iterator();
while(it.hasNext()){
Character key = it.next();
Integer value = map.get(key);
sb.append(key+"("+value+")");
}
return sb.toString();
}
}
Collections 集合工具类,该工具类中定义的静态方法都可以用来操作集合
常见方法
对List集合进行排序
sort(list)根据元素的自然顺序排序该list集合中的元素必须实现Comparable
sort(list comparator)根据比较器排序
对list进行二分查找,前提该List集合一定要有序
binarySearch
(
List
,
key
)要求
list
集合中的元素都是
Comparable
的子类
binarySearch
(
List key Comparator
)
对元素去最大值或最小值
max
(
Collection
)该集合中元素必须实现
comparable
接口
max
(
Collection
,
Comparator
)
min
(
Collection
)该集合中元素必须实现
comparable
接口
min
(
Collection
,
Comparator
)
对集合进行反转
reverse(List)
对比较方式进行强行逆转
Comparator reverseOrder
()
Comparator reverseOder
(
Comparator
)
对
list
集合中的元素进行位置上的置换
swap(list,x,y)
对
list
集合进
元素的替换。如果被替换的元素不存在,那么原
合不变。
replaceAll(list,old,new);
可以将不同步的
合变成同步的集合。
Set synchronizedSet(Set<T> s)
Map synchronizedMap(Map<K,V> m)
List synchronizedList(List<T> list)
代码示例
class CollectionsDemo
{
public static void main(String[] args)
{
Collections
:是集合框架的工具类。里面的方法都是静态的。
demo_4();
}
public static void demo_4() {
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("zhangsan");
list.add("zhaoliu");
list.add("xiaoqiang");
System.out.println(list);
// Collections.replaceAll(list, "cba", "nba"); // set(indexOf("cba"),"nba");
Collections.shuffle(list);
// Collections.fill(list, "cc");
System.out.println(list);
}
public static void demo_3() {
/*
TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){
public int compare(String o1, String o2) {
int temp = o2.compareTo(o1);
return temp;
}
});
*/
TreeSet<String>ts=newTreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));
ts.add("abc");
ts.add("hahaha");
ts.add("zzz");
ts.add("aa");
ts.add("cba");
System.out.println(ts);
}
public static void demo_2(){
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
// Collections.sort(list);
System.out.println(list);
// int index = Collections.binarySearch(list, "cba");
// System.out.println("index="+index);
//
获取最大值。
String max = Collections.max(list,new ComparatorByLength());
System.out.println("max="+max);
}
public static void demo_1(){
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
System.out.println(list);
//
对
list
集合进行指定顺序的排序。
// Collections.sort(list);
// mySort(list);
// mySort(list,new ComparatorByLength());
Collections.sort(list,new ComparatorByLength());
System.out.println(list);
}
public static <T> void mySort(List<T> list,Comparator<? super T> comp){
for (int i = 0; i < list.size()-1; i++) {
for (int j = i+1; j < list.size(); j++) {
if(comp.compare(list.get(i), list.get(j))>0){
// T temp = list.get(i);
// list.set(i, list.get(j));
// list.set(j, temp);
Collections.swap(list, i, j);
}
}
}
}
public static <T extends Comparable<? super T>> void mySort(List<T> list){
for (int i = 0; i < list.size()-1; i++) {
for (int j = i+1; j < list.size(); j++) {
if(list.get(i).compareTo(list.get(j))>0){
// T temp = list.get(i);
// list.set(i, list.get(j));
// list.set(j, temp);
Collections.swap(list, i, j);
}
}
}
}
}
Arrays:用于对数组操作的工具类。
1,binarySearch(int[])
binarySearch(double[])
2,sort(int[])
sort(char[])
3,toString(int[]).....:将数组变成字符串。
4,copyOf();复制数组。
5,copyOfRange(int[] ,form,to):复制部分数组。
6,equals(int[],int[]);比较两个数组是否相同。
7,List asList(T[]);将数组变成合。
这样可以通过集合的操作来操作数组中元素,
但是不可以使用增删方法,add,remove 。因为数组长度是固定的,会出现
UnsupportOperationExcetion。
可以使用的方法:contains,indexOf。。。
如果数组中存入的基本数据类型,那么asList 会将数组实体作为集合中的元素。
如果数组中的存入的应用数据类型,那么asList 会将数组中的元素作为集合中的元素
代码示例
class ArraysDemo
{
public static void main(String[] args)
{
/*
如果数组中的元素是对象,那么转成集合时,直接将数组中的元素作为集合中的元素进行集合存储。
如果数组中的元素是基本类型数值,那么会将该数组作为集合中的元素进行存储。
*/
int[] arr = {31,11,51,61};
List<int[]> list = Arrays.asList(arr);
System.out.println(list);
}
}
--------------------- android培训、java培训、java学习型技术博客、期待与您交流! -------------------