List集合、Set集合、Map集合等重要知识点

Java集合知识树

集合继承关系结构图Collction部分
Tips：图中标红为常用的集合。

集合继承关系结构图Map部分

1、集合的概念

集合就是一个容器

2、集合和数组的区别

• 集合不定长的可自动扩容;数组定长,访问较快,不可扩容
• 数组一旦规定了类型存放的元素类型必须一致，就相当于垃圾分类一样；集合就像一个垃圾桶什么都能装
• 数组可以包含基本数据类型或引用类型的对象;而集合中只能包含引用类型的对象

3、集合的分类

• 单列集合：父类：Collection

  • 单列集合的分类：

    • List接口：
      • ArrayList集合（类）*
      • LinkedList集合（类）*
    • Set接口：
      • hashSet集合（类）*
    • TreeSet集合（类）

  • **特点：**在内存中存储方式是单列

  • 方法	含义
    boolean add(Object)	集合中加入一个对象，成功时返回true
    boolean addAll(Collection)	集合中加入另外一个集合对象
    int size()	集合内容纳的元素数量
    boolean isEmpty()	集合是否为空
    boolean contains(Object)	集合内是否含有参数对象
    Iterator iterator()	产生一个迭代器
    Object[] toArray()	返回一个包含所有元素的对象数组

  boolean remove(Object)	从集合中删除对象
  boolean removeAll(Collection)	清空指定集合
  boolean containsAll(Collection)	判断集合内是否包含子集
  boolean retainAll(Collection)	仅保留此 collection 中那些也包含在指定 collection 的元素
  void clear()	清空集合

  • 注意：
    • 所有的单列集合都可以用这些方法
    • Collection是一个接口，要想使用这些方法必须由子类实例去使用

• **双列集合：**Map父类

  • 分类：

    • HashMap(类)*
    • TreeMap(类)

• HashTable(类)

• **特点：**在内存中存储方式是双列 ，通过key获取value值

• 方法：

  方法	含义
  Object put(Object key,Object value)	将指定的值与此映射中的指定键相关联
  void putAll(Map t)	将映射t中所有映射关系复制到此映射中
  Object get(Object key)	返回此映射中映射到指定键的值
  Object remove(Object key)	若存在此键的映射关系,将其从映射中移除
  boolean containsKey(Object key)	若此映射包含指定键的映射关系，返回 true
  boolean containsValue(Object value)	若此映射为指定值映射一个或多个键,返回 true
  int size()	返回此映射中的键-值映射对数
  boolean isEmpty()	若此映射未包含键-值映射关系,返回 true
  Set keySet()	返回此映射中包含的键的 set 集合
  Collection values()	返回此映射中的所有值对象的Collection集合

4、List集合

• 特点：三有产品 有序 有重复值 有索引 (有空值)

• ArraysList：

  • 特点：ArraysList是基于数组的，数据结构：线性表 存储方式是:顺序存储，也就是在逻辑地址上连续的元素，在物理地址也连续（所有数据的访问都是通过物理地址获取），访问速度非常快，但是插入和删除修改操作非常慢

  • **特点：**LinkedList基于链表 数据结构：线性表 存储方式：链式存储，在逻辑地址上连续的在物理地址上不一定连续 ，访问速度慢，但是增加删除修改操作快

  • 声明和创建

    ArrayList alist1=new ArrayList<>(); List alist2=new ArrayList<>(); 

    *以后我么用以下方法创建集合

  • Collection中的方法：

    /**
    		 * 创建集合：
    		 * ArrayList alist1=new ArrayList<>();
    		   List alist2=new ArrayList<>();
    		 * ArrayList<引用数据类型> l1=new ArrayList<>();  引用数据类型规定了集合的元素的数据类型
    		 */ ArrayList alist1=new ArrayList<>(); /*alist1.add(e)*/ alist1.add('c'); alist1.add(123); alist1.add("zhangsan"); //给集合创建的时候规定元素的数据类型 ArrayList<Integer> l1=new ArrayList<>(); l1.add(12); l1.add(13); l1.add(16); /*l1.add("zhangsan");  只能存放Integer类型的数据*/ ArrayList<String> l2=new ArrayList<>(); l2.add("zhangsan"); //addAll(collection c) /*l1.addAll(l2);  ArrayList<Integer> is not applicable */ //size() 集合中元素的个数，集合的大小  对比数组用的是length System.out.println(l1.size());//2 //isEmpty() 判断一个集合是否为空 Item kouhong1=new Item(450.00,"阿玛尼限量款001","送女盆友最佳","阿玛尼"); Item kouhong2=new Item (255.00,"迪奥（Dior）烈艳蓝金唇膏 口红 3.5g 999号 哑光-经典正红","无数杂志的首版！比亮光版偏橘调一点点！黄皮白皮皆安全的大红，适合春天衬衣，夏天黑裙的妆容","dior"); Item kouhong3=new Item (888.00,"迪奥（Dior2）烈艳蓝金唇膏 口红 3.5g 999号 哑光-经典正红","无数杂志的首版！比亮光版偏橘调一点点！黄皮白皮皆安全的大红，适合春天衬衣，夏天黑裙的妆容","dior"); ArrayList<Item> l3=new ArrayList<>(); l3.add(kouhong1); l3.add(kouhong2); l3.add(kouhong3); /**
    		 * 需求：如果集合l3为空就不做往页面传输数据的操作，否则传数据给页面显示
    		 */ if(l3.isEmpty()) { System.out.println("请获取数据"); }else { System.out.println("传输数据"); } System.out.println(l3); //boolean contains(Object)  集合内是否含有参数对象 System.out.println(l3.contains("张三"));//false System.out.println(l3.contains(kouhong1));//true System.out.println(l1.contains(12));//true //Object[] toArray()  返回一个包含所有元素的对象数组 System.out.println(alist1);//[c, 123, zhangsan] Object[] o1=new Object[] {"张三",123,'3'}; Object[] o2=alist1.toArray(); System.out.println(Arrays.toString(o2));//[c, 123, zhangsan] //boolean remove(Object)  从集合中删除对象 System.out.println(l3.remove(kouhong1)); System.out.println("l3:"+l3+" l3.size():"+l3.size()); //boolean removeAll(Collection) 清空指定集合 ArrayList<Integer> l4=new ArrayList<>(); l4.add(12); l4.add(13); ArrayList<Integer> l5=new ArrayList<>(); l5.add(1); l5.add(2); l4.addAll(l5); System.out.println(l4);//[12, 13, 1, 2] l4.removeAll(l1); System.out.println(l4);//[1, 2]  因为这个方法会移除源集合中目标集合的元素 //boolean containsAll(Collection) 判断集合内是否包含子集所有元素 ArrayList<Integer> l6=new ArrayList<>(); l6.add(1); System.out.println(l4.containsAll(l5));//true System.out.println(l4.containsAll(l6));//true //clear() 清空集合 l4.clear(); System.out.println(l4);//[] 

  • List中的方法：

    /**
    		 * List自有方法
    		 */ //add(int index,Object element) ArrayList<Integer> Q7=new ArrayList<>(); /*Q7.add(1,1);//java.lang.IndexOutOfBoundsException: Index: 1, Size: 0*/ Q7.add(12); Q7.add(13); Q7.add(14); System.out.println("Q7:"+Q7);//[12, 13, 14] Q7.add(1, 2); System.out.println("Q7:"+Q7);//[12, 2, 13, 14] // get(int index)返回列表中指定位置的元素  // indexOf(Object o) 在list中查询元素的索引值，如不存在，返回－1 /*List中如果存在多个重复元素，indexOf()方法返回第一个匹配元素的index。
    		lastIndexOf(o)是返回最后一个匹配元素的index.*/ System.out.println(Q7.indexOf(2));//1 //boolean remove(index)  通过索引从集合中删除对象 List集合特有 Q7.remove(0); System.out.println(Q7);//[2, 13, 14] //set(int index,Object element) Q7.set(2, 15); System.out.println(Q7);//[2, 13, 15] //List集合中要重点记住的方法：add() , get(index) ,set(index,值),remove(index),remove(Object) 

• LinkedList：

  • **特点：**LinkedList基于链表 存储方式：链式存储，在逻辑地址上连续的在物理地址上不一定连续 数据结构：线性表 ，访问速度慢，但是增加删除修改操作快

  • 注意：

    • LinkedList拥有List和单列集合中所有的方法
    • LikedList中特有的方法

  • 声明和创建：

    LinkedList<Integer> l1=new LinkedList<>(); LinkedList l2=new LinkedList<>(); List l3=new LinkedList<>(); 

  • LinkedList自有方法：

    方法	含义
    void addFirst(Object o)	将给定元素插入此列表的开头
    void addLast(Object o)	将给定元素追加到此列表的结尾
    Object getFirst()	返回此列表的第一个元素
    Object getLast()	返回此列表的最后一个元素
    Object removeFirst()	移除并返回此列表的第一个元素
    Object removeLast()	移除并返回此列表的最后一个元素

  • List集合的遍历

    LinkedList<Integer> l1=new LinkedList<>(); /*LinkedList l2=new LinkedList<>();
    		List l3=new LinkedList<>();*/ l1.add(12); l1.add(13); l1.add(14); l1.add(15); /**
    		 * List的遍历
    		 * 方式1： for循环
    		 * 方式2：使用迭代器
    		 */ /*	for(int i=0;i<l1.size();i++) {
    			System.out.println(l1.get(i));
    		}
    		
    		for(Integer i:l1) {
    			System.out.println(i);
    		}
    		
    		Item kouhong1=new Item(450.00,"阿玛尼限量款001","送女盆友最佳","阿玛尼");
    		Item kouhong2=new Item (255.00,"迪奥（Dior）烈艳蓝金唇膏 口红 3.5g 999号 哑光-经典正红","无数杂志的首版！比亮光版偏橘调一点点！黄皮白皮皆安全的大红，适合春天衬衣，夏天黑裙的妆容","dior");
    		Item kouhong3=new Item (888.00,"迪奥（Dior2）烈艳蓝金唇膏 口红 3.5g 999号 哑光-经典正红","无数杂志的首版！比亮光版偏橘调一点点！黄皮白皮皆安全的大红，适合春天衬衣，夏天黑裙的妆容","dior");
    		ArrayList<Item> l3=new ArrayList<>();
    		l3.add(kouhong1);
    		l3.add(kouhong2);
    		l3.add(kouhong3);
    		for(Item i:l3) {
    			System.out.println(i);
    		}*/ //方式2 使用迭代器 Iterator it=l1.iterator(); while(it.hasNext()) { //hasNext() 迭代器中是否有下一个元素 System.out.println(it.next());//next()获取迭代器中的值 } } 

5、Set集合

• **特点：**三无产品 无序，无索引，无重复值 （可以有null,有且仅有个null） (想去除重复值我们可以使用Set集合)

• 声明和创建

   Set<String> s1=new HashSet<>(); HashSet<Integer> s2=new HashSet<>(); 

  public static void main(String[] args) { Set<String> s1=new HashSet<>(); HashSet<Integer> s2=new HashSet<>(); /*
  		 * 无序无索引无重复值 
  		 * 
  		 * 每次将数据插入Set集合，都会先去判断（使用equals()方法判断）原先的集合中是否有该对象，如果有就替换之前的对象
  		  两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复，在set中只保留一个。
  		 */ s1.add("zhangsan"); s1.add("zhangsan1"); s1.add("zhangsan2"); s1.add("zhangsan3"); s1.add("zhangsan4"); s1.add("zhangsan5"); s1.add("zhangsan5"); s1.add(null); s1.add(null); System.out.println(s1);//[null, zhangsan1, zhangsan3, zhangsan2, zhangsan, zhangsan5, zhangsan4] System.out.println(s1.size());//7 /**
  		 * 访问set集合： 
  		 * 先将Set集合转为List集合，再访问  
  		 * ArrayList<String> l1=new ArrayList<>(s1);
  		 * l1.get(index)
  		 * 
  		 * 
  		 * 
  		 */ //单列集合互相转换   数据类型必须一致 /*Set<数据类型>-->List<数据类型> */ ArrayList<String> l1=new ArrayList<>(s1); System.out.println(l1); System.out.println(l1.get(1)); /*List<数据类型>-->Set<数据类型>*/ HashSet<String> s3=new HashSet<>(l1); System.out.println(s3); Set s4=new HashSet<>(); s4.add('c'); s4.add(123); s4.add("zhangsan"); s4.add(new Date()); System.out.println(s4); ArrayList l2=new ArrayList<>(s4); System.out.println(l2);//[c, zhangsan, 123, Wed Apr 22 14:34:34 CST 2020] /**
  		 * 遍历
  		 * 1、先将Set集合转为List集合，再遍历  
  		 * 2、直接使用forEach
  		 * 3、迭代器 Iterator
  		 */ /*for(int i=0;i<l1.size();i++) {
  			System.out.println(l1.get(i));
  		}*/ /*for(String s:s1) {
  			System.out.println(s);
  		}*/ /*for(Object o:s4) {
  			System.out.println(o);
  		}*/ /*Iterator it=s4.iterator();
  		while(it.hasNext()) {
  			System.out.println(it.next());
  		}*/ /**
  		 * HashSet，在遍历集合中元素时，不关心元素的顺序，能有null值  基于哈希表
  		   TreeSet，按照升序排列遍历集合中的元素 ,不能有null值     基于红黑树   执行速度慢  
  		 */ Set<Integer> ts=new TreeSet<>(); ts.add(12); ts.add(11); ts.add(4); ts.add(3); ts.add(20); ts.add(9); /*ts.add(null);*/ System.out.println(ts);//[3, 4, 9, 11, 12, 20] } 

6、Map集合

• 特点：双列集合，通过key获取value值，数据结构：双向链表+红黑树

• 注意：

  • key不可以重复，value可以重复，如果后面添加进集合中的键值对，key不能重复，key重复的话会以最后一次添加的value为主（覆盖之前的value）
  • key能有null但有且仅有一个，value可以有null
  • Map是不同于Collection的另外一种集合接口，没有继承关系
  • key和value都是引用数据类型，都是存储对象的内存地址

• 集合，通过key获取value值，数据结构：双向链表+红黑树

  import java.util.Collection; import java.util.HashMap; import java.util.Map; public class MapTest01 { public static void main(String[] args) { // 创建Map集合对象 Map<Integer, String> map = new HashMap<>(); // 向Map集合中添加键值对 map.put(1, "zhangsan"); // 1在这里进行了自动装箱。 map.put(2, "lisi"); map.put(3, "wangwu"); map.put(4, "zhaoliu"); // 通过key获取value String value = map.get(2); System.out.println(value); // 获取键值对的数量 System.out.println("键值对的数量：" + map.size()); // 通过key删除key-value map.remove(2); System.out.println("键值对的数量：" + map.size()); // 判断是否包含某个key // contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法。 System.out.println(map.containsKey(new Integer(4))); // true // 判断是否包含某个value System.out.println(map.containsValue(new String("wangwu"))); // true // 获取所有的value Collection<String> values = map.values(); // foreach for(String s : values){ System.out.println(s); } // 清空map集合 map.clear(); System.out.println("键值对的数量：" + map.size()); // 判断是否为空 System.out.println(map.isEmpty()); // true } } 

• Map集合遍历

  import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class MapTest02 { public static void main(String[] args) { // 第一种方式：获取所有的key，通过遍历key，来遍历value Map<Integer, String> map = new HashMap<>(); map.put(1, "zhangsan"); map.put(2, "lisi"); map.put(3, "wangwu"); map.put(4, "zhaoliu"); // 遍历Map集合 // 获取所有的key，所有的key是一个Set集合 Set<Integer> keys = map.keySet(); // 遍历key，通过key获取value // 迭代器可以 /*Iterator<Integer> it = keys.iterator();
          while(it.hasNext()){
              // 取出其中一个key
              Integer key = it.next();
              // 通过key获取value
              String value = map.get(key);
              System.out.println(key + "=" + value);
          }*/ // foreach也可以 for(Integer key : keys){ System.out.println(key + "=" + map.get(key)); } // 第二种方式：Set<Map.Entry<K,V>> entrySet() // 以上这个方法是把Map集合直接全部转换成Set集合。 // Set集合中元素的类型是：Map.Entry Set<Map.Entry<Integer,String>> set = map.entrySet(); // 遍历Set集合，每一次取出一个Node // 迭代器 /*Iterator<Map.Entry<Integer,String>> it2 = set.iterator();
          while(it2.hasNext()){
              Map.Entry<Integer,String> node = it2.next();
              Integer key = node.getKey();
              String value = node.getValue();
              System.out.println(key + "=" + value);
          }*/ // foreach(效率比较高) // 这种方式，因为获取key和value都是直接从node对象中获取的属性值。  for(Map.Entry<Integer,String> node : set){ System.out.println(node.getKey() + "--->" + node.getValue()); } } } 

本文地址：https://blog.csdn.net/wbw1314520/article/details/108021171