Contest Algorithms January 2016 Look at some features of Java used in many competition problems. 2....

Contest AlgorithmsJanuary 2016

Look at some features of Java used in many competition problems.

2. Java Features

Contest Algorithms: 2. Java Features

1. Multi-dimensional Arrays 2. Arrays class: sort, binary search, comparators 3. Strings 4. Regular Expressions 5. Bitwise Ops

Overview

Use a two-dimensional array to represent a matrix or a table.

1. Multi-dimensional Arrays (2D/3D)

An array is the fastest way to do random access to data

But an array's size is fixed If it runs out of space, you have to create a new array and

copy everything over, which is slow

Array Features

Contest Algorithms 5

import java.io.*;import java.util.*;

public class UseGraph // use Main in contests{ public static void main(String[] args) throws Exception { Scanner sc = new Scanner(System.in); // Scanner sc = new Scanner(new File("graphData.txt")); // for testing

int numVs = sc.nextInt(); int[][] adjMat = new int[numVs][]; // use numVs as no. of rows for (int i = 0; i < numVs; i++) { adjMat[i] = new int[numVs]; // create ith row array for (int j = 0; j < numVs; j++) // fill row adjMat[i][j] = sc.nextInt(); } :

Fill an Integer Matrix see UseGraph.javain Part 1

Two-dimensional Arrays

0 1 2 3 4

1 2 3 4

0 1 2 3 4 matrix[2][1] = 7;

matrix = new int[5][5];

int[][] array = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12} };

array.length == 4

array[0].length == 3

matrix.length == 5

matrix[0].length == 5

no. rows

no. columns

int[][] array = new int[4][3];array[0][0] = 1; array[0][1] = 2; array[0][2] = 3; array[1][0] = 4; array[1][1] = 5; array[1][2] = 6; array[2][0] = 7; array[2][1] = 8; array[2][2] = 9; array[3][0] = 10; array[3][1] = 11; array[3][2] = 12;

int[][] array = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};

int[][] x = new int[3][4];

Lengths of Two-dimensional Arrays

x[0][0] x[0][1] x[0][2] x[0][3] x[1][0] x[1][1] x[1][2] x[1][3] x[2][0] x[2][1] x[2][2] x[2][3]

x.length is 3

x[0].length is 4

x[1].length is 4

x[2].length is 4

int[][] array = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};

array.lengtharray[0].lengtharray[1].lengtharray[2].lengtharray[3].length

array[4].length ArrayIndexOutOfBoundsException

Each row in a two-dimensional array is itself an array. So, the rows can have different lengths. Such an array is known as a ragged array.

int[][] matrix = { {1, 2, 3, 4, 5}, {2, 3, 4, 5}, {3, 4, 5}, {4, 5}, {5}};

Ragged Arrays

matrix.length is 5matrix[0].length is 5matrix[1].length is 4matrix[2].length is 3matrix[3].length is 2matrix[4].length is 1

1 2 3 4 5

int[][] triangleArray = { {1, 2, 3, 4, 5}, {2, 3, 4, 5}, {3, 4, 5}, {4, 5}, {5} };

1 2 3 4 1 2 3 1 2 1 2

for (int row = 0; row < matrix.length; row++) { for (int col = 0; col < matrix[row].length; col++) matrix[row][col] = (int)(Math.random() * 100);}

Initializing arrays with random values

int total = 0;for (int row = 0; row < matrix.length; row++) { for (int col = 0; col < matrix[row].length; col++) total += matrix[row][col];}

Summing all elements

for (int col = 0; col < matrix[0].length; col++) { int total = 0; for (int row = 0; row < matrix.length; row++) total += matrix[row][col]; System.out.println("Sum for column " + col + " is " + total);}

Summing elements by column

for (int i = 0; i < matrix.length; i++) { for (int j = 0; j < matrix[i].length; j++) { int i1 = (int)(Math.random() * matrix.length); int j1 = (int)(Math.random() * matrix[i].length); // Swap matrix[i][j] with matrix[i1][j1] int temp = matrix[i][j]; matrix[i][j] = matrix[i1][j1]; matrix[i1][j1] = temp; }}

Random shuffling

double[][][] scores = new double[10][5][2];

Three-dimensional Arrays

Matrix.java contains methods for creating 2D matricies of doubles, adding, multiplying, taking powers, etc.

Also Gaussian Elimination

Basic Matrix Functions

see Matrix.java

Matrix(int M, int N)Matrix(double[][] data)Matrix(double[] arr, int side)

int getRows()int getCols()double[][] getData()

void setElem(int i, int j, double val)double getElem(int i, int j)

Matrix transpose()Matrix add(Matrix B)Matrix subtract(Matrix B)boolean eq(Matrix B)Matrix multiply(Matrix B)Matrix power(long exp)double[] flatten()Matrix solve(Matrix rhs)void print()

// static methodsMatrix random(int M, int N)Matrix identity(int N)

public static void main(String[] args) { double[][] d = { { 1, 2, 3 }, { 4, 5, 6 }, { 9, 1, 3} }; Matrix D = new Matrix(d); D.print(); System.out.println("Value at (0,1): " + D.getElem(0,1));

Matrix A = Matrix.random(5, 5); A.print();

Matrix B = A.transpose(); B.print();

Matrix C = Matrix.identity(5); C.print();

A.add(B).print(); B.multiply(A).print();

// shouldn't be equal since AB != BA in general System.out.println( A.multiply(B).eq(B.multiply(A)) );

Matrix b = Matrix.random(5, 1); b.print(); Matrix x = A.solve(b); x.print(); A.multiply(x).print(); } // end of main()

There's also a less fully-featured boolean matrix class see BoolMat.java

It illustrates how to implement 'add' and 'multiply' for boolean values

'add' uses boolean OR (||) multiply uses boolean AND (&&)

Boolean Matrix

A set of static utility methods fill(): fill an array with a value equals(): compare two arrays for equality

Probably most useful are:

2. Arrays class

static void sort(Object [] a);

static void sort(Object [] a, Comparator c);

static int binarySearch(Object [] a, Object key);

static int binarySearch(Object [] a, Object key, Comparator c)

Sorts the objects into ascending order A stable sort:

equal elements are not reordered You can specify a range

fromIndex to toIndex-1 The objects need to have a Comparator class

or implement Comparable

Arrays.sort() see GenericSorting.java

interface COMPARATOR<T> java.util

Methods

int compare(T x, T y) Compares its two arguments for order. Returns a negative integer, zero, or a positive integer to specify that x is less than, equal to, or greater than y.

boolean equals(Object obj) Returns true if this object equals obj and false otherwise.

The Comparator Interface

continued

Comparing Circlespublic class Circle{ private double xCenter, yCenter; private double radius;

public Circle(double x, double y, double r) { xCenter = x; yCenter = y; radius = r; }

public double getX() { return xCenter; }

see Circle.java

public double getY() { return yCenter; }

public double getRadius() { return radius; }

public double getArea() { return Math.PI * radius * radius; }

: // more methods, but no comparison function

} // end of Circle class

Comparing Circle Radiipublic class RadiiComp implements Comparator<Circle>{ public int compare(Circle c1, Circle c2) { double radC1 = c1.getRadius(); double radC2 = c2.getRadius();

// returns < 0 if radC1 < radC2, // 0 if radC1 == radC2, // > 0 if radC1 > radC2 return (int)(radC1 – radC2); } // end of compare()

// equals() is inherited from Object superclass

} // end of RadiiComp class

see RadiiComp.java

Comparing Circle Positionspublic class DistComp implements Comparator<Circle>{ public int compare(Circle c1, Circle c2) { double c1Dist = (c1.getX() * c1.getX()) + (c1.getY() * c1.getY()); double c2Dist = (c2.getX() * c2.getX()) + (c2.getY() * c2.getY());

// returns < 0 if c1Dist < c2Dist, // 0 if c1Dist == c2Dist, // > 0 if c1Dist > c2Dist return (int)(c1Dist - c2Dist); } // end of compare()

// equals() is inherited from Object superclass} // end of DistComp class

see DistComp.java

Comparing Circles in Two WaysCircle c1 = new Circle(0, 0, 5); // (x,y),rCircle c2 = new Circle(3, 2, 7);

RadiiComp rComp = new RadiiComp();if (rComp.compare(c1, c2) < 0) System.out.println("Circle 1 is smaller than circle 2");

DistComp dComp = new DistComp();if (dComp.compare(c1, c2) < 0) System.out.println("Circle 1 is nearer to origin than circle 2");

Circle 1 is smaller than circle 2Circle 1 is nearer to origin than circle 2

see UseCircles.java

// sort(Object [] a, Comparator c)Circle[] circles = // ... add circle objects;

Arrays.sort(circles, new RadiiComp()); // circles will be sorted by ascending radii

Arrays.sort(circles, new DistComp()); // circles will be sorted by ascending distance from origin

Sorting Circlessee UseCircles.java

static int binarySearch(Object [] a, Object key)static int binarySearch(Object [] a, Object key, Comparator c) Only usable on a sorted array If there are multiple equal elements, there is no

guarantee which one will be found Returns:

Index if found the key (-(insertion point) - 1) if key not found

Array.binarySearch()

int[] values = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

int index = Arrays.binarySearch(values, 8); // find '8'

System.out.println("Index = " + index);

System.out.println("Value = " + values[index]);

OutputIndex = 7

Value = 8

Examples

int[] values = { 0, 2, 4, 8 };int index = Arrays.binarySearch(values, 400); // no such valueSystem.out.println(index);

Output-5 // -4 -1

Circle[] circles = // ... add circle objectsArrays.sort(circles, new DistComp()); // must be sorted before search

Circle c = new Circle(0, 0, 3); // (x,y),r

int idx = Arrays.binarySearch(circles, c, new DistComp()); // will try to find a circle that is same distance from origin as c

Search for a Circlesee UseCircles.java

The Comparable Interface

The Comparable<T> interface is another way to compare objects.

The interface defines a single method:

public interface Comparable<T>{ int compareTo(T item); }

compareTo() Meaning

compareTo() should return an integer that is negative, 0, or positive.

Meaning: obj.compareTo(item) < 0 when obj < item obj.compareTo(item) == 0 when obj == item obj.compareTo(item) > 0 when obj > item

Time24 Class with Comparablepublic class Time24 implements Comparable<Time24>{ . . . public int compareTo(Time24 item) //compares times { int time = hour*60 + minute; // use minutes int ttime = item.hour*60 + item.minute;

// compare, returning -1, 0, or 1 if (time < ttime) return -1; else if (time == ttime) return 0; else return 1; }}

Time24 t1 = new Time24(12,30);Time24 t2 = new Time24(15,10);int res = t1.compareTo(t2); // -1

see Time24.java

Comparator vs. Comparable

• Comparator.compare(T x, T y) comparison is done between two objects, x and y the method is implemented outside the T class

• Comparable.compareTo(T y) comparison is done between 'this' object and object y the method is implemented by the T class

Benefits of Comparator

The comparison code is in a separate place from the other code for a class.

1. This means that the same objects can be compared in different ways by defining different Comparators

see the two comparators for circles

String message = new String("Welcome to Java");

String message = "Welcome to Java";

3. Strings

Escape Characters

How can you make a String that has quotes? String foo = "oh so cool"; String bar = "oh so \"cool\", more so";

Escape character is \ (the backslash)

String s1 = new String("Welcome");String s2 = "welcome";

if (s1.equals(s2)) // s1 and s2 have the same contents if (s1 == s2

// s1 and s2 have the same reference

String Comparisons

Almost always, thisis the method you want.

compareTo(Object object)

String s1 = new String("Welcome");

String s2 = "welcome";

if (s1.compareTo(s2) > 0) // s1 is greater than s2

else if (s1.compareTo(s2) == 0) // s1 and s2 have the same contents else // s1 is less than s2

Do not use message[0] Use message.charAt(index) Index starts from 0

Retrieving Individual Chars in a String

W e l c o m e t o J a v a

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

message

Indices

message.charAt(0) message.charAt(14) message.length() is 15

String s1 = "Welcome to Java";String s2 = s1.substring(0, 11) + "HTML";

Extracting Substrings

W e l c o m e t o J a v a

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

message

Indices

message.substring(0, 11) message.substring(11)

"Welcome".toLowerCase() returns a new string, welcome"Welcome".toUpperCase() returns a new string, WELCOME

" Welcome ".trim() returns a new string, Welcome

"Welcome".replace('e', 'A') returns a new string, WAlcomA"Welcome".replaceFirst("e", "AB") returns a new string, WABlcome"Welcome".replace("e", "AB") returns a new string, WABlcomAB"Welcome".replace("el", "AB") returns a new string, WABlcome

Converting, Replacing

String[] tokens = "Java#HTML#Perl".split("#", 0);for (int i = 0; i < tokens.length; i++) System.out.print(tokens[i] + " ");

Splitting a String

Java HTML Perldisplays

"Welcome to Java".indexOf('W') returns 0."Welcome to Java".indexOf('x') returns -1."Welcome to Java".indexOf('o', 5) returns 9.

"Welcome to Java".indexOf("come") returns 3."Welcome to Java".indexOf("Java", 5) returns 11."Welcome to Java".indexOf("java", 5) returns -1.

"Welcome to Java".lastIndexOf('a') returns 14.

Finding a Char or a Substring

There are several valueOf() methods for converting a character, an array of characters, and numeric values into a string.

e.g.String.valueOf(5.44) "5.44"

Converting into a String

public static void main(String[] args) { if (args.length != 2) { System.out.println("Usage: java BaseChange <integer> <base>"); return; } int num = parseInt(args[0]); int base = parseInt(args[1]); if (base < 2) { System.out.println("Base cannot be < 2; using 16"); base = 16; } else if (base > Character.MAX_RADIX){ System.out.println("Base cannot be > " + Character.MAX_RADIX + "; using 16"); base = 16; } String baseVal = Integer.toString(num, base).toUpperCase(); System.out.println("Conversion of " + num + " to base " + base + " == " + baseVal);} // end of main()

Base Conversion (toString(n,radix))

see BaseChange.java

Execution

The Character Class

java.lang.Character

+Character(value: char)

+charValue(): char

+compareTo(anotherCharacter: Character): int

+equals(anotherCharacter: Character): boolean

+isDigit(ch: char): boolean

+isLetter(ch: char): boolean

+isLetterOrDigit(ch: char): boolean

+isLowerCase(ch: char): boolean

+isUpperCase(ch: char): boolean

+toLowerCase(ch: char): char

+toUpperCase(ch: char): char

Constructs a character object with char value

Returns the char value from this object

Compares this character with another

Returns true if this character equals to another

Returns true if the specified character is a digit

Returns true if the specified character is a letter

Returns true if the character is a letter or a digit

Returns true if the character is a lowercase letter

Returns true if the character is an uppercase letter

Returns the lowercase of the specified character

Returns the uppercase of the specified character

StringBuilder/StringBuffer can be used wherever a string is used

they are faster than String if you are doing a lot of string building

StringBuilder sb = new StringBuilder("hello");sb.add(" andrew");sb.add(" davison");

after the end of the building, convert to a String:String s = sb.toString();

StringBuilder and StringBuffer

Useful String Utilities

see StringFun.javaboolean isNullOrEmpty(String s)String toString(Exception e)String unquote(String s)String sort(String s) String removeAll(String s, char unwanted)String padRight(String s, int n) String padLeft(String s, int n) String getHexString(byte[] b)boolean onlyDigits(String s)boolean hasNDigits(String s, int n)boolean isBinary(String s)String stripControls(String s) String removeSpaceDups(String s)void appendToFile(String fnm, String s)String readAll(String fnm)ArrayList<String> toList(String[] arr)boolean contains(String[] arr, String s)String[] toArray(ArrayList<String> strsList)HashSet<String> toSet(String[] arr)

String reverse(String s)String[] reverse(String[] strs)String[] getWords(String s)String reverseWords(String s)String rotRight(String s)String rotLeft(String s)boolean isRotation(String s1, String s2) boolean isPalindrome(String s)String shift(String s, int shift) char shift(char ch, int shift)boolean isLetter(char ch)ArrayList<String> permutate(String s)boolean areAnagrams(String s1, String s2)String[] genSubsets(String s)int levDist(String s, String t)String join(String toJoin, Object[] listString join(String toJoin, List<String> list)String join(String toJoin, Set set)

public static void main(String[] args) { String s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; String res = StringFun.reverse(s); System.out.println("Reverse: " + res);

s = "Could you pretty please reverse this sentence"; res = StringFun.reverseWords(s); System.out.println("Reverse Words: " + res );

String[] results = StringFun.getWords("Could you, if possible, help me!"); System.out.println("Words:"); for(String r : results) System.out.println(" " + r); :

Usage see StringFunTests.java

s = "superman"; System.out.println("Rotate right: " + StringFun.rotRight(s) ); System.out.println("Rotate left: " + StringFun.rotLeft(s) );

System.out.println("Is Palindrome: " + StringFun.isPalindrome("ABCDEFGHIJKLMNOPQRSTUVWXYZ")); System.out.println("Is Palindrome: " + StringFun.isPalindrome("ABCDEFGHIJKKJIHGFEDCBA"));

results = StringFun.genSubsets("abcde"); System.out.println("Generate Subsets: {" + StringFun.join(", ", results) + "}");

int dist = StringFun.levDist("kitten", "sitting"); System.out.println("Edit Distance: " + dist); // 3

System.out.println("Rot4: " + StringFun.shift("andrew",4));

ArrayList<String> perms = StringFun.permutate("jim"); System.out.println("Permutations: {" + StringFun.join(", ", perms) + "}"); :

System.out.println("Remove all: " + StringFun.removeAll("algorithms", 'a'));

System.out.println("Pad right: \"" + StringFun.padRight("cat", 10) + "\"");

System.out.println("Is 5 digits: " + StringFun.hasNDigits("19745", 5));

String htxt = StringFun.readAll("hull1.txt"); System.out.println("Read all: \"" + htxt + "\"");

htxt = StringFun.stripControls(htxt); System.out.println("Read all: \"" + htxt + "\"");

htxt = StringFun.removeSpaceDups(htxt); System.out.println("Read all: \"" + htxt + "\""); } // end of main()

A regular expression (regex) is a pattern for matching against a string.

You can use regular expressions for matching, replacing, and splitting strings.

4. Regular Expressions

Replacing and Splitting Strings

java.lang.String

+matches(regex: String): boolean

+replaceAll(regex: String, replacement: String): String

+replaceFirst(regex: String, replacement: String): String

+split(regex: String): String[]

Returns true if this string matches the pattern.

Returns a new string that replaces all matching substrings with the replacement.

Returns a new string that replaces the first matching substring with the replacement.

Returns an array of strings consisting of the substrings split by the matches.

boolean b = "Java is fun".matches("Java.*");

String s = "Java Java Java".replaceAll("v\\w", "wi");

String s = "Java Java Java".replaceFirst("v\\w", "wi");

String[] s = "Java1HTML2Perl".split("\\d");

Examples

See the Pattern class documentation e.g. at https://docs.oracle.com/javase/8/docs/api/

java/util/regex/Pattern.html

Regex Documentation

Regular Expression Matches Example x a specified character x Java matches Java . any single character Java matches J..a (ab|cd) a, b, or c ten matches t(en|im] [abc] a, b, or c Java matches Ja[uvwx]a [^abc] any character except Java matches Ja[^ars]a

a, b, or c [a-z] a through z Java matches [A-M]av[a-d] [^a-z] any character except Java matches Jav[^b-d] a through z [a-e[m-p]] a through e or Java matches m through p [A-G[I-M]]av[a-d] [a-e&&[c-p]] intersection of a-e Java matches with c-p [A-P&&[I-M]]av[a-d] \d a digit, same as [1-9] Java2 matches "Java[\\d]" \D a non-digit $Java matches "[\\D][\\D]ava" \w a word character Java matches "[\\w]ava" \W a non-word character $Java matches "[\\W][\\w]ava" \s a whitespace character "Java 2" matches "Java\\s2" \S a non-whitespace char Java matches "[\\S]ava" p* zero or more Java matches "[\\w]*" occurrences of pattern p p+ one or more Java matches "[\\w]+" occurrences of pattern p p? zero or one Java matches "[\\w]?Java" occurrence of pattern p Java matches "[\\w]?ava" p{n} exactly n Java matches "[\\w]{4}" occurrences of pattern p p{n,} at least n Java matches "[\\w]{3,}" occurrences of pattern p p{n,m} between n and m Java matches "[\\w]{1,9}" occurrences (inclusive)

Codeimport java.util.regex.*; public class RegexTest { public static void main(String args[]) { String pattern = "[a-z]+"; String text = "Now is the time";

Pattern p = Pattern.compile(pattern); Matcher m = p.matcher(text); while (m.find()) System.out.println( text.substring( m.start(), m.end() ) ); }}

Output: owisthetime

see RegexTest.java

Test Rigpublic class TestRegex{ public static void main(String[] args) { if (args.length != 2) { System.out.println("Usage: java TestRegex string regExp"); System.exit(0); } System.out.println("Input: \"" + args[0] + "\""); System.out.println("Regular expression: \"" + args[1] + "\""); Pattern p = Pattern.compile(args[1]); Matcher m = p.matcher(args[0]); while (m.find()) System.out.println("Match \"" + m.group() + "\" at positions "+ m.start() + "-" + (m.end()-1)); } // end of main()} // end of TestRegex class

see TestRegex.java

m.group() returns the string matched by the pattern usually used instead of String.substring()

The Java tutorial on REs is very good: http://java.sun.com/docs/books/tutorial/

essential/regex/

Online tutorials: http://ocpsoft.com/opensource/

guide-to-regular-expressions-in-java-part-1/ and part-2

More Information on Regexs

"~" inverts a bit pattern

"<<" shifts a bit pattern to the left ">>" shifts a bit pattern to the right

">>>" shifts a zero into the leftmost pos, while the pos after ">>" depends on sign extension

& performs AND ^ performs OR |performs inclusive OR

5. Bitwise Operations

The most-significant-bit is on the left:10010110^ ^| |------- bit 0||-------------- bit 7

The value of bit 0 is 20, bit 1 is 21, ..., bit 7 is 27

A Word About Bit Order

c = a ^ b; /* 49 = 0011 0001 */ System.out.println("a ^ b = " + c );

c = ~a; /*-61 = 1100 0011 */ System.out.println("~a = " + c );

c = a << 2; /* 240 = 1111 0000 */ System.out.println("a << 2 = " + c );

c = a >> 2; /* 215 = 1111 */ System.out.println("a >> 2 = " + c );

c = a >>> 2; /* 215 = 0000 1111 */ System.out.println("a >>> 2 = " + c ); } // end of main()}

public class BitsTest { public static void main(String args[]) { int a = 60; /* 60 = 0011 1100 */ int b = 13; /* 13 = 0000 1101 */ int c = 0;

c = a & b; /* 12 = 0000 1100 */ System.out.println("a & b = " + c );

c = a | b; /* 61 = 0011 1101 */ System.out.println("a | b = " + c );

a ^ b = 49~a = -61a << 2 = 240a >> 15a >>> 15

a & b = 12a | b = 61

see BitsTest.java

Bitwise Operations

Bitwise AND (&)

Bitwise inclusive OR(|) Bitwise exclusive OR(^)

Bitwise Assignment Ops

Work with binary numbers using Integer.parseInt() e.g. Integer.parseInt("101", 2);

creates an integer with the binary value of 101 (decimal 5).

Loop with binary:// loops from 5 up to and including 15for (int b = Integer.parseInt("0101",2); b <= Integer.parseInt("1111",2); b++) {

/* do stuff here */}

Using ParseInt

Low Level Bit Hacks You Absolutely Must Know http://www.catonmat.net/blog/low-level-bit-hacks-you-absolutely-

must-know/ 10 hacks, including: " Check if the integer is even or odd", "Test if the n-th bit

is set", "Set the n-th bit", "Unset the n-th bit", toggle the nth bit

Bit Twiddling Hacks https://graphics.stanford.edu/~seander/bithacks.html

Hacker's Delight, 2nd edHenry S. Warren

http://www.hackersdelight.org/

More Information on Bits BitFun.java

Contest Algorithms January 2016 Look at some features of Java used in many competition problems. 2....

Documents

Transcript of Contest Algorithms January 2016 Look at some features of Java used in many competition problems. 2....

Major Java 8 features

Java 8 - Features Overview

CHAPTER 1 JAVA 7 FEATURES - capcourse.com · After completing “Java 7 Features,” you will be able to: Identify and use new features of the Java language available as of the 7th

Features in Java 7

Java 7 – New Features

Introduction to Java. Overview History of Java Java Releases - Evolution Java Features Java White Paper Buzzwords Java & Internet.

Java se7 features

Java EE 6 New features in practice Part 1 - Informáticavitorsouza/wp-content/uploads/java-en... · Java EE 6 New features in practice Part 1. May 2010 Java EE 6, new features in

Java 1.5 features

Java 8 Features - bedford-computing.co.ukbedford-computing.co.uk/.../03/Java-8-Features.pdf · Java 8 Features iv Preface It’s been a while since Java 8 is out in the public and

General Features of Java Programming Language

Java 7 new features

Java 8 - functional features

Java 1.7 Features

Contest Algorithms January 2016 3. Collections 1Contest Algorithms: 3. Collections.

55 New Features in Java 7

Java ee 7 New Features

Language Features of Java Generics

Java 5 and 6 New Features

New Functional Features of Java 8