--------------------- 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学习型技术博客、期待与您交流！ -------------------
扫一扫
1106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
