7.14~7.15学习总结

2023-11-25 12:40
文章标签 学习 总结 7.14 7.15

本文主要是介绍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方法是线程的入口点；@Overridepublic 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;}@Overridepublic 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
{@Overridepublic void run() {for(int i=0;i<10;i++){System.out.println("放空大脑");}System.out.println("--------end------");}
}

这篇关于7.14~7.15学习总结的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/423826。

相关文章

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

1.为什么要引入虚拟继承 虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2，而类B1、B2都继承自类A，因此在类D中两次出现类A中的变量和函数。为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。实现的代码如下： class A class B1:public virtual A; class B2:pu
阅读更多...
51单片机学习记录———定时器

51单片机学习记录———定时器

文章目录 前言一、定时器介绍二、STC89C52定时器资源三、定时器框图四、定时器模式五、定时器相关寄存器六、定时器练习 前言 一个学习嵌入式的小白~ 有问题评论区或私信指出~ 提示：以下是本篇文章正文内容，下面案例可供参考 一、定时器介绍 定时器介绍：51单片机的定时器属于单片机的内部资源，其电路的连接和运转均在单片机内部完成。 定时器作用： 1.用于计数系统，可
阅读更多...
问题：第一次世界大战的起止时间是 #其他#学习方法#微信

问题：第一次世界大战的起止时间是 #其他#学习方法#微信

问题：第一次世界大战的起止时间是 A.1913 ~1918 年 B.1913 ~1918 年 C.1914 ~1918 年 D.1914 ~1919 年 参考答案如图所示
阅读更多...
[word] word设置上标快捷键 #学习方法#其他#媒体

[word] word设置上标快捷键 #学习方法#其他#媒体

word设置上标快捷键 办公中，少不了使用word，这个是大家必备的软件，今天给大家分享word设置上标快捷键，希望在办公中能帮到您！ 1、添加上标 在录入一些公式，或者是化学产品时，需要添加上标内容，按下快捷键Ctrl+shift++就能将需要的内容设置为上标符号。 word设置上标快捷键的方法就是以上内容了，需要的小伙伴都可以试一试呢！
阅读更多...
AssetBundle学习笔记

AssetBundle学习笔记

AssetBundle是unity自定义的资源格式，通过调用引擎的资源打包接口对资源进行打包成.assetbundle格式的资源包。本文介绍了AssetBundle的生成，使用，加载，卸载以及Unity资源更新的一个基本步骤。 目录 1.定义： 2.AssetBundle的生成： 1）设置AssetBundle包的属性——通过编辑器界面 补充：分组策略 2）调用引擎接口API
阅读更多...
Javascript高级程序设计(第四版)--学习记录之变量、内存

Javascript高级程序设计(第四版)--学习记录之变量、内存

原始值与引用值 原始值：简单的数据即基础数据类型，按值访问。 引用值：由多个值构成的对象即复杂数据类型，按引用访问。 动态属性 对于引用值而言，可以随时添加、修改和删除其属性和方法。 let person = new Object();person.name = 'Jason';person.age = 42;console.log(person.name,person.age);//'J
阅读更多...
大学湖北中医药大学法医学试题及答案，分享几个实用搜题和学习工具 #微信#学习方法#职场发展

大学湖北中医药大学法医学试题及答案，分享几个实用搜题和学习工具 #微信#学习方法#职场发展

今天分享拥有拍照搜题、文字搜题、语音搜题、多重搜题等搜题模式，可以快速查找问题解析，加深对题目答案的理解。 1.快练题 这是一个网站 找题的网站海量题库,在线搜题,快速刷题~为您提供百万优质题库,直接搜索题库名称,支持多种刷题模式:顺序练习、语音听题、本地搜题、顺序阅读、模拟考试、组卷考试、赶快下载吧! 2.彩虹搜题 这是个老公众号了 支持手写输入，截图搜题，详细步骤，解题必备
阅读更多...
《offer来了》第二章学习笔记

《offer来了》第二章学习笔记

1.集合 Java四种集合：List、Queue、Set和Map 1.1.List：可重复 有序的Collection ArrayList： 基于数组实现，增删慢，查询快，线程不安全 Vector： 基于数组实现，增删慢，查询快，线程安全 LinkedList： 基于双向链实现，增删快，查询慢，线程不安全 1.2.Queue：队列 ArrayBlockingQueue：
阅读更多...
十五.各设计模式总结与对比

十五.各设计模式总结与对比

1.各设计模式总结与对比 1.1.课程目标 1、 简要分析GoF 23种设计模式和设计原则,做整体认知。 2、 剖析Spirng的编程思想，启发思维,为之后深入学习Spring做铺垫。 3、 了解各设计模式之间的关联，解决设计模式混淆的问题。 1.2.内容定位 1、 掌握设计模式的"道" ，而不只是"术" 2、 道可道非常道，滴水石穿非一日之功，做好长期修炼的准备。 3、 不要为了
阅读更多...
硬件基础知识——自学习梳理

硬件基础知识——自学习梳理

计算机存储分为闪存和永久性存储。 硬盘（永久存储）主要分为机械磁盘和固态硬盘。 机械磁盘主要靠磁颗粒的正负极方向来存储0或1，且机械磁盘没有使用寿命。 固态硬盘就有使用寿命了，大概支持30w次的读写操作。 闪存使用的是电容进行存储，断电数据就没了。 器件之间传输bit数据在总线上是一个一个传输的，因为通过电压传输（电流不稳定），但是电压属于电势能，所以可以叠加互相干扰，这也就是硬盘，U盘
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2