1、map集合

  1.1、特点:将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值。

  1.2、Map集合和Collection集合的区别?
      Map集合存储元素是成对出现的,Map集合的键是唯一的,值是可重复的。可以把这个理解为:夫妻对
      Collection集合存储元素是单独出现的,Collection的儿子Set是唯一的,List是可重复的。可以把这个理解为:光棍(11.11)

  1.3Map集合的功能概述:
      1:添加功能
        V put(K key,V value):添加元素。
                    如果键是第一次存储,就直接存储元素,返回null
                     如果键不是第一次存在,就用值把以前的值替换掉,返回以前的值
      2:删除功能
         void clear():移除所有的键值对元素
         V remove(Object key):根据键删除键值对元素,并把值返回
      3:判断功能
        boolean containsKey(Object key):判断集合是否包含指定的键
        boolean containsValue(Object value):判断集合是否包含指定的值
        boolean isEmpty():判断集合是否为空
      4:获取功能
        Set<Map.Entry<K,V>> entrySet():返回的是键值对对象的集合
        V get(Object key):根据键获取值
        Set<K> keySet():获取集合中所有键的集合
        Collection<V> values():获取集合中所有值的集合
      5:长度功能
       int size():返回集合中的键值对的对数  

  1. public class MapDemo {
  2. public static void main(String[] args) {
  3. // 创建集合对象
  4. Map<String, String> map = new HashMap<String, String>();
  5.  
  6. // 添加元素
  7. // V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你,等会讲
  8. // System.out.println("put:" + map.put("文章", "马伊俐"));
  9. // System.out.println("put:" + map.put("文章", "姚笛"));
  10.  
  11. map.put("邓超", "孙俪");
  12. map.put("黄晓明", "杨颖");
  13. map.put("周杰伦", "蔡依林");
  14. map.put("刘恺威", "杨幂");
  15.  
  16. // void clear():移除所有的键值对元素
  17. // map.clear();
  18.  
  19. // V remove(Object key):根据键删除键值对元素,并把值返回
  20. // System.out.println("remove:" + map.remove("黄晓明"));
  21. // System.out.println("remove:" + map.remove("黄晓波"));
  22.  
  23. // boolean containsKey(Object key):判断集合是否包含指定的键
  24. // System.out.println("containsKey:" + map.containsKey("黄晓明"));
  25. // System.out.println("containsKey:" + map.containsKey("黄晓波"));
  26.  
  27. // boolean isEmpty():判断集合是否为空
  28. // System.out.println("isEmpty:"+map.isEmpty());
  29.  
  30. //int size():返回集合中的键值对的对数
  31. System.out.println("size:"+map.size());
  32.  
  33. // 输出集合名称
  34. System.out.println("map:" + map);
  35. }
  36. }
  1. /*
  2. * 获取功能:
  3. * V get(Object key):根据键获取值
  4. * Set<K> keySet():获取集合中所有键的集合
  5. * Collection<V> values():获取集合中所有值的集合
  6. */
  7. public class MapDemo2 {
  8. public static void main(String[] args) {
  9. // 创建集合对象
  10. Map<String, String> map = new HashMap<String, String>();
  11.  
  12. // 创建元素并添加元素
  13. map.put("邓超", "孙俪");
  14. map.put("黄晓明", "杨颖");
  15. map.put("周杰伦", "蔡依林");
  16. map.put("刘恺威", "杨幂");
  17.  
  18. // V get(Object key):根据键获取值
  19. System.out.println("get:" + map.get("周杰伦"));
  20. System.out.println("get:" + map.get("周杰")); // 返回null
  21. System.out.println("----------------------");
  22.  
  23. // Set<K> keySet():获取集合中所有键的集合
  24. Set<String> set = map.keySet();
  25. for (String key : set) {
  26. System.out.println(key);
  27. }
  28. System.out.println("----------------------");
  29.  
  30. // Collection<V> values():获取集合中所有值的集合
  31. Collection<String> con = map.values();
  32. for (String value : con) {
  33. System.out.println(value);
  34. }
  35. }
  36. }
  1. /**map集合的遍历:2 种方式*/
  2. /*
  3. * Map集合的第一种遍历。
  4. * Map -- 夫妻对
  5. * 思路:
  6. * A:把所有的丈夫给集中起来。
  7. * B:遍历丈夫的集合,获取得到每一个丈夫。
  8. * C:让丈夫去找自己的妻子。
  9. *
  10. * 转换:
  11. * A:获取所有的键
  12. * B:遍历键的集合,获取得到每一个键
  13. * C:根据键去找值
  14. */
  15. public class MapDemo3 {
  16. public static void main(String[] args) {
  17. // 创建集合对象
  18. Map<String, String> map = new HashMap<String, String>();
  19.  
  20. // 创建元素并添加到集合
  21. map.put("杨过", "小龙女");
  22. map.put("郭靖", "黄蓉");
  23. map.put("杨康", "穆念慈");
  24. map.put("陈玄风", "梅超风");
  25.  
  26. // 遍历
  27. // 获取所有的键
  28. Set<String> set = map.keySet();
  29. // 遍历键的集合,获取得到每一个键
  30. for (String key : set) {
  31. // 根据键去找值
  32. String value = map.get(key);
  33. System.out.println(key + "---" + value);
  34. }
  35. }
  36. }
  37.  
  38. /*
  39. * Map集合的第2种遍历。
  40. * Map -- 夫妻对
  41. *
  42. * 思路:
  43. * A:获取所有结婚证的集合
  44. * B:遍历结婚证的集合,得到每一个结婚证
  45. * C:根据结婚证获取丈夫和妻子
  46. *
  47. * 转换:
  48. * A:获取所有键值对对象的集合
  49. * B:遍历键值对对象的集合,得到每一个键值对对象
  50. * C:根据键值对对象获取键和值
  51. *
  52. * 这里面最麻烦的就是键值对对象如何表示呢?
  53. *
  54. * Set<Map.Entry<K,V>> entrySet():返回的是键值对对象的集合
  55. */
  56. public class MapDemo4 {
  57. public static void main(String[] args) {
  58. // 创建集合对象
  59. Map<String, String> map = new HashMap<String, String>();
  60.  
  61. // 创建元素并添加到集合
  62. map.put("杨过", "小龙女");
  63. map.put("郭靖", "黄蓉");
  64. map.put("杨康", "穆念慈");
  65. map.put("陈玄风", "梅超风");
  66.  
  67. // 获取所有键值对对象的集合
  68. Set<Map.Entry<String, String>> set = map.entrySet();
  69. // 遍历键值对对象的集合,得到每一个键值对对象
  70. for (Map.Entry<String, String> me : set) {
  71. // 根据键值对对象获取键和值
  72. String key = me.getKey();
  73. String value = me.getValue();
  74. System.out.println(key + "---" + value);
  75. }
  76. }
  77. }

2、HashMap:Map集合的子类。是基于哈希表的Map接口实现。
           哈希表的作用是用来保证键的唯一性的。

  1.  
  1. public class HashMapDemo2 {
  2. public static void main(String[] args) {
  3. // 创建集合对象
  4. HashMap<Integer, String> hm = new HashMap<Integer, String>();
  5.  
  6. // 创建元素并添加元素
  7. // Integer i = new Integer(27);
  8. // Integer i = 27;
  9. // String s = "林青霞";
  10. // hm.put(i, s);
  11.  
  12. hm.put(27, "林青霞");
  13. hm.put(30, "风清扬");
  14. hm.put(28, "刘意");
  15. hm.put(29, "林青霞");
  16.  
  17. // 下面的写法是八进制,但是不能出现8以上的单个数据
  18. // hm.put(003, "hello");
  19. // hm.put(006, "hello");
  20. // hm.put(007, "hello");
  21. // hm.put(008, "hello");
  22.  
  23. // 遍历
  24. Set<Integer> set = hm.keySet();
  25. for (Integer key : set) {
  26. String value = hm.get(key);
  27. System.out.println(key + "---" + value);
  28. }
  29.  
  30. // 下面这种方式仅仅是集合的元素的字符串表示
  31. // System.out.println("hm:" + hm);
  32. }
  33. }
  1.  
  1.  

3、 LinkedHashMap:HashMap的子类,是Map接口的哈希表和链接列表实现,具有可预知的迭代顺序。
      由哈希表保证键的唯一性
      由链表保证键盘的有序(存储和取出的顺序一致)

  1. /*
  2. * LinkedHashMap:是Map接口的哈希表和链接列表实现,具有可预知的迭代顺序。
  3. * 由哈希表保证键的唯一性
  4. * 由链表保证键盘的有序(存储和取出的顺序一致)
  5. */
  6. public class LinkedHashMapDemo {
  7. public static void main(String[] args) {
  8. // 创建集合对象
  9. LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();
  10.  
  11. // 创建并添加元素
  12. hm.put("2345", "hello");
  13. hm.put("1234", "world");
  14. hm.put("3456", "java");
  15. hm.put("1234", "javaee");
  16. hm.put("3456", "android");
  17.  
  18. // 遍历
  19. Set<String> set = hm.keySet();
  20. for (String key : set) {
  21. String value = hm.get(key);
  22. System.out.println(key + "---" + value);
  23. }
  24. }
  25. }

4、TreeMap:是基于红黑树的Map接口的实现。

  1. /*
  2. * TreeMap:是基于红黑树的Map接口的实现。
  3. *
  4. * HashMap<String,String>
  5. * 键:String
  6. * 值:String
  7. */
  8. public class TreeMapDemo {
  9. public static void main(String[] args) {
  10. // 创建集合对象
  11. TreeMap<String, String> tm = new TreeMap<String, String>();
  12.  
  13. // 创建元素并添加元素
  14. tm.put("hello", "你好");
  15. tm.put("world", "世界");
  16. tm.put("java", "爪哇");
  17. tm.put("world", "世界2");
  18. tm.put("javaee", "爪哇EE");
  19.  
  20. // 遍历集合
  21. Set<String> set = tm.keySet();
  22. for (String key : set) {
  23. String value = tm.get(key);
  24. System.out.println(key + "---" + value);
  25. }
  26. }
  27. }

5、Collections:是针对集合进行操作的工具类,都是静态方法。

  1、Collection和Collections的区别?
    Collection:是单列集合的顶层接口,有子接口List和Set。
    Collections:是针对集合操作的工具类,有对集合进行排序和二分查找的方法

  2、Collections方法:

    public static <T> void sort(List<T> list):排序 默认情况下是自然顺序。
    public static <T> int binarySearch(List<?> list,T key):二分查找
    public static <T> T max(Collection<?> coll):最大值
    public static void reverse(List<?> list):反转
    public static void shuffle(List<?> list):随机置换

  1. public class CollectionsDemo {
  2. public static void main(String[] args) {
  3. // 创建集合对象
  4. List<Integer> list = new ArrayList<Integer>();
  5.  
  6. // 添加元素
  7. list.add(30);
  8. list.add(20);
  9. list.add(50);
  10. list.add(10);
  11. list.add(40);
  12.  
  13. System.out.println("list:" + list);
  14.  
  15. // public static <T> void sort(List<T> list):排序 默认情况下是自然顺序。
  16. // Collections.sort(list);
  17. // System.out.println("list:" + list);
  18. // [10, 20, 30, 40, 50]
  19.  
  20. // public static <T> int binarySearch(List<?> list,T key):二分查找
  21. // System.out
  22. // .println("binarySearch:" + Collections.binarySearch(list, 30));
  23. // System.out.println("binarySearch:"
  24. // + Collections.binarySearch(list, 300));
  25.  
  26. // public static <T> T max(Collection<?> coll):最大值
  27. // System.out.println("max:"+Collections.max(list));
  28.  
  29. // public static void reverse(List<?> list):反转
  30. // Collections.reverse(list);
  31. // System.out.println("list:" + list);
  32.  
  33. //public static void shuffle(List<?> list):随机置换
  34. Collections.shuffle(list);
  35. System.out.println("list:" + list);
  36. }
  37. }

java学习笔记 --- 集合(续)的更多相关文章

  1. java学习笔记—集合之Map集合

    p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; text-align: center; font: 12.0px Times } p.p2 { margin: 0.0p ...

  2. 0015 Java学习笔记-集合-TreeMap集合

    主要的方法 构造方法: TreeMap(); TreeMap(Comparator<?super K> comparator); TreeMap(Map<? extends K,? ...

  3. 0014 Java学习笔记-集合-HashMap集合

    主要的方法 + 构造方法: * HashMap(); - 默认大小16,负载因子0.75 * HashMap(int initialCapacity); * HashMap(int initialCa ...

  4. Java学习笔记--集合元素的比较Comparable,Comparator

    原文见: http://www.cnblogs.com/sunflower627/p/3158042.html 1. Comparator 和 Comparable 相同的地方 他们都是java的一个 ...

  5. java学习笔记 --- 集合

    1.定义:集合是一种容器,专门用来存储对象 数组和集合的区别?   A:长度区别  数组的长度固定 集合长度可变 B:内容不同  数组存储的是同一种类型的元素  而集合可以存储不同类型的元素  C:元 ...

  6. Java学习笔记——集合

    类集简介 从JDK1.2开始Java引入了类集开发框架,所谓的类集指的就是一套动态对象数组的实现方案,在实际开发之中没有有何一项开发可以离开数组,但是传统的数组实现起来非常的繁琐.而且长度是其致命伤, ...

  7. java学习笔记-集合set

    equals指内容(值)相等,== 指地址相等 ===============set类 set继承自collection,但set没有新增方法,只是set里的元素不重复,下面是set常用方法 ==== ...

  8. 0017 Java学习笔记-集合-集合一般:HashSet和HashMap

    几个概念 桶(bucket):hash表里可以存储元素的位置 hash冲突:equals()返回false的不相等对象的hashCode()值相等,意味着一个bucket要放几个元素 容量(capac ...

  9. Java学习笔记之---集合

    Java学习笔记之---集合 (一)集合框架的体系结构 (二)List(列表) (1)特性 1.List中的元素是有序并且可以重复的,成为序列 2.List可以精确的控制每个元素的插入位置,并且可以删 ...

随机推荐

  1. 51nod 1073约瑟夫环

    思路传送门 :http://blog.csdn.net/kk303/article/details/9629329 n里面挑选m个 可以递推从n-1里面挑m个 然后n-1里面的x 可以转换成 n里面的 ...

  2. C#调用系统蜂鸣(需要发出警告时挺好用的 即使没有声卡)

    http://heavenslv.iteye.com/blog/1033870 // 声明 public class BeepUp { /// <param name="iFreque ...

  3. Cent OS 常用配置命令

    1.ifconfig   #查看网络接口状态 2.ifconfig –a  #查看主机所有接口的情况 3.ifconfig eth0 192.168.1.106 netmask 255.255.255 ...

  4. java中常量接口及实现常量接口的利与弊

    在所做的项目中,将程序中很多要用的常量放置在ServiceConstants的接口中,称其为常量接口,只要实现该接口,就可以 在项目中直接使用常量接口中的常量,通过上网搜索之后,将很好的两篇博客链接储 ...

  5. stm32 pwm 电调 电机

    先上代码 python 树莓派版本,通俗表现原理.stm32 C语言版本在后面 import RPi.GPIO as GPIO import time mode=2 IN1=11 def setup( ...

  6. Seleniumz中 dr.quit()和dr.close()的区别

    /** * dr.quit()和dr.close()都可以退出浏览器,简单的说一下两者的区别:第一个close, * 如果打开了多个页面是关不干净的,它只关闭当前的一个页面.第二个quit, * 是退 ...

  7. selenium_webdriver(python)获取元素属性值,浏览器窗口控制、网页前进后退,title/url打印

    <span style="font-family: Arial, Helvetica, sans-serif;"><span style="font-s ...

  8. Anagram 由颠倒字母顺序而构成的字

    2018-07-15 19:23:08 Valid Anagram 问题描述: 问题描述: 可以使用map来记录各个字符出现的个数,在O(n)的时间复杂度内完成,当然也可以使用排序算法在O(nlogn ...

  9. WPF:改变ListBoxItem和ListViewItem的颜色

    目录 1. 改变ListBoxItem颜色 2. ListViewItem的颜色设置 注意: 本文仅讨论默认ListBoxItem和ListViewItem的鼠标指向和被选择后的前景和背景颜色设置.如 ...

  10. 转:Too many systemd: Created slice !

    OS: centos-release-7-4.1708 /va/log/message  大量这种提示信息: resolvent: Here is how I got rid of these: vi ...