java基础过度进阶随堂笔记

java基础过度进阶随堂笔记

注: 以下讲的内容都是一些基础,想了解更多的高级特性看这篇文章没用

IO流

FileOutputStream

现在我们有了读取,但是要怎么写入呢,就要用文件输出流

顾名思义,他的意思是文件输出流,也就是写入文件的数据。

用法 OutputStream f = new FileOutputStream(“文件路径”)
然后有了文件输出流,我们可以用write方法写入。

例:

try {
 OutputStream fileOutputStream=new FileOutputStream("src/feige011");
            String[] s= {"feige011 is back\n","feige011 is ready\n","feige011 is fly"};
            for (String value : s) {
                fileOutputStream.write(value.getBytes());
            }
            fileOutputStream.close();
}catch (Exception e){
	  System.out.println(e.getMessage());
 }

FileInputStream

顾名思义,他的意思是文件读取流,也就是读取文件的数据。

用法 InputStream f = new FileInputStream(“文件路径”)
然后有了文件输入流,我们可以用read方法读取。

例:

try {
 FileInputStream fileInputStream=new FileInputStream("src/feige011");
            int size=fileInputStream.available();
            for(int i=0;i<size;i++){
                System.out.print((char) fileInputStream.read());
            }
}catch (Exception e){
	  System.out.println(e.getMessage());
 }

输出

feige011 is back
feige011 is ready
feige011 is fly

也就是你这个文件的内容

这样就结束了是不是很简单，但是别忘了抛出异常,因为编译器不确定你是否有这个文件,所以,如果不抛出异常他会报错的

多线程

创建线程开始

  new Thread(new Runnable() {
                @Override
                public void run() {
                    
                }
            }).start();

锁(synchronized)

首先,锁的概念是什么,为什么要引进锁:
举个例子:当你想抢火车票,每次发１张,100个线程同时进行,当你马上要拿到这张票的时候,这张票突然被其他人给抢走了,这时候,我们是不是就不能用这张票的逻辑来进行下一步操作了.
例:

import java.util.Date;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class MeTextLock {
    public static String obj1 = "火车票";
    public static final Semaphore a1 = new Semaphore(1);
    public static void main(String[] args) {
        Lock1 la = new Lock1();
        new Thread(la).start();
        Lock2 lb = new Lock2();
        new Thread(lb).start();
    }
}
class Lock1 implements Runnable{
    public void run() {
        try {
            System.out.println(new Date().toString() + " Lock1 开始抢火车票");
            if(UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)){
                System.out.println(new Date().toString() + " Lock1 抢到了 火车票");
                Thread.sleep(3000); // 此处等待是给B能锁住机会
            }else{
                System.out.println("草Lock1,没抢到火车票");
            }
//                synchronized (LockTest.obj1) {
//
//                }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Lock2 implements Runnable{
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println(new Date().toString() + " Lock2 开始抢火车票");
            if(UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)){
                System.out.println(new Date().toString() + " Lock2 抢到了 火车票");
                Thread.sleep(3000); // 此处等待是给B能锁住机会
            }else{
                System.out.println("草Lock2,没抢到火车票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出

Sat Mar 06 09:45:09 CST 2021 Lock1 开始抢火车票
Sat Mar 06 09:45:09 CST 2021 Lock1 抢到了 火车票
Sat Mar 06 09:45:10 CST 2021 Lock2 开始抢火车票
草Lock2,没抢到火车票

Lambda表达式

首先我们要知道Lambda是干嘛的,
总结,让代码变简洁,代码行数变少
例:
我们都知道创建线程

  new Thread(new Runnable() {
                @Override
                public void run() {
                    
                }
            }).start();

那么我们用Lambda表达式就可以这样写:

 new Thread(
                ()->{
                }
        ).start();

标准格式为(参数)->{逻辑}
那么什么时候适用呢,就是只有一个抽象方发的时候,可以用一手Lambda表达式
例:
正常你应该这么写的东西

 String[] planets = new String[]{
                "1", "22", "333", "999999999", "88888888", "7777777"
        };
        Arrays.sort(planets, new Comparator<String>() {
            @Override
            public int compare(String first, String second) {
                return (first.length() - second.length());
            }
        });
        System.out.println(Arrays.toString(planets));

输出

[1, 22, 333, 7777777, 88888888, 999999999]

这是一个排序
所以Lambda表达式应该怎么写呢

      String[] planets = new String[]{
                "1", "22", "333", "999999999", "88888888", "7777777"
        };
         Arrays.sort(planets,(String f,String s)->(f.length()-s.length()));
        System.out.println(Arrays.toString(planets));

常用的Lambda函数

  //接受参数返回boolean类型
        Predicate<String> oddLength=s->
                s.length() % 2 != 0;
        //接受参数不返回
        Consumer<String> printer=s->
                System.out.println("planet: "+s);
        //不接受参数返回任意类型
        Supplier<String> planetFactory=()->
                planets[(int) floor(random()*6)];
//        接受参数返回任意类型
        Function<String,String> upper = s-> s.toUpperCase();