out/

.idea/

src/META-INF

These are "executable Cheat Sheets" demonstrating some foundational Java syntax and commonly used classes.

import java.util.Arrays;

import java.util.List;

public class ArrayCheatSheet {

public static void main(String[] args) {

// Class reference: none

// Tutorial: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html

// Language specification: http://docs.oracle.com/javase/specs/jls/se8/html/jls-10.html

// Array Module: http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Array.html

// Arrays Module: http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html

// Notes:

// - can not change size of array in Java

// - when passed into a method, the contents of an array are muteable

// basic

int[] odds = {1, 3, 5, 7};

System.out.println(odds); // prints out hash? id? pointer?

System.out.println(Arrays.toString(odds)); // prints out items

// creation, initializatoin and literals

int[] b = new int[3]; // initialized to zeros (null for String)

int[] a = {1, 3, 5}; // array literal

int[] evens = new int[]{2, 4, 6};

System.out.println(new int[]{2, 4, 6, 8, 10}); // pass array literal to function

// indexing and assignment

a[0] = 42; // assign to index

int c = a[1]; // index into array

b = a; // assigns each variable a reference to same data

// iteration

for (int i = 0; i < a.length; ++i) {

System.out.println(a[i]);

}

for (int val: a) {

System.out.println(val);

}

// copying

int[] trg = new int[7];

System.arraycopy(odds, 0, trg, 0, odds.length); // (src, srcStart, trg, trgStart, length)

// Multidimensional arrays

// In Java, a multidimensional array is one whose components are themselves arrays

int[][] grid = {

{1, 2, 3, 4},

{5, 6, 7, 8}

};

System.out.println(grid[1][3]); // [row][column]

for (int[] row: grid) {

for (int val: row) {

System.out.println(val);

}

}

// because Java arrays are "arrays-in-arrays", you can have ragged arrays

int[][] ragged = {

{1, 2, 3, 4, 5},

{6, 7},

{8, 9, 10}

};

// Arrays module (see reference link above)

// (compare, sort, fill, search, copy, toString, etc.)

System.out.println(Arrays.toString(a));

// convert Array to List

Integer[] x = {2, 4, 6, 8}; // List<T> must contain an object. Can't have List of primitive type.

List<Integer> items = Arrays.asList(x); // returns a fixed-size list backed by the specified array

System.out.println(x[1] + " " + items.get(1));

x[1] = 999; // if you mutate backing array, you are also mutating the List

System.out.println(x[1] + " " + items.get(1));

}

}

import java.io.*;

import java.nio.file.*;

import java.util.List;

public class FileProcessingCheatSheet {

public static void main(String[] args) throws IOException {

// Come up with the whole way to write text to a file, read from a file, manipulate path names, etc.

// There are lots of way to do this. Do I want to touch on all of them? Pick one and run with it?

// Remember, there was an issue in clipboard where it wasn't reading files with newlines as you would expect (platform independent newlines)

// FileReader/Writer are basic and only support writing characters and streams

// Wrapping FileReader/Writer in BufferedReader/Writer adds buffering and line-oriented operations

// basic

// PrintWriter is similar to System.out

PrintWriter w = new PrintWriter("test_data.txt"); // could also use a BufferedWriter

w.println("line one"); // OS-independent line separator

w.printf("line %d%n", 2); // %n = OS-independent line separator

w.println("line three");

w.close();

BufferedReader i = new BufferedReader(new FileReader("test_data.txt"));

String line;

while ((line = i.readLine()) != null) { // .readline() consumes line terminator

System.out.println("READ: " + line);

}

i.close();

// console (simple prompts for input)

// (also see InputCheatSheet)

Console c = System.console();

if (c == null) {

System.out.println("No console. Skipping consle sample code.");

} else {

String inp = c.readLine("Enter text here Mr. %s", "Smith"); // Can be string literal, or empty for no prompt

System.out.println("Entered: " + inp);

}

// write to a file (write vs append)

PrintWriter appending = new PrintWriter(new FileWriter("test_data.txt", true));

appending.println("New line appended"); // uses OS-independent line separator

appending.printf("another line%n"); // %n - OS-independent line separator

appending.println("final line");

appending.close();

// Note: java.io is older (From Java 1.4) where java.nio is newer

// - can use File.toPath() to convert from "old" to "new"

// - java.nio.file.Path = core of file processing in Java

// - java.nio.file.Path replaces java.io.File (from Java 1.7)

// - file or directory corresponding to the Path might not exist

// - operate on path itself and don't access filesystem

// - Paths is a Path helper class

// - java.nio.file.Files

// - static methods that take Path's to read, write, and manipulate files and directories on filesystems.

Path p1 = Paths.get("c:\\abc\\def");

System.out.println(p1);

Path p1b = Paths.get("aa\\bb\\cc\\dd"); // relative path

System.out.println(p1b.toAbsolutePath());

Path p2 = Paths.get("\\aa\\bb\\cc\\dd");

System.out.println(p2);

System.out.println(p2.toString());

System.out.println(p2.getFileName());

System.out.println(p2.getParent());

System.out.println(p2.getRoot()); // null if a relative path

System.out.println(p2.getNameCount());

System.out.println(p2.getName(0));

System.out.println(p2.subpath(1, 3));

System.out.println(p2.toUri());

System.out.println(p2.resolve("ee.txt")); // joining two Paths

System.out.println(p2.resolve(Paths.get("yy\\zz"))); // joining two Paths

System.out.println(Paths.get("home").relativize(Paths.get("home\\sally\\bar"))); // Result: sally\bar

p1.equals(p2);

p1.startsWith(p2);

p1.endsWith(p2);

for (Path path_name: p2) {

System.out.println("Path: " + path_name);

}

//

Path tmp = Paths.get("test_data.txt");

Files.exists(tmp);

Files.notExists(tmp);

Files.isReadable(tmp);

Files.isWritable(tmp);

Files.isExecutable(tmp);

Files.size(tmp);

Files.isDirectory(tmp);

Files.isRegularFile(tmp);

// read lines from a file

List<String> lines = Files.readAllLines(tmp);

for (String s: lines) {

System.out.println("_" + s + "_");

}

// stream interface to read lines from a file

Files.lines(tmp)

.filter(s -> s.startsWith("line"))

.forEach(s -> System.out.println("*" + s + "*"));

Path tmp2 = Paths.get("temp2.txt");

Path tmp3 = Paths.get("temp3.txt");

Files.copy(tmp, tmp2);

Files.move(tmp2, tmp3);

Files.delete(tmp3);

Files.createDirectory(Paths.get("mytempdir"));

Files.delete(Paths.get("mytempdir"));

// iterate over root directories in filesystem

Iterable<Path> dirs = FileSystems.getDefault().getRootDirectories();

for (Path p: dirs) {

System.out.println(p);

}

// iterate over directory

try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get("src"))) {

for (Path file : stream) {

System.out.println("In src: " + file.getFileName());

}

}

// iterate over directory with glob matching

try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get("src"), "*.java")) {

for (Path entry : stream) {

System.out.println("Glob: " + entry.getFileName());

}

}

}

}

import java.io.BufferedReader;

import java.io.Console;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.Scanner;

public class InputCheatSheet {

public static void main(String[] args) throws IOException {

// demonstrate different ways to read from stdin

readFromScanner();

readFromConsole();

readFromBufferedReader();

parsingExample();

}

private static void readFromScanner() {

System.out.print("Enter your name: ");

Scanner scanner = new Scanner(System.in);

String name = scanner.nextLine();

System.out.println("NAME: " + name);

}

/** Does not work when run from inside IntelliJ, System.console() returns null */

private static void readFromConsole() {

Console console = System.console();

if (console != null) {

String name = console.readLine("Enter your name: ");

System.out.println("NAME: " + name);

} else {

System.out.println("ERROR: Console not supported");

}

}

private static void readFromBufferedReader() throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

System.out.print("Enter your name: ");

String name = br.readLine();

System.out.println("NAME: " + name);

}

private static void parsingExample() {

System.out.print("Enter ids separated by commas: ");

Scanner scanner = new Scanner(System.in);

String line = scanner.nextLine();

System.out.println("LINE: " + line);

String[] tokens = line.split(",");

for (String token : tokens) {

System.out.println("Integer: " + Integer.valueOf(token));

}

}

}

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

public class ListCheatSheet {

public static void main(String[] args) {

// Class Reference: http://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#ArrayList--

// Tutorial: http://docs.oracle.com/javase/tutorial/collections/interfaces/list.html

// Collections Framework Overview (with nice chart of all classes): http://docs.oracle.com/javase/8/docs/technotes/guides/collections/overview.html

// basic

List<Integer> a = new ArrayList<>(); //

a.add(42);

a.add(99);

System.out.println(a);

// creation, initialization and literals

Integer[] blah = {1, 2, 3};

ArrayList<Integer> b = new ArrayList<>(Arrays.asList(blah));

ArrayList<Integer> c = new ArrayList<>(Arrays.asList(1, 2, 3));

ArrayList<Integer> d = new ArrayList<>(Arrays.asList(new Integer[]{2, 4, 6, 8}));

d.addAll(c);

ArrayList<Integer> clone = (ArrayList<Integer>)d.clone(); // requires cast?

b.clear();

List<Integer> testList = new ArrayList(); // lists are often created this way...

List<Integer> nums = Arrays.asList(2, 4, 6, 8); // be careful as this is an array-backed, quasi-immuteable, special List

List<String> strings = Arrays.asList("abc", "def", "ghi");

List<String> arguments = Arrays.asList(args); // convert args array to List

//List<Integer> blah = List.of(2, 4, 6); // Java 9 (shorter, safer)

// accessing

d.isEmpty();

d.size();

d.get(3);

d.contains(42);

d.indexOf(6); // first index where object is found, otherwise -1

List<Integer> blah2 = d.subList(1, 3);

blah2.set(1, 1243);

// mutate

d.set(1, 99); // set index 1 to value 99

d.remove(2); // by index

d.remove((Integer)8); // by value (cast used to force use of the Object overload

d.removeAll(a); // removes all items in a from d

d.removeIf(v -> v % 3 == 0);

d.sort(Integer::compareTo); // should be able to drop the comparator argument in Java 8?

Collections.sort(d);

d.replaceAll(v -> v + 100); // replaces all elements with result of function (UnaryOperator, lambda, etc.)

// iterating

for (int i = 0; i < a.size(); ++i) {

System.out.println(a.get(i));

}

for (Integer val: a) {

System.out.println(val);

}

a.forEach(val -> {

System.out.println(val);

});

//////// conversion

// List to Array

List<String> z = Arrays.asList("Beatrice", "Gerty", "Floyd");

String[] other = new String[z.size()];

String[] conv = z.toArray(other);

}

}