阅读EnumSet抽象类源码 - 快网idc优惠网

EnumSet是Java枚举类型的泛型容器，Java既然有了SortedSet、TreeSet、HashSet等容器，为何还要多一个EnumSet<T>呢？答案肯定是EnumSet有一定的特性，举个例子，EnumSet的速度很快。其他特性就不一一列举了，毕竟本文的内容不是介绍EnumSet的特性。

专门为枚举类设计的集合类，所有元素必须是枚举类型

EnumSet的集合元素是有序的，内部以位向量的形成存储，因此占用内存小，效率高

不允许加入null元素

源码

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

package java.util;

import sun.misc.SharedSecrets;

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

implements Cloneable, java.io.Serializable

{

/**

* 元素类型

*/

final Class<E> elementType;

/**

* 通过数组存储元素

*/

final Enum[] universe;

private static Enum[] ZERO_LENGTH_ENUM_ARRAY = new Enum[0];

EnumSet(Class<E>elementType, Enum[] universe) {

this.elementType = elementType;

this.universe = universe;

}

/**

* 创造一个空的 enum set 并制定其元素类型

* @param elementType the class object of the element type for this enum

* set

* @throws NullPointerException if <tt>elementType</tt> is null

*/

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");

if (universe.length <= 64)

return new RegularEnumSet<>(elementType, universe);

else

return new JumboEnumSet<>(elementType, universe);

}

/**

* 创建一个包含所有在指定元素类型的元素的枚举set

*

* @param elementType the class object of the element type for this enum

* set

* @throws NullPointerException if <tt>elementType</tt> is null

*/

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

EnumSet<E> result = noneOf(elementType);

result.addAll();

return result;

}

/**

* Adds all of the elements from the appropriate enum type to this enum

* set, which is empty prior to the call.

*/

abstract void addAll();

/**

* 创建一个枚举设置相同的元素类型与指定枚举set

*

* @param s the enum set from which to initialize this enum set

* @throws NullPointerException if <tt>s</tt> is null

*/

public static <E extends Enum<E>> EnumSet<E> copyOf(EnumSet<E> s) {

return s.clone();

}

/**

* 创建一个枚举集从指定集合初始化，最初包含相同的元素

* @param c the collection from which to initialize this enum set

* @throws IllegalArgumentException if <tt>c</tt> is not an

* <tt>EnumSet</tt> instance and contains no elements

* @throws NullPointerException if <tt>c</tt> is null

*/

public static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c) {

if (c instanceof EnumSet) {

return ((EnumSet<E>)c).clone();

} else {

if (c.isEmpty())

throw new IllegalArgumentException("Collection is empty");

Iterator<E> i = c.iterator();

E first = i.next();

EnumSet<E> result = EnumSet.of(first);

while (i.hasNext())

result.add(i.next());

return result;

}

/**

* 创建一个枚举集合，其元素与 s 相同

* @param s the enum set from whose complement to initialize this enum set

* @throws NullPointerException if <tt>s</tt> is null

*/

public static <E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> s) {

EnumSet<E> result = copyOf(s);

result.complement();

return result;

}

/**

* 1 个元素枚举集合

*

* @param e the element that this set is to contain initially

* @throws NullPointerException if <tt>e</tt> is null

* @return an enum set initially containing the specified element

*/

public static <E extends Enum<E>> EnumSet<E> of(E e) {

EnumSet<E> result = noneOf(e.getDeclaringClass());

result.add(e);

return result;

}

/**

* 2 个元素枚举集合

*

* @param e1 an element that this set is to contain initially

* @param e2 another element that this set is to contain initially

* @throws NullPointerException if any parameters are null

* @return an enum set initially containing the specified elements

*/

public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2) {

EnumSet<E> result = noneOf(e1.getDeclaringClass());

result.add(e1);

result.add(e2);

return result;

}

/**

* 3 个元素枚举集合

*

* @param e1 an element that this set is to contain initially

* @param e2 another element that this set is to contain initially

* @param e3 another element that this set is to contain initially

* @throws NullPointerException if any parameters are null

* @return an enum set initially containing the specified elements

*/

public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3) {

EnumSet<E> result = noneOf(e1.getDeclaringClass());

result.add(e1);

result.add(e2);

result.add(e3);

return result;

}

/**

* 4 个元素枚举集合

* @param e1 an element that this set is to contain initially

* @param e2 another element that this set is to contain initially

* @param e3 another element that this set is to contain initially

* @param e4 another element that this set is to contain initially

* @throws NullPointerException if any parameters are null

* @return an enum set initially containing the specified elements

*/

public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4) {

EnumSet<E> result = noneOf(e1.getDeclaringClass());

result.add(e1);

result.add(e2);

result.add(e3);

result.add(e4);

return result;

}

/**

* 5 个元素枚举集合

*

* @param e1 an element that this set is to contain initially

* @param e2 another element that this set is to contain initially

* @param e3 another element that this set is to contain initially

* @param e4 another element that this set is to contain initially

* @param e5 another element that this set is to contain initially

* @throws NullPointerException if any parameters are null

* @return an enum set initially containing the specified elements

*/

public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4,

E e5)

{

EnumSet<E> result = noneOf(e1.getDeclaringClass());

result.add(e1);

result.add(e2);

result.add(e3);

result.add(e4);

result.add(e5);

return result;

}

/**

* n 个元素枚举集合

*

* @param first an element that the set is to contain initially

* @param rest the remaining elements the set is to contain initially

* @throws NullPointerException if any of the specified elements are null,

* or if <tt>rest</tt> is null

* @return an enum set initially containing the specified elements

*/

@SafeVarargs

public static <E extends Enum<E>> EnumSet<E> of(E first, E... rest) {

EnumSet<E> result = noneOf(first.getDeclaringClass());

result.add(first);

for (E e : rest)

result.add(e);

return result;

}

/**

* 区间内元素的枚举集合

*

* @param from the first element in the range

* @param to the last element in the range

* @throws NullPointerException if {@code from} or {@code to} are null

* @throws IllegalArgumentException if {@code from.compareTo(to) > 0}

* @return an enum set initially containing all of the elements in the

* range defined by the two specified endpoints

*/

public static <E extends Enum<E>> EnumSet<E> range(E from, E to) {

if (from.compareTo(to) > 0)

throw new IllegalArgumentException(from + " > " + to);

EnumSet<E> result = noneOf(from.getDeclaringClass());

result.addRange(from, to);

return result;

}

/**

* Adds the specified range to this enum set, which is empty prior

* to the call.

*/

abstract void addRange(E from, E to);

/**

* Returns a copy of this set.

*

* @return a copy of this set

*/

public EnumSet<E> clone() {

try {

return (EnumSet<E>) super.clone();

} catch(CloneNotSupportedException e) {

throw new AssertionError(e);

}

/**

* Complements the contents of this enum set.

*/

abstract void complement();

/**

* Throws an exception if e is not of the correct type for this enum set.

*/

final void typeCheck(E e) {

Class eClass = e.getClass();

if (eClass != elementType && eClass.getSuperclass() != elementType)

throw new ClassCastException(eClass + " != " + elementType);

}

/**

* Returns all of the values comprising E.

* The result is uncloned, cached, and shared by all callers.

*/

private static <E extends Enum<E>> E[] getUniverse(Class<E> elementType) {

return SharedSecrets.getJavaLangAccess()

.getEnumConstantsShared(elementType);

}

/**

* This class is used to serialize all EnumSet instances, regardless of

* implementation type. It captures their "logical contents" and they

* are reconstructed using public static factories. This is necessary

* to ensure that the existence of a particular implementation type is

* an implementation detail.

*

* @serial include

*/

private static class SerializationProxy <E extends Enum<E>>

implements java.io.Serializable

{

/**

* The element type of this enum set.

*

* @serial

*/

private final Class<E> elementType;

/**

* The elements contained in this enum set.

*

* @serial

*/

private final Enum[] elements;

SerializationProxy(EnumSet<E> set) {

elementType = set.elementType;

elements = set.toArray(ZERO_LENGTH_ENUM_ARRAY);

}

private Object readResolve() {

EnumSet<E> result = EnumSet.noneOf(elementType);

for (Enum e : elements)

result.add((E)e);

return result;

}

private static final long serialVersionUID = 362491234563181265L;

}

Object writeReplace() {

return new SerializationProxy<>(this);

}

// readObject method for the serialization proxy pattern

// See Effective Java, Second Ed., Item 78.

private void readObject(java.io.ObjectInputStream stream)

throws java.io.InvalidObjectException {

throw new java.io.InvalidObjectException("Proxy required");

}

总结

以上就是本文关于阅读EnumSet抽象类源码的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！

原文链接：http://blog.csdn.net/qunxingvip/article/details/51925112

相关文章

微信

快网idc优惠网

QQ交流群