Java - Revision history

Admin: /* Flags */

2019-03-12T16:01:31Z

Flags

← Older revision		Revision as of 16:01, 12 March 2019
Line 215:		Line 215:
	=Flags=		=Flags=

	{{~~JavaFlag~~}}		{{CSFlag}}

Admin: /* Lambdas for Comparators */

2019-03-12T16:00:31Z

Lambdas for Comparators

← Older revision	Revision as of 16:00, 12 March 2019
Line 212:	Line 212:



		=Flags=

		{{JavaFlag}}

Admin: /* Assorted Advanced Features */

2019-03-12T16:00:18Z

Assorted Advanced Features

← Older revision		Revision as of 16:00, 12 March 2019
Line 182:		Line 182:
	A "cheap" way to get this without the use of generics (older versions of Java) was to store underlying objects in an Object[] array, and let the type of object be determined at runtime.		A "cheap" way to get this without the use of generics (older versions of Java) was to store underlying objects in an Object[] array, and let the type of object be determined at runtime.

	An example, demonstrated by implementing an array-based, Python-list-like Java object, is here: https://charlesreid1.com~~:3000~~/cs/java/src/master/arrays/python-list/PythonList.java		An example, demonstrated by implementing an array-based, Python-list-like Java object, is here: https://git.charlesreid1.com/cs/java/src/master/arrays/python-list/PythonList.java

	This does not use templating, and illustrates the Object[] array notation/approach.		This does not use templating, and illustrates the Object[] array notation/approach.
Line 192:		Line 192:
	The "new" way to do it in recent versions of Java is to work like a Collections object, using the diamond notation. When the class is defined, a type <T> can be specified as a "template" type, in place of the generic Object class.		The "new" way to do it in recent versions of Java is to work like a Collections object, using the diamond notation. When the class is defined, a type <T> can be specified as a "template" type, in place of the generic Object class.

	An example of this is here, in a generics/templated linked list: https://charlesreid1.com~~:3000~~/cs/java/src/master/lists/linked-lists/TList.java		An example of this is here, in a generics/templated linked list: https://git.charlesreid1.com/cs/java/src/master/lists/linked-lists/TList.java

	<pre>		<pre>

Admin: /* Measuring Performance of Java Code */

2018-01-07T09:06:53Z

Measuring Performance of Java Code

← Older revision		Revision as of 09:06, 7 January 2018
Line 53:		Line 53:

	See [[Java/Profiling]] and [[Java/Timing]]		See [[Java/Profiling]] and [[Java/Timing]]

			Also see [[Java/Memory]] for memory profiling

	=Easily Reading from Input Files=		=Easily Reading from Input Files=

Admin: /* Exceptions */

2017-06-01T06:12:28Z

Exceptions

← Older revision		Revision as of 06:12, 1 June 2017
Line 158:		Line 158:

	Useful link: http://www.javamex.com/tutorials/exceptions/exceptions_unchecked.shtml		Useful link: http://www.javamex.com/tutorials/exceptions/exceptions_unchecked.shtml

			==Interfaces==

			See [[Java/Interfaces]]

			Collections interface and Iterable interface are two common interfaces in Java API:
			* https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html
			* https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html

			Example of class that uses these: List class
			* https://docs.oracle.com/javase/8/docs/api/java/util/List.html

	=Assorted Advanced Features=		=Assorted Advanced Features=

Admin: /* New (diamond notation) approach */

2017-06-01T05:51:13Z

New (diamond notation) approach

← Older revision		Revision as of 05:51, 1 June 2017
Line 178:		Line 178:

	The "new" way to do it in recent versions of Java is to work like a Collections object, using the diamond notation. When the class is defined, a type <T> can be specified as a "template" type, in place of the generic Object class.		The "new" way to do it in recent versions of Java is to work like a Collections object, using the diamond notation. When the class is defined, a type <T> can be specified as a "template" type, in place of the generic Object class.

			An example of this is here, in a generics/templated linked list: https://charlesreid1.com:3000/cs/java/src/master/lists/linked-lists/TList.java

	<pre>		<pre>

	public class MyContainer<T> {		public class MyContainer<T> {

Line 188:		Line 189:

	// .....blah blah blah.....		// .....blah blah blah.....

	}		}
	</pre>		</pre>

Admin at 05:50, 1 June 2017

2017-06-01T05:50:22Z

← Older revision		Revision as of 05:50, 1 June 2017
Line 1:		Line 1:
	Cool: http://www.ibm.com/developerworks/library/j-robots/index.html		Cool: http://www.ibm.com/developerworks/library/j-robots/index.html

			More cool: http://www.javamex.com/tutorials/exceptions/exceptions_uncaught_handler.shtml#

	=Getting Started=		=Getting Started=

Admin: /* Generics */

2017-06-01T05:44:25Z

Generics

← Older revision		Revision as of 05:44, 1 June 2017
Line 159:		Line 159:
	=Assorted Advanced Features=		=Assorted Advanced Features=

	==Generics==		==Generics in Java==

	Generics involve designing a data structure or class that takes an object of arbitrary type.		Generics involve designing a data structure or class that takes an object of arbitrary type. Java provides the "old" way to do it, and the "new" way to do it.

			===Old (object array) approach===

	A "cheap" way to get this without the use of generics (older versions of Java) was to store underlying objects in an Object[] array, and let the type of object be determined at runtime.		A "cheap" way to get this without the use of generics (older versions of Java) was to store underlying objects in an Object[] array, and let the type of object be determined at runtime.
Line 169:		Line 171:
	This does not use templating, and illustrates the Object[] array notation/approach.		This does not use templating, and illustrates the Object[] array notation/approach.

	This leads to difficulties with consistent typing of collections of data. Hence the diamond notation introduced in (relatively) recent versions of Java. When the class is defined, a type <T> can be specified as a "template" type, in place of the generic Object class.		This leads to difficulties with consistent typing of collections of data. Hence the diamond notation introduced in (relatively) recent versions of Java.

			===New (diamond notation) approach===

			The "new" way to do it in recent versions of Java is to work like a Collections object, using the diamond notation. When the class is defined, a type <T> can be specified as a "template" type, in place of the generic Object class.

	<pre>		<pre>

	public class MyContainer<T> {		public class MyContainer<T> {

Admin: /* Generics */

2017-06-01T05:43:01Z

Generics

@@ Line 163: / Line 163: @@
 Generics involve designing a data structure or class that takes an object of arbitrary type.
-A "cheap" way to get this without the use of generics (older versions of Java) was to store underlying objects in an Object[] array, and let the type of object be determined at runtime. This led to difficulties with consistent typing of collections of data. Hence the diamond notation introduced in (relatively) recent versions of Java.
+A "cheap" way to get this without the use of generics (older versions of Java) was to store underlying objects in an Object[] array, and let the type of object be determined at runtime.
-When the class is defined, a type <T> can be specified as a "template" type, in place of the generic Object class.
+An example, demonstrated by implementing an array-based, Python-list-like Java object, is here: https://charlesreid1.com:3000/cs/java/src/master/arrays/python-list/PythonList.java
 ==Decorators==

Admin: /* Generics */

2017-06-01T05:41:07Z

Generics

← Older revision		Revision as of 05:41, 1 June 2017
Line 164:		Line 164:

	A "cheap" way to get this without the use of generics (older versions of Java) was to store underlying objects in an Object[] array, and let the type of object be determined at runtime. This led to difficulties with consistent typing of collections of data. Hence the diamond notation introduced in (relatively) recent versions of Java.		A "cheap" way to get this without the use of generics (older versions of Java) was to store underlying objects in an Object[] array, and let the type of object be determined at runtime. This led to difficulties with consistent typing of collections of data. Hence the diamond notation introduced in (relatively) recent versions of Java.

			When the class is defined, a type <T> can be specified as a "template" type, in place of the generic Object class.

	==Decorators==		==Decorators==