我需要创建一个具有初始值的集合。
Set<String> h = new HashSet<String>();
h.add("a");
h.add("b");
是否有一种方法可以在一行代码中做到这一点?例如,它对于最终的静态字段很有用。
我需要创建一个具有初始值的集合。
Set<String> h = new HashSet<String>();
h.add("a");
h.add("b");
是否有一种方法可以在一行代码中做到这一点?例如,它对于最终的静态字段很有用。
当前回答
有几种方法:
双大括号初始化
这是一种创建匿名内部类的技术,它有一个实例初始化器,在创建实例时将string添加到自身:
Set<String> s = new HashSet<String>() {{
add("a");
add("b");
}}
请记住,这实际上会在每次使用HashSet时创建一个新的子类,尽管不必显式地编写一个新的子类。
一种实用方法
编写一个返回Set的方法并不是太难写:
public static Set<String> newHashSet(String... strings) {
HashSet<String> set = new HashSet<String>();
for (String s : strings) {
set.add(s);
}
return set;
}
上面的代码只允许使用String类型,但是允许使用任何使用泛型的类型应该不会太难。
利用图书馆
许多库都有一个方便的方法来初始化集合对象。
例如,谷歌Collections有一个Sets.newHashSet(T…)方法,该方法将用特定类型的元素填充HashSet。
其他回答
只是一个小提示,不管你最终使用了这里提到的哪种好方法,如果这是一个通常不被修改的默认设置(就像你正在创建的库中的默认设置),遵循以下模式是一个好主意:
// Initialize default values with the method you prefer, even in a static block
// It's a good idea to make sure these defaults aren't modifiable
private final static Set<String> DEFAULT_VALUES = Collections.unmodifiableSet(...);
private Set<String> values = DEFAULT_VALUES;
好处取决于您为该类创建的实例数量以及更改默认值的可能性。
如果您决定遵循这种模式,那么您还必须选择最易读的集初始化方法。由于不同方法之间的效率差异可能不会太大,因为您将只初始化一次集合。
在Eclipse Collections中,有几种不同的方法来初始化一个包含字符'a'和'b'的Set语句。Eclipse Collections同时为对象类型和基本类型提供了容器,因此我演示了如何使用Set<String>或CharSet,以及可变、不可变、同步和不可修改的这两个版本。
Set<String> set =
Sets.mutable.with("a", "b");
HashSet<String> hashSet =
Sets.mutable.with("a", "b").asLazy().into(new HashSet<String>());
Set<String> synchronizedSet =
Sets.mutable.with("a", "b").asSynchronized();
Set<String> unmodifiableSet =
Sets.mutable.with("a", "b").asUnmodifiable();
MutableSet<String> mutableSet =
Sets.mutable.with("a", "b");
MutableSet<String> synchronizedMutableSet =
Sets.mutable.with("a", "b").asSynchronized();
MutableSet<String> unmodifiableMutableSet =
Sets.mutable.with("a", "b").asUnmodifiable();
ImmutableSet<String> immutableSet =
Sets.immutable.with("a", "b");
ImmutableSet<String> immutableSet2 =
Sets.mutable.with("a", "b").toImmutable();
CharSet charSet =
CharSets.mutable.with('a', 'b');
CharSet synchronizedCharSet =
CharSets.mutable.with('a', 'b').asSynchronized();
CharSet unmodifiableCharSet =
CharSets.mutable.with('a', 'b').asUnmodifiable();
MutableCharSet mutableCharSet =
CharSets.mutable.with('a', 'b');
ImmutableCharSet immutableCharSet =
CharSets.immutable.with('a', 'b');
ImmutableCharSet immutableCharSet2 =
CharSets.mutable.with('a', 'b').toImmutable();
注意:我是Eclipse Collections的提交者。
你可以在Java 6中做到:
Set<String> h = new HashSet<String>(Arrays.asList("a", "b", "c"));
但是为什么呢?我不认为它比显式地添加元素更具有可读性。
如果你正在寻找最紧凑的初始化集合的方法,那么在Java9中:
Set<String> strSet = Set.of("Apple", "Ball", "Cat", "Dog");
===================== 下面详细的回答 ==========================
使用Java 10(不可修改的集合)
Set<String> strSet1 = Stream.of("A", "B", "C", "D")
.collect(Collectors.toUnmodifiableSet());
在这里,收集器实际上会返回Java 9中引入的不可修改的集合,这可以从源代码中的语句set -> (set <T>) set. of(set. toarray())中明显看出。
需要注意的一点是Collections.unmodifiableSet()方法返回指定集合的不可修改视图(根据文档)。不可修改的视图集合是不可修改的集合,也是备份集合上的视图。注意,对备份集合的更改仍然是可能的,如果发生更改,则通过不可修改的视图可见。但是在Java 10中,collections . tounmodifiableset()方法返回的是真正不可变的集合。
使用Java 9(不可修改的集合)
下面是最紧凑的初始化集合的方法:
Set<String> strSet6 = Set.of("Apple", "Ball", "Cat", "Dog");
这个方便工厂方法有12个重载版本:
static <E> Set<E> of() static <E> Set<E> of(E e1) Set<E> of(E e1, E e2) / /……等等 static <E> Set<E> of(E…elem)
那么一个自然的问题是,当我们有var-args时,为什么我们需要重载版本?答案是:每个var-arg方法都在内部创建一个数组,重载版本将避免不必要的对象创建,也将从垃圾收集开销中节省我们。
使用Java 8(可修改的集合)
在Java 8中使用流。
Set<String> strSet1 = Stream.of("A", "B", "C", "D")
.collect(Collectors.toCollection(HashSet::new));
// stream from an array (String[] stringArray)
Set<String> strSet2 = Arrays.stream(stringArray)
.collect(Collectors.toCollection(HashSet::new));
// stream from a list (List<String> stringList)
Set<String> strSet3 = stringList.stream()
.collect(Collectors.toCollection(HashSet::new));
使用Java 8(不可修改的集合)
使用Collections.unmodifiableSet ()
我们可以这样使用Collections.unmodifiableSet():
Set<String> strSet4 = Collections.unmodifiableSet(strSet1);
但这看起来有点尴尬,我们可以像这样编写自己的收集器:
class ImmutableCollector {
public static <T> Collector<T, Set<T>, Set<T>> toImmutableSet() {
return Collector.of(HashSet::new, Set::add, (l, r) -> {
l.addAll(r);
return l;
}, Collections::unmodifiablSet);
}
}
然后把它用作:
Set<String> strSet4 = Stream.of("A", "B", "C", "D")
.collect(ImmutableCollector.toImmutableSet());
使用Collectors.collectingAndThen ()
另一种方法是使用collections . collectingandthen()方法,它允许我们执行额外的整理转换:
import static java.util.stream.Collectors.*;
Set<String> strSet5 = Stream.of("A", "B", "C", "D").collect(collectingAndThen(
toCollection(HashSet::new),Collections::unmodifiableSet));
如果我们只关心Set,那么我们也可以使用collections . toset()来代替collections . tocollection (HashSet::new)。
还可以检查Java 8的这个答案。
Builder模式在这里可能有用。今天我也遇到了同样的问题。在这里,我需要Set变异操作来返回Set对象的引用,因此我可以将它传递给超类构造函数,这样它们也可以通过依次构造一个新的StringSetBuilder来继续添加到相同的Set,脱离子类刚刚构建的Set。我写的构建器类看起来像这样(在我的例子中,它是一个外部类的静态内部类,但它也可以是它自己的独立类):
public interface Builder<T> {
T build();
}
static class StringSetBuilder implements Builder<Set<String>> {
private final Set<String> set = new HashSet<>();
StringSetBuilder add(String pStr) {
set.add(pStr);
return this;
}
StringSetBuilder addAll(Set<String> pSet) {
set.addAll(pSet);
return this;
}
@Override
public Set<String> build() {
return set;
}
}
注意addAll()和add()方法,它们是Set.add()和Set.addAll()的Set返回对应物。最后注意build()方法,该方法返回对构建器封装的Set的引用。下面说明了如何使用这个Set构建器:
class SomeChildClass extends ParentClass {
public SomeChildClass(String pStr) {
super(new StringSetBuilder().add(pStr).build());
}
}
class ParentClass {
public ParentClass(Set<String> pSet) {
super(new StringSetBuilder().addAll(pSet).add("my own str").build());
}
}