Java零基础后端知识（三）

public class ScheduledThreadPoolDemo {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);//线程池允许执行的线程数
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟1秒执行，每3秒执行一次");
            }
        },1,3, TimeUnit.SECONDS);
        scheduledExecutorService.shutdown();
    }
}

public class ScheduledThreadPoolDemo {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);//线程池允许执行的线程数
        scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟5秒执行");
            }
        },3, TimeUnit.SECONDS);
        scheduledExecutorService.shutdown();
    }
}

public class InetAddressDemo {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress localHost = InetAddress.getLocalHost();//获得本机主机IP地址
        System.out.println(localHost);
        InetAddress byName = InetAddress.getByName("www.baidu.com");
        InetAddress byName2 = InetAddress.getByName("WIN-AVA5NQL1LU5");
        System.out.println(byName);
    }
}

public class Client {
    public static void main(String[] args) throws IOException {
        //创建socket对象，其实是开启实现io的虚拟接口
        Socket client=new Socket("localhost",10086);//需要指定数据接收方的ip地址和端口号
        //获取输出流对象，向服务端发送数据
        OutputStream outputStream = client.getOutputStream();
        //向输出流对象进行包装
        DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
        //传输数据
        dataOutputStream.writeUTF("hello，你好，我是客户端");
        //关闭流操作
        dataOutputStream.close();
        outputStream.close();
        client.close();
    }
}

public class Server {
    public static void main(String[] args) throws IOException {
        //服务端需要使用serversocket来开放本地的端口
        ServerSocket serverSocket=new ServerSocket(10086);
       //需要接受client传输过来的数据，需要定义socket对象
        Socket server=serverSocket.accept();
        //通过server获取输入流对象
        InputStream inputStream = server.getInputStream();
        //对输入流进行包装
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        //读取对应的数据
        String str=dataInputStream.readUTF();
        System.out.println(str);
        //关闭所有的流操作
        dataInputStream.close();
        inputStream.close();
        server.close();
        serverSocket.close();
    }
}

public class LambdaDemo {
    public static void main(String[] args) {
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread1 running...");
            }
        });
        thread1.start();
       Thread thread2=new Thread(()-> System.out.println("thread2  running.."));
       thread2.start();
       List<String> lists= Arrays.asList("java","javascript","scala","python");
        Collections.sort(lists, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        for(String str:lists){
            System.out.println(str);
        }
        Collections.sort(lists,(a,b)->(a.length()-b.length()));
        lists.forEach(System.out::println);
    }
}

public class LambdaDemo2 {
    public static void main(String[] args) {
        /**
         *在Java中提供了一系列的函数式接口，用来接受后续传入的逻辑，但是对输入和输出有要求
         */
        Function<String,Integer> f1=(str)->{return str.length();};//第一个参数是输入的参数，第二个是返回的数据
        System.out.println(f1.apply("abcdefg"));
        Supplier<String> s1=()->{return "mashibing";};
        Supplier<String> s2=()->"mashibing2";
        System.out.println(s1.get());
        System.out.println(s2.get());
    }
}

public class Test2 {
    static String put(){
        System.out.println("puting...");
        return "put";
    }
    public static void main(String[] args) {
        //静态方法引用
       Supplier<String> s=Test2::put;
        System.out.println(s.get());
    }
}

public class Test3 {
    public String put(){
        return "put...";
    }
    public static void main(String[] args) {
        Supplier<String> s=new Test3()::put ;
        System.out.println(s.get());
    }
}

public class Test4 {
    public static void main(String[] args) {
        Consumer<Too> t1=Too::foo;
        t1.accept(new Too());
        Consumer<Too2> t2=Too2::foo;
        t2.accept(new Too2());
    }
}
class Too{
    public Integer fun(String s){
        return 1;
    }
    public void foo(){
        System.out.println("foo");
    }
}
class Too2{
    public Integer fun(String s){
        return 1;
    }
    public void foo(){
        System.out.println("foo....");
    }
    public void show(){
        System.out.println("too...s");
    }
}

public class Test5 {
    public static void main(String[] args) {
       Supplier<Person> s2=Person::new;
       s2.get();
       Supplier<List> s1= ArrayList::new;
       Function<String,Account> f1=(str)->new Account(str);
       Function<String,Account> f2=Account::new;
       f1.apply("abc");
       f2.apply("def");
        Consumer<Integer> c1=Account::new;
        c1.accept(3);
    }
}
class Account{
    public Account(){
        System.out.println("调用无参构造方法");
    }
    public  Account(int age){
        System.out.println("age 参数方法调用");
    }
    public Account(String str){
        System.out.println("str 参数方法调用");
    }
}
class Person{
    public Person(){
        System.out.println("无参构造方法调用");
    }
}