private void basicReject(RichIterable<Integer> iterable) { Collection<Integer> actual1 = ParallelIterate.reject(iterable, Predicates.greaterThan(10000)); Collection<Integer> actual2 = ParallelIterate.reject( iterable, Predicates.greaterThan(10000), HashBag.<Integer>newBag(), 3, this.executor, true); Collection<Integer> actual3 = ParallelIterate.reject(iterable, Predicates.greaterThan(10000), true); RichIterable<Integer> expected = iterable.reject(Predicates.greaterThan(10000)); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected, actual1); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected.toBag(), actual2); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual3.getClass().getSimpleName(), expected.toBag(), HashBag.newBag(actual3)); }
private void assertContains123(Collection<Integer> coll, Class<?> expectedClass) { assert coll.getClass() == expectedClass; // will fail with caching objectify, this is ok assert coll.size() == 3; Iterator<Integer> it = coll.iterator(); assert it.next() == 1; assert it.next() == 2; assert it.next() == 3; }
@Test public void selectSortedSet() { RichIterable<Integer> iterable = Interval.oneTo(20000).toSortedSet(); Collection<Integer> actual1 = ParallelIterate.select(iterable, Predicates.greaterThan(10000)); Collection<Integer> actual2 = ParallelIterate.select(iterable, Predicates.greaterThan(10000), true); RichIterable<Integer> expected = iterable.select(Predicates.greaterThan(10000)); Assert.assertSame(expected.getClass(), actual1.getClass()); Assert.assertSame(expected.getClass(), actual2.getClass()); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected, actual1); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected, actual2); }
private static Collection<Object> deepClone(Collection<Object> sourceCollection) { Collection<Object> collection = createCollection(sourceCollection.getClass()); for (Object entry : sourceCollection) { collection.add(deepClone(entry)); } return collection; }
/** * Dynamically check that the members of the collection are all instances of the given type (or * null), and that the collection itself is of the given collection type. * * @param <E> the collection's element type * @param c the collection to cast * @param type the class of the collection's element type. * @return the dynamically-type checked collection. * @throws java.lang.ClassCastException */ @SuppressWarnings("unchecked") static <E, TypedC extends Collection<E>> TypedC dynamicallyCastCollection( Collection<?> c, Class<E> type, Class<TypedC> collectionType) { if (c == null) return null; if (!collectionType.isInstance(c)) throw new ClassCastException(c.getClass().getName()); assert checkCollectionMembers(c, type) : "The collection contains members with a type other than " + type.getName(); return collectionType.cast(c); }
/** * 转化一批bean,并不注入指定属性 * * @param beans * @param fieldNames * @return * @throws InstantiationException * @throws IllegalAccessException * @throws InvocationTargetException * @throws NoSuchMethodException */ public static Collection describeCollectionExcludeFields(Collection beans, String[] fieldNames) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException { Collection rst = null; if (beans != null) { rst = beans.getClass().newInstance(); for (Object bean : beans) rst.add(describeExcludeFields(bean, fieldNames)); } return rst; }
@SuppressWarnings("unchecked") public void testCreateCollection() throws Exception { Collection<POJO1> collection; collection = mapper.createCollection( POJO1.class, (Class<? extends Collection<?>>) (Class<?>) List.class, 5); assertEquals(ArrayList.class, collection.getClass()); collection = mapper.createCollection( POJO1.class, (Class<? extends Collection<?>>) (Class<?>) Set.class, 5); assertEquals(HashSet.class, collection.getClass()); collection = mapper.createCollection( POJO1.class, (Class<? extends Collection<?>>) (Class<?>) Queue.class, 5); assertEquals(PriorityQueue.class, collection.getClass()); }
private void basicCollectIf(RichIterable<Integer> collection) { Predicate<Integer> greaterThan = Predicates.greaterThan(10000); Collection<String> actual1 = ParallelIterate.collectIf(collection, greaterThan, String::valueOf); Collection<String> actual2 = ParallelIterate.collectIf( collection, greaterThan, String::valueOf, HashBag.<String>newBag(), 3, this.executor, true); Collection<String> actual3 = ParallelIterate.collectIf( collection, greaterThan, String::valueOf, HashBag.<String>newBag(), 3, this.executor, true); Bag<String> expected = collection.collectIf(greaterThan, String::valueOf).toBag(); Verify.assertSize(10000, actual1); Verify.assertNotContains(String.valueOf(9000), actual1); Verify.assertNotContains(String.valueOf(21000), actual1); Verify.assertContains(String.valueOf(15976), actual1); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected, HashBag.newBag(actual1)); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected, actual2); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual3.getClass().getSimpleName(), expected, actual3); }
private Collection cloneCollection() { try { Collection newCol = (Collection) value.getClass().newInstance(); PropertyIterator iter = iterator(); while (iter.hasNext()) { newCol.add(iter.next().clone()); } return newCol; } catch (Exception e) { log.error("Couldn't clone collection", e); return value; } }
private void basicCollect(RichIterable<Integer> iterable) { Collection<String> actual1 = ParallelIterate.collect(iterable, String::valueOf); Collection<String> actual2 = ParallelIterate.collect( iterable, String::valueOf, HashBag.<String>newBag(), 3, this.executor, false); Collection<String> actual3 = ParallelIterate.collect(iterable, String::valueOf, true); RichIterable<String> expected = iterable.collect(String::valueOf); Verify.assertSize(20000, actual1); Verify.assertContains(String.valueOf(20000), actual1); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected, actual1); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected.toBag(), actual2); Assert.assertEquals( expected.getClass().getSimpleName() + '/' + actual3.getClass().getSimpleName(), expected.toBag(), HashBag.newBag(actual3)); }
public void test_for_issue() throws Exception { String jsons = "[[1,1,1,2,3],[2,3,12,3,4],[1],[2]]"; Collection<Collection<Integer>> collections // = JSON.parseObject(jsons, new TypeReference<Collection<Collection<Integer>>>() {}); Assert.assertEquals(4, collections.size()); Assert.assertEquals(ArrayList.class, collections.getClass()); Collection<Integer> firstItemCollection = collections.iterator().next(); Assert.assertEquals(5, firstItemCollection.size()); Assert.assertEquals(ArrayList.class, firstItemCollection.getClass()); }
protected String buildSnippetAssertCollection(String expression, Collection value) { Random r = new Random(); String type = value.getClass().getCanonicalName(); String localVar = "collection_" + Math.abs(r.nextInt()); String newCollection = type + " " + localVar + " = new " + type + "<Object>();\n"; for (Object v : value) { newCollection += "\t" + localVar + ".add(" + printPrimitiveString(v) + ");\n"; } newCollection += "\t" + junitAssertClassName + ".assertEquals(" + localVar + ", " + expression + ");"; return newCollection; }
@SuppressWarnings("unchecked") public void testCollection() { Collection<Integer> collection = new LinkedList<Integer>(); collection.add(1); collection.add(2); collection.add(3); String output = dump(collection); assertEquals("[1, 2, 3]\n", output); Collection<Integer> obj = (Collection<Integer>) load(output); // System.out.println(obj); assertEquals(3, obj.size()); assertTrue( "Create ArrayList by default: " + obj.getClass().toString(), obj instanceof ArrayList); }
protected <K, J extends Set<V>, V> void addToMap(Map<K, J> map, K key, Collection<V> newValues) { J values = map.get(key); if (values == null) { try { values = (J) newValues.getClass().newInstance(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } map.put(key, values); } values.addAll(newValues); }
private void basicFlatCollect(RichIterable<Integer> iterable) { Collection<String> actual1 = ParallelIterate.flatCollect(iterable, INT_TO_TWO_STRINGS); Collection<String> actual2 = ParallelIterate.flatCollect( iterable, INT_TO_TWO_STRINGS, HashBag.<String>newBag(), 3, this.executor, false); Collection<String> actual3 = ParallelIterate.flatCollect(iterable, INT_TO_TWO_STRINGS, true); RichIterable<String> expected1 = iterable.flatCollect(INT_TO_TWO_STRINGS); RichIterable<String> expected2 = iterable.flatCollect(INT_TO_TWO_STRINGS, HashBag.<String>newBag()); Verify.assertContains(String.valueOf(20000), actual1); Assert.assertEquals( expected1.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected1, actual1); Assert.assertEquals( expected2.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected2, actual2); Assert.assertEquals( expected1.getClass().getSimpleName() + '/' + actual3.getClass().getSimpleName(), expected1.toBag(), HashBag.newBag(actual3)); }
// creates set from specified collection with specified permission // all collection elements are verified before adding protected SecureSet(AuthPermission perm, Collection<? extends SST> s) { this(perm); // Subject's constructor receives a Set, we can trusts if a set is // from bootclasspath, // and not to check whether it contains duplicates or not boolean trust = s.getClass().getClassLoader() == null; for (SST o : s) { verifyElement(o); if (trust || !elements.contains(o)) { elements.add(o); } } }
@SuppressWarnings("unchecked") private void bindCollectionAssociation(MutablePropertyValues mpvs, PropertyValue pv) { Object v = pv.getValue(); Collection collection = (Collection) bean.getPropertyValue(pv.getName()); collection.clear(); final Class associatedType = getReferencedTypeForCollection(pv.getName(), getTarget()); final boolean isArray = v != null && v.getClass().isArray(); final PropertyEditor propertyEditor = findCustomEditor(collection.getClass(), pv.getName()); if (propertyEditor == null) { if (isDomainAssociation(associatedType)) { if (isArray) { Object[] identifiers = (Object[]) v; for (Object id : identifiers) { if (id != null) { associateObjectForId(pv, id, associatedType); } } mpvs.removePropertyValue(pv); } else if (v != null && (v instanceof String)) { associateObjectForId(pv, v, associatedType); mpvs.removePropertyValue(pv); } } else if (GrailsDomainConfigurationUtil.isBasicType(associatedType)) { if (isArray) { Object[] values = (Object[]) v; List list = collection instanceof List ? (List) collection : null; for (int i = 0; i < values.length; i++) { Object value = values[i]; try { Object newValue = getTypeConverter().convertIfNecessary(value, associatedType); if (list != null) { if (i > list.size() - 1) { list.add(i, newValue); } else { list.set(i, newValue); } } else { collection.add(newValue); } } catch (TypeMismatchException e) { // ignore } } } } } }
@Test public void testFilter() { List<String> list = newTestList(); Collection<String> filtered = filter( list, new Predicate<String>() { @Override public Boolean apply(String s) { return "one".equals(s); } }); assertSame(filtered.getClass(), list.getClass()); assertEquals(2, list.size()); assertEquals(1, filtered.size()); assertTrue(filtered.contains("one")); }
public static void testaAdicionarNaColecao(Collection colecao, int quantidade) { long inicio = System.currentTimeMillis(); for (int i = 0; i < quantidade; i++) { colecao.add("Objeto " + i); } long termino = System.currentTimeMillis(); System.out.println( "Tempo para adicionar " + quantidade + " objetos na " + colecao.getClass().getSimpleName() + " foram : " + (termino - inicio) + " Milisegundos"); }
// once-per-game initialization private void initOnce() { initialized = true; log.info("initOnce()"); visualizerService.newRun(); // registrations for message listeners: Collection<MessageHandler> handlers = context.getBeansOfType(MessageHandler.class).values(); for (MessageHandler handler : handlers) { log.debug("initializing..." + handler.getClass().getName()); handler.initialize(); } Collection<DomainRepo> repos = context.getBeansOfType(DomainRepo.class).values(); for (DomainRepo repo : repos) { log.debug("recycling..." + repos.getClass().getName()); repo.recycle(); } }
@Test public void testFlatMap() { List<String> list = newTestList(); Collection<String> mapped = flatMap( list, new Function<String, Collection<String>>() { @Override public Collection<String> apply(String s) { return list(">", s); } }); assertSame(mapped.getClass(), list.getClass()); assertEquals(2, list.size()); assertEquals(4, mapped.size()); assertTrue(mapped.contains(">")); assertTrue(mapped.contains("one")); assertTrue(mapped.contains("two")); }
@Test public void get() throws InterruptedException { HazelcastClient hClient = getHazelcastClient(); MultiMap<String, Integer> multiMap = hClient.getMultiMap("get"); assertTrue(multiMap.put("a", 1)); assertTrue(multiMap.put("a", 2)); Map<Integer, CountDownLatch> map = new HashMap<Integer, CountDownLatch>(); map.put(1, new CountDownLatch(1)); map.put(2, new CountDownLatch(1)); Collection<Integer> collection = multiMap.get("a"); assertEquals(Values.class, collection.getClass()); assertEquals(2, collection.size()); for (Iterator<Integer> it = collection.iterator(); it.hasNext(); ) { Integer o = it.next(); map.get(o).countDown(); } assertTrue(map.get(1).await(10, TimeUnit.SECONDS)); assertTrue(map.get(2).await(10, TimeUnit.SECONDS)); }
@Test public void testMap() { List<String> list = newTestList(); Collection<String> mapped = map( list, new Function<String, String>() { @Override public String apply(String s) { return s + s; } }); assertSame(mapped.getClass(), list.getClass()); assertTrue(list.contains("one")); assertTrue(list.contains("two")); assertTrue(mapped.contains("oneone")); assertTrue(mapped.contains("twotwo")); assertEquals(2, list.size()); assertEquals(2, mapped.size()); }
// fail with helpful message if e.g. we are asserting a Set .equals a List private static void compatibleCollections(Collection a, Collection b) { if (a.getClass().isAssignableFrom(b.getClass()) || b.getClass().isAssignableFrom(a.getClass())) { TestCase.assertEquals(a, b); } else { TestCase.fail( "Collections are of incompatible types: " + a.getClass() + " (" + a.toString() + ") and " + b.getClass() + " (" + b.toString() + ")."); } }
/** * Implementation of the OCL * * <ul> * <li><tt>Set::excluding(object : T) : Set(T)</tt> * <li><tt>Bag::excluding(object : T) : Bag(T)</tt> * <li><tt>Sequence::excluding(object : T) : Sequence(T)</tt> * </ul> * * operations. * * @param self the source collection * @param object an object * @return the source collection without any occurences of the object */ public static <E> Collection<E> excluding(Collection<E> self, Object object) { Collection<E> result = null; if (self instanceof LinkedHashSet<?>) { result = createNewOrderedSet(self); } else if (self instanceof Set<?>) { result = createNewSet(self); } else if (self instanceof Bag<?>) { result = createNewBag(self); } else if (self instanceof List<?>) { List<E> resultSeq = createNewSequence(self); while (resultSeq.remove( object)) {; // for sequences we need to remove all the matching elements } return resultSeq; } else { throw new RuntimeException( "Unsupported collection type " + self.getClass().getName()); // $NON-NLS-1$ } // non-sequences (bags remove all occurrences internally) result.remove(object); return result; }
DeltaAnalysisRunnable( LibrarySource librarySource, URI unitUri, Map<URI, String> suppliedSources, DartUnit suppliedUnit, DartNode completionNode, int completionLocation, Collection<DartCompilationError> parseErrors) { super(parseErrors); librarySource.getClass(); // quick null check unitUri.getClass(); // quick null check suppliedSources.getClass(); // quick null check suppliedUnit.getClass(); // quick null check completionNode.getClass(); // quick null check parseErrors.getClass(); // quick null check this.librarySource = new LibraryWithSuppliedSources(librarySource, suppliedSources); this.parsedUnit = suppliedUnit; this.completionNode = completionNode; this.completionLocation = completionLocation; String sourceString = suppliedSources.get(unitUri); this.source = new DartSourceString(unitUri.getPath(), sourceString); this.unitUri = unitUri; }
@SuppressWarnings("unchecked") protected Collection convertToTypedCollection( Collection original, String propertyName, Class requiredType, TypeDescriptor typeDescriptor) { boolean originalAllowed = requiredType.isInstance(original); if (!originalAllowed && !Collection.class.isAssignableFrom(requiredType)) { return original; } MethodParameter methodParam = typeDescriptor.getMethodParameter(); Class elementType = null; if (methodParam != null) { elementType = GenericCollectionTypeResolver.getCollectionParameterType(methodParam); } if (elementType == null && originalAllowed && !this.propertyEditorRegistry.hasCustomEditorForElement(null, propertyName)) { return original; } Iterator it; try { it = original.iterator(); if (it == null) { if (logger.isDebugEnabled()) { logger.debug( "Collection of type [" + original.getClass().getName() + "] returned null Iterator - injecting original Collection as-is"); } return original; } } catch (Throwable ex) { if (logger.isDebugEnabled()) { logger.debug( "Cannot access Collection of type [" + original.getClass().getName() + "] - injecting original Collection as-is", ex); } return original; } Collection convertedCopy; try { if (CollectionFactory.isApproximableCollectionType(requiredType)) { convertedCopy = CollectionFactory.createApproximateCollection(original, original.size()); } else { convertedCopy = (Collection) requiredType.newInstance(); } } catch (Throwable ex) { if (logger.isDebugEnabled()) { logger.debug( "Cannot create copy of Collection type [" + original.getClass().getName() + "] - injecting original Collection as-is", ex); } return original; } int i = 0; for (; it.hasNext(); i++) { Object element = it.next(); String indexedPropertyName = buildIndexedPropertyName(propertyName, i); if (methodParam != null) { methodParam.increaseNestingLevel(); } Object convertedElement = convertIfNecessary(indexedPropertyName, null, element, elementType, typeDescriptor); if (methodParam != null) { methodParam.decreaseNestingLevel(); } try { convertedCopy.add(convertedElement); } catch (Throwable ex) { if (logger.isDebugEnabled()) { logger.debug( "Collection type [" + original.getClass().getName() + "] seems to be read-only - injecting original Collection as-is", ex); } return original; } originalAllowed = originalAllowed && (element == convertedElement); } return (originalAllowed ? original : convertedCopy); }
public static void main(String[] args) throws Exception { // 第1点:Java的泛型仅仅只是通用Java的编译器实现的,进行全安检查,编译成class文件后没有保留泛型信息 Collection<Integer> c1 = new ArrayList<Integer>(); Collection<String> c2 = new ArrayList<String>(); // 1.1 获取c1与c2的字节码看是否相同 System.out.println("c1与c2的字节码是否相同:" + (c1.getClass() == c2.getClass())); // true c1.add(23); // 1.2 通用反射我们可以向c1中添加String类型的数据(class文件没有任何泛型) Class clazz = c1.getClass(); Method collAddMethod = clazz.getMethod("add", Object.class); collAddMethod.invoke(c1, "http://zmx.iteye.com"); for (Object obj : c1) { System.out.println(obj); } // 泛型中的?通配符:表示任何类型,它与Object是有区别的如下所示: // collection1可以存放任保类型,而collection2则只能放在Object类型 Collection<?> collection1 = new ArrayList<String>(); collection1 = new ArrayList<Integer>(); collection1 = new ArrayList<Object>(); Collection<Object> collection2 = new ArrayList<Object>(); // 泛型中的向上或向下限定 // collection3表示它可以存放Number或Number的子类 Collection<? extends Number> collection3 = null; collection3 = new ArrayList<Number>(); collection3 = new ArrayList<Double>(); collection3 = new ArrayList<Long>(); // collection4表示它可以存放Integer或Integer的父类 Collection<? super Integer> collection4 = null; collection4 = new ArrayList<Object>(); // 泛型简单使用(Map.Entry是Map的一个内部类,表法Map中存在的一个对象) Map<String, Integer> testMap = new HashMap<String, Integer>(); testMap.put("xiaobojava", 2); testMap.put("mengya", 3); testMap.put("zmx", 6); Set<Map.Entry<String, Integer>> entrySet = testMap.entrySet(); for (Map.Entry<String, Integer> entry : entrySet) { System.out.println(entry.getKey() + ":" + entry.getValue()); } // 自定义泛型 String[] a = {"aa", "bb", "cc"}; swap(a, 1, 2); Integer[] b = {32, 45, 67}; swap(b, 1, 2); // 泛型中的类型不能为基本数据类型(如下就不行) int[] c = {1, 3, 5}; // swap(c,1,2); Vector<Date> v1 = new Vector<Date>(); // 由于泛型是由编译器实现的语法检查,编译成class文件后没有保留泛型信息,但可以根据Method获取 Method applyMethod = GenericStudy.class.getMethod("applyVector", Vector.class); // getGenericParameterTypes()按照声明顺序返回 Type 对象的数组,这些对象描述了此 Method // 对象所表示的方法的形参类型的。 Type[] type = applyMethod.getGenericParameterTypes(); // ParameterizedType extends Type ParameterizedType pType = (ParameterizedType) type[0]; // applyVector只用一个参数 // getRawType()返回 Type 对象,表示声明此类型的类或接口 System.out.println("getRawType()方法:表示声明此类型的类或接口是:" + pType.getRawType()); // getActualTypeArguments()返回表示此类型实际类型参数的 Type 对象的数组。 System.out.println( "getActualTypeArguments()方法:实际类型参数的 Type 对象" + pType.getActualTypeArguments()[0]); // Vector<Date>只用一个Date类型 }
/** * Convert an Object to a Collection with elements of the desired type. If it is a Collection and * it is of the same collection and element type it is returned as is, otherwise a new Collection * is created with all elements converted to the desired type. If it is a String representation of * a Collection it is converted to a Collection. * * @param <E> The element type. * @param <C> The Collection type. * @param obj The Object to be converted. * @param collectionType The desired Collection type. * @param elementType The desired element type. * @param emptyIfNull Whether or not an empty Collection should be returned if the Collection * could not be converted. * @return The converted Collection. */ public <E, C extends Collection<E>> C convertToCollection( Object obj, Class<C> collectionType, Class<E> elementType, boolean emptyIfNull) { // Grab defaults for types if interfaces or non-datareference collections are provided Class<? extends C> constructionCollectionType; Class<? extends E> constructionElementType; if (collectionType.equals(List.class)) { if (DataReferencable.class.isAssignableFrom(elementType)) { constructionCollectionType = (Class) DataReferenceList.class; constructionElementType = (Class) DataReference.class; } else { constructionCollectionType = (Class) ArrayList.class; } } else if (collectionType.equals(Set.class)) { if (DataReferencable.class.isAssignableFrom(elementType)) { constructionElementType = (Class) DataReference.class; throw new IllegalArgumentException( "Set class is not supported for DataReferencable elements"); } constructionCollectionType = (Class) HashSet.class; } else { constructionCollectionType = collectionType; } if (obj != null) { if (obj instanceof Collection) { // If it's already a collection Collection collection = (Collection) obj; Class cachedElementType = getCachedElementType(collection); // If we have cached it's element type return if same if (cachedElementType != null && elementType.isAssignableFrom(cachedElementType) && collection.getClass().equals(constructionCollectionType)) { setCachedElementType(collection, elementType); return (C) collection; } else { return _convertContents(collection, constructionCollectionType, elementType); } } else { try { // If it's a single value convertable to E E e = convert(obj, elementType); C c = CollectionUtils.instanceOf(constructionCollectionType); c.add(e); return c; } catch (ConversionException ex) { } try { // If it's a string representation of one or many E's String string = convert(obj, String.class); String[] split = TextUtils.splitOnSpacesAndCommas(string); C c = CollectionUtils.instanceOf(constructionCollectionType); for (String str : split) { try { E e = convert(obj, elementType); c.add(e); } catch (ConversionException ex) { } } if (!c.isEmpty()) { return c; } } catch (ConversionException ex) { } } } // Fall through to here if a collection could not be converted for any reason if (emptyIfNull) { return CollectionUtils.instanceOf(constructionCollectionType); } else { return null; } }
static void f1(Holder<List<?>> holder) { System.out.println("Calling methods for the Holder: "); System.out.println("holder: " + holder); System.out.println("holder.get(): " + holder.get()); System.out.println("Calling holder.set(Arrays.asList(1,2,3)"); holder.set(Arrays.asList(1, 2, 3)); System.out.println("holder.get(): " + holder.get()); int[] ia = {1, 2, 3}; System.out.println("int[] ia = {1,2,3}"); System.out.println("holder.equals(ia): " + holder.equals(ia)); List iaList = Arrays.asList(ia); System.out.println("List iaList = Arrays.asList(ia)"); System.out.println("holder.equals(iaList): " + holder.equals(iaList)); List<Integer> l = new ArrayList<Integer>(); for (int i = 1; i < 4; i++) l.add(i); System.out.println("l = List<Integer>() and add 1,2,3"); System.out.println("holder.equals(l): " + holder.equals(l)); System.out.println(); System.out.println("Calling methods for the List: "); System.out.println("holder.get(): " + holder.get()); System.out.println("holder.get().getClass(): " + holder.get().getClass()); // Incompatible types: // List<? extends Integer> list = holder.get(); // OK, but can't add anything: List<?> list = holder.get(); System.out.println("list: " + list); // list.add(new Object()); List list1 = holder.get(); // OK, but: // list1.add(new Object()); // Warning: unchecked call to add(E) and // UnsupportedOperationException at runtime System.out.println("list1.getClass(): " + list1.getClass()); System.out.println("list.equals(list1): " + list.equals(list1)); // list.clear(); // runtime UnsupportedOperationException System.out.println("list.contains(1): " + list.contains(1)); Collection<Integer> c = new HashSet<Integer>(); for (int i = 1; i < 4; i++) c.add(i); System.out.println("list.containsAll(c): " + list.containsAll(c)); System.out.println("list.equals(c): " + list.equals(c)); System.out.println("list = " + list); System.out.println("c = " + c); System.out.println("c.getClass(): " + c.getClass()); // c is not a List System.out.println("list.get(0) = " + list.get(0)); System.out.println("list.hashCode() = " + list.hashCode()); System.out.println("list.indexOf(2) = " + list.indexOf(2)); ListIterator li = list.listIterator(); System.out.println("After ListIterator li = list.listIterator():"); System.out.println("li.next() = " + li.next()); // runtime errors: UnsupportedOperationException: // list.remove(0); // list.removeAll(c); // list.retainAll(c1); // list.set(1,4); // compile error: set(int, ?) in list<?> cannot // be applied to (int,int) System.out.println("list.size() = " + list.size()); System.out.println("list.subList(1,2) = " + list.subList(1, 2)); Object[] oa = list.toArray(); System.out.println("After Object[] oa = list.toArray():"); System.out.println("oa = "); for (Object o : oa) System.out.print(o + " "); System.out.println(); // Error: runtime error ArrayStoreException: // Double[] da = list.toArray(new Double[3]); Number[] na = list.toArray(new Number[3]); System.out.println("After Number[] na = list.toArray(new Number[3]):"); System.out.println("na = "); for (Number n : na) System.out.print(n + " "); System.out.println(); }