If you need different behaviour when you’re dealing with a value-type then you’re obviously going to need to perform some kind of test. You don’t need an explicit check for boxed value-types, since all value-types will be boxed** due to the parameter being typed as object. This code should meet your stated criteria: If value … Read more
I first tought your question was a dupe of What code does the compiler generate for autoboxing? However, after your comment on @ElliottFrisch I realized it was different : I know the compiler behaves that way. I’m trying to figure out whether that behavior is guaranteed. For other readers, assume that “behaves that way” means … Read more
No, it does not exist. Actually, it was explicitly not implemented so as not to clutter the Stream API with tons of classes for every primitive type. Quoting a mail from Brian Goetz in the OpenJDK mailing list: Short answer: no. It is not worth another 100K+ of JDK footprint each for these forms … Read more
I guess (or at least it is an alternative) this way is more performant: public static IntStream baz(List<Integer> list) { return list.stream().mapToInt(Integer::intValue); } since the function Integer::intValue is fully compatible with ToIntFunction since it takes an Integer and it returns an int. No autoboxing is performed. I was also looking for an equivalent of Function::identity, … Read more
When it comes to collections, generics make it possible to avoid boxing/unboxing by utilizing actual T[] arrays internally. List<T> for example uses a T[] array to store its contents. The array, of course, is a reference type and is therefore (in the current version of the CLR, yada yada) stored on the heap. But since … Read more
This is similar to answers posted here, but uses expression trees to emit il to cast between types. Expression.Convert does the trick. The compiled delegate (caster) is cached by an inner static class. Since source object can be inferred from the argument, I guess it offers cleaner call. For e.g. a generic context: static int … Read more
Boxing refers to a conversion of a non-nullable-value type into a reference type or the conversion of a value type to some interface that it implements (say int to IComparable<int>). Further, the conversion of an underlying value type to a nullable type is also a boxing conversion. (Caveat: Most discussions of this subject will ignore … Read more
The Short Answer The key point is this: == between two reference types is always reference comparison More often than not, e.g. with Integer and String, you’d want to use equals instead == between a reference type and a numeric primitive type is always numeric comparison The reference type will be subjected to unboxing conversion … Read more
That’s a great question! Boxing occurs for exactly one reason: when we need a reference to a value type. Everything you listed falls into this rule. For example since object is a reference type, casting a value type to object requires a reference to a value type, which causes boxing. If you wish to list … Read more
byte[] to Byte[] : byte[] bytes = …; Byte[] byteObject = ArrayUtils.toObject(bytes); Byte[] to byte[] : Byte[] byteObject = new Byte[0]; byte[] bytes = ArrayUtils.toPrimitive(byteObject);