Core Java. Lecture #2

<dependency>
  <groupId>org.apache.commons</groupId> (1)
  <artifactId>commons-csv</artifactId> (2)
  <version>1.14.1</version> (3)
</dependency>

implementation("org.apache.commons:commons-csv:1.14.1")

mvn archetype:generate \
    -DarchetypeGroupId=org.atp-fivt \
    -DarchetypeArtifactId=homework-quickstart \
    -DarchetypeVersion=3.0

<build><plugins>
     ...
     <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <version>3.4.2</version>
        <configuration> (1)
          <archive><manifest>
              <mainClass>edu.phystech.App</mainClass>
            </manifest></archive>
        </configuration>
      </plugin>

java -jar target\helloworld-1.0-SNAPSHOT.jar
Hello World!

abstract   continue   for          new         switch
assert     default    if           package     synchronized
boolean    do         goto         private     this
break      double     implements   protected   throw
byte       else       import       public      throws
case       enum       instanceof   return      transient
catch      extends    int          short       try
char       final      interface    static      void
class      finally    long         strictfp    volatile
const      float      native       super       while
_ (underscore)

             null       true        false

var var = 42;

(Java 9)
open     module      requires    transitive    exports
opens    to          uses        provides      with

(Java 10)
var

(Java 14)
yield    record

(Java 15)
sealed   non-sealed  permits

(Java 21)
when

/**
 * This is the first sample program in Core Java Chapter 3
 * @version 1.01 1997-03-22
 * @author Gary Cornell
 */
public class FirstSample
{
  public static void main(String[] args)
  {
  /*multiline
  comment*/
  System
    .out //single-line comment
    .println("We will not use 'Hello, World!'");
  }
}

double x = 9.997F; //float to double converted implicitly
int nx = (int) x; //9
nx = (int) Math.round(x); //10

String s = "Hello, world!";

//Before Java 13
String txt =
      "Some\n" +
      "  Nested\n" +
      "    Text\n" +
      "  Is\n" +
      "Here\n";

Some
  Nested
    Text
  Is
Here

    String txt = """
      Some
        Nested
          Text
        Is
      Here
      """;

//The maximum number of spaces ahead has been removed:
Some
  Nested
    Text
  Is
Here

// declaration
double salary;
int vacationDays;
long earthPopulation;
boolean done;

// not very welcomed
int i, j;

// technically possible, but . . .
int суммаНДФЛ;

int vacationDays;
System.out.println(vacationDays); //COMPILATION ERROR
  // variable not initialized

int vacationDays;
vacationDays = 12;

int vacationDays = 12;

final int a;
...
a = 42; // initialization

...
a = 43; // compilation error:
  // variable a might already have been initialized

int n;
. . .
{
  int k;
  int n; // Error--can't redefine n in inner block
  . . .
} // k is only defined up to here

var i = 1; // i is of int type

//BEFORE JAVA 10
URL codefx = new URL("http://codefx.org");
URLConnection connection = codefx.openConnection();
Reader reader = new BufferedReader(
    new InputStreamReader(connection.getInputStream()));

//AFTER JAVA 10
var codefx = new URL("http://codefx.org");
var connection = codefx.openConnection();
var reader = new BufferedReader(
    new InputStreamReader(connection.getInputStream()));

x != 0 && 1 / x > x + y // no division by 0

int x;
System.out.println(x = 42); //prints 42

while ((n = readValue()) != null)
  ... //do something with n

x < y ? x : y

//Conjunction operator has higher priority than disjunction, that's why
a || b && c
// is equivalent to
a || (b && c)

//Since += associates right to left, the expression
a += b += c
//means
a += (b += c)
//That is, the value of b += c
// (which is the value of b after the addition)
//is added to a.

double r;
for (int i = 0; i < 10; i++, r = Math.random()) {

}

int[] luckyNumbers = smallPrimes;
luckyNumbers[5] = 12; // now smallPrimes[5] is also 12

luckyNumbers = Arrays.copyOf(luckyNumbers, 2 * luckyNumbers.length);
//now luckyNumbers is a separate array
//and it became twice as long

 String[] a = new String[1];
 // Compiles. after all, a string is an object,
 // and so why not think of an array of strings as an array of objects?
 Object[] b = a;
 // runtime ArrayStoreException
 b[0] = 5;

final boolean flag = false;
. . .
while (flag) {
   . . . //won't compile, unreachable code
}

for (int i = 1; i <= 10; i++)
  System.out.println(i);

for (int i = 1; i <= 10; i++, j++)
  System.out.println(i);

for (int i = 1; i <= 10; i++)
{
. . .
}
// i no longer defined here

int i;
for (i = 1; i <= 10; i++)
{
. . .
}
// i is still defined here

while (years <= 100) {
  balance += payment;
  double interest = balance * interestRate / 100;
  balance += interest;
  if (balance >= goal) break;
  years++;
}

Scanner in = new Scanner(System.in);
while (sum < goal) {
  System.out.print("Enter a number: ");
  n = in.nextInt();
  if (n < 0) continue;
  sum += n; not executed if n < 0
}

Scanner in = new Scanner(System.in); int n;
read_data: while (. . .) { // <<<label is here!
  . . .
  for (. . .) {
    System.out.print("Enter a number >= 0: ");
    n = in.nextInt();
    if (n < 0)
      break read_data;
      // break out of read_data loop
    . . .
   }
}
if (n < 0) {
  // deal with bad situation
} else {
  // carry out normal processing
}