7.14~7.15学习总结

Java的前置知识学习时间截至了，慌的一批~~。

看看自己学的，再看看要求学的，简直：

现在继续：IO流里面的Commons_IO的用法：

public class Main
{
    public static void main(String[]args) throws IOException {
        long len= FileUtils.sizeOf(new File("小花花"));
        System.out.println(len);
        len=FileUtils.sizeOf(new File("dest"));
        System.out.println(len);
        Collection<File>files=FileUtils.listFiles(new File("dest"), EmptyFileFilter.NOT_EMPTY,null);//第一个参数文件，第二个参数是过滤器，这里的意思是将空的过滤，只留下非空的，第三个参数
       for(File f:files)
       {
           System.out.println(f.getAbsolutePath());
       }

        //默认是一层子集，如果要操作子孙集,可以使用第三个参数；
        System.out.println("---------------");
       Collection<File>files2=FileUtils.listFiles(new File("C:\\Users\\zplaz\\IdeaProjects\\xiaohuahua\\src"),EmptyFileFilter.NOT_EMPTY, DirectoryFileFilter.INSTANCE);
       for(File ff:files2)
       {
           System.out.println(ff.getAbsolutePath());
       }
       //如果想要让只是后缀为。Java的文件出现在列出来：
        Collection<File>files3=FileUtils.listFiles(new File("C:\\Users\\zplaz\\IdeaProjects\\xiaohuahua\\src"),new SuffixFileFilter("java"), DirectoryFileFilter.INSTANCE);
        for(File ff:files3)
        {
            System.out.println(ff.getAbsolutePath());
        }
        //如果是想要两个都有的话或者都可以的话可以用
       // FileFilterUtils.or();
        //FileFilterUtils.and();将其作为两个参数
        //读取文件
        String msg=FileUtils.readFileToString(new File("小花花"),"UTF-8");
        System.out.println(msg);
        byte[]datas=FileUtils.readFileToByteArray(new File("小花花"));
        System.out.println(datas.length);
        //逐行读取
        List<String>msgs=FileUtils.readLines(new File("小花花"),"UTF-8");
        for(String string:msgs)
        {
            System.out.println(string);
        }
        //迭代器逐行读取
        LineIterator it=FileUtils.lineIterator(new File("小花花"),"UTF-8");
        while(it.hasNext())
        {
            System.out.println(it.nextLine());

        }
        //写出文件
        FileUtils.write(new File("小花花三"),"小麻子说她真的很喜欢小饺子，难怪小饺子总是打喷嚏","UTF-8",true);
        //FileUtils.writeStringToFile();和上面的一样使用
        FileUtils.writeByteArrayToFile(new File("小花花4"),"累瘫了，但是好快乐".getBytes("UTF-8"),true);
        //使用字节数组打印出来

        //写出列表
        List<String>datass=new ArrayList<String>();
        datass.add("小花花");
        datass.add("泥巴巴");
        datass.add("所以说，小麻子是小花花，小饺子是她爸爸");
        FileUtils.writeLines(new File("小花花"),datass,/*条目间隔符*/"。。。。",true);


    }
}

创建线程方式1：

创建一个类继承Tread，并且创建该对象，用对象调用start（）开启多线程；

public class Main extends Thread
{
    //run方法是线程的入口点；
    @Override
    public void run() {
          for(int i=0;i<20;i++)
          {
              System.out.println("一边敲代码");
          }
    }
    public static void main(String[]args)
    {
        //启动线程
        Main  st=new Main();
        st.start();//start方法由cpu调用不保证立即运行
        for(int i=0;i<20;i++)
        {
            System.out.println("一边听歌");
        }
    }
}
/*
结果：
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边敲代码
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边听歌
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码
一边敲代码


*/

创建方式二：

public class StartRun implements Thread
{
    public void run()
    {
       for(int i=0;i<20;i++)
       { System.out.println("一边听歌");}
    }
    public void main(String[]args)
    {
        /*StartRun st=new StartRun();
        Thread t=new Thread(st);
        t.start();*/
        new Thread(new StartRun()).start();//可以使用匿名
        for(int i=0;i<20;i++)
        {
            System.out.println("一边coding");
        }
    }
}

Runnable接口的run方法是不可以抛出异常，且run方法的返回值为空，但是Callable中的call方法可以抛出异常，并且有返回值；Callable比Runnnable好用一些，但是也麻烦一些，流程如下：

1.创建执行服务：

2.提交执行

3.获取结果

4.关闭服务·；

总结：创建线程总共有三种方式：常用的两种，（继承thread类，重写Runnble接口，guc并发包，实现Callable接口）；

Lambda表达式：

如果一个接口的实现类里面只有一个方法，且这个方法就只实现一次，那么这个接口的实现类可以简化为

接口类 变量=(方法形参参数没有类型修饰，如果只有一个参数，括号可以省略)->
{
//如果只有一行代码，花括号可以省略
被重写的方法体
//如果函数体里面总共就一个语句，还是返回语句，可以连return都省略
}
//这样就可以将方法实现类放在这一小坨代码

直接写在要被应用的地方；这里来一个多线程的例子：

public class LambdaTest01 {
    public static void main(String[] args) {
        new Thread(() ->
        {
            System.out.println("一边学习");
        }).start();
        new Thread(() -> System.out.println("小麻子说超级喜欢小饺子")).start();
        System.out.println("一边想做小麻子爸爸");

    }
}


/*

//结果：
一边学习
一边想做小麻子爸爸
小麻子说超级喜欢小饺子

*/

线程状态：新生状态，就绪状态，运行状态，死亡状态，阻塞状态之后不能立刻进行运行状态，而是要先进入就绪状态，当线程进入死亡状态后，不可以在新生，除非开启一个新的线程；

一般停止线程不要用stop方法，不安全

Sleep，yield：第一个让线程由运行状态到阻塞状态，再由阻塞状态到就绪状态；第二个直接由运行状态跳回就绪状态；第二个让cpu直接重新调度；

//礼让
public class yield {
    public static void main(String[]args)
    {

            new Thread(()->{
                for(int i=0;i<100;i++)
                {
                    System.out.println("小麻子爱吃草线程"+i);
                }
            }).start();
            for(int i=0;i<100;i++)
            {
                if(i%20==0)Thread.yield();
                System.out.println("main"+i);
            }

    }

}

join插队：

join是成员方法，join写在哪个方法里面那个方法就被阻塞了，必须达到相应的条件执行完才可以执行后面的，但是如果传入一个时间的话，时间到了cpu就会重新调度，不会再管这个阻塞了

public class Join {
    public static void main(String[]args) throws InterruptedException {

        Thread t=new Thread(()->
        {
            for(int i=0;i<100;i++)
            {

                System.out.println("线程方法"+i);


            }
        });
        t.start();
        for(int i=0;i<100;i++)
        {
            if(i==20)t.join();//主方法必须等i==20之后才可以继续执行
            System.out.println("main方法"+i);

        }
    }

}
/*
main方法0
main方法1
main方法2
main方法3
main方法4
main方法5
main方法6
main方法7
main方法8
main方法9
main方法10
main方法11
main方法12
main方法13
main方法14
main方法15
main方法16
main方法17
main方法18
main方法19
线程方法0
线程方法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
线程方法37
线程方法38
线程方法39
线程方法40
线程方法41
线程方法42
线程方法43
线程方法44
线程方法45
线程方法46
线程方法47
线程方法48
线程方法49
线程方法50
线程方法51
线程方法52
线程方法53
线程方法54
线程方法55
线程方法56
线程方法57
线程方法58
线程方法59
线程方法60
线程方法61
线程方法62
线程方法63
线程方法64
线程方法65
线程方法66
线程方法67
线程方法68
线程方法69
线程方法70
线程方法71
线程方法72
线程方法73
线程方法74
线程方法75
线程方法76
线程方法77
线程方法78
线程方法79
线程方法80
线程方法81
线程方法82
线程方法83
线程方法84
线程方法85
线程方法86
线程方法87
线程方法88
线程方法89
线程方法90
线程方法91
线程方法92
线程方法93
线程方法94
线程方法95
线程方法96
线程方法97
线程方法98
线程方法99
main方法20
main方法21
main方法22
main方法23
main方法24
main方法25
main方法26
main方法27
main方法28
main方法29
main方法30
main方法31
main方法32
main方法33
main方法34
main方法35
main方法36
main方法37
main方法38
main方法39
main方法40
main方法41
main方法42
main方法43
main方法44
main方法45
main方法46
main方法47
main方法48
main方法49
main方法50
main方法51
main方法52
main方法53
main方法54
main方法55
main方法56
main方法57
main方法58
main方法59
main方法60
main方法61
main方法62
main方法63
main方法64
main方法65
main方法66
main方法67
main方法68
main方法69
main方法70
main方法71
main方法72
main方法73
main方法74
main方法75
main方法76
main方法77
main方法78
main方法79
main方法80
main方法81
main方法82
main方法83
main方法84
main方法85
main方法86
main方法87
main方法88
main方法89
main方法90
main方法91
main方法92
main方法93
main方法94
main方法95
main方法96
main方法97
main方法98
main方法99
*/

观察线程的状态：

public class AllState {
    public static void main(String[]args) throws InterruptedException {
        Thread t=new Thread(()->{
            for(int i=0;i<5;i++)
            {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("小麻子");

        });
        Thread.State state=t.getState();
        System.out.println(state);

        t.start();
        state=t.getState();
        System.out.println(state);
        while(state!=Thread.State.TERMINATED)
        {
            Thread.sleep(200);
        state=t.getState();
        System.out.println(state);
        }
        state=t.getState();
        System.out.println(state);
    }
}
/*
NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
小麻子
TERMINATED
TERMINATED


*/

线程的优先级，优先级要在start方法之前，而且优先级高的有大概率先执行，但是不一定先执行；

守护线程：

/*
守护线程是为用户线程服务的，jvm不用等待守护线程执行完毕；
默认线程都是用户线程，jvm等待所有用户线程执行完毕，否则不h会停止
 */


public class daemonTest {
    public static void main(String[]args)
    {
        God god=new God();
        You1 you1=new You1();
        Thread t=new Thread(god);
        t.setDaemon(true);//将用户线程改为守护线程
                t.start();
        new Thread(you1).start();
    }

}
class You1 extends Thread
{
    public void run()
    {
        for(int i=0;i<=365*100;i++)
        {
            System.out.println("开心每一天");
        }
        System.out.println("oooo...");
    }
}
class God extends Thread
{
    public void run()
    {
        for(int i=0;i<=365*1000;i++)
        {
            System.out.println("bless you");
        }
        System.out.println("ooooo....");
    }
}

并发：同一个对象对多个线程同时操作；

将一个大的方法加上synchronized会大大影响效率；sychronized锁的是对象和类；当这个修饰方法的时候，成员方法修饰的是资源，如果锁错了就凉凉还是会谢；同步化块：synchronized（obj）同步化块目标更明确，可以锁不变的对象。

/**
 * 线程安全，在并发时保证数据的正确性，效率尽可能高
 */


public class safeTest {
   public static void main(String[]args)
    {
        Account account=new Account(100,"结婚礼金");
        SynDrawing you=new SynDrawing(account,80,"可悲的你");
        SynDrawing wife=new SynDrawing(account,90,"happy的他");
        you.start();
        wife.start();

    }
}
class SynDrawing extends Thread
{
    Account account;
    int drawingMoney;
    int packetTotal;

    public SynDrawing( Account account, int drawingMoney,String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        try {
            test();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void test() throws InterruptedException {
        if(account.money<=0)return;
        synchronized(account)
        {
            if(account.money-drawingMoney<0)return ;
            Thread.sleep(1000);
            account.money-=drawingMoney;
            packetTotal+=drawingMoney;
            System.out.println(this.getName()+"-->账户余额为"+account.money);
            System.out.println(this.getName()+"-->口袋里的钱为"+packetTotal);
        }
    }
}
class Account
{
    int money;
    String name;

    public Account(int monney, String name) {
        this.money = monney;
        this.name = name;
    }
}


/*
可悲的你-->账户余额为20
可悲的你-->口袋里的钱为80



*/

并发编程操作容器的时候都可以想到并发容器：将容器类型替换为

这里以List为例；

在一个同步块中如果有两个及以的所的时候可能会发生死锁；解决：避免锁套锁

时间类：

public class Others {
    public static void main(String[]args)
    {
        Timer timer=new Timer();
        //执行安排
        Calendar cal=new GregorianCalendar(2099,12,31,53,54);
        timer.schedule(new MyTask(),cal.getTime(),200);//指定时间第二个参数，第一次执行的时间是，第三个参数是每过200毫秒执行一次1


    }



}//任务类
class MyTask extends TimerTask
{

    @Override
    public void run() {
    for(int i=0;i<10;i++)
    {
        System.out.println("放空大脑");
    }
    System.out.println("--------end------");
    }
}