ios nsset 里的数据怎么取

千锋扣丁学堂iOS开发学习为您解答：

1、集合：集合（NSSet）和数组（NSArray）有相似之处，都是存储不同的对象的地址；不过NSArray是有序的集合，NSSet是无序的集合。

集合是一种哈希表，运用散列算法，查找集合中的元素比数组速度更快，但是它没有顺序。

NSSet set = [[NSSet alloc] initWithObjects:@"one",@"two",@"three",@"four", nil];2 [set count]; //返回集合中对象的个数

判断集合中是否拥有某个元素

//判断集合中是否拥有@“two”2 BOOL ret = [set containsObject:@"two"];

判断两个集合是否相等

NSSet set2 = [[NSSet alloc] initWithObjects:@"one",@"two",@"three",@"four", nil];2 //判断两个集合是否相等3 BOOL ret = [set isEqualToSet:set2];

判断set是否是set2的子集合

NSSet set2 = [[NSSet alloc] initWithObjects:@"one",@"two",@"three",@"four",@"five", nil];2 //判断set是否是set2的子集合3 BOOL ret = [set isSubsetOfSet:set2];

集合也可以用枚举器来遍历

//集合也可以用枚举器来遍历2 NSEnumerator enumerator = [set objectEnumerator];3 NSString str;4 while (str =[enumerator nextObject]) {5 ……6 }

通过数组来初始化集合（数组转换为集合）

NSArray array = [[NSArray alloc] initWithObjects:@"one",@"two",@"three",@"four", nil];2 NSSet set = [[NSSet alloc] initWithArray:array];

集合转换为数组

NSArray array2 = [set allObjects];

2、可变集合NSMutableSet

//可变集合NSMutableSet2 NSMutableSet set = [[NSMutableSet alloc] init];3 [set addObject:@"one"];4 [setaddObject:@"two"];5 [set addObject:@"two"]; //如果添加的元素有重复，实际只保留一个

删除元素

//删除元素2 [set removeObject:@"two"];3 [set removeAllObjects];

将set2中的元素添加到set中来，如果有重复，只保留一个

//将set2中的元素添加到set中来，如果有重复，只保留一个2 NSSet set2 = [[NSSet alloc] initWithObjects:@"two",@"three",@"four", nil];3 [set unionSet:set2];

删除set中与set2相同的元素

[set minusSet:set2];

3、指数集合（索引集合）NSIndexSet

//指数集合（索引集合）NSIndexSet2 NSIndexSet indexSet = [[NSIndexSet alloc] initWithIndexesInRange:NSMakeRange(1,3)]; //集合中的数字是123

根据集合提取数组中指定位置的元素

//根据集合提取数组中指定位置的元素2 NSArray array = [[NSArray alloc] initWithObjects:@"one",@"two",@"three",@"four", nil];3 NSArray newArray = [array objectsAtIndexes:indexSet]; //返回@"two",@"three",@"four"

4、可变指数集合NSMutableIndexSet

NSMutableIndexSet indexSet = [[NSMutableIndexSet alloc] init];2 [indexSet addIndex:0]3 [indexSet addIndex:3];4[indexSet addIndex:5];5 //通过集合获取数组中指定的元素6 NSArray array = [[NSArray alloc] initWithObjects:@"one",@"two",@"three",@"four",@"five",@"six", nil];7 NSArray newArray = [array objectsAtIndexes:indexSet]; //返回@"one"，@"four"，@"six"

你想问的应该是：javautilSet 有没有像 list 一样的get方法吧？

答案是没有；

List特点：元素有放入顺序，元素可重复

Set特点：元素无放入顺序，元素不可重复

List的get方法需要下标，其实也就是放入顺序，由于Set没有放入顺序，所以这应该就是没有给Set设计get方法的原因吧

（扩展：在Set中的位置是由元素的HashCode决定的，位置其实是固定的）

要取Set的值，一般是用iterator() 方法获取迭代器进行 *** 作，也可以用toArray()方法转成数组来 *** 作。

Set集合的特点主要有：元素不重复、存储无序的特点。

打开 Set 集合，主要实现类有 HashSet、LinkedHashSet 、TreeSet 、EnumSet（ RegularEnumSet、JumboEnumSet ）等等，总结 Set 接口实现类，图如下：

由图中的继承关系，可以知道，Set 接口主要实现类有 AbstractSet、HashSet、LinkedHashSet 、TreeSet 、EnumSet（ RegularEnumSet、JumboEnumSet ），其中 AbstractSet、EnumSet 属于抽象类，EnumSet 是在 jdk15 中新增的，不同的是 EnumSet 集合元素必须是枚举类型。

HashSet 是一个输入输出无序的集合，集合中的元素基于 HashMap 的 key 实现，元素不可重复；

LinkedHashSet 是一个输入输出有序的集合，集合中的元素基于 LinkedHashMap 的 key 实现，元素也不可重复；

TreeSet 是一个排序的集合，集合中的元素基于 TreeMap 的 key 实现，同样元素不可重复；

EnumSet 是一个与枚举类型一起使用的专用 Set 集合，其中 RegularEnumSet 和 JumboEnumSet 不能单独实例化，只能由 EnumSet 来生成，同样元素不可重复；

下面咱们来对各个主要实现类进行一一分析！

HashSet 是一个输入输出无序的集合，底层基于 HashMap 来实现，HashSet 利用 HashMap 中的key元素来存放元素，这一点我们可以从源码上看出来，阅读源码如下：

public class HashSet<E>

extends AbstractSet<E>

implements Set<E>, Cloneable, javaioSerializable{

}

打开HashSet的add()方法，源码如下：

public boolean add(E e) {

//向 HashMap 中添加元素

return mapput(e, PRESENT)==null;

}

其中变量PRESENT，是一个非空对象，源码部分如下：

private static final Object PRESENT = new Object();

可以分析出，当进行add()的时候，等价于

HashMap map = new HashMap<>();

mapput(e, new Object());//e 表示要添加的元素

在之前的集合文章中，咱们了解到 HashMap 在添加元素的时候 ，通过equals()和hashCode()方法来判断传入的key是否相同，如果相同，那么 HashMap 认为添加的是同一个元素，反之，则不是。

从源码分析上可以看出，HashSet 正是使用了 HashMap 的这一特性，实现存储元素下标无序、元素不会重复的特点。

HashSet 的删除方法，同样如此，也是基于 HashMap 的底层实现，源码如下：

public boolean remove(Object o) {

//调用HashMap 的remove方法，移除元素

return mapremove(o)==PRESENT;

}

HashSet 没有像 List、Map 那样提供 get 方法，而是使用迭代器或者 for 循环来遍历元素，方法如下：

public static void main(String[] args) {

Set<String> hashSet = new HashSet<String>();

Systemoutprintln("HashSet初始容量大小："+hashSetsize());

hashSetadd("1");

hashSetadd("2");

hashSetadd("3");

hashSetadd("3");

hashSetadd("2");

hashSetadd(null);

}

输出结果：

HashSet初始容量大小：0

HashSet容量大小：4

null,1,2,3,

===========

null,1,2,3,

需要注意的是，HashSet 允许添加为null的元素。

LinkedHashSet 是一个输入输出有序的集合，继承自 HashSet，但是底层基于 LinkedHashMap 来实现。

如果你之前了解过 LinkedHashMap，那么你一定知道，它也继承自 HashMap，唯一有区别的是，LinkedHashMap 底层数据结构基于循环链表实现，并且数组指定了头部和尾部，虽然数组的下标存储无序，但是却可以通过数组的头部和尾部，加上循环链表，依次可以查询到元素存储的过程，从而做到输入输出有序的特点。

如果还不了解 LinkedHashMap 的实现过程，可以参阅集合系列中关于 LinkedHashMap 的实现过程文章。

阅读 LinkedHashSet 的源码，类定义如下：

public class LinkedHashSet<E>

extends HashSet<E>

implements Set<E>, Cloneable, javaioSerializable {

}

查询源码，super调用的方法，源码如下：

HashSet(int initialCapacity, float loadFactor, boolean dummy) {

//初始化一个 LinkedHashMap

map = new LinkedHashMap<>(initialCapacity, loadFactor);

}

LinkedHshSet没有重写add方法，而是直接调用HashSet的add()方法，因为map的实现类是LinkedHashMap，所以此处是向LinkedHashMap中添加元素，当进行add()的时候，等价于

HashMap map = new LinkedHashMap<>();

mapput(e, new Object());//e 表示要添加的元素

LinkedHashSet也没有重写remove方法，而是直接调用HashSet的删除方法，因为LinkedHashMap没有重写remove方法，所以调用的也是HashMap的remove方法，源码如下：

public boolean remove(Object o) {

//调用HashMap 的remove方法，移除元素

return mapremove(o)==PRESENT;

}

同样的，LinkedHashSet 没有提供 get 方法，使用迭代器或者 for 循环来遍历元素，方法如下：

public static void main(String[] args) {

Set<String> linkedHashSet = new LinkedHashSet<String>();

Systemoutprintln("linkedHashSet初始容量大小："+linkedHashSetsize());

linkedHashSetadd("1");

linkedHashSetadd("2");

linkedHashSetadd("3");

linkedHashSetadd("3");

linkedHashSetadd("2");

linkedHashSetadd(null);

linkedHashSetadd(null);

}

输出结果：

linkedHashSet初始容量大小：0

linkedHashSet容量大小：4

1,2,3,null,

===========

1,2,3,null,

可见，LinkedHashSet 与 HashSet 相比，LinkedHashSet 输入输出有序。

TreeSet 是一个排序的集合，实现了NavigableSet、SortedSet、Set接口，底层基于 TreeMap 来实现。TreeSet 利用 TreeMap 中的key元素来存放元素，这一点我们也可以从源码上看出来，阅读源码，类定义如下：

public class TreeSet<E> extends AbstractSet<E>

implements NavigableSet<E>, Cloneable, javaioSerializable {

}

new TreeSet<>()对象实例化的时候，表达的意思，可以简化为如下：

NavigableMap<E,Object> m = new TreeMap<E,Object>();

因为TreeMap实现了NavigableMap接口，所以没啥问题。

public class TreeMap<K,V>

extends AbstractMap<K,V>

implements NavigableMap<K,V>, Cloneable, javaioSerializable{

}

打开TreeSet的add()方法，源码如下：

public boolean add(E e) {

//向 TreeMap 中添加元素

return mput(e, PRESENT)==null;

}

其中变量PRESENT，也是是一个非空对象，源码部分如下：

private static final Object PRESENT = new Object();

可以分析出，当进行add()的时候，等价于

TreeMap map = new TreeMap<>();

mapput(e, new Object());//e 表示要添加的元素

TreeMap 类主要功能在于，给添加的集合元素，按照一个的规则进行了排序，默认以自然顺序进行排序，当然也可以自定义排序，比如测试方法如下：

public static void main(String[] args) {

Map initMap = new TreeMap();

initMapput("4", "d");

initMapput("3", "c");

initMapput("1", "a");

initMapput("2", "b");

//默认自然排序，key为升序

Systemoutprintln("默认 排序结果:" + initMaptoString());

//自定义排序，在TreeMap初始化阶段传入Comparator 内部对象

Map comparatorMap = new TreeMap<String, String>(new Comparator<String>() {

@Override

public int compare(String o1, String o2){

//根据key比较大小，采用倒叙，以大到小排序

return o2compareTo(o1);

}

});

comparatorMapput("4", "d");

comparatorMapput("3", "c");

comparatorMapput("1", "a");

comparatorMapput("2", "b");

Systemoutprintln("自定义 排序结果:" + comparatorMaptoString());

}

输出结果：

默认 排序结果:{1=a, 2=b, 3=c, 4=d}

自定义 排序结果:{4=d, 3=c, 2=b, 1=a}

相信使用过TreeMap的朋友，一定知道TreeMap会自动将key按照一定规则进行排序，TreeSet正是使用了TreeMap这种特性，来实现添加的元素集合，在输出的时候，其结果是已经排序好的。

如果您没看过源码TreeMap的实现过程，可以参阅集合系列文章中TreeMap的实现过程介绍，或者阅读 jdk 源码。

TreeSet 的删除方法，同样如此，也是基于 TreeMap 的底层实现，源码如下：

public boolean remove(Object o) {

//调用TreeMap 的remove方法，移除元素

return mremove(o)==PRESENT;

}

TreeSet 没有重写 get 方法，而是使用迭代器或者 for 循环来遍历元素，方法如下：

public static void main(String[] args) {

Set<String> treeSet = new TreeSet<>();

Systemoutprintln("treeSet初始容量大小："+treeSetsize());

treeSetadd("1");

treeSetadd("4");

treeSetadd("3");

treeSetadd("8");

treeSetadd("5");

}

输出结果：

treeSet初始容量大小：0

treeSet容量大小：5

1,3,4,5,8,

===========

1,3,4,5,8,

使用自定义排序，有 2 种方法，第一种在需要添加的元素类，实现Comparable接口，重写compareTo方法来实现对元素进行比较，实现自定义排序。

/

创建一个Person实体类，实现Comparable接口，重写compareTo方法，通过变量age实现自定义排序 测试方法如下：

public static void main(String[] args) {

Set<Person> treeSet = new TreeSet<>();

Systemoutprintln("treeSet初始容量大小："+treeSetsize());

treeSetadd(new Person("李一",18));

treeSetadd(new Person("李二",17));

treeSetadd(new Person("李三",19));

treeSetadd(new Person("李四",21));

treeSetadd(new Person("李五",20));

}

输出结果：

treeSet初始容量大小：0

treeSet容量大小：5

按照年龄从小到大，自定义排序结果：

李二:17,李一:18,李三:19,李五:20,李四:21,

第二种方法是在TreeSet初始化阶段，Person不用实现Comparable接口，将Comparator接口以内部类的形式作为参数，初始化进去，方法如下：

public static void main(String[] args) {

//自定义排序

Set<Person> treeSet = new TreeSet<>(new Comparator<Person>(){

@Override

public int compare(Person o1, Person o2) {

if(o1 == null || o2 == null){

//不用比较

return 0;

}

//从小到大进行排序

return o1getAge() - o2getAge();

}

});

Systemoutprintln("treeSet初始容量大小："+treeSetsize());

treeSetadd(new Person("李一",18));

treeSetadd(new Person("李二",17));

treeSetadd(new Person("李三",19));

treeSetadd(new Person("李四",21));

treeSetadd(new Person("李五",20));

}

输出结果：

treeSet初始容量大小：0

treeSet容量大小：5

按照年龄从小到大，自定义排序结果：

李二:17,李一:18,李三:19,李五:20,李四:21,

需要注意的是，TreeSet不能添加为空的元素，否则会报空指针错误！

EnumSet 是一个与枚举类型一起使用的专用 Set 集合，继承自AbstractSet抽象类。与 HashSet、LinkedHashSet 、TreeSet 不同的是，EnumSet 元素必须是Enum的类型，并且所有元素都必须来自同一个枚举类型，EnumSet 定义源码如下：

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>

implements Cloneable, javaioSerializable {

}

EnumSet是一个虚类，不能直接通过实例化来获取对象，只能通过它提供的静态方法来返回EnumSet实现类的实例。

EnumSet的实现类有两个，分别是RegularEnumSet、JumboEnumSet两个类，两个实现类都继承自EnumSet。

EnumSet会根据枚举类型中元素的个数，来决定是返回哪一个实现类，当 EnumSet元素中的元素个数小于或者等于64，就会返回RegularEnumSet实例；当EnumSet元素个数大于64，就会返回JumboEnumSet实例。

这一点，我们可以从源码中看出，源码如下：

public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {

Enum<>[] universe = getUniverse(elementType);

if (universe == null)

throw new ClassCastException(elementType + " not an enum");

//当元素个数小于或者等于 64 的时候，返回 RegularEnumSet

if (universelength <= 64)

return new RegularEnumSet<>(elementType, universe);

else

//大于64，返回 JumboEnumSet

return new JumboEnumSet<>(elementType, universe);

}

noneOf是EnumSet中一个静态方法，用于判断是返回哪一个实现类。

我们来看看当元素个数小于等于64的时候，使用RegularEnumSet的类，源码如下：

class RegularEnumSet<E extends Enum<E>> extends EnumSet<E> {

}

RegularEnumSet 通过二进制运算得到结果，直接使用long来存放元素。

我们再来看看当元素个数大于64的时候，使用JumboEnumSet的类，源码如下：

class JumboEnumSet<E extends Enum<E>> extends EnumSet<E> {

}

JumboEnumSet 也是通过二进制运算得到结果，使用long来存放元素，但是它是使用数组来存放元素。

二者相比，RegularEnumSet 效率比 JumboEnumSet 高些，因为 *** 作步骤少，大多数情况下返回的是 RegularEnumSet，只有当枚举元素个数超过 64 的时候，会使用 JumboEnumSet。

添加元素：

//新建一个EnumEntity的枚举类型，定义2个参数

public enum EnumEntity {

WOMAN,MAN;

}

创建一个空的 EnumSet：

//创建一个 EnumSet，内容为空

EnumSet<EnumEntity> noneSet = EnumSetnoneOf(EnumEntityclass);

Systemoutprintln(noneSet);

输出结果：

[]

创建一个 EnumSet，并将枚举类型的元素全部添加进去：

//创建一个 EnumSet，将EnumEntity 元素内容添加到EnumSet中

EnumSet<EnumEntity> allSet = EnumSetallOf(EnumEntityclass);

Systemoutprintln(allSet);

输出结果：

[WOMAN, MAN]

创建一个 EnumSet，添加指定的枚举元素：

//创建一个 EnumSet，添加 WOMAN 到 EnumSet 中

EnumSet<EnumEntity> customSet = EnumSetof(EnumEntityWOMAN);

Systemoutprintln(customSet);

查询元素

EnumSet与HashSet、LinkedHashSet、TreeSet一样，通过迭代器或者 for 循环来遍历元素，方法如下：

EnumSet<EnumEntity> allSet = EnumSetallOf(EnumEntityclass);

for (EnumEntity enumEntity : allSet) {

Systemoutprint(enumEntity + ",");

}

输出结果：

WOMAN,MAN,

HashSet 是一个输入输出无序的 Set 集合，元素不重复，底层基于 HashMap 的 key 来实现，元素可以为空，如果添加的元素为对象，对象需要重写 equals() 和 hashCode() 方法来约束是否为相同的元素。

LinkedHashSet 是一个输入输出有序的 Set 集合，继承自 HashSet，元素不重复，底层基于 LinkedHashMap 的 key来实现，元素也可以为空，LinkedHashMap 使用循环链表结构来保证输入输出有序。

TreeSet 是一个排序的 Set 集合，元素不可重复，底层基于 TreeMap 的 key来实现，元素不可以为空，默认按照自然排序来存放元素，也可以使用 Comparable 和 Comparator 接口来比较大小，实现自定义排序。

EnumSet 是一个与枚举类型搭配使用的专用 Set 集合，在 jdk15 中加入。EnumSet 是一个虚类，有2个实现类 RegularEnumSet、JumboEnumSet，不能显式的实例化改类，EnumSet 会动态决定使用哪一个实现类，当元素个数小于等于64的时候，使用 RegularEnumSet；大于 64的时候，使用JumboEnumSet类，EnumSet 其内部使用位向量实现，拥有极高的时间和空间性能，如果元素是枚举类型，推荐使用 EnumSet。

1、JDK17&JDK18 源码

2、程序园 - java集合－EnumMap与EnumSet

3、 Java极客技术 - >

以上就是关于ios nsset 里的数据怎么取全部的内容，包括:ios nsset 里的数据怎么取、java set有get方法吗、深入浅出的分析 Set集合等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！