Java tricky questions

var z = x <-- y;

void method() {
    {
        int a;
    }
    foo: {
        int a;
    }
    bar: if (1 < 2) {
        break bar;
    }
}

http://google.com
int x = 1;

int x = 1;
// \u000a x=2;
System.out.println(x);

package deadlocks;

public class Deadlock1 {
    void method(String label) {
        Boolean x = true;
        synchronized (x) {
            while (true) {
                System.out.println("Running " + label);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Deadlock1 deadlock1 = new Deadlock1();
        new Thread(() -> deadlock1.method("1")).start();
        new Thread(() -> deadlock1.method("2")).start();
    }
}

package deadlocks;

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Deadlock2 {
    public static void main(String[] args) {
        List<Integer> values = IntStream.range(0, 100).boxed().collect(Collectors.toList());
        List<Integer> results = values.parallelStream() // paralell czyli szybciej? ;)
                .map(Deadlock2::process)
                .collect(Collectors.toList());
        System.out.println(results);
    }

    private static Integer process(int x) {
        System.out.println(Thread.currentThread() + " Entered " + x);
        CompletableFuture<Integer> async = CompletableFuture.supplyAsync(() -> slowFunction(x)); // puszczamy w tle, a my cośtam dalej możemy sobie robić bo kiedyś nam sie to policzy...
        while (!async.isDone()) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return async.join();
    }

    private static int slowFunction(int x) {
        return x + 1;
    }
}

int n = 0;
n--;
System.out.println(n++);

int a = -1;
System.out.println(1 - a++);

final ArrayList<Integer> ints = new ArrayList<>();
ints.add(1);

final ArrayList<Integer> ints2 = new ArrayList(){{
	add(1);
}};

System.out.println(ints);
System.out.println(ints2);

final ArrayList<Integer> ints2 = new ArrayList<>() {
	@Override
	public boolean add(Integer o) {
		return super.add(o);
	}

	{add(1);}
};

int a = 1, b = 2;
System.out.println(a+++--b*++a);

public static void main(String[] args) {
    boolean a;
    if(smartThings()) {
        a = true;
    }
    System.out.println(a);
}

static boolean smartThings() {
    return true;
}

class Person {
  String name;

  Person(String name){
    this.name=name;
  }
  
  public boolean equals(Person p){
     return name.equals(p.name);
  }

  public int hashCode() {
    return name.hashCode();
  }
}

//…
Person p1 = new Person(„A”),
       p2 = new Person(„A”);

Set<Person> ppl = new HashSet<>();
ppl.add(p1);
ppl.add(p2);
System.out.println(ppl.size());

class Base {
  Base(int x) {}
}

class Sub extends Base {}

int n=0;
n=n--;
System.out.println(n);

Integer x1 = 50;
Integer x2 = 50;
System.out.println(x1 == x2);
Integer y1 = 500;
Integer y2 = 500;
System.out.println(y1 == y2);

class A {
    public static final int X = B.Y + 1;   
}
class B {
    public static final int Y = A.X + 1;
}
public class C {
    public static void main(String []args){
        System.out.println("X = "+A.X+", Y = "+B.Y);
     }
}

int i = 0;
i = i++ - ++i;