Java Gold资格认证:1Z0-809题解

1

答案改正：3 d 20 a 24 a 39 c 40 a 53 d 56 bc 60 d 69 d 70 d 76 a 77 a 87 c 102 ab 116 a 117 b 119 b 120 a 132 a 140 b 148 d 152 d 153 d 156 d 

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

class MyClass  implements  AutoCloseable{
    int test;
    public  void close(){
    }
    public MyClass copyObject() {
        //return new MyClass(); 如果改成这样，结果是0
      return this;//把obj1的rest传给obj，结果是100
    }
}
    public static void main(String[] args) throws Exception {
        MyClass obj = null;
        try(MyClass obj1 = new MyClass()){
            obj1.test= 100;
            obj = obj1.copyObject();
        }
        System.out.println(obj.test);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public static void main(String[] args) {
         String url = "jdbc:mysql://localhost:3306/flystone";
          String name = "root";
          String password = "";
        try {

            Connection conn = DriverManager.getConnection(url, name, password);
            String query = "Select * FROM employees WHERE EMPLOYEE_ID = 110";
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery(query);
  /*          while (rs.next()) {
                System.out.println("ID:" + rs.getObject(1));//rs.getInt("Id")
            }*/
            System.out.println("ID:" + rs.getInt("EMPLOYEE_ID"));//rs.getInt("Id")//java.sql.SQLException: Before start of result set
        } catch (SQLException se) {
            System.out.println("Error");
        }
    }

1
2

while (resultSet.next()){
} //取值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Test_004 {
    public static void main(String[] args) {
        int i;
        char c;
        try (FileInputStream fis = new FileInputStream("/home/111.txt");
             InputStreamReader isr = new InputStreamReader(fis);) {
            while (isr.ready()) { //line n1
                isr.skip(2);
                i = isr.read();
                c = (char) i;
                System.out.print(c);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5

public class Test7 {
    public static void main(String[] args) {
        Stream.of("Joe", "Paul", "Alice", "Tom").filter(s -> s.contains("a")).peek(s -> System.out.println("peek" + s)).findFirst();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;



public class Test009 {

    public static void main(String[] args) {
        List<String> str = Arrays.asList("my", "pen", "is", "your", "pen");
        Predicate<String> test = s -> {
            int i = 0;
            boolean result = s.contains("pen");
            System.out.print(i++ + " : ");
            return result;
        };
        str.stream()
                .filter(test)
                .findFirst()
                .ifPresent(System.out::print);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Test010 {
    public static void main(String[] args) {
        Stream<Path> paths = Stream.of(Paths.get("data.doc"),
                Paths.get("data.txt"),
                Paths.get("data.xml"));
        paths.filter(s -> s.toString().endsWith("txt")).forEach(
                s -> {
                    try {
                        Files.readAllLines(s)
                                .stream()
                                .forEach(System.out::println); //line n1
                    } catch (IOException e) {
                        System.out.println("Exception");
                    }
                });
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.io.IOException;



class Video {
    public void play() throws IOException {
        System.out.print("Video played.");
    }
}
class Game extends Video {
    public void play() throws Exception {
        super.play();//注释掉的话就不输出父类的play()
        System.out.print("Game played.");
    }
}
class Solution{
    public static void main(String[] args) {
        try {
            new Game() .play() ;
        }catch (Exception e) {
            System.out.print(e.getclass());
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Stream<Path> files = Files.walk(Paths.get(System.getProperty("user.home")));
files.forEach(fName -> { //line n1
    try {
        Path aPath = fName.toAbsolutePath(); //line n2
        System.out.println(fName + ":"
                + Files.readAttributes(aPath, BasicFileAttributes.class).creationTime());
    } catch (IOException ex) {
        ex.printStackTrace();
    }
});

1
2
3
4
5
6

public class Test013 {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(10, 20, 8);
        System.out.println(nums.stream().max(Comparator.comparing(a -> a)).get());
    }
}

1
2

Path file = Paths.get("courses.txt");
// line n1

1
2

List<String> fc = Files.list(file);
fc.stream().forEach (s -> System.out.println(s));

1
2

Stream<String> fc = Files.readAllLines(file);
fc.forEach (s -> System.out.println(s));

1
2

List<String> fc = readAllLines(file);//  List<String> fc = Files.readAllLines(file);
fc.stream().forEach (s -> System.out.println(s));

1
2

Stream<String> fc = Files.lines(file);
fc.forEach (s -> System.out.println(s));

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

public static void main(String[] args) {
    int rateOfInterest = 0;
    String accountType = "LOAN";
    switch (accountType) {
        case "RD":
            rateOfInterest = 5;
            break;
        case "FD":
            rateOfInterest = 10;
            break;
        default:
            assert false : "No interest for this account"; //line n1
    }
    System.out.println("Rate of interest:" + rateOfInterest);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Employee {
    String dept, name;

    public Employee(String d, String n) {
        dept = d;
        name = n;
    }

    public String toString() {
        return getDept() + ":" + getName();
    }

    public String getDept() {
        return dept;
    }

    public String getName() {
        return name;
    }
  
    public static void main(String[] args) {
        List<Employee> emps = Arrays.asList(
                new Employee ("sales", "Ada"),
        new Employee ("sales", "Bob") ,
                new Employee ("hr","Bob"),
        new Employee ("hr", "Eva"));

        Stream<Employee> s = emps. stream()
                .sorted (Comparator.comparing( (Employee e) -> e .getDept ()).thenComparing( (Employee e) -> e.getName())) ;

        List<Employee> eSorted = s.collect (Collectors.toList());
        System.out.println(eSorted);

    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class Test017 {
    public static void main(String[] args) {
        Baz d = new Daze();
        d.b("hello");
    }
}


class Foo{
    public  void b(String s){
        System.out.println("F"+s);
    }
}

class Bar extends Foo{
    public  void b(String s){
        System.out.println("Bar"+s);
    }
}
class Baz extends Bar{
    public  void b(String s){
        System.out.println("baz"+s);
    }
}

class Daze extends Baz{
    private Bar bb= new Bar();
    public  void b(String s){
        bb.b(s);
        super.b(s);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Test020 {
    public static void main(String[] args) {
        List<Person> sts = Arrays.asList(
                new Person("Jack", 30),
                new Person ("Mike Hill", 21),
                new Person ("Thomas Hill", 24)) ;
        Stream<Person> resList = sts.stream().filter(s -> s.getAge() >= 25) ;
        long count = resList. filter(s -> s.getName (). contains ("Hill")) .count() ;
        System.out.println(count);
    }
}
class Person {
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import java.util.concurrent.CyclicBarrier;

class Worker extends Thread {
    CyclicBarrier cb;
    public Worker(CyclicBarrier cb) {
        this.cb = cb;
    }
    public void run() {
        try {
            cb.await();
            System.out.println("Worker...");
        } catch (Exception ex) {
        }
    }
}
class Master implements Runnable { //line n1
    public void run() {
        System.out.println("Master...");
    }
}
public class Test021 {
    public static void main(String[] args) {
        Master master = new Master();
        CyclicBarrier cb = new CyclicBarrier(1, master);
        Worker worker = new Worker(cb);
        worker.start();
    }
}

1

Files.copy(source, destination, StandardCopyOption.REPLACE_EXISTING);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Test023 {
}

interface Doable {

    public void doSomething(String s);
}

abstract class Task implements Doable {

    public void doSomethingElse(String s) {
    }
}

class Do implements Doable {

    public void doSomething(Integer i) {
    }

    public void doSomething(String s) {
    }

    public void doThat(String s) {
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Test024 {
    public static void main(String[] args) {
        Path path1 = Paths.get("/software/././sys/readme.txt") ;
        Path path2 = path1.normalize() ;
        Path path3 =path2.relativize(path1);
        System.out.println(path1.getNameCount());///software/././sys/readme.txt
        System.out.println(path2.getNameCount());///software/sys/readme.txt
        System.out.println(path3.getNameCount());//../../././sys/readme.txt
    }//5:3:6
}

1
2
3
4
5
6
7
8

public class Main {
    public static void main(String[] args) {
        var directory = Paths.get("/a/b/c/directory");
        var file = Paths.get("/a/b/c/directory/e/file");

        System.out.println(directory.relativize(file)); // => e\file
    }    
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class  Person1 implements Comparable<Person1> {
    String name;
    Person1(String name){
        this.name=name;
    }
    @Override
    public int compareTo(Person1 p) {
        return this.name.compareTo(p.name);
    }
}

1

public int compareTo(T o);

1
2
3
4
5

List<Integer> list1 = Arrays.asList(10, 20);
List<Integer> list2 = Arrays.asList(15, 30);
	Stream.of(list1, list2)
.flatMap(list -> list.stream())
.forEach(s -> System.out.print(s + " "));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class Test028 {

    public static void main(String[] args) {
        Book1 b1 = new Book1();
        b1.b("java");//b(java.lang.String)' has private access in 'Book1'
        Book1 b2 = new Ebook();
        b2.b("www.");//b(java.lang.String)' has private access in 'Book1'
    }
}


class Book1{
    private   String b(String s){//private
        return "F"+s;
    }
}

class Ebook extends Book1{
    public  String b(String url){
      return "view"+url;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Test029 {
    public static void main(String[] args) {
        final Counter obj1 = new Counter();
        final Counter obj2 = new Counter();
        new Thread(new Runnable() {
            public void run() {
                obj1.display(obj2);
            }
            }) .start();
                new Thread(new Runnable() {
                    public void run() {
                        obj2.display(obj1);
                    }
                }) .start();
            }
        }
        class Counter extends Thread {
            int i = 10;
            public synchronized void display(Counter obj) {
                try {
                    System.out.println("sss");
                    Thread.sleep(5);
                    obj.increment(this);
                    System.out.println(i);
                } catch (InterruptedException e) {
                }
            }
            public synchronized void increment(Counter obj) {
                i++;
            }
        }

1
2
3
4
5
6
7
8

public class Test031 {
    public static void main(String[] args) {
        List<String> nums = Arrays.asList("ee", "se");
        String ans = nums.parallelStream()
                .reduce("java", (a, b) -> a.concat(b));
        System.out.println(ans);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

 final class IceCream {
    public void prepare() {
    }
}

 class Cake {
    public final void bake(int min, int temp) {//final不能重写
    }
    public void mix() {
    }
}

 class Shop {
    private Cake c = new Cake();
    private final double discount = 0.25;
    public void makeReady() {
        c.bake(10, 120);
    }
}
 class Bread extends Cake {
    public void bake(int minutes, int temperature) {//报错 bake(int, int)' cannot override 'bake(int, int)' in 'Cake'; overridden method is final
    }
    public void addToppings() {
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Test035 {
    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        String url = "jdbc:mysql://localhost:3306/flystone";
        String name = "root";
        String password = "";
        try {
            Properties prop = new Properties();
            prop.put("user", name);
            prop.put("password", password);

            Connection conn = DriverManager.getConnection(url, prop);
            Statement st = conn.createStatement();
            String query = "DELETE  FROM employees WHERE EMPLOYEE_ID = 109";
            System.out.println("s" + st.execute(query));//while(rs.next()) 就是 将rs全部进行读取 不用会报错
/*            String query = "Select * FROM employees WHERE EMPLOYEE_ID = 110";
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while (rs.next()) {
                System.out.println("ID:" + rs.getObject(1));//rs.getInt("Id")
            }
            // System.out.println("ID:" + rs.getInt("EMPLOYEE_ID"));//rs.getInt("Id")*/
        } catch (SQLException se) {
            System.out.println("Error");
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class Test037 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService es = Executors.newFixedThreadPool(2);
        Future f1 = es.submit(new Caller("Call"));
        Future f2 = es.submit(new Runner("Run"));
        String str1 = (String) f1.get();
        String str2 = (String) f2.get();//line n1
        System.out.println(str1 + " : " + str2);
    }
}

class Caller implements Callable<String> {
    String str;
    public Caller(String s) {
        this.str = s;
    }
    public String call() throws Exception {
        return str.concat(" Caller");
    }
}

class Runner implements Runnable {
    String str;
    public Runner(String s) {
        this.str = s;
    }
    public void run() {
        System.out.println(str.concat(" Runner"));
    }
}

1
2
3
4
5

 Future<String>f1=es.submit(c1);
Future<String>f2= (Future<String>) es.submit(r1);
//报错Callable不能直接execute
 es.execute(c1);
 Future<String>f1=es.execute(c1);

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

public class Test039 {
    public static void main(String[] args) {
        IntConsumer consumer = e -> System.out.println(e);
        Integer value = 90;
        //a 
        //Function<Integer> funRef = e->e+10;
        //b
        //IntFunction funRef = e->e+10;
        //Integer result = (Integer) funRef.apply(10);//20 改成value的话是100
      	//c
        ToIntFunction<Integer>  funRef = e->e + 10;
        int result = (Integer) funRef.applyAsInt(value);//100
        consumer.accept(result);//100
    }
}

1

Function<Integer,Integer> funRef = e -> e + 10;//ok

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

public class Test040 {
    public static void main(String[] args) {

        List<Emp> emp = Arrays.asList(
                new Emp("John", "Smith"),
                new Emp("Peter", "Sam"),
                new Emp("Thomas", "Wale"));
        List<Emp> list = emp.stream().sorted(Comparator.comparing(Emp::getfName).reversed().thenComparing(Emp::getlName)).collect(Collectors.toList());//a
        List<Emp> listb = emp.stream()
                .sorted(Comparator.comparing(Emp::getfName).thenComparing(Emp::getlName))
                .collect(Collectors.toList());//a
        listb.stream().map(s->s.getfName()).forEach(System.out::print);

    }
}

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

import java.util.function.IntFunction;
import java.util.stream.IntStream;

public class Test043 {
    public static void main(String[] args) {

        IntStream stream = IntStream.of(1, 2, 3);
        IntFunction<Integer> inFu = x -> y -> x * y; // line n1
      IntFunction<IntUnaryOperator> inFu = x -> y -> x * y;//b
        IntStream newStream = stream.map(inFu.apply(10)); // line n2
        newStream.forEach(System.out::print);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class Test044 {
    public static void main(String[] args) {
        for(Course a:Course.values()){
            System.out.println(a+"f"+a.getCost());
        }
    }
}

enum Course{
    Java(100),J2me(150);
    private  int cost;

     Course(int i) {
        this.cost=i;
        }
     int getCost(){//d 不可以static
        return cost;
    }
}

1

枚举被设计成是单例模式，即枚举类型会由JVM在加载的时候，实例化枚举对象，你在枚举类中定义了多少个就会实例化多少个，JVM为了保证每一个枚举类元素的唯一实例，是不会允许外部进行new的，所以会把构造函数设计成private，防止用户生成实例，破坏唯一性。不可以public。

1
2
3
4
5
6
7
8

public class Test047 {
    public static void main(String[] args) {
        double d = 15;
        Locale l = new Locale("en","US");
        NumberFormat format = NumberFormat.getCurrencyInstance(l);
        System.out.println(format.format((d)));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

private static String url = "jdbc:mysql://localhost:3306/javabeantest";
private static String name = "root";
private static String password = "123456";
private static Connection conn = null;
static {
	try {
		Class.forName("com.mysql.jdbc.Driver");	
	} catch (ClassNotFoundException e) {
		e.printStackTrace();
	}
}
public static Connection getConnection() {
	try {
		conn = DriverManager.getConnection(url,name,password);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return conn;
}

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

	public static void main(String[] args) {
		Connection conn = DBUtils.getConnection();
		try {
			Statement sttm = conn.createStatement();
			ResultSet rs = sttm.executeQuery("select * from person");
			while(rs.next()) {
				System.out.println(rs.getObject(1)+".."+rs.getObject(2)+".."+rs.getObject(3));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

1
2
3
4
5
6
7
8

    public static void main(String[] args) throws SQLException {
             final  String str1 = "Java";
             StringBuffer strBuf = new StringBuffer("Course");
        UnaryOperator<String> u = (str2)-> str1.concat(str2);
                   UnaryOperator<String> c = (str3)-> str3.toLowerCase();
        //System.out.println(u.apply(c.apply(strBuf)));//d

    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

    String url="jdbc:mysql://localhost:3306/1713_day03";
    Properties properties =new Properties();
    properties.put("user", "root");
    properties.put("password", "123");
    Connection connection = DriverManager.getConnection(url, properties);
    //3.获得statement对象
    Statement statement = connection.createStatement();
    //4.定义sql语句
    String sql="insert into user (name,passwod) values('木子','123')";
    //5. 执行
    int  rowCount = statement.executeUpdate(sql);
    if (rowCount>0) {
        System.out.println("����ɹ�");
    }else {
        System.out.println("����ʧ��");
    }
    //6.关闭
    statement.close();
    connection.close();
}

1
2
3
4
5
6
7

public static void main(String[] args) {
    Predicate<String> test1 = w ->{
        System.out.println("111");
        return w.equals("do");
    };
    Predicate test2 = (String w) ->w.length() >3;//编译出错
}

1
2
3
4
5
6

public static void main(String[] args) {
    List<Integer> li = Arrays.asList(10,20,30);
    Function<Integer,Integer> fn =f1->f1+f1;
    Consumer<Integer> conVal = s -> System.out.println(s);
    li.stream().map(fn).forEach(conVal);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class Test063 {

    public static void main(String[] args) {

        List<Product> products = new ArrayList(Arrays.asList(new Product(1, 10),
                new Product(2, 30),
                new Product(2, 30)));
        Product p = products.stream().reduce(new Product(4, 0), (p1, p2) -> {
            p1.price += p2.price;
            return new Product(p1.id, p1.price);
        });
        products.add(p);
        products.stream().parallel()
                .reduce((p1, p2) -> p1.price > p2.price ? p1 : p2)
                .ifPresent(System.out::println);
    }
}

class Product {
    int id;
    int price;
    public Product(int id, int price) {
        this.id = id;
        this.price = price;
    }
    public String toString() {
        return id + " : " + price;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class Test064 {
    public static void main(String[] args) {
        try (ImageScanner ir = new ImageScanner();
             ImagePrinter iw = new ImagePrinter()) {
            ir.scanImage();
            iw.printImage();
        } catch (Exception e) {
            System.out.print(e.getMessage());
        }
    }
}

class ImageScanner implements AutoCloseable {
    public void close() throws Exception {
        System.out.print("Scanner closed. ");
    }
    public void scanImage() throws Exception {
        System.out.print("Scan.");
        throw new Exception("Unable to scan. ");
    }
}

class ImagePrinter implements AutoCloseable {
    public void close() throws Exception {
        System.out.print("Printer closed. ");
    }
    public void printImage() {
        System.out.print("Print.");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class Test066 {
    public static void main(String[] args) {
        Foo<String, Integer> mark = new Foo<String, Integer> ("Steve", 100);
        Foo<String, String> pair = Foo.twice ("Hello World!");
        //Foo<?, ?> percentage = new Foo<?, ?>(97, 32);//new Foo<?, ?>(97, 32) error
        Foo<?, ?> percentage = new Foo<>(97, 32);// right
        Foo<?, ?> percentage2 = new Foo<Integer, Integer>(97, 32);//right
        Foo<String, String> grade = new Foo<>("John", "A");
        System.out.println(pair.getValue());
    }
}
class Foo<K, V> {

    private K key;
    private V value;

    public Foo(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public static <T> Foo<T, T> twice(T value) {
        return new Foo<T, T>(value, value);
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }
}

1
2
3
4
5
6
7
8

Predicate<String> test = n -> {
    System.out.println("Searching...");
    return n.contains("red");
};
colors.stream()
        .filter(c -> c.length() > 3)
        .allMatch(test);
        List<String> colors = Arrays.asList("red", "green", "yellow");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Test {
    public static void main(String[] args) {

        List<String> cs = Arrays.asList("Java","Java se");
        boolean b1 = cs.stream().anyMatch(w ->w.equals("Java"));
        boolean b2 = cs.stream().allMatch(w ->w.equals("Java"));
        System.out.println(b);

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

class FileThread implements Runnable {

    String fName;

    public FileThread(String fName) {
        this.fName = fName;
    }

    public void run() {
        System.out.println(fName);
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();
        Stream<Path> listOfFiles = Files.walk(Paths.get("Java Projects"));
        listOfFiles.forEach(line -> {
            executor.execute(new FileThread(line.getFileName().toString())); //line n1
        });
        executor.shutdown();
        executor.awaitTermination(5, TimeUnit.DAYS); //line n2
    }
}

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

//计算器
interface calc{
    //抽象方法
    //int sum(int x,int y);
    //实体方法 加上default 方法就变成了实体方法
    public default int sum(int x,int y,int z)
    {
        return x+y+z;
    }
    //加上static可以实现实体方法
    public static int mul(int x,int y) {
        return x*y;
    }
    int max(int x,int y);
}

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

public class Test076 {
    public static void main(String[] args) {

        Map<Integer,Integer> mVal = new HashMap<>();
        mVal.put(1,10);
        mVal.put(2,20);
        //BiConsumer<Integer,Integer> a //right
        BiFunction<Integer,Integer,String>c = (i,j)->{//wrong BiFunction not have accept()
            System.out.println(i +"," +j+";");
        };
        c.accept(1,2);
        mVal.forEach(c);
    }
}

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

public default boolean test(String str) {
    return str.equals("Java");
}
List<String> strs = Arrays.asList("Java", "Java EE", "Java ME");
Predicate<String> cf1 = s -> s.length() > 3;
Predicate cf2 = new CourseFilter() { //line n1
    public boolean test(String s) {
        return s.contains("Java");
    }
};
long c = strs.stream()
        .filter(cf1)
        .filter(cf2) //line n2
        .count();
System.out.println(c);//3

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

try {
Connection conn = DriverManager.getConnection(dbURL, username, password);
String query = "Select * FROM Item WHERE ID = 110";
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(query);
while (rs.next()) {
    System.out.println("ID:" + rs.getInt("Id"));
    System.out.println("Description:" + rs.getString("Descrip"));
    System.out.println("Price:" + rs.getDouble("Price"));
    System.out.println("Quantity:" + rs.getInt("Quantity"));
}
} catch (SQLException se) {
    System.out.println("Error");
}

1
2
3

Console console = System.console();//console null
char[]pass = console.readPassword("Enter");
String password = new String(pass);

1
2
3
4
5
6
7
8
9

public static void main(String[] args) {
    List<Student> stds = Arrays.asList(
            new Student("Jessy", "Java ME", "Chicago"),
            new Student("Helen", "Java EE", "Houston"),
            new Student("Mark", "Java ME", "Chicago"));
    stds.stream()
            .collect(Collectors.groupingBy(Student::getCourse))
            .forEach((src, res) -> System.out.println(src));
}

1
2
3
4
5

Path source = Paths.get("/green.txt");
Path target = Paths.get("/colors/yellow.txt");
Files.move(source, target, StandardCopyOption.ATOMIC_MOVE);
Files.delete(source);

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

public static void main(String[] args) throws Exception {
    try {
        doStuff();
    } catch (ArithmeticException | NumberFormatException | Exception e) {//error
        System.out.println(e.getMessage());
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }

}
static void doStuff() throws ArithmeticException, NumberFormatException, Exception {
    if (Math.random() > -1) throw new Exception ("Try again");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

    public static void main(String[] args) throws Exception {
        /*Moveable<Integer> animal = n -> System.out.println("Running" + n);
        animal.run(100);
        animal.walk(20);*/ a right
      /*  Moveable<Integer> animal = n -> n + 10;
        animal.run(100);
        animal.walk(20);*/ Moveable没有返回值
  /*      Moveable animal = (Integer n) -> System.out.println(n);
        animal.run(100);
        Moveable.walk(20);*/
    }
}

interface Moveable<Integer> {
    public default void walk(Integer distance) {
        System.out.println("Walking");
    }
    public void run(Integer distance);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public interface InterfaceA {

    /**
     * 静态方法
     */
    static void showStatic() {
        System.out.println("InterfaceA++showStatic");
    }

    /**
     * 默认方法
     */
    default void showDefault() {
        System.out.println("InterfaceA ++showDefault");
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class Test091 {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList (new Product ( "MotherBoard", 5),
                new Product (" Speaker", 20)) ;
        products.stream ().filter (Product.ProductFilter::isAvailable) .forEach(p -> System. out. println(p)) ;//error
    }
}
class Product {
    String name;
    int qty;
    public String toString() {
        return name;
    }
    public Product(String name, int qty) {
        this.name = name;
        this.qty = qty;
    }
    static class ProductFilter {
        public boolean isAvailable(Product p) {//static is needed
            return p.qty >= 10;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

abstract class Shape {
    Shape() { System.out.println("Shape"); }
    protected void area() { System.out.println("Shape"); }
}

class Square extends Shape {
    int side;
    Square(int side) {
        /* insert code here */
        this.side = side;
    }
    public void area() { System.out.println("Square"); }
}
class Rectangle extends Square {
    int len, br;
    Rectangle(int x, int y) {//error super(x);
        /* insert code here */
        len = x; br = y;
    }
    void area() { System.out.println("Rectangle"); }//error
}

1
2

Stream<String> fc = Files.lines(file);
fc.forEach (s -> System.out.println(s));

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

String techName;
 
TechName(String techName) {
    this.techName = techName;
}
}
List<TechName> tech = Arrays.asList(
        new TechName("Java-"),
        new TechName("Oracle DB-"),
        new TechName("J2EE-")
);
Stream<TechName> stre = tech.stream();
stre.map(a -> a.techName).forEach(System.out::print);

1
2
3
4
5
6
7
8
9

class Computer {
    private Card sCard = new SCard();

    private abstract class Card {
    }

    private class SCard extends Card {
    }
}

1
2
3
4
5
6
7
8
9

class Block{
    int bno;
    static class Counter{
        int lo;
        Counter(){
        lo = bno;
        }
    }
}

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

Locale c = new Locale("de","DE");
Locale deLocale = Locale.GERMAN;
Locale deLocale = new Locale.Builder().setLanguage("de").setRegion("DE").build();
     System.out.println("Default language name (default): "
                      + deLocale.getDisplayLanguage());
       System.out.println("German language name (German): "
                      + deLocale.getDisplayLanguage(deLocale));
      System.out.println("German language name (French): "
                  + deLocale.getDisplayLanguage(c));
//Default language name (default): 德文
//German language name (German): Deutsch
//German language name (French): Deutsch

1
2
3

Stream<List<String>> strs = Stream.of(Arrays.asList("text1","text2"),Arrays.asList("text2","text3"));
Stream<String>bs2 = strs.filter(b->b.contains("text1")).flatMap(rs->rs.stream());
bs2.forEach(b-> System.out.println(b));

1
2
3
4
5
6
7

Deque<String> queue = new ArrayDeque<>();
queue.add("suana");
queue.add("duana");
queue.add("wuana");
System.out.println(queue.pop());
System.out.println(queue.remove());
System.out.println(queue);

1
2
3
4
5
6

UnaryOperator<Integer> uo1 = s -> s * 2; //line n1
List<Double> loanValues = Arrays.asList(1000.0, 2000.0);
loanValues.stream()
        .filter(lv -> lv >= 1500)
        .map(lv -> uo1.apply(lv)) //line n2
        .forEach(s -> System.out.print(s + " "));''