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

最新推荐文章于 2023-06-15 18:55:53 发布

wbw1314520

最新推荐文章于 2023-06-15 18:55:53 发布

阅读量377

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/wbw1314520/article/details/108021171

版权

Java集合知识树

集合继承关系结构图Collction部分
Tips：图中标红为常用的集合。
Collection继承树
集合继承关系结构图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());
        }
    }
}

wbw1314520

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
List集合、Set集合、Map集合等重要知识点

目录Java集合知识树1、集合的概念2、集合和数组的区别3、集合的分类4、List集合5、Set集合6、Map集合Java集合知识树集合继承关系结构图Collction部分Tips：图中标红为常用的集合。集合继承关系结构图Map部分1、集合的概念集合就是一个容器2、集合和数组的区别集合不定长的可自动扩容;数组定长,访问较快,不可扩容数组一旦规定了类型存放的元素类型必须一致，就相当于垃圾分类一样；集合就像一个垃圾桶什么都能装数组可以包含基本数据类型或引用类型的对象;而集合中只能包含引
复制链接

扫一扫