Java Programmer Gold SE 8 Qualification Summary (for those who are familiar with Java)

Purpose of the article

We have summarized the contents of the Java Programmer Gold SE 8 exam. It's for niche people who have been doing Java for a long time but don't know much about SE8.

How did you write this article?

The other day I took and passed the Java SE 8 Programmer II (1Z0-809) and got the Oracle Certified Java Programmer, Gold SE 8. I acquired it once when I was in Java2, but it was clearly different from the knowledge level required by the world today, so I decided to study again in the sense of updating my knowledge. Knowledge of SE8 is becoming essential even in Android development. When I take the test, I have a summary of the test range, but I can't stand to store it as it is when the test is over, so I decided to leave it in the form of an article. I would be very happy if it would be of benefit to anyone.

Summary of points

Java basics

Numeric literal prefix

The prefix added to the beginning of the number determines the base number.

• "0b" ... binary
• "0" ... octal number
• None ... Decimal number
• "0x" ... Hexadecimal

Timing to initialize final variable

Instance variables with the final qualifier must be initialized in the constructor

Initialization order by initializer and constructor

Processes related to object initialization are executed in the following order

1. static initializer When loading a class
2. Instance initializer When creating an instance, before executing the constructor Declaring a variable does not execute it. Requires instantiation
3. Constructor

Enumeration value inheritance and interface implementation

• Enumerated methods name () and toString () return their own string representation
• name () is final and cannot be overridden. toString () is possible
• Enums can implement interfaces and define abstract methods. If you do these, you need to override each enumeration value
• If you want to get the enumerated value from a string, you can use the valueOf () method

Notes on enumerated values

• Constructors can be defined for enumerated values, but instantiation by new is not allowed, so adding public or protected to the constructor will result in a compilation error. If nothing is attached, the compilation will pass, but new cannot be done (a compilation error will occur).
• If you define a field without a final declaration, the value of that field can be changed at any time.

enum Direction {
    North(0), South(1);

    //If you do not declare final, you can change this value
    int index;
    private Direction(int index) { this.index = index; }
}

//Example of changing the index field of Direction
Direction d = Direction.North;
System.out.println(d.index);    // 0
d.index = 10;
System.out.println(d.index);    // 10

hashCode () and equals ()

• The following two conditions are required to make multiple objects equivalent.
• The return value (hash value) of hashCode () is the same
• ʻEquals () `is true
• Duplicate check in collection is as follows. If both are established, they are considered to be equivalent.

1. Check if the hash values are the same
2. Compare only those with the same hash value with ʻequals () `

• When implementing hashCode (), implement so that values are returned from objects with the same value.
• The argument of ʻequals () `is Object. If it is the same type as the receiver, the override will not be established and the overload will be established. No compilation error

Interface method

• The instance method defined in the interface may be a public abstract method. Compilation passes even if there is a description such as abstract
• In a situation where multiple interfaces have default methods with the same name, if both are inherited or implemented, the default methods will conflict and a compile error will occur. However, overriding the default method on the inheriting or implementing side resolves the error.

interface Sample {
    // "public abstract"Compiles with or without
    public abstract void execute();
}

interface A { default void execute() { System.out.println("A"); } }
interface B { default void execute() { System.out.println("B"); } }
interface C extends A, B {
    //Uncommenting this will eliminate the compilation error
    // default void execute() { System.out.println("C"); }
}

Conditions for the override to hold

• When overriding a method, the return value must be the same as or a subclass of the superclass type
• Method overriding does not hold unless the following match. Overload even if the order does not match

1. Method name
2. Argument type
3. Argument order

• static methods and static fields can also be redefined in subclasses However, you can't call the parent's static method using the super keyword because it's "hidden" rather than overridden.

Method local class

• You can refer to the variables in the method directly from the method local class, but the variables must be practically final. Even if there is no final declaration, it will be automatically treated as final when referenced from the method local class. This is the same for lambda
• If you give a method variable to a method-local class in the constructor, you don't have to make it final because you don't directly reference the original variable.
• If you refer to a member variable of a class outside the method from a method local class, you can change the member variable.

Lambda expression

1. Argument data type can be omitted
2. If there is one argument, "()" can be omitted
3. If there is one expression on the right side, "{}" can be omitted regardless of whether there is a return value from the right side.
4. If there is one expression on the right side and a return value is returned, return can be omitted.

Functional interface

Function related

Consumer related

Predicate related

Supplier

Functional interface that accepts primitive types

• Each of int, long, and double has its own functional interface. ** BooleanSupplier only ** exists in boolean
• Method names for Supplier, ʻUnaryOperator, BinaryOperator follow below ** Rule: [Method name] As [Data type] ** Example: ʻapplyAsInt, getAsBoolean, etc.

Functional interface that returns a primitive type

Method reference

• Can only be used within a functional interface
• When taking an argument, write it in the same way as a static method reference.

collection

Arrays#asList

• The list generated by ʻArrays # asList` only refers to the array given as an argument. Changes made to the original array will also be reflected in the list
• The list generated by ʻArrays # asList is ** incompatible with ʻArrayList <E>. ** Cast fails

The nature of the collection class and how to distinguish it

• List is the order of the index in principle
• Set and Map distinguish their properties by the prefix of the class name
• Classes starting with Linked will be inserted in the order they are inserted.
• Classes starting with Tree are sorted by natural order. When arranged in natural order, it becomes ** number → alphabet (large) → alphabet (small) **

The nature of the Queue interface

• There are two types of insert / delete / check methods, and the behavior when the method execution fails is different.
• Exception occurred
• Insert… ʻadd (E) `
• Remove ... remove ()
• Inspection… get ()
• Return null
• Insert ... ʻoffer (E) `
• Delete ... poll ()
• Inspection… peek ()
• Inaccessible element by index

Deque interface properties

• The difference from Queue is that you can insert or remove elements at the beginning or end, as the name of ** Double Ended Queue ** suggests.
• Exception occurred
• Insert… ʻaddFirst (E) , push (E) / ʻaddLast (E)
• Delete… removeFirst () / removeLast ()
• Inspection… getFirst (), pop () / getLast ()
• Return null
• Insert… ʻofferFirst (E) / ʻoffset Last (E)
• Delete ... pollFirst () / pollLast ()
• Inspection… peekFirst () / peekLast ()
• Same as Queue, the element cannot be accessed by index
• The Queue interface extension in the java.util.concurrent package also has a method that allows you to set a timeout. Waiting does not always occur, and waiting occurs when you cannot insert or delete.
• The implementation of Deque, ʻArrayDeque`, cannot contain nulls.

Generics

Generics and type parameters

• When declaring a type parameter for a class, the type parameter cannot be used for the following purposes:
• static member
• Creating instances and arrays with the new operator
• Type validation with ʻinstanceof`
• Reference to .class
• You may or may not specify the type when using a method with type parameters applied
• The generic type syntax is as follows ** class class name <type parameter (, type parameter n)> {...} **
• When using type parameters in class declarations, you can use the extends keyword but not the super keyword
• The syntax of the method is as follows Declaration: ** return type method name (type argument name) {...} ** Use: ** Receiver. Method name (type argument name) {...} **

Wildcard

• Wildcards are "?" Instead of"*"("*"is Kotlin)
• Wildcards cannot be used for type parameters in class declarations
• The wildcard type is not fixed until it is executed, so adding a wildcard to the specified list will result in a compile error. The exception is that the list declared with <? Super XXXXX> can contain objects of the same type as XXXXX.
• If you use a wildcard, a compile error will not occur if there is no problem within the range that can be judged from the declared contents. Compile error if it becomes clear that the types are incompatible

Where a compile error occurs when using wildcards for type parameters

• If you use wildcards for type parameters, you will get a compile error at ** where you actually add the object **

Comparable and Comparator

Comparable interface

• Belongs to the java.lang package
• Interface to be compared
• The only method that should be implemented in Comparable iscompareTo (To). Returns a negative value if it is less than the comparison partner, zero if it is equal, and a positive value if it is greater.
• When declaring a class, the type parameter of Comparable <T> is given the type of the object that compareTo takes as an argument.

Comparator interface

• Belongs to the java.util package
• Interface for comparison. Note that the comparison target is not limited to those that implement the Comparable interface.
• The following two methods should be implemented in Comparator (ʻequals` is optional)
  • compare(T t1, T t2)
  • equals(T o)
• compare (T t1, T t2) returns a positive value if t1 is greater than t2, zero if t1 and t2 are equal, and a negative value if t1 is less than t2.

Stream API

Generate a stream with a finite number of elements

• Collection#stream() -> Stream<E>
• Arrays#stream(E[] array) -> Stream<E>
• Arrays#stream(int[] array) -> IntStream
• Arrays#stream(long[] array) -> LongStream
• Arrays#stream(double[] array) -> DoubleStream
• Stream#of(E… values) -> Stream<E>
• Stream#empty() -> Stream<E>
• IntStream#of(int… values) -> IntStream
• LongStream#of(long… values) -> LongStream
• DoubleStream#of(double… values) -> DoubleStream
• IntStream#range() ／ IntStream#rangeClosed() -> IntStream
• LongStream#range() ／ LongStream#rangeClosed() -> LongStream
• BufferedReader#lines() -> Stream<String>
• java.nio.file.Files#lines() -> Stream<String>

Generate a stream with an infinite number of elements

Both methods of java.util.stream.Stream

• generate(Supplier<T> supplier)
  Create a Stream that holds an infinite number of elements provided by the supplier
• iterate(T seed, UnaryOperator<T> f)
  Seed is the first element, and after that it creates a Stream that holds the previous element multiplied by f indefinitely.

Stream termination operation

• Only one termination operation on the same stream. If you do it multiple times, you will get ʻIllegalStateException`
• Nothing is done just by calling the intermediate operation, nothing is done unless the termination operation is called. All processing is executed when the termination operation is called
• In pipeline processing, all intermediate / termination operations are performed one by one in the stream, and then the next element is processed. In other words, ** "Intermediate operation of element 1 x m-> Termination operation of element 1" ⇒ "Intermediate operation of element 2 x m-> Termination operation of element 2" ⇒ ... ⇒ "Intermediate operation of element n x m-> Termination of element n" Operation "**

Stream # reduce return value

Stream # reduce is a method for aggregating the contents of Stream. In the method that sets the initial value in the first argument, the return value is not ʻOptional`

• reduce (BinaryOperator op)… The return value is ʻOptional `
• reduce (T initial, BinaryOperator op)… The return value is T

Termination operation with an optional return value

• The return value is ʻOptional` by the following method
• findAny ()… Results may change each time you run
• findFirst ()… The same result can be obtained no matter how many times it is executed.
  • min()
  • max()
  • reduce(BinaryOperator op)
• The type of ʻOptional differs depending on the type of Stream. For example, findAny ()` is as follows
  • Stream#findAny() … Optional<T>
  • IntStream#findAny() … OptionalInt
  • LongStream#findAny() … OptionalLong
  • DoubleStream#findAny() … OptionalDouble

Create an instance of Optional

• ʻOptional # of (T value) `… value cannot be null
• ʻOptional # ofNullable (T value) `… value can be null
• OptionalInt#of(int value)
• OptionalLong#of(long value)
• OptionalDouble#of(double value)

Optional # ifPresent and Optional # isPresent

• There are two methods to determine if there is a value (null or not null):

1. ʻisPresent () `… Determines the presence or absence of a value
2. ʻifPresent (Consumer)… Execute Consumer` if there is a value

There are multiple methods for retrieving a value from Optional

The method to get the value from ʻOptional `is below. If a value exists, that value is obtained, but if it does not exist, the behavior is different.

• get()
NoSuchElementException if it does not exist
• orElse(T)
  Returns an argument if it does not exist
• orElseGet(Supplier<T>)
  Returns the value returned by Supplier if it does not exist
• orElseThrow(Supplier<X extends Exception>)
  Throws an exception returned by Supplier if it does not exist

Optional types specific to a particular data type

ʻThe method for retrieving the related class and value of Optional ` is as follows

• Optional<T>#get()
• OptionalInt#getAsInt()
• OptionalLong#getAsLong()
• OptionalDouble#getAsDouble()

Type conversion between Stream and XXXStream

• Conversion between the same Stream types ismap ()
• Conversion to Stream <T> type is mapToObj ()
• ʻConversion to IntStream type is mapToInt () `
• Conversion to LongStream type ismapToLong ()
• Conversion to DoubleStream type ismapToDouble ()

Stream # collect () method and Collector class

• collect () is a method that aggregates the elements in Stream to get one object.
• The Collectors class provides an implementation of the Collector interface that suits your needs. Due to its nature, some methods and roles of the Stream class overlap.

exception

Error、Exception、 RuntimeException

• All subclasses of Throwable and belong to the java.lang package
• ʻError and ʻException are subclasses of Throwable
• RuntimeException is a subclass of ʻException (a grandchild of Throwable`)
• The only checked exceptions that require try ~ catch are subclasses of ʻException other than RuntimeException`.

Order to catch exceptions

• Exceptions should be caught in order from the subclass
• Catch a superclass before a subclass will result in a compile error
• Not a run-time error

Exception multi-catch

• Compile error when catching multiple inherited exceptions at once
• The exception object when multi-catch is implicitly treated as final and cannot be reassigned. If it is not multi-catch, it will not be treated as final

Exception rethrow

• If a method catches and rethrows multiple types of exception objects, the exceptions taken by the throws and catch methods do not have to match.
• When picking up the parent class of all possible exceptions by catch and throwing it as it is, etc.

//In SE7 and later, you may catch two exceptions together.
//It is not Exception but IllegalAccessException and ArighmeticException that are thrown from execute
private void execute(int number) throws IllegalAccessException, ArithmeticException {
    try {
        switch (number) {
            case 1:
                throw new IllegalAccessException();
            case 2:
                throw new ArithmeticException();
            default:
                System.out.println("No exception");
        }
    } catch (Exception e) {
        throw e;
    }
}

Override method to throw exception

• When overriding a method with a throws declaration in a subclass, it is up to you to declare the overridden method throws.
• The exception to declaring throws in an overridden method must be the same as or a subclass of the original method.
• RuntimeException and its subclasses can be unconditionally specified in throws. However, since it is an unchecked exception, compilation will pass without catching at the caller.

try ~ with ~ resources statement

• Can be used alone with try only in try ~ with ~ resources statement
• The resource to use must implement java.lang.AutoCloseable or its subinterface java.io.Closeable.
• Both ʻAutoCloseable / Closeablehave athrows declaration in close () , so whether you use it for a resource or in try`, you must catch an exception to get a compile error.
  • AutoCloseable#close() throws Exception
  • Closeable#close() throws IOException
• If an exception occurs in close () of ʻAutoCloseable or Closeable`, it will be caught by catch.
• If an exception occurs on both the try block and the resource close, the exception raised byclose ()is stored as an array of Throwable in the exception object caught as a suppressed exception, and getSuppressed ( ) Can be obtained
• The execution order when an exception occurs in the try ~ with ~ resources statement is as follows.

1. try block
2. Close resources in the reverse order of declaration (the code below closes in order from N to 1)
3. catch block
4. finally block

// (1) ->Close in order from Resource N to 1() -> (2) -> (3)Execute in the order of
try (Resource1; Resource2; ...; ResourceN) {
    (1)
} catch (Exception e) {
    (2)

    // getSuppressed()You can take an array of Throwable with
    for (Throwable th : e.getSuppressed()) { ... }
} finally {
    (3)
}

Assertions and how to use them

• Assertion is a function that throws ʻAssertionError when false is detected in the ʻassert statement, and the syntax is as follows. ʻAssert boolean expression: error message;`
• boolean Expressions can be enclosed in parentheses or not
• Error messages can be omitted
• Assertions are disabled by default. AssertError is not thrown unless you explicitly specify the "-ea" option (short for "enable assertion"?) In the java command.
• To explicitly disable it, specify the "-da" option (short for "disable assertion"?) With the java command.
• If you want to specify that it is the target of the assertion, specify the target of the assertion (not the target if -da) by separating it with a colon as java -ea: [class name].

Date and Time API

Class list

1. LocalDate… Date
2. LocalTime… Time
3. LocalDateTime… Date + time
4. ʻOffsetTime`… Time including the difference from UTC / GMT in “+ hh: mm”
5. ʻOffsetDateTime`… Date & time including the difference from UTC / GMT in “+ hh: mm”
6. ZonedDateTime… Date + time including the difference from UTC / GMT in time zone ID

• All implement the Temporal interface. Moreover, its super interface is TemporalAccessor
• The difference between "Local ~", "Offset ~" and "Zoned ~" is the difference in the method of expressing the same date and time.
• Can be converted to each with LocalDateTime # toLocalDate () and LocalDateTime # toLocalTime ()
• Two methods can get the month
• getMonth ()… Month Get by enumeration value
• getMonthValue ()… Get by int value

Enumeration list

1. Month: Represents the month JANUARY, FEBRUARY, MARCH, …, DECEMBER
2. DayOfWeek: Represents the day of the week SUNDAY, MONDAY, TUESDAY, …, SATURDAY

Instantiation of LocalDate / LocalTime / LocalDateTime

1. now()
2. of(year, month, dayOfMonth, ...)
   Create an instance with a value that can be handled by each class as an argument You can set the argument month to the Month enumerated value instead of an integer. Only LocalDateTime has an overload that takes LocalDate and LocalTime as arguments. It may take year, month, day, hour, minute, second, millisecond as arguments
3. parse(String)、parse(String, DateTimeFormatter)
   Create an instance from a string If you use DateTimeFormatter together, you can use any format string.

LocalDate # of and LocalTime # of overloads

• LocalDate # of has two overload methods. In both cases, the date is specified, but the other differences are as follows.

1. The second argument is int
2. The second argument is the Month enumeration value

• LocalTime # of has three overloaded methods, all specifying the hour and minute, but the other differences are as follows:

1. Hours only
2. Specify seconds in addition to hours and minutes
3. Specify seconds and nanoseconds in addition to hours and minutes

java.time.format.DateTimeFormatter

1. ofPattern(String)
   Specify format pattern
2. ofLocalizedDate(FormatStyle)
   Specify the date format method
3. ofLocalizedTime(FormatStyle)
   Specify the time format method
4. ofLocalizedDateTime(FormatStyle)
   Specify the date and time format
5. ofLocalizedDateTime(FormatStyle, FormatStyle)
   Specify the date and time format method separately for date and time
6. Static predefined formatter BASIC_ISO_DATE etc.

java.time.format.FormatStyle

There are 4 types of FormatStyle

• FormatStyle.FULL
  Complete format including time zone. Exception at runtime when applied to LocalDateTime etc. that do not have zone information
• FormatStyle.LONG
  Concise format including time zone. Exception at runtime when applied to LocalDateTime etc. that do not have zone information
• FormatStyle.MEDIUM
  Concise format without timezone
• FormatStyle.SHORT
  Concise date and time formatting without timezone

LocalDateTime dateTime = LocalDateTime.of(2020, 8, 14, 9, 54, 30);
ZonedDateTime zDateTime =
    ZonedDateTime.of(dateTime, ZoneId.systemDefault());

// FormatStyle.FULL… “August 14, 2020 9:54:30”
println(fmt1.format(zDateTime));

// FormatStyle.LONG … 『2020/08/14 9:54:30 JST』
println(fmt2.format(zDateTime));

// FormatStyle.MEDIUM … 『2020/08/14 9:54:30』
println(fmt3.format(dateTime));

// FormatStyle.SHORT … 『20/08/14 9:54』
println(fmt4.format(dateTime));

Date and Time API format string

• "y"… year
• "M"… Month (uppercase)
• "d"… day
• "H" ... hour (uppercase)
• "m"… minutes
• "s"… seconds
• "S" ... milliseconds (capital letters)
• "n" ... nanoseconds

Date / time addition / subtraction

Add ... plus (Temporal Amount amount ToAdd) Subtraction… minus (Temporal Amount amount To Subtract)

• Period and Duration implement the TemporalAmount interface
• It is possible to add or subtract to individual fields such as plusYears and plusWeeks, but when dealing with multiple fields at once, call plus with Period and Duration as arguments.

Daylight saving time

• Daylight saving time application start date (time advance date) and application end date (time return date) are different every year even in the same area. However, the time is fixed at 02:00
• When the application is started, the offset is reduced by 1 hour and the time is advanced by 1 hour. It will be 03:00 one minute after 01:59 because it will advance one hour from 02:00. If you take the interval between 01:00 and 03:00 on the application start date, it will be 1 hour instead of 2 hours.
• When the application is finished, the offset increases by 1 hour and the time returns by 1 hour. It will be 01:00 one minute after 01:59 because it will return one hour from 02:00.

Period: Date

• The Period expression with toString () is ** "P00Y00M00D" ** The leading "P" is an acronym for "Period"
• There are several ways to instantiate Period
• Take the difference between two LocalDate and LocalDateTime with the between method
• Generated by the ofXXXXX method such as ʻofYears (1)`. However, method chain is not possible
• Period can be added or subtracted by year, month, day or week The addition and subtraction methods are plusXXXXX / minusXXXXX. plusYears (1) etc. If you add the weeks with plusWeeks (3), you get "P21D". Because there is no Period expression for the week
• LocalDate / LocalDateTime can add or subtract dates with Period as an argument with the plus / minus method.

//Addition of years using Period
LocalDateTime dt = LocalDateTime.now();
Period p = Period.ofYears(1);

//This is equivalent to the following two lines (method chain is meaningless)
// Period p1 = Period.ofDays(1);
// Period p = Period.ofYears(2);
Period p = Period.ofDays(1).ofYears(2);

Duration: hours, minutes and seconds

• The Duration expression oftoString ()is " PT00H00M00S " The leading "PT" is an abbreviation for "Period of Time"
• There are several ways to instantiate Duration
• Take the difference between two LocalDateTime and LocalTime with the between method
• Generated by the ofXXXXX method such as ʻofHours (1)`
• Generated with ChromeUnit in of methods such as ʻof (1, ChronoUnit.HOURS)`
• Duration can be added or subtracted in days, hours, minutes, seconds, milliseconds, nanoseconds When the days are added, it becomes PT24H, and when it is less than a millisecond, it becomes PT0.13S.
• LocalTime / LocalDateTime can add or subtract hours, minutes and seconds with Duration as an argument with the plus / minus method.

java.time.Instant

• Class that expresses the passage from epoch time
• There are several ways to create an instance
  1. Instant#now()
  2. Instant#ofEposSecond(long)
  3. Instant#ofEpocMilli(long)
  4. LocalDateTime#toInstant(ZoneOffset)
  5. ZonedDateTime#toInstant()
• LocalDateTime # toInstant requires ZoneOffset because LocalDateTime does not contain time zone information.
• ʻInstant` timezone is always UTC

Input / output

Reading using java.io.Reader

• Reader
  • public int read()
    Returns the read character. When you reach the end **-1 **
  • public int read(char[] buffer)
  • public int read(char[] buffer, int offset, int length)
    Returns the number of characters by putting the read characters in part or all of the array. When you reach the end **-1 **
• BufferedReader
  • public String readLine()
    Returns the read line of text. ** null ** when you reach the end

Writing using java.io.Writer

• Writer
  • public void write(char[] buffer)
  • public void write(char[] buffer, int offset, int length)
    Write part or all of the array
  • public void write(int c)
    Write one character
  • public void write(String str)
  • public void write(String str, int offset, int length)
    Write part or all of the string
• BufferedWriter
  • public void newLine()
    Write a newline character

Read position control of java.io.Reader and java.io.InputStream

• skip(long bytes)
  Skips the specified number of bytes from the current position
• mark(int readAheadLimit)
  Mark the current position so that you can return with reset (). The argument is ** the upper limit of the number of characters that can be read while maintaining the mark **
• reset()
  Return to the position where mark () was done

//The contents of the file are"01234567"
//The execution result is"025676"
try (BufferedReader br =
        new BufferedReader(new FileReader("sample.txt"))) {
    for (int i = 0; i < 3; i++) {
        br.skip(i); //Skip i bytes
        System.out.print((char)br.read());
    }
    br.mark(3); //present location("6"INDEX with=5 places)Mark
    System.out.print(br.readLine());
    br.reset(); //Marked position(INDEX=5 places)Back to
    System.out.println((char)br.read());
} catch (IOException e) {
    e.printStackTrace();
}

java.io.PrintWriter

• A subclass of java.io.Writer that can output primitive types as they are For boolean / char / char [] / int / float / long / String / Object
• Strings can be formatted using format in addition to print and println
• Has automatic flash function
• There is PrintStream in a class with the same function Replaced by PrintWriter in JDK1.2, but remains for backward compatibility

java.io.Console

• Read data from standard input
• Get a singleton instance with System # console (). ** Returns null if not available **
• Get the entered string as a String with readLine ()
• Get the entered character string with char [] with readPassword (). Since the password is read, the character string is not displayed when entering
• You can get the PrintWriter and Reader associated with the console with writer () and reader (), respectively.
• Console itself has printf and format methods to print strings to the console

Notes on serialization

• Classes that implement the java.io.Serializable interface can be serialized
• Either of the following is not subject to serialization

1. static variable
2. Transient declared member variable

• If the superclass can be serialized, so can the subclass
• Deserialization does not call the instance initialization block or the constructor. However, the static initialization block is called Also, in the following cases, only the superclass constructor is called.

1. It is Serializable itself, but the superclass is not Serializable
2. The superclass has a no-argument constructor
3. The subclass constructor does not explicitly call the parent constructor

• Whether or not a member variable can be serialized depends on the data type of the contents, not on the field. Whatever the type of variable, it can be serialized if its contents are Serializable

NIO2

java.nio.file.Path (feature)

• Generated by the following method
  • Paths#get(String, String...)
  • FileSystem#getPath(String, String...)
• The main features are as follows. Features not found in java.io.File
• Handle file and directory paths
• File attributes (owner, permissions, etc.) can be acquired and changed
• Can handle symbolic links
• It is possible to change and monitor events that occur in the directory, such as creating files.
• Mutual conversion with java.io.File is possible
  • File#toPath()
  • Path#toFile()

java.nio.file.Path (method)

• getRoot()
  Returns the root of the path. Null from Path generated by relative path
• subpath(int start, int end)
  Generates a Path that extracts the range specified by the index, excluding the root.
• getName(int)
  Returns the part specified by the index as a String, excluding the root
• relativize(Path)
  Returns the relative path to the argument
• resolve(String)、resolve(Path)
  Resolve the path. The Path that is the return value differs depending on the argument
• Arguments are relative paths ... Returns concatenated arguments to the receiver
• Argument is an absolute path ... Returns the argument as it is
• Empty argument ... Returns the receiver itself
• resolveSibling(String)、resolveSibling(Path)
  Resolve the path to the receiver's parent. The Path that is the return value differs depending on the argument
• Argument is an absolute path ... Returns the argument concatenated to the receiver
• Other ... Arguments are concatenated and returned to the receiver
• normalize()
  Returns the path converted to the appropriate shape by removing redundant parts such as "." And ".."

String sp1 = "/tmp/work1/sample.txt";
String sp2 = "/tmp/work2/dummy.txt";
Path p1 = Paths.get(sp1);
Path p2 = FileSystems.getDefault().getPath(sp2);
println(p1.getRoot());      // "/"
println(p1.subpath(0, 2));  // "tmp/work1"
println(p1.relativize(p2)); // "../../work2/dummy.txt"
println(p1.getName(0));     // "tmp"

Path rp = p1.resolve("../dat");
println(rp);                // "/tmp/work1/sample.txt/../dat"
println(rp.normalize());    // "/tmp/work1/dat"

//For Windows
Path wp = Paths.get("C:¥¥temp¥¥work¥¥sample.txt");
println(wp.getRoot());      // "C:¥"

java.nio.file.FileSystem

Provides an interface to the file system. Get with the static method of the FileSystems class

• FileSystems#getDefault
• FileSystems#getFileSystem
• FileSystems#newFileSystem

java.nio.file.Files (file operation)

The following are all static methods

• copy
  Copy files and directories

1. The contents of the directory are not copied
2. When a file with the same name exists in the copy destination, an exception is made if there is no overwrite specification in CopyOption.
3. The default behavior is that copying a file does not copy attributes
4. If you copy a symbolic link without specifying CopyOption, the entity indicated by the link will be copied.
5. The path given to the argument is not the place to copy / move, but the path after moving / copying

• move
  Move files and directories. Behavior is the same as 1 to 5 of copy
• getAttribute(Path, String, LinkOption...)
  Read file attribute values (file size, modification date, etc.)
• Stream<String> lines(Path)
• List<String> readAllLines(Path)
  Returns all lines of the file. The return type differs depending on the method

java.nio.file.Files (directory manipulation)

The following are all static methods

• createDirectory()
  Create a directory, but not a parent
• createDirectories()
  Create a directory including parents
• delete ／ deleteIfExists
  Delete the file. If it fails, the former is an exception, the latter is a boolean type and the result is returned. Neither can be deleted if there is a file in the directory and an exception is thrown
• newDirectoryStream(Path)
  Returns the path in the directory with the implementation class DirectoryStream <Path> of ʻIterable`
• list(Path)
  Returns a list of files and directories in a directory with Stream <Path>. Exception throws if argument is not a directory

java.nio.file.Files (search directory)

The following are all static methods

• walk()
• walkFileTree()
  Search recursively including subdirectories
• list()
  Search only that directory
• find()
  Recursively search for items that meet the conditions, including subdirectories
• All of these return values are streams, so pipeline processing is possible.

java.nio.file.attribute

A package that contains classes that represent the attributes of a file (creation time, access time, owner, etc.). Also includes an attribute view interface that shows a set of attribute information

• BasicFileAttributes interface Basic attribute information
• DosFileAttributes interface DOS attribute information
• PosixFileAttributes interface Unix / Linux attribute information
• ʻAttributeView` interface A set of attribute information. The following exist as subinterfaces
  • BasicFileAttributeView
  • DosFileAttributeView
  • PosixFileAttributeView

Parallel processing

Functions provided by the concurrency utility

1. Thread pool Thread creation and reuse
2. Parallel collection A collection that can properly handle parallel access from multiple threads
3. Atomic variables Implemented a series of indivisible operations to prevent value inconsistencies due to concurrent access (same as synchronized)
4. Counting semaphore You can freely set the number of threads that can access a finite number of resources in parallel.

Parallel collection

• API related to parallel processing is as follows. All java.util.concurrent packages
• BlockingQueue interface
• BlockingDeque interface
• ConcurrentMap interface
• ConcurrentHashMap class
• CopyOnWriteArrayList class
• CopyOnWriteArraySet class
• If you operate a collection object that does not support parallel processing from multiple threads, java.util.ConcurrentModificationException will occur.
• If you use an iterator in an extended for statement when operating from multiple threads, the contents of the collection at the time the iterator was created will be used.

java.util.concurrent.ConcurrentMap interface

• V getOrDefault(Object key, V defaultValue)
  Returns the value associated with key. Returns defaultValue if not
• V putIfAbsent(K key, V value)
  Added only when the value associated with key is not in the map
• boolean remove(Object key, Object value)
  Delete any elements that match both key and value
• V replace(K key, V value)
  Replace if the value specified for key is in the map
• V replace(K key, V oldValue, V newValue)
  Replace the value with newValue if there is an element that matches both key and oldValue

//The contents of the map[1, "One"], [2, "Two.2"], [3, "Three"]
Map<Integer, String> map = new ConcurrentHashMap<>();
map.put(1, "One");
map.putIfAbsent(1, "One.2"); //Do not add(KEY=1 element already exists)
map.put(2, "Two");
map.replace(2, "Two.2");           //Replacement
map.replace(2, "Two.22", "Two.3"); //Do not replace(The second argument is different from the existing value)
map.put(3, "Three");     //Delete
map.remove(3, "Three2"); //Do not delete(The second argument is different from the existing value)

java.util.concurrent.CopyOnWriteArrayList class

• When changing the internally held element, copy the array containing the old element, change it, and replace it. Therefore, the overhead increases as the size of the list increases.
• If another thread accesses the list while modifying an element (copying to a new array), it will refer to the contents of the old array.

java.util.concurrent.CyclicBarrier class

• Provides the ability to align each thread in a thread party (a collection of threads that work with emphasis)
• Specify the number of threads to cooperate in the constructor. The first argument is the number of threads to be coordinated, and if there is a second argument, the process executed when the trip (= barrier is released)
  • new CyclicBarrier(int)
  • new CyclicBarrier(int, Runnable)
• The thread that executed ʻawait ()waits until the number of threads specified in the constructor ofCyclicBarrier` awaits.
  • await(long timeout) No timeout
  • await(long timeout, TimeUnit unit) There is a timeout
• If you do new CyclicBarrier (3) for 4 threads, a trip will occur when 3 threads ʻawait. But the last one can't break through the barrier until two more threads ʻawait, so it can't continue.

//There are 3 threads for 2 barriers, so
// "wait wait wait finish finish"And the process stops
ExecutorService service = Executors.newCachedThreadPool();
CyclicBarrier barrier = new CyclicBarrier(2);
for (int i = 0; i < 3; i++) {
    service.execute(() -> {
        try {
            System.out.print("wait ");
            barrier.await();
            System.out.println("finish ");
        } catch (BarrierBrokenException | InterruptedException ignore) {
        }
    });
}
service.shutdown();

ExecutorService inheritance relationship

• Executor … execute(Runnabble)
• ʻExecutorService… submit (Runnable)etc. *ThreadPoolExecutor *ForkJoinPool`
• ScheduledExecutorService…schedule (Runnable, long, TimeUnit)etc. * ScheduledThreadPoolExecutor

Executors methods and corresponding ExecutorService specifications

• newSingleThreadExecutor()
  Perform tasks in a single thread
• newCachedThreadPool()
  Create new threads or reuse them to perform tasks as needed
• newFixedThreadPool(int)
  Perform tasks by reusing a fixed number of threads
• newScheduledThreadPool(int)
  Perform tasks by reusing a fixed number of threads. Tasks can be scheduled
• newSingleThreadScheduledExecutor()
  Perform tasks in a single thread. Tasks can be scheduled

ExecutorService#execute

• Get a ʻExecutorService object of the appropriate nature with a static method of the ʻExecutors class and execute it with the ʻexecute (Runnable)` method
• Use the following method to check the execution status of the task
  • isShutdown()
    If true, new tasks cannot be accepted (possibly unexecuted or running tasks)
  • isTerminated()
    If true, new tasks cannot be accepted and all tasks have been completed.
• If ʻisShutdown () is not true, a new task ʻexecute is possible. ʻExcute` when true raises an exception

ExecutorService#submit

• ExecutorService has multiple overload methods and the return value is Future. What you can get from Future depends on the method
  • Future<T> submit(Runnable)
    Execute the task. You can get the success or failure of the task
  • Future<?> submit(Runnable, T)
    Executes the task of the first argument and returns the value of the second argument. You can get the success or failure of the task
  • Future<T> submit(Callable<T>)
    Execute the task. You can get the return value from the task
• The task will be executed immediately, but when Future # get () is executed, there will be a waiting time until the value can be obtained even after the task is completed.
• You can also cancel a task that was submitted fromFuture <T>(only if possible).

Runnable and Callable

• Runnable
• Do not return a return value
• Cannot throw checked exception
• Can be executed with either ʻexecute or submit`
• Callable
• Can return a return value
• Can throw checked exceptions
• Can only be executed with submit

java.util.concurrent.Future interface

• V get()
  You can get the execution result of the task
• boolean cancel(boolean)
  Attempt to cancel task
• boolean isCancelled()
  Know if the task has been cancelled
• boolean isDone()
  Know if the task is complete

Parallel stream

• Generate
  • Collection#parallelStream()
    Generate a parallel stream from a collection
• Mutual conversion
  • BaseStream#parallel()
    Generate a parallel stream from a sequential stream
  • BaseStream#sequential()
    Generate sequential stream from parallel stream
• Judgment
  • BaseStream#isParallel()
    Determine if it is a parallel stream

//Parallel stream generation
Arrays.asList(1, 2, 3).parallelStream().forEach(System.out::println);

//Generate a parallel stream from a sequential stream
Stream.of("a", "b", "c").parallel().forEach(System.out::println);

//Generate sequential stream from parallel stream
Arrays.asList("A", "B", "C").parallelStream().sequential().forEach(System.out::println);

Fork / Join framework

• I abandoned here. If you are serious, let's study properly

Atomic variables

• Classes with names starting with Atomic ~ guarantee that operations on the values they handle are thread-safe.
• The main classes are as follows. Float and Double do not exist
• ʻAtomicInteger`… int type
• ʻAtomicLong`… long type
• ʻAtomicBoolean`… boolean type
• ʻAtomicReference`… Reference type

JDBC

Execute query

• The packages to which the class to be used belong are java.sql and javax.sql
• The URL format for connecting to DB with JDBC is as follows jdbc: [DB name] // [host (: port)] / [db-name](? option)
• The basic processing flow is as follows

1. Get Connection withDriverManager # getConnection (url, id, pass)
2. Get Statement withConnection # createStatement ()
3. Get ResultSet withStatement # executeQuery (sql)
4. Extract the result of the query from ResultSet

• Prior to JDBC3.0, you had to run Class.forName ([JDBC driver class name]) before DriverManager # getConnection.
• ʻEven if the result of the query executed by executeQueryis 0, the return value will be emptyResultSet` instead of null.
• Only one ResultSet can be handled by oneStatement. If you get another ResultSet without closing the first ResultSet, the first one will be closed automatically. Exception when trying to manipulate a closed ResultSet ʻAutomatically closes when executeUpdate` etc. is executed

Proper use of methods in Statement

• ResultSet executeQuery(String sql)
  Returns the query execution result
• int executeUpdate(String sql)
  Execute SQL such as INSERT / UPDATE / DELETE and return the number of processes
• boolean execute(String sql)
  Executes any kind of SQL, including queries, and returns whether the processing resulted in ResultSet. If true, ResultSet is returned, if false, it is not. If ResultSet is returned as a result of processing, get it withStatement # getResultSet (). If it is not ResultSet, useStatement # getUpdateCount ()to get the number of processes.

Acquisition and properties of ResultSet

• In Connection # createStatement (type, concurrency), specify "scrollability" and "table data updateability" of ResultSet in order.
• There are three types of scrollability, all of which are constants of the ResultSet class.
• TYPE_FORWARD_ONLY… Can only be moved in the forward direction
• TYPE_SCROLL_INSENSITIVE… Can be moved in both directions. Does not reflect changes to the cursor
• TYPE_SCROLL_SENSITIVE… Can be moved in both directions. Reflect changes to the cursor
• There are two types of table data updateability, all of which are constants of the ResultSet class.
• CONCUR_READ_ONLY… Read only
• CONCUR_UPDATABLE… Updatable
• When getting an updatable ResultSet withStatement # createStatement (..., ResultSet.CONCUR_UPDATABLE), the column to be updated must be specified in the select statement of ʻexecuteQuery`.

ResultSet scrolling method

• boolean absolute(int)
  Move to the specified line (specify the absolute position). The first line is 1.0 beforeFirst
• boolean relative(int)
  Move by specifying a relative position. Positive values go to the next line, negative values go to the previous line
• boolean next()
  Move to the next line
• boolean previous()
  Move to the previous line
• boolean first()
  Move to first line
• void beforeFirst()
  Move just before the first line
• boolean last()
  Move to last line
• void afterLast()
  Move immediately after the last line

Updatable ResultSet

• Update Change with ʻupdateString or ʻupdateInt and confirm the change with ʻupdateRowEven if the type ofStatement is TYPE_SCROLL_INSENSITIVE, the contents of the DB and even the result set will not be changed unless it is ʻupdateRow.
  • updateString(int, String)
  • updateInt(int, int)
  • updateRow()
• Insert Use moveToInsertRow to move to the insert row, use ʻupdateString or ʻupdateInt to specify the insertion content, and use ʻinsertRow` to insert.
  • moveToInsertRow()
  • insertRow()
• Delete Delete the current line
  • deleteRow()

Localization and format

Get java.util.Locale object

1. Locale#getDefault()
   Java runtime environment locale
2. new Locale(String)
   The argument is "language code"
3. new Loacle(String, String)
   The argument is "language code, country code"
4. new Loacle(String, String, String)
   The argument is "language code, country code, variant"
5. Set the appropriate value for Locale.Builder generated by new and generate it withbuild ()

java.util.Properties

• Supported file formats are text and XML
• For text files, list the keys and values separated by = or:
• Load property list from file
  • load(InputStream)
  • load(Reader)
  • loadFromXML(InputStream)
• Output property list
  • list(OutputStream)
  • list(Writer)
  • entrySet()
  • forEach(BiConsumer)
• Get property
  • getProperty(String)
    Returns null if there is no corresponding Key
  • getProperty(String, String)
    If there is no corresponding Key, return the second argument

java.util.ListResourceBundle

• Prepare the resource as a .class file and put it in the place where the classpath is put.
• How to use is as follows

1. Define a public class that inherits ListResourceBundle Override public Object [] [] getContents () The fully qualified name (package name + class name) of this class will be the base name, and this class will be for the default locale. Example: Class name is "MyResource"
2. Define a class for a locale different from 1 by inheriting ListResourceBundle The naming rule is ** "base name_language code_country code" ** Example: The class name for the English locale will be "MyResource_en_US"
3. Get the ListResourceBundle object withResourceBundle # getBundle (base name [, locale])
4. Get the value with ResourceBundle # getXXXXX (key string)

java.util.PropertyResourceBundle

• Prepare the resource in the .properties file and put it in the location where the classpath is put.
• How to use is as follows

1. Create a properties file for the default locale

• Extension is **. Properties **
• Define multiple properties in "key name = value" format
• File must be ISO-8859-1 encoded
• File naming convention is the same as the class name of ListResourceBundle

2. Create a file for a locale different from 1

• File naming convention is the same as the class name of ListResourceBundle
• MyResource_en_US.properties for English locale

3. Get the PropertyResourceBundle object withResourceBundle # getBundle (base name [, locale])

• Same method to get ListResourceBundle

4. Use the following method to retrieve the value. there is no getInt

• ResourceBundle # getObject (key string)
• ResourceBundle # getString (key string)
• ResourceBundle # getStringArray (key string)

Priority of resource bundles used

• If the resource bundle corresponding to the locale does not exist, a MissingResourceException exception will be thrown.
• There is no exception even if there are multiple resource bundles with the same name.
• Search resource bundles by individual property rather than by file. The search priority is as follows

1. Language code and country code match
2. Language code matches
3. Match default locale

• If the property corresponding to the specified key does not exist in any class / file, MissingResourceException will occur.
• If both the ListResourceBundle class and the properties file have the same name, the class takes precedence over the file.

Format numbers using NumberFormat

• Use the static method of the NumberFormat class to get the desired object
  • getInstance()
    Numerical format of default locale
  • getInstance(Locale)
    Numerical format for any locale
  • getCurrencyInstance(Locale)
    Currency format for any locale
  • getIntegerInstance(Locale)
    Integer format for any locale
• Get a formatted string with format (long) or format (double)
• Get a number from a string with parse (String). The return value is Number

Change log

• 2020/08/23
  Published on Qiita
• 2020/08/24
  Changed the list of functional interfaces to tabular format Added sample code for enumerated values