本文目录
System类
概述 系统相关类
特点
a.构造私有，不能利用构造方法new对象
b.方法都是静态的
使用
类名直接调用
常用的方法
static long currentTimeMIllis() 获取当前系统时间的毫秒值
static void exit(int status) 结束当前正在执行的jvm
static void gc() 运行垃圾回收器
static void arraycopy(Object src, int srcPos, object dest, int destpos, int length)
数组复制 src：源数组 srcPos：从源数组的哪个索引开始复制 dest：目标数组 destPos：从目标数组的哪个索引开始黏贴
length：复制多少个元素
long start =System.currentTimeMillis();System.out.println("start = "+ start);Date date =newDate(1705928207741L);System.out.println("date = "+ date);System.out.println("==========================");String[] arr1 ={"李云龙","孔杰","丁伟","张大彪","段鹏"};String[] arr2 =newString[6];System.arraycopy(arr1,0,arr2,1,3);System.out.println(Arrays.toString(arr2));
Arrays数组工具类
概述：Arrays数组工具类
作用：操作数组
特点：构造私有，不能来利用构造new对象
方法都是静态的，
类名直接调用
常用的方法
static String toString(int a) 按照[元素1,元素2]格式打印
static void sort(int a) 数组排序—升序
static int binarSearch(int a, int key) 二分查找，升序数组
static int copyOf(int original, int newLength) 数组扩容
int[] arr ={2,5,34,6,76,534,3};System.out.println(Arrays.toString(arr));Arrays.sort(arr);System.out.println(Arrays.toString(arr));System.out.println(Arrays.binarySearch(arr,534));//数组扩容int[] arr1 ={1,2,3,4,5};int[] arr2 =Arrays.copyOf(arr1,200);
arr2 = arr1;System.out.println(Arrays.toString(arr2));
枚举
枚举介绍
引用数据类型：
类 数组 接口 注解 枚举
所有枚举类的父类 ----- Enum
public snum 枚举类类名{
代码体；
}
枚举类的成员
所有成员默认static final常量，不用写上static fianl
每一个枚举修饰当前枚举类的对象
问题 枚举类中的枚举都是什么类型，本类类型
枚举的使用场景 一般都是表示状态
构造特点 枚举类中的构造都是private的
publicenumStatus{weifukuan("未付款"),//相当于Status weifukuan = new Status("未付款")yifukuan("已付款"),weifahuo("未发货"),yifuhuo("已发货");String name;Status(){}privateStatus(String name){this.name = name;}publicStringgetname(){return name;}
publicclass test01 {publicstaticvoidmain(String[] args){// 由于枚举类中的枚举都是静态的，所以我们可以寄直接类名直接调用Status weifahuo =Status.weifahuo;Status yifahuo =Status.yifuhuo;System.out.println(weifahuo);System.out.println(yifahuo.getname());}}
枚举的方法
方法名
String toString() 说明 返回枚举常量的名称，它包含在声明中
values() 说明 返回枚举类型的对象数组，可以快速便利出所有的枚举值
valueOf(String str) 说明 将一个字符串转成枚举类型
System.out.println("================================");System.out.println(weifahuo.toString());System.out.println(yifahuo.getname());System.out.println("================================");Status[] value =Status.values();for(int i =0; i < value.length; i++){System.out.println(value[i].getname());}Status weifukuan =Status.valueOf("weifukuan");System.out.println(weifukuan.getname());
stream中的long count方法
作用 统计元素个数
注意 count也是一个终结方法
long count = st.count();System.out.println(count);
stream中的Stream filter(predicate<? super T>) predicate)()方法
方法 stream中的Stream filter(predicate<? super T>) predicate)()方法返回一个新的stream流对象
作用 根据某个条件及进行元素过滤
st.filter(newPredicate<String>(){@Overridepublicbooleantest(String s){return s.length()==3;}}).forEach(newConsumer<String>(){@Overridepublicvoidaccept(String s){System.out.println(s);}});
Stream limit(long maxSize)方法
Stream limit(long maxSize)方法: 获取strea流对象中的前n个对象，返回一个新的Stream流对象
st.limit(3).forEach(newConsumer<String>(){@Overridepublicvoidaccept(String s){System.out.println(s);}});
Stream skip(long n)
Stream skip(long n): 跳过stream流对象中的前n个元素，返回一个新的Stream流对象
st.skip(3).forEach(newConsumer<String>(){@Overridepublicvoidaccept(String s){System.out.println(s);}});
static Stream concat(Stream<? extrends T> a, Stream<? extends T>b)
static Stream concat(Stream<? extrends T> a, Stream<? extends T>b):两个流合成一个流
publicstaticvoidmain(String[] args){finalStream<String> xiaoguizi =Stream.of("狗日子山本","傻子土肥原","切腹的东条英机");finalStream<String> xiaoguizi1 =Stream.of("矬子天皇","爆打落水狗麦克阿瑟");finalStream<String> concat =Stream.concat(xiaoguizi, xiaoguizi1);
concat.forEach(newConsumer<String>(){@Overridepublicvoidaccept(String s){System.out.println(s);}});
Stream转换成集合
从Stream流对象转成集合对象，使用Stream接口方法collect
finalObject li = xiaoguizi.collect(Collectors.toList());System.out.println(li);
基本包装类
概述 基本类型对应的引用数据类型
注意 基本类型和对应的包装类其实是可以相互转换的
装箱： 将基本类型转成相应的包装类 — 自动
拆箱：将包装类转成对应的基本类型------自动
手动拆箱
int intValue()
方法：
装箱方法
Integer(int value)
Integer(String s) ------s必须是数字格式
static Integer valueOf(int i)
static Integer valueOf(String s) s必须是数字格式
finalInteger i1 =newInteger(10);finalInteger i2 =newInteger("10");System.out.println(i1+1);System.out.println(i2+1);System.out.println("============================");finalInteger i3 =Integer.valueOf(10);finalInteger i4 =Integer.valueOf("1");System.out.println(i3+1);System.out.println(i4);
自动装箱与拆箱的相关问题
笔试题
Integer i1 =100;Integer i2 =100;System.out.println(i1==i2);//TrueSystem.out.println("=================");Integer i3 =200;Integer i4 =200;System.out.println(i3 == i4);//False
参数如果不在-128 ~~ 127 直接，会返回new Integer地址值，所以会有不同的True和False
基本类型和String之间的相互转换
方式1 +”“
方式2 String中的静态方法 static String valueOf(int i)
Stirng转成基本数据类型
每个包装类中，都有一个一样的方法
prase###：###代表的是具体的方法
int i =10;String a = i+"";System.out.println(a+1);String b =String.valueOf(a);System.out.println(b+1);int c =Integer.parseInt("1010");System.out.println(c+1);
以后我们写标准的JavaBean，我们的属性只要是基本类型的都要写成包装类
多线程基本了解
进程：进入到内存中执行的应用程序
线程 是进程的一个执行单元
线程作用：负责当前进程中程序的运行，一个进程中至少有同一个线程，一个进程就可以有多个线程
并发:同一时刻多个线程同时操作了同一个线程
并行：同一时刻多个线程同时执行不同的程序
cpu调度
分时调度：值得是让所用的线程轮流获取CPU使用权，并且平均分配每个线程占用的cpu的时间片
抢占式调度：多个线程抢占CPU使用权，谁先抢到，谁先执行
线程都是有优先级的，优先级高的，先抢到CPU的使用权的几率大
java写出来的程序都是抢占式调度
主线程：在内存和CPU之间开辟的一条专门为main方法服务的通道 — 主线程
创建线程的方式(重点)
步骤
1.随意定义一个类，继承Thead线程类
2.重写Thread类中的方法，设置线程任务(该线程要具体干什么)
3.创建自定义线程对象
4.调用Thead类中的start方法(开启线程，jvm自动执行run方法)
publicclassMyTheadextendsThread{@Overridepublicvoidrun(){for(int i =0; i <5; i++){System.out.println("李云龙......."+ i);}}}
publicstaticvoidmain(String[] args){//创建自定义线程对象MyThead myThead =newMyThead();
myThead.start();//开启线程，jvm自动执行run方法
myThead.run();//不能直接调用run方法，如果只调用run方法，此线程并没有被开启for(int i =0; i <5; i++){System.out.println("丁伟......."+i);}}
注意:不能一个线程对象调用多次start方法
Thread类中的方法
//创建自定义线程对象MyThead myThead =newMyThead();
myThead.setName("丁伟");
myThead.start();//开启线程，jvm自动执行run方法//myThead.run(); //不能直接调用run方法，如果只调用run方法，此线程并没有被开启for(int i =0; i <5; i++){//睡眠一秒Thread.sleep(1000L);System.out.println(Thread.currentThread().getName());System.out.println(newMyThead().getName()+"丁伟......."+i);}
第二种方式_实现Runnable接口
1.创建一个实现类，实现Runnable接口
2.重写run方法，设置线程任务
3.创建实现类对象，传递到Threa中
4.调用Thread中的start方法，开启线程，jvm自动执行run 方法
publicclassMyRunnableimplementsRunnable{@Overridepublicvoidrun(){for(int i =0; i <5; i++){System.out.println(Thread.currentThread().getName()+"....执行了"+i);}}
publicstaticvoidmain(String[] args){MyRunnable myRunnable =newMyRunnable();Thread thread =newThread(myRunnable,"李云龙");
thread.start();for(int i =0; i <5; i++){System.out.println(Thread.currentThread().getName()+"执行了...."+i);}}
两种实现多线程的方式的区别
继承：只能单继承，具有局限性
实现：一个类继承一个类的同时实现一个或者多个接口，比较灵活，打破了继承的局限性。
匿名内部类创建多线程
匿名内部类回顾
new 接口(){
重写方法
}.重写的方法();
newThread(newRunnable(){@Overridepublicvoidrun(){System.out.println(Thread.currentThread().getName()+"执行了");}}).start();System.out.println("============lambda表达式================");newThread(()->System.out.println(Thread.currentThread().getName()+"执行了")).start();
线程安全
什么时候出现线程安全问题，多个线程共同访问同一个资源时
线程安全问题-
如下举例为线程不安全代码
publicclass ticket implementsRunnable{int ticket =100;@Overridepublicvoidrun(){while(true){if(ticket>0){System.out.println(Thread.currentThread().getName()+"买了第"+ticket+"张票");
ticket--;}}}}publicclass test03 {publicstaticvoidmain(String[] args){
ticket ticket =newticket();finalThread zhangsan =newThread(ticket,"张三");finalThread lisu =newThread(ticket,"李四");finalThread wangwu =newThread(ticket,"王五");
zhangsan.start();
lisu.start();
wangwu.start();}}
出现问题的原因：CPU在多条线程之间做告诉切换。
使用同步代码块解决安全问题
同步代码块
synchronized(任意对象){
可能出现线程不安全问题的代码
}
执行特点
a.任意对象，充当的是锁对象
b.如果进了synchronized代码块块 ，相当于上锁了，其他的线程只能在同步代码块外面排队，不能执行；如果等到一个抢到锁的线程出了synchronized代码块，相当于释放锁，其他等待的线程才能抢锁去执行
注意
多个线程之间使用的锁对象必须是同一把锁，否则无法保证线程安全
publicclass ticket implementsRunnable{int ticket =100;Object obj =newObject();@Overridepublicvoidrun(){while(true){try{Thread.sleep(100);}catch(InterruptedException e){
e.printStackTrace();}synchronized(obj){if(ticket>0){System.out.println(Thread.currentThread().getName()+"买了第"+ticket+"张票");
ticket--;}}}}}
同步方法解决线程安全问题
普通同步方法
格式
修饰符 synchronized 返回值类型 方法名(参数){
可能出现线程安全的代码
}
默认锁 this
两种方法
publicsynchronizedvoidmethod(){if(ticket>0){System.out.println(Thread.currentThread().getName()+"买了第"+ticket+"张票");
ticket--;}}publicvoidmethod1(){synchronized(this){if(ticket>0){System.out.println(Thread.currentThread().getName()+"买了第"+ticket+"张票");
ticket--;}}}
静态同步方法
1.格式
修饰符 static synchronized 返回值类型 方法名（参数）{
可能出现线程安全的代码
}
2.默认锁 当前类.class
publicstaticsynchronizedvoidmethod2(){//静态同步方法if(ticket>0){System.out.println(Thread.currentThread().getName()+"买了第"+ticket+"张票");
ticket--;}}publicstaticvoidmethod3(){synchronized(ticket.class){if(ticket>0){System.out.println(Thread.currentThread().getName()+"买了第"+ticket+"张票");
ticket--;}}}
死锁
1.死锁介绍（锁嵌套有可能会产生死锁）
指的是两个或者两个以上的线程在执行的过程中，由于竞争同步锁而产生的一种阻塞现象；如果没有外力的作用，他们将无法继续执行下去，这种情况称之为死锁
举例说明
线程T1：拥有两个嵌套锁，只有当R1锁解除之后，再解除R2锁以后，才能继续执行
线程T2：拥有两个嵌套锁，只有当R2锁解除之后，再解除R1锁以后，才能继续执行
如上则会出现这个情况：T1持有R1锁，但是必须再拿到R2锁才能继续执行，而T2正在持有R2锁，但是再拿到R1锁才能继续执行
此时两个线程处于相互等待的状态，就是死锁，在程序中的死锁将出现在同步代码的嵌套中
publicclassLockA{staticLockA lockA =newLockA();}publicclassLockB{staticLockB lockB =newLockB();}
publicclassDieLockimplementsRunnable{privateboolean flag;publicDieLock(boolean flag){this.flag = flag;}publicDieLock(){}@Overridepublicvoidrun(){if(flag){synchronized(LockA.lockA){System.out.println(Thread.currentThread().getName()+"中A锁成功解锁，继续运行还需B锁");synchronized(LockB.lockB){System.out.println(Thread.currentThread().getName()+"中B锁成功解锁，运行完毕");}}}else{synchronized(LockB.lockB){System.out.println(Thread.currentThread().getName()+"中B锁成功解锁，继续运行还需A锁");synchronized(LockA.lockA){System.out.println(Thread.currentThread().getName()+"中A锁成功解锁，运行完毕");}}}}}
publicclass test04 {publicstaticvoidmain(String[] args){DieLock dieLock =newDieLock(true);DieLock dieLock1 =newDieLock(false);Thread t1 =newThread(dieLock,"T1");finalThread t2 =newThread(dieLock1,"T2");
t1.start();
t2.start();}}
线程状态
介绍
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态，在线程的生命周期中，有六种状态
以下是各个状态相互转换图
sleep和wait(time)区别，继续执行。
a.sleep(time)：线程睡眠，在睡眠的过程中不会释放锁，等到超时以后，自动醒来，继续执行
b.wait(time)：线程等待，在等待的过程中会释放锁，等待超时或者中途被notify方法唤醒，会重新抢锁，抢到了继续执行，抢不到，阻塞
wait 和nitify方法介绍
a.wait：调用无参的wait，线程将进入到无限等待的状态，会释放锁对象，需要其他的线程调用notify或者notifyAII唤醒等待的线程，唤醒之后，重新抢锁，抢到了继续执行，抢不到锁阻塞
b.notify：唤醒等待的线程，如果只有一条线程等待，会直接唤醒这条等待的线程，如果有多条线程等待，会随机选一条等待
注意
一条线程等待，我们怎么就能准确唤醒这一条等待的线程？
wait和notify两个方法需要同一把锁对象调用
wait和notify需要在同步代码块中使用
版权归原作者 龙俊俊 所有， 如有侵权，请联系我们删除。