List、Set、Map集合小总结

最新推荐文章于 2024-06-06 09:32:02 发布

扛刀仔

最新推荐文章于 2024-06-06 09:32:02 发布

阅读量149

点赞数

分类专栏： java 文章标签：集合

本文链接：https://blog.csdn.net/weixin_44540005/article/details/91950118

版权

java 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

先看下关系图

Collection（集合）
├---List（有序且允许元素重复,允许元素为null）（接口）
│ ├--LinkedList（不同步，线程不安全）（三个主要的实现类之一）
│ ├--ArrayList（不同步，线程不安全）（三个主要的实现类之一）
│ └--Vector（同步，线程安全）（三个主要的实现类之一）
└---Set（set是无序，不允许元素重复）
├---HashSet（实现类）
├---TreeSet（实现类）
Map（接口）
├---HashMap（线程不安全）（实现类）
├---TreeMap（线程不安全）（实现类）
└---HashTable（线程安全）（实现类）

一.集合的体系结构：
1、List,Set,Map是集合体系中最主要的三个接口。
其中list和set是继承自collection接口
Map也属于集合系统但是与collection接口不同

2、list是有序且允许元素重复,允许元素为null,ArrayList、LinkedList和Vector是三个主要的实现类
(1)、Vector、ArrayList都是以类似数组的形式存储在内存中，LinkedList则以链表的形式进行存储。
(2)、Vector线程安全的(同步)，ArrayList、LinkedList线程不安全的(不同步)。
(3)、ArrayList、Vector适合查找，不适合指定位置的插入、删除操作；LinkedList适合指定位置插入、删除操作，不适合查找。
(4)、ArrayList在元素填满容器时会自动扩充容器大小的50%，而Vector则是100%，因此ArrayList更节省空间

3、set是无序，不允许元素重复；HashSet和TreeSet是两个实现类
(1)、HashSet 基于HashMap实现,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的
(2)、TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值

4、 Comparator 和 Comparable 的区别
Comparator 定义在类的外部, 此时我们的类的结构不需要有任何变化，从小到大：o1-o2 从大到小：o2-o1
Comparable 定义在类的内部，耦合性较强从小到大：this-o 从大到小：o-this

5、Map是接口,Map特性就是根据一个对象查找对象；HashMap、HashTable、TreeMap是它的实现类
HashMap 线程不安全，key，value允许为null,用hash表实现的Map,就是利用对象的hashcode(hashcode()是Object的方法)进行快速散列查找.
HashTable 线程安全，key，value不允许为null
TreeMap 线程不安全，根据key对节点进行排序，保证所有的key-value处在有序状态，key不允许为null

为了线程安全而提出，线程安全的就是同步的，不安全的就是不同步的;
不同步的运行速度要比同步的快,这是因为有锁的机制存在

1、list

package com.gx.collectiondemo.listdemo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;
/**
 * list是有序且允许元素重复,允许元素为null
 * list、HashSet、TreeSet存储方式：通过键值对。
 * @author en
 *
 */
public class ListDemo1 {
	public static void main(String[] args) {
		//list是有序且允许元素重复,
		//允许元素为null,ArrayList、LinkedList和Vector是三个主要的实现类
		List<String> list = new ArrayList<>();//不同步，线程不安全
		List<String> list2 = new LinkedList<>();//不同步，线程不安全
		List<String> list3 = new Vector<>();//同步线程安全
		

		list3.add("E");
		list3.add("F");
		list3.add("K");

		// 添加元素
		list.add("A");
		list.add("B");
		list.add("C");
		list.add("D");
		list.add("E");
		list.add("A");
		
		list.add("F");
		list.add("G");
		list.add(null);
		list.add(null);

		System.err.println("ArrayList:"+list.toString());
		
		// 移除
		list.remove(1);// 通过索引移除
		list.remove("D");// 通过对象移除

		list.removeAll(list3);//EFK 移除多个 (通过list与list3的交集，作为移除的对象)

		System.out.println("list删除后输出:"+list);
		
		// for 循环遍历
		System.out.println("for循环遍历");
		// 获取list的元素个数list.size()
		for (int i = 0; i < list.size(); i++) {
			// 获取list中某个元素 list.get(index)
			System.out.print(list.get(i) + "\t");
		}
		
		//foreach 循环遍历
		System.out.println("\nforeach 循环：");
		for (String string : list) {
			System.out.print(string + "\t");
		}
		
		// Iterator迭代器
		System.out.println("\nIterator 迭代器 while 遍历：");
		Iterator<String> iterator = list.iterator();
		while (iterator.hasNext()) {//iterator.hasNext()判断是否有下一个元素
			System.out.print(iterator.next() + "\t");// iterator.next()获取下一个元素
		}
		
		System.out.println("\nIterator 迭代器 for 遍历：");
		for (Iterator iterator2 = list.iterator(); iterator2.hasNext();) {
			String string = (String) iterator2.next();
			System.out.print(string + "\t");
		}

		System.out.println();
		// 返回对象o在List集合中第一次出现的位置索引。
		System.out.println("A元素第一次出现的位置：" + list.indexOf("A"));
		// 返回对象o在List集合中最后一次出现的位置索引。
		System.out.println("A元素最后一次出现的位置：" + list.lastIndexOf("A"));
		// 返回对象o在List集合中是否存在该元素  contains:包含
		System.out.println("List集合中是否存在元素：" + list.contains("A"));
		
		
		List<Integer> list_int = new ArrayList<>();
		list_int.add(1);
		
		

		// 替换元素（注意list.set的索引从零开始）
		list.set(0, "CC");
		System.out.println("替换之后输出:"+list);

		//截取list（其中一段，赋值给sList）
		// [fromIndex,toIndex)
		List<String> sList = list.subList(1, 2);
		System.out.println("截取1-2中的一段赋值给sList"+sList);

		// 判断集合是否为空
		System.out.println("List集合否为空：" + list.isEmpty());
		
		// 清空集合
		list.clear();
		System.out.println("List集合否为空：" + list.isEmpty());
	}
}

2、Set

HashSet

package com.gx.collectiondemo.setdemo;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
/**
 * set 无序 不允许重复元素 
 * HashSet 可以放入null，但只能放入一个null
 * list、HashSet、TreeSet存储方式：通过键值对。
 * @author en
 *
 */
public class HashSetDemo {
	public static void main(String[] args) {
		HashSet<String> set = new HashSet<>();

		// 添加元素
		set.add("B");
		set.add("A");
		set.add("D");
		set.add("C");
		set.add("A");
		set.add("F");
		set.add("G");
		set.add("I");
		set.add("I");
		set.add("I");
		set.add("I");
		set.add(null);
		

		// 移除
		//set.remove("I");

		List<String> list = new ArrayList<>();
		list.add("F");
		list.add("G");
		set.removeAll(list);

		//

		// 输出set
		System.out.println(set.toString());
		//foreach 遍历
		System.out.println("foreach遍历:");
		for (String string : set) {
			System.out.print(string + "  ");
		}
		// 迭代器遍历
		System.out.println("\nIterator 迭代器 while:");
		Iterator<String> iterator = set.iterator();
		while (iterator.hasNext()) {
			System.out.print(iterator.next() + "  ");
		}
		System.out.println("\nIterator 迭代器 for:");
		for (Iterator iterator2 = set.iterator(); iterator2.hasNext();) {
			String string = (String) iterator2.next();
			System.out.print(string + "  ");
		}

		// 获取元素个数
		System.out.println("HashSet的元素格个数：" + set.size());
		// HashSet中是否包含某个元素
		System.out.println("HashSet中是否包含某个元素：" + set.contains("F"));
		
		//清空set
		set.clear();
		
		//
		System.out.println("set是否为空"+set.isEmpty());
	}
}

TreeSet

package com.gx.collectiondemo.setdemo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

/**
 * TreeSet不允许放入null值
 * list、HashSet、TreeSet存储方式：通过键值对。
 * @author en
 *
 */
public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<String> set = new TreeSet<>();

		// 添加元素
		set.add("B");
		set.add("A");
		set.add("D");
		set.add("C");
		set.add("A");
		set.add("F");
		set.add("G");
		set.add("H");
		set.add("I");
		set.add("I");
		set.add("I");

		// 移除
		// set.remove("I");
		
		List<String> list = new ArrayList<>();
		list.add("F");
		list.add("G");
		set.removeAll(list);//FG 移除多个 (通过list与set的交集，作为移除的对象)

		// 输出set
		System.out.println("移除后的set:"+ set.toString());
		
		
		// 遍历
		System.out.println("foreach遍历:");
		for (String string : set) {
			System.out.print(string + "  ");
		}
		
		
		// 迭代器遍历
		System.out.println("\nIterator 迭代器 while:");
		Iterator<String> iterator = set.iterator();
		while (iterator.hasNext()) {
			System.out.print(iterator.next() + "  ");
		}
		
		System.out.println("\nIterator 迭代器 for:");
		for (Iterator iterator2 = set.iterator(); iterator2.hasNext();) {
			String string = (String) iterator2.next();
			System.out.print(string + "  ");
		}

		// 获取元素个数
		System.out.println("HashSet的元素格个数：" + set.size());
		
		// HashSet中是否包含某个元素
		System.out.println("HashSet中是否包含某个元素：" + set.contains("F"));

		// 清空set
		//set.clear();

		//
		System.out.println("set是否为空" + set.isEmpty());
		
		String first = set.first();
		System.out.println("第一个元素:" + first);
		String last = set.last();
		System.out.println("最后一个元素:" + last);
		String str1 = set.lower(last);
		System.out.println("最后一个元素的前一个元素:" + str1);
		String str2 = set.higher(first);
		System.out.println("第一个元素的后一个元素:" + str2);
		String str3 = set.floor("H");
		System.out.println("集合中小于或者等于给定元素的最大元素:" + str3);
		
		
		System.out.println("===============");
		System.out.println(set);
		//移除第一个对象，并返回该对象
		System.out.println(set.pollFirst());
		//移除最后一个对象，并返回该对象
		System.out.println(set.pollLast());
		System.out.println(set);
	}
}

3、map

package com.gx.mapdemo;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * Map接口 
 *   key-value
 *   根据一个对象查找对象.
 *   HashMap、HashTable、TreeMap是它的实现类,
 * @author en
 *
 */
public class HashMapAndHashTable {
	public static void main(String[] args) {
		//如果是基本数据类型，声明的map的时候使用包装类
		Map<Integer, String> map=new HashMap<>();
		Map<Integer, String> map2=new Hashtable<>();
		
		//添加数据 put当key不存在时，添加key-value
		map.put(1, "str1");
		map.put(2, "str2");
		map.put(3, "str3");
		map.put(4, "str4");
		map.put(5, "str5");
		//put 当key存在时，修改key对应的value
		map.put(5, "111111");
		
		map.put(6, null);
		
		
		//移除 remove(key)
		map.remove(5);
		
		//判断是否存在key
		System.out.println("是否存在key：5===》"+map.containsKey(5));
		//判断是否存在value
		System.out.println("是否存在Value:str4====>"+map.containsValue("str4"));
		
		//清空map
		//map.clear();
		
		System.out.println("map是否为空："+map.isEmpty());
		
		//输出  （隐藏有toString强制转换）
		System.out.println(map);
		//遍历
		Set<Integer> keysSet=map.keySet();
		Iterator<Integer> iterator=keysSet.iterator();//迭代器Iterator
		while(iterator.hasNext()){
			Integer intKey=iterator.next();
			System.out.println("key:"+intKey+"---->Value:"+map.get(intKey));
		}
//		System.out.println("--------------------");
//		for (Iterator<Integer> iterator2 = keysSet.iterator(); iterator2.hasNext();) {
//			int intKey = iterator2.next();
//			System.out.println("key:"+intKey+"---->Value:"+map.get(intKey));
//		}
//		System.out.println("--------------------");
//		for (int intKey : keysSet) {
//			System.out.println("key:"+intKey+"---->Value:"+map.get(intKey));
//		}
	}
}

扛刀仔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
List、Set、Map集合小总结

先看下关系图Collection（集合） ├---List（有序且允许元素重复,允许元素为null）（接口） │ ├--LinkedList（不同步，线程不安全）（三个主要的实现类之一） │ ├--ArrayList（不同步，线程不安全）（三个主要的实现类之一） │ └--Vector（同步，线程安全）（三个主要的实现类之一） └-...
复制链接

扫一扫

专栏目录