容器四

最新推荐文章于 2022-10-11 00:30:00 发布
原创 最新推荐文章于 2022-10-11 00:30:00 发布 · 206 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Set #迭代器Iterator

博客介绍了Set接口特点为唯一、无序，讲解了HashSet用法与底层实现，分析TreeSet使用及底层红黑树结构，使用TreeMap需比较器。还阐述迭代器由来，介绍用迭代器遍历集合和Map，提及ListIterator可解决并发修改异常。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Set接口_HashSet的用法

Set接口

Set接口的特点：唯一，无序

HashSet的用法

package cn.xjion.pro09;

import java.util.HashSet;
import java.util.Iterator;

public class TestHashSet {
	public static void main(String[] args) {
//		HashSet底层数据结构是使用的hash表，主要结构为数组+链表
//		创建集合对象
		HashSet hs = new HashSet<>();
		hs.add("java");
		System.out.println(hs.add("world"));
		hs.add("Hello");
		System.out.println(hs.add("world"));
		System.out.println("集合中元素个数："+hs.size());
		System.out.println(hs);
		System.out.println(hs.contains("java")+"\t\t"+hs.contains("java1"));
		System.out.println("————————————————————————————————");
//		使用迭代器遍历元素
		for(Iterator ite = hs.iterator();ite.hasNext();){
			System.out.println(ite.next());
		}
	}
}

Person

package cn.xjion.pro09;
//	Person类实现Person型的Comperable接口
public class Person implements Comparable<Person>{
//	属性
	private String name;
	private int age;
//	get，set方法
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
//	带参构造方法
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
//空构造器
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
//	重写hashCode和equals方法
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
//	重写toString
@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	//	重写compareTo方法
	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		return 0;
	}
}

测试：

package cn.xjion.pro09;

import java.util.HashSet;

public class TestPerson {
	public static void main(String[] args) {
		HashSet hs = new HashSet<>();
//		创建4个Person类型的对象
		Person p1 = new Person("jion", 20);
		Person p2 = new Person("lqimi", 22);
		Person p3 = new Person("xxxjion", 20);
		Person p4 = new Person("jack", 30);
//		添加到集合中
		hs.add(p1);
		hs.add(p2);
		hs.add(p3);
		hs.add(p4);
		System.out.println(hs);
	}
}

HashSet的底层实现_JDK源码分析

package cn.xjion.pro09;

import java.util.HashSet;
import java.util.Iterator;

public class TestHashSet {
	/**
	 *  HashSet底层源码分析
	 *  private transient HashMap<E,Object> map;
	 *  private static final Object PRESENT = new Object();
	 *  public HashSet() {
        	map = new HashMap<>();  //创建HashSet时，底层创建的是一个HashMap对象
    	}
    	
    	public boolean add(E e) {
    					key-->e,value-->PRESENT,是一个Object类型的对象
    					map集合中的所有value都是统一的Object类型对象
        	return map.put(e, PRESENT)==null;
    	}
    	public int size() {
        	return map.size();
    	}
    	public boolean contains(Object o) {
        	return map.containsKey(o);//在map集合中判断key是否存在
    	}
    	
    	public Iterator<E> iterator() {
        	return map.keySet().iterator(); //获取map集合中所有的key的集合，再得到迭代器对象
    	}
    	
    	HashSet使用了HashMap的数据结构，
    		底层都是哈希表（顺序表+链表）
	 * 
	 */
	public static void main(String[] args) {
		//HashSet底层数据结构使用的是hash表，主结构数组+链表
		//创建集合对象
		HashSet hs = new HashSet();
		hs.add("hello");
		System.out.println(hs.size());
		System.out.println(hs.contains("hello"));
		//使用迭代器遍历元素
		Iterator ite = hs.iterator();
		while (ite.hasNext()) {
			System.out.println(ite.next());
		}
	}
}

TreeSet的使用_JDK源码分析

底层数据结构

TreeMap(Key，唯一的升序的)，底层数据结构：红黑树，而且TreeMap中的key实际上就是一个TreeSet，如果使用自定义对象作为key，要求必须具备比较规则。

使用TreeMap要求使用内部比较器或者外部比较器

使用：

比较器

package cn.xjion.pro09;

import java.util.Comparator;

public class ComCharactorAndAge implements Comparator{
	public int compare(Object o1,Object o2) {
		Person p1 = (Person)o1;
		Person p2 = (Person)o2;
		if (p1.getName().compareTo(p2.getName())<0){
			return -1;
		}else if(p1.getName().compareTo(p2.getName())>0) {
			return 1;
		}else {
			return p1.getAge() - p2.getAge();
		}
	}
}

Person

package cn.xjion.pro09;
//	Person类实现Person型的Comperable接口
public class Person implements Comparable<Person>{
//	属性
	private String name;
	private int age;
//	get，set方法
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
//	带参构造方法
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
//空构造器
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
//	重写hashCode和equals方法
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
//	重写toString
@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	//	重写compareTo方法
	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		return 0;
	}
}

public class TestTreeSet {
	/**
	 *  TreeSet的底层使用的是TreeMap -->红黑树
	 *  TreeSet JDK源码分析
	 *  private transient NavigableMap<E,Object> m; //一个接口，间接继承了Map
	 *  private static final Object PRESENT = new Object();
	 *  public TreeSet() {
        	this(new TreeMap<E,Object>());//创建了一个TreeMap的对象
    	}
    	//调用的本类中的带参构造方法
    	TreeSet(NavigableMap<E,Object> m) {
        	this.m = m;		//接口new 实现类
    	}
    	
    	public TreeSet(Comparator<? super E> comparator) {
        	this(new TreeMap<>(comparator));  //调用了本类中的带参构造方法
    	}
    	
    	public boolean add(E e) {
        	return m.put(e, PRESENT)==null; //传入的元素作为Map中的key,统一的值为Object类型的对象
    	}
    	
    	public int size() {
        	return m.size();
    	}
	 */
	public static void main(String[] args) {
		ComCharactorAndAge comc = new ComCharactorAndAge();
		TreeSet ts = new TreeSet(comc);
		//创建集合对象
		//TreeSet ts = new TreeSet();
		//创建Person对象
		Person p1 = new Person("marry",20);
		Person p2 = new Person("lili",19);
		Person p3 = new Person("jack",20);
		Person p4 = new Person("marry",18);
		//添加到集合中
		ts.add(p1);
		ts.add(p2);
		ts.add(p3);
		ts.add(p4);
		System.out.println("集合中元素的个数：" + ts.size());
		System.out.println(ts);
	}
}

迭代器

由来：

使用迭代器遍历集合

package cn.xjion.pro09;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

public class Test {
	/**
	 * 	public Iterator<E> iterator() {
        	return new Itr();
    	}
    	
    	private class Itr implements Iterator<E> {
	        int cursor;       // index of next element to return
	        int lastRet = -1; // index of last element returned; -1 if no such
	    
	        Itr() {}
	
	        public boolean hasNext() {
	            return cursor != size;
	        }
	
	        @SuppressWarnings("unchecked")
	        public E next() {
	            
	            int i = cursor;
	           
	            Object[] elementData = ArrayList.this.elementData;
	            
	            cursor = i + 1;
	            return (E) elementData[lastRet = i]; //根据索引获取元素
	      }
	 * 
	 */
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("hello");
		al.add("java");
		al.add("world");
		Iterator<String> ite = al.iterator();
		while (ite.hasNext()) {
			System.out.println(ite.next());
		}
		
		HashSet<Integer> hs = new HashSet<Integer>();
		hs.add(456);
		hs.add(123);
		hs.add(789);
		Iterator<Integer> ite2 = hs.iterator();
		while (ite2.hasNext()) {
			System.out.println(ite2.next());
		}
	}
}

迭代器遍历Map

ListIterator接口

ListIterator是对Iterator接口的扩展，用于解决并发修改的异常。

package cn.xjion.pro09;

import java.util.ArrayList;
import java.util.ListIterator;

public class Test {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("hello");
		al.add("world");
		al.add("java");
		
		ListIterator<String> ite = al.listIterator();
		while (ite.hasNext()) {
			String str = ite.next();
			if ("world".equals(str)) {
				ite.add("sql");
			}
		}
		System.out.println(al);
		System.out.println("逆向遍历元素");
		while (ite.hasPrevious()) {
			System.out.println(ite.previous());
		}
	}
}

遍历Map

package cn.xjion.pro09;

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

public class TestMap {
	public static void main(String[] args) {
		HashMap<String,Integer>  hm = new HashMap<String,Integer>();
		hm.put("hello", 123);
		hm.put("world",456);
		hm.put("java", 567);
		//第一种
		Set<String> set = hm.keySet();
		for (String str : set) {
			System.out.println(str + "\t" + hm.get(str));
		}
		//第二种遍历 
		Set<Entry<String,Integer>> entry = hm.entrySet();
		for (Entry<String, Integer> ent : entry) {
			System.out.println(ent.getKey() + "\t" + ent.getValue());
		}
	}
}

 

 

JAVA面试题合集二(集合容器)
qq_44773677的博客
10-03 232
1.hashmap的初始容量16,之后每次扩容为原来的2倍 hashtable初始为11,扩容为原来的2n+1 2.JDK1.8hashmap红黑树,链表大于8 3.单线程hashmap.多线程ConcurrentHashMap使用 4.JDK1.8 ConcurrentHashMap CAS算法 5.comparable接口有一个comparTo(Object obj)方法 compartor接口有一个compare(Object o1,Object o2)
Java 面试题 (二) -------- Java 集合相关
在森林里麋了鹿
12-06 802
Java 集合相关知识点
Java集合（十二）TreeMap解读
超级程序诞生的博客
10-11 2836
我们发现TreeMap类里面除了提供无参的类以外，也有TreeMap(Comparator )这样子的构造器。TreeMap可以传入一个实现了 Comparator接口的一个匿名内部类，匿名内部类里面我们仍然可以去指定添加我们的键值对的这种排序规则。1.构造器，把传入的实现了Comparator接口的匿名内部类（对象），传给了TreeMap的comparator属性。我们继续进行添加，查看源码。如果我们使用TreeMap，里面放置的是（e为Key，PRESENT为对应的那一个值）。
java常见的面试题
qq_46611668的博客
09-09 436
java面试题 01、谈谈你对spring的理解 Spring是一种轻量级的框架，他的出现就是为了解耦。把创建对象的过程全部交给spring容器去管理。 Spring框架最大的两个特性就是：ioc + aop 01-1、IOC IOC（控制反转）是一种设计思想，就是将原本在程序中new对象的过程交给spring容器去管理。 ioc容器它的底层其实就是一个Map，Map中存放着各种各样的对象。 以前创建对象的主动权和时机是由自己把控的，ioc让对象的创建由spring自动生产，通过java的反射机制，根据配置
java learn—— HashSet
yooppa的博客
10-28 174
1、元素不能重复 Set中的元素，不能重复 第二次插入同样的数据，是插不进去的，容器中只会保留一个 2、没有顺序 Set中的元素，没有顺序。 严格的说，是没有按照元素的插入顺序排列 HashSet的具体顺序，既不是按照插入顺序，也不是按照hashcode的顺序。 注： 不保证Set的迭代顺序; 确切的说，在不同条件下，元素的顺序都有可能不一样 换句话说，同样是插入0-9到HashSet中， 在JVM的不同版本中，看到的顺序都是不一样的。 所以在开发的时候，不能依赖于某种臆测的顺序，这个顺序本身是不稳定的
ue4-docker：虚幻引擎4的Windows和Linux容器
01-30
虚幻引擎4 Docker容器 •• 寻找开始的地方？ 请查看以获取有关在Docker容器内使用Unreal Engine的与实现无关的信息，然后前往以查看特定于使用ue4-docker项目的详细信息。 ue4-docker Python软件包包含一组...
jetson容器：适用于NVIDIA Jetson和JetPack-L4T的机器学习容器
02-03
Jetson和JetPack的机器学习容器 以下Docker容器映像托管在 （NGC）上，用于在Jetson上进行机器学习： 还为以下容器提供了Dockerfile，这些容器可以为JetPack 4.4或更高版本构建： ROS Melodic（ ros:melodic-ros-...
云产品-云计算基础-容器服务CCS
06-22
4. 容器应用的健康检查、日志、Web终端、标准输出查看、监控等容器特性功能； 5. 基于IAM的权限管理； 6. 在线动态资源扩缩容。 CCS架构依赖Mesos的Role实现各实例的底层资源分配，通过CCS实例（即实例Marathon）...
Java同步容器和并发容器详解
08-25
四、结论 Java同步容器和并发容器都是Java基础类库中使用频率最高的一部分。同步容器可以确保线程安全，但是性能相对较差。并发容器可以解决同步容器的性能问题，但是需要根据实际情况选择合适的容器。 Java同步...
Java容器总结
03-16
4. **Servlet容器**：Servlet容器，如Tomcat、Jetty，它们运行并管理Servlet，处理HTTP请求和响应。源码解析可以帮助我们理解Servlet的生命周期，以及如何通过容器实现多线程、并发处理和会话管理。 5. **Spring...
HashSet中add()方法的使用
Dream It Possible
06-19 5107
HashSet 传入对象,怎么过滤 首先,我们知道所有的Set里面都套了一个Map,使用Map的Key存值,Value存放一个固定的Object,这是适配器模式。源码如下： public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable { static final long serialVersionUID =
Java面试题总结（乱序版，2020-08-20）
学Java，找哪吒
08-21 4233
一、String 属于基础的数据类型吗？ 二、java 中操作字符串都有哪些类？它们之间有什么区别？ 三、String str="i"与 String str=new String(“i”)一样吗？ 四、如何决定使用 HashMap 还是 TreeMap？ 五、请谈谈 volatile 有什么特点，为什么它能保证变量对所有线程的可见性？ 六、为什么说 Synchronized 是一个悲观锁？乐观锁的实现原理又是什么？什么是 CAS，它有什么特性？ 七、乐观锁一定就是好的吗？ 八、说一下 jsp
java经典面试题（二）
xy294636185的博客
06-28 343
41.Java中的HashSet内部是如何工作的？ HashSet的内部采用HashMap来实现。由于Map需要key和value，所以HashSet中所有key都有一个默认的value，类似于HashMap，HashSet不允许重复的key，只允许有一个null key，意思是HashSet中只允许存储一个null对象。 public class HashSet<E> extends AbstractSet<E> implements Set<E>,Cloneab
3.java中的数据结构
骚小孩啊丶
02-04 225
java中关于数据结构的工具类，暂时就这么称呼吧，其实也贼拉多，害看图包 上面的图肯定时不全，知识一些常用的。简单看一下上面列举出来的“工具类”的源码和一些常见的面试问题： List接口中的“工具类”，是一个有序集合，可以重复。 ArrayList:底层使用数组实现的，数据是有序数据(插入的顺序)，具有索引查找比较快，线程不安全。 属性： //默认容量 private sta...
面试题解--Java（全）
qq_45424937的博客
08-08 2193
Java 线程不安全的 线程安全的 StringBuilder StringBuffer ArrayList Vector HashMap Hashtable 基本数据类型 字符型：char 布尔型：Boolean 数值型： 整数类型：byte（1字节）， short（2字节）， int（4字节）， long（8字节） 浮点型：float（4字节）， double（8字节） byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。 short：16位，
关于Java中的集合你应该知道的一切
byd666的博客
03-27 2264
1.集合的分类 &nbsp;&nbsp;我们可以从一张类图来了解集合整个的情况，图中虚线框为接口，实线框为类，加重的实线框为比较重要的类。 2.集合相关概念 2.1集合和数组的区别 &nbsp;&nbsp;集合：集合类存放于java.util包中，集合中存放的是对象的引用，长度可以发生改变，可在多数情况下使用。 &nbsp;&nbsp;数组：可以存储有限个类型相同的变量的集合...
【Java X 源码剖析】Collection的源码分析-JDK1.8-仍在更新
The Beginning
03-13 430
Collection接口下的结构 目录 Set HashSet LinkedHashSet（父类HashSet，底层Map为LinkedHashMap） TreeSet（依赖TreeMap） ConcurrentSkipListSet List-Queue PriorityQueue（默认小顶堆） ①public boolean offer(E e) /publ...
HashSet
weixin_30640769的博客
08-20 141
private static final Object PRESENT = new Object(); // 使用 HashMap 实现 public HashSet() { map = new HashMap<>(); } // value 为 一个常量的Object public boolean add...
java map 实现 序列化_Java集合(九)--基于Map实现的Set简析
weixin_28867333的博客
02-26 1403
HashSet此类由一个哈希表(实际上是一个HashMap实例)支持。 不保证元素的顺序，特别是，它不保证顺序随着时间的推移保持不变。该集合没有重复的元素并且允许使用null元素。另外，跟之前分析的其他集合类一样，它是非同步的。定义及说明定义如下：public class HashSet extends AbstractSetimplements Set, Cloneable, java.io.S...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值