多线程

最新推荐文章于 2020-09-19 09:30:20 发布
最新推荐文章于 2020-09-19 09:30:20 发布
阅读量227 收藏
点赞数 2
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hello_zbs/article/details/105326329
版权
本文详细介绍了Java中的多线程概念，包括线程与进程的区别、线程的五种状态、线程创建的三种方式（Thread、Runnable、Callable）、线程的并发控制（如synchronized、Lock）以及线程通信（wait、notify）。还通过实例解析了线程安全问题及解决策略，并探讨了线程优先级和线程状态的检查方法。
摘要由CSDN通过智能技术生成

线程

线程和进程之间的区别:
进程:每一进程都有自己独立的代码和数据空间, 进程之间切换开销较大,一个进程包含1~n个线 程,进程是资源分配的最小单位
线程:同一类的线程共享代码和数据空间, 线程之间切换开销较小,线程是cpu调度的最小单位

线程和进程一样都分为5个阶段: 创建 就绪 运行 阻塞 终止

多进程: 操作系统能同时运行多个任务(程序)

多线程: 同一个程序中有多个顺序流执行(多任务执行就是多线程),提高效率

单线程:单任务,单个路径执行,需要排序,效率较低

学习多线程的核心掌握知识: 线程的开启方式 线程状态 线程安全

线程的创建方式:
1.继承Thread类,重写run() start()
2.实现Runnable接口,重写run() —推荐
3.实现Callable接口,重写call()

public class ThreadDemo01 extends Thread{
	
	@Override
	public void run() {
		for(int i=1;i<=20;i++) {
		public class ThreadDemo01 extends Thread{
	
	@Override
	public void run() {
		for(int i=1;i<=20;i++) {
//主线程
	public static void main(String[] args) {
		//创建一个线程
		ThreadDemo01 th = new ThreadDemo01();
		//开启线程
				th.start(); //等待cpu的调度,时间片同一时刻分配给哪一个线程,哪一个线程就会执行,我们无法控制cpu的调度分配

for(int i=1;i<=20;i++) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
				}
			System.out.println("一边敲代码...");
		}
	}
}

开启线程的第二种方式

1.实现Runnable接口,重写run方法
优点:
1.避免单继承的局限性
2.实现资源共享

public class ThreadDemo02 implements Runnable{

	@Override
	public void run() {
		for(int i=1;i<=20;i++) {
		try {
    Thread.sleep(5);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   System.out.println("一边吃饭...");
   		}
	}
	
	
	public static void main(String[] args) {
		
		//1创建线程
		Thread th = new Thread(new ThreadDemo02());
		//2.开启线程
		th.start();

for(int i=1;i<=20;i++) {
			try {
				Thread.sleep(5);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("一边讲课...");
		}
	}

}

Web12306

实现Runnable接口,实现资源共享案例(当一份资源多个代理同时操作这是就并发,需要控制安全)
例子：
// 有100张票,3个人分别把这100张票买完

public class Web12306_03 implements Runnable{
	//共享资源  100张票
	int tickets = 100;
	
	public static void main(String[] args) {
  Web12306_03 web = new Web12306_03();
  //创建线程
  Thread th1= new Thread(web,"张三");
  Thread th2= new Thread(web,"李四");
  Thread th3= new Thread(web,"王五");

//开启线程
		th1.start();
		th2.start();
		th3.start();
	}
@Override
		public void run() {
		// A B C
		while(true) {
			if(tickets<=0) {
				break;
			}
			//A B C
			try {
				Thread.sleep(100); //ms数
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets--);
		}
	}
}

//龟兔赛跑
兔子,每跑10步就休息5ms
乌龟一直跑
谁先跑完100步,谁就赢了,如果一旦有人赢了,比赛就结束

public class Racer04 implements Runnable{
	private  String winner;//胜利者
	@Override
	public void run(){
	for(int steps =1;steps<=100;steps++) {		
			if(Thread.currentThread().getName().equals("rabbit") && steps%10==0) {
				try {
				Thread.sleep(2);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+"-->"+steps);
   //比赛是否结束
   boolean flag = gameOver(steps);
   if(flag) {
    break;
   }
  }
 }
 /**
  * 
  * @param steps  当前参赛者的步数
  * @return  是否结束游戏
  * 		true  结束
  * 		false	继续
  */
	 private boolean gameOver(int steps) {
		if(winner!=null) { //存在胜利者
			return true;
		}else {
		if(steps ==100) {
				winner = Thread.currentThread().getName();
				System.out.println("winner==>"+winner);
				return true;
			}
		}
		return false;
	}
	
	public static void main(String[] args) { 
  Racer04 racer = new Racer04();
  new Thread(racer,"tortoise").start();
  new Thread(racer,"rabbit").start();
 }
}

Callable接口

优点:
call方法可以抛出异常
带出返回值
缺点:
使用麻烦

例子：
//模拟龟兔赛跑,实现Callable接口

public class Racer05 implements Callable<Integer>{
	private  String winner;//胜利者
	
	private boolean gameOver(int steps) {
	if(winner!=null) { //存在胜利者
			return true;
		}else {
			if(steps ==100) {
			winner = Thread.currentThread().getName();
				System.out.println("winner==>"+winner);
				return true;
			}
		}
			return false;
	}

	@Override
	public Integer call() throws Exception {
  for(int steps =1;steps<=100;steps++) {  
   //模拟休息 因为兔子总是睡懒觉,如果是兔子的话,我们就让他每走十步睡2毫秒
   if(Thread.currentThread().getName().equals("pool-1-thread-1") && steps%10==0) {
    try {
    Thread.sleep(2);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+"-->"+steps);
   //比赛是否结束
   boolean flag = gameOver(steps);
   if(flag) {
    return steps;
   }
  }
  return null;
 }
 
 public static void main(String[] args) throws InterruptedException, ExecutionException {
  Racer05 racer = new Racer05();
  //创建执行服务: 
  ExecutorService  ser=Executors.newFixedThreadPool(2);
  //提交执行: 
  Future<Integer> result1 =ser.submit(racer) ;
  Future<Integer> result2 =ser.submit(racer) ;
  //获取结果:  
  Integer r1 =result1.get();
  Integer r2 =result2.get();
		System.out.println(r1+"-->"+r2);
		//关闭服务:  
		ser.shutdownNow();
	}
}

通过内部类实现创建多线程

public class ThreadDemo06 {
	//静态内部类
	static class Inner01 implements Runnable{

		@Override
		public void run() {
			for(int i = 0;i<20;i++) {
				System.out.println("一遍听课..");
			}
		}
		
	}

public static void main(String[] args) {
  //局部内部类
  class Inner02 implements Runnable{
   @Override
   public void run() {
    for(int i = 0;i<20;i++) {
     System.out.println("一遍听歌..");
    }
    
}

}
		
		new Thread(new Inner01()).start();
		new Thread(new Inner02()).start();
		//匿名内部类
		new Thread(new Runnable(){

@Override
			public void run() {
				for(int i = 0;i<20;i++) {
					System.out.println("一遍吃烧烤..");
				}
			}
			
			}).start();
		//Lambda表达式
		new Thread(()->{
				for(int i = 0;i<20;i++) {
					System.out.println("一遍喝啤酒..");
				}
					}).start();
		
	}
}

线程状态:

新生状态 : new,一个线程一旦进入新生状态,就会有自己的内存和工作空间
就绪状态 : start()方法,线程进入就绪状态,进入就绪不代表会马上执行,会进入就绪队列,等待cpu的调度
运行状态 : 当系统选中某一个正在等待线程,一旦得到获取cpu调度资源,才会运行
阻塞状态 : sleep…
死亡状态|终止状态 : 线程结束

注意:
如果一个线程一旦进入死亡状态,不会恢复,重新创建是一个新的线程了
如果一个线程一旦进入阻塞状态,不会马上恢复运行状态,会先进入就绪,等待cpu的调度

一个线程如何进入终止状态:
1.正常执行完毕
2.stop,destory…(废弃)
3.添加外部标识控制–推荐

如何进入就绪状态:
1).start()
2)阻塞解除
3)调用yield
4)线程切换

如何进入阻塞状态:
1)sleep
2)wait
3)join

sleep: 线程进入睡眠状态,参数为ms数,让出cpu的资源
1.放大问题的可能性
2.模拟网络延迟

//模拟网络延迟倒计时: 倒计时10…9…8…7…1结束

public class StateDemo01 implements Runnable{
	public static void main(String[] args) {
		new Thread(new StateDemo01()).start();
	}

@Override
	public void run() {
		for(int i=10;i>0;i--) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
			e.printStackTrace();
			}
			System.out.println(i);
		}
	}
}

join 线程插队

public class JoinDemo03 {
	public static void main(String[] args) {
		new Thread(new Father()).start();
	}
}

class Father implements Runnable{

	@Override
	public void run() {
		System.out.println("想吸烟了..");
		System.out.println("给儿子钱,让儿子去买烟..");
		
		//开启儿子线程
		Thread t = new Thread(new Son());
		t.start();

//		try {
//			t.join();
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//			System.out.println("儿子丢了,去找儿子..");
//		}

System.out.println("接过烟吸一口...");
	}
	
}

class Son implements Runnable{

	@Override
	public void run() {
		System.out.println("借过钱...去买烟");
		System.out.println("路过一家游戏厅,进去玩耍10s");
		for(int i=1;i<=10;i++) {
			try {
			Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(i+"s");
		}
		System.out.println("赶紧去买烟...");
		System.out.println("烟买好了给老爸..");
	}
	
}

Thread.State getState() 获取线程状态

public class ThreadState02 {
	public static void main(String[] args) {
		Thread th = new Thread(()->{
			for(int i =1;i<=10;i++) {
			if(i==5) {
					System.out.println("线程即将休眠");
					try {
						Thread.sleep(20);
					} catch (InterruptedException e) {
					e.printStackTrace();
					}
				}
				System.out.println(i);
						}
		});
		
		System.out.println("th线程状态:"+th.getState()); //NEW
		th.start();
		System.out.println("th线程状态:"+th.getState());  //RUNNABLE


while(th.getState()!=Thread.State.TERMINATED) { 
			  System.out.println("th线程状态:"+th.getState()); 
		}

System.out.println("th线程状态:"+th.getState());
	}
}

yield

礼让线程,当线程执行到yield,会让出cpu的资源,直接进入就绪状态

public class YieldDemo02 implements Runnable{
public static void main(String[] args) {
YieldDemo02 y = new YieldDemo02();
new Thread(y,“A”).start();
new Thread(y,“B”).start();
}

@Override
public void run() {
System.out.println(Thread.currentThread().getName()+“开始了”);
Thread.yield();
System.out.println(Thread.currentThread().getName()+“结束了”);
}

}

线程优先级

1~10 默认5
void setPriority(int newPriority)
更改线程的优先级。
int getPriority()
返回线程的优先级
MAX_PRIORITY, MIN_PRIORITY,NORM_PRIORITY

注意: 设置优先级,可以提高优先执行的可能,但不一定

public class PriorityDemo04 implements Runnable{
 public static void main(String[] args) {
  PriorityDemo04 p = new PriorityDemo04();
  Thread th1 = new Thread(p,"zhangsan");
  Thread th2 = new Thread(p,"lisi");
		Thread th3 = new Thread(p,"wangwu");
		Thread th4 = new Thread(p,"zhaoliu");

th1.setPriority(1);
		th2.setPriority(Thread.MAX_PRIORITY);
		th3.setPriority(Thread.NORM_PRIORITY);
		th4.setPriority(7);

th1.start();
		th2.start();
		th3.start();
		th4.start();
}


	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority());
			}

}

锁

当多线程的环境下,多个线程操作同一份资源的时候,可能会发生线程不安全问题

控制线程安全:
synchronized 同步 关键字 锁lock 在同步范围内的代码都需要排队执行
同步方法:在方法上使用synchronized关键字进行修饰
静态方法 -->类
成员方法 -->对象
同步块 :
synchronized(类.class|this|资源){
锁住的代码范围
}
类.class : 每一个类否只有一个class对象,可以通过类名.class获取,唯一的
this : 当前对象
资源 : 成员属性
必须为自定义引用数据类型

锁一定要锁不变的内容,才能锁住

锁的范围大,效率低,锁的范围太小,锁不住
思考: 哪一些代码想要线程排队执行,可以把这些代码控制在同步范围内?锁什么能把这些代码锁住?

public class SynWeb12306_01 implements Runnable{
	//共享资源  100张票
	int tickets = 100;

public static void main(String[] args) {
  SynWeb12306_01 web = new SynWeb12306_01();
  //创建线程
  Thread th1= new Thread(web,"孙悟空");
  Thread th2= new Thread(web,"猪八戒");
  Thread th3= new Thread(web,"沙悟净");

//开启线程
		th1.start();
		th2.start();
		th3.start();
	}

//锁范围内的代码都需要排队执行
	// A B C
	@Override
	public void run() {
		while(true) {
			// A B C
			if(!test()) {
				break;
			}
		}
	}
/**
	 * @return false: 票没了
	 * return true: 代表还有票
	 */
public synchronized boolean test() {
		if(tickets<=0) {
			return false;
		}
		//A B C
		try {
			Thread.sleep(100); //ms数
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets--);
		return true;
	}
}

同步块:
锁类 类名.calss
锁类,这个类的所有对象都被锁住了
可以使用锁this,之锁住当前对象

sleep: 抱着资源睡觉
不会释放对象的锁,会释放cpu的资源

public class SynWeb12306_02 implements Runnable{
	//共享资源  100张票
	int tickets = 100;

public static void main(String[] args) {
  SynWeb12306_02 web = new SynWeb12306_02();
  //创建线程
  Thread th1= new Thread(web,"孙悟空");
  Thread th2= new Thread(web,"猪八戒");
  Thread th3= new Thread(web,"沙悟净");

//开启线程
		th1.start();
		th2.start();
		th3.start();
	}

@Override
	public void run() {
		while(true) {
			//A B C
			synchronized (SynWeb12306_02.class) {
			if(tickets<=0) {
					break;
				}
				//A B C
				try {
				Thread.sleep(100); //ms数
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets--);
			}
		}
	}
}

生产者消费者模式
通过wait和notify方法实现线程通信,必须使用在一个同步唤醒下
wait 当一个线程进执行到wait方法,进入到一个和该对象相关的等待池中进行等待,等待对方唤醒
同时释放对象锁,和cpu的资源
notidy: 唤醒对象等待池中的线程,被唤醒的线程只是被激活了,需要再次获取对象的资源才能执行
wait,notify,notifyAll方法用于协调多线程对共享数据的处理,所以只能在一个同步环境下使用

sleep: 不会释放对象资源,释放cpu资源
wait: 会释放对象资源,释放cpu资源

public class Demo004Synchronized4 {
 public static void main(String[] args) {
  SyncStack stack = new SyncStack();
  ShengChan sc = new ShengChan(stack);
  Chi chi = new Chi(stack);
		
		sc.start();
		chi.start();
	}
}

// 馒头类
class Mantou {

}

// 有生产、有消费功能的工厂
class SyncStack{
	List<Mantou> list = new ArrayList<Mantou>();  // 容器,10就满了
	
	// 生产馒头的方法
	public synchronized void push(Mantou mantou){
		
		// 我认为现在已经放满了
		if(list.size()==10){
			try {
			// 通知别人可以来买了
				this.notify();//如果不唤醒的话。以后这两个线程都会进入等待线程，没有人唤醒。
				// 满了之后就停止生产
				this.wait();
				} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}else{
		list.add(mantou);
   System.out.println("生产第" + +list.size()+ "个馒头");
   try {
    Thread.sleep(300);
   } catch (InterruptedException e) {
   // TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		}
	
	// 吃馒头的方法
	public synchronized void pop(){
		// 吃完了
		if(list.size()==0){
			try {
			// 通知别人该生产了
    this.notify();; //唤醒在当前对象等待池中等待的第一个线程。notifyAll叫醒所有在当前对象等待池中等待的所有线程。
    // 停下吃的动作
    this.wait();
                //wait后，线程会将持有的锁释放。sleep是即使睡着也持有互斥锁。
                } catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

list.remove(list.size()-1);
		System.out.println("现在还剩下  " + list.size() + " 个馒头");
		try {
			Thread.sleep(300);
			} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			
		}
	}
}

// 生产馒头的线程
class ShengChan extends Thread{
	SyncStack stack;
	public ShengChan(SyncStack stack){
		this.stack = stack;
		}
	
	@Override
	public void run() {
		// 一直生产馒头
		while(true){
		Mantou mantou = new Mantou();
			stack.push(mantou);
		}
	}
}
class Chi extends Thread{
	SyncStack stack;
	public Chi(SyncStack stack){
		this.stack = stack;
	}

@Override
	public void run() {
		// 一直吃馒头
		while(true){
			this.stack.pop();
		}
	}
}

例子
//人车公用街道
一个街道 ,有一个信号灯, 提供2个功能 东西走向的功能we 一个南北走向的功能ns
人 走东西 true
车 走南北 false

public class StreetDemo05 {
	public static void main(String[] args) {
		Street s = new Street();
		new Thread(new Person(s)).start();
		new Thread(new Car(s)).start();
	}
}

class Street{
	boolean flag = false;
	
	//南北
	synchronized void ns() {
	if(flag==true) {
   try {
    this.wait();
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    	}
		}else {
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
					e.printStackTrace();
			}
			System.out.println("车走....");
			//唤醒对方
			this.notify();
			//车走完了,信号灯要改为true
			flag=true;
		}
}
	
	//东西
	synchronized void we() {
		if(flag==false) {
			try {
			this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				}
		}else {
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
			// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("人走....");
			//唤醒对方
			this.notify();
			//车走完了,信号灯要改为true
			flag=false;
		}
	}
}

class Person implements Runnable{
	Street street;

public Person(Street street) {
		this.street = street;
	}

	@Override
	public void run() {
		while(true) {
			street.we();
		}
	}
}

class Car implements Runnable{
	Street street;
	
	public Car(Street street) {
		this.street = street;
	}
	
	@Override
	public void run() {
		while(true) {
			street.ns();
		}
	}
}
好来污最佳男主角
关注
面向对象面
Hello_zbs的博客
06-29 345
向过程与面向对象的区别 面向过程：侧重点流程，从头到尾一气呵成，牵一发而动全身，重构复杂。流水线式。 面向对象：模块化(类)，抽离重复的部分。模块组合完成业务。上帝视角。 类和对象的区别 类：模板，模块，图纸。 对象：根据图纸构建出来的具体的事物。 类如何构建 属性 String brand;// 品牌 String color;// 颜色 int speed;// 速度 行为 public void run() { System.out.println("车会跑"); } 综合代码 package
Servlet
Hello_zbs的博客
09-04 592
Servlet的实现 Servlet 是 Server 与 Applet 的缩写，是服务端小程序的意思。使用 Java 语言编写的服务器端程序，可以像生成动态的 WEB 页，Servlet 主要运行在服务器端，并由服务器调用执行， 是一种按照 Servlet 标准来开发的类。 是 SUN 公司提供的一门用于开发动态 Web 资源的技术。（言外之意：要实现 web 开发，需要实现 Servlet 标准）Servlet 本质上也是 Java 类，但要遵循 Servlet 规范进行编写，没有 main()方法，它
CSS的使用方式
Hello_zbs的博客
06-11 234
内联样式表 CSS代码和HTML代码放在同一个文件中 用法：借助标签中的style属性，在属性中设置样式 <!-- 内联样式 --> <p style="color: red;">p标签1</p> 内联样式表 CSS代码和HTML代码放在同一个文件中用法：借助网页中的style标签，在标签中设置样式，一般情况下style标签写在head标签的最后。 <!-- 内部样式 --> <style type="text/css"> /* 把p
深入对象（三）
Hello_zbs的博客
03-27 330
面向对象三大特性 封装:encapsulation 隐藏信息 继承: inheritance 延续+扩展父类信息 多态: polymorphism 模糊策略 以不变应万变 （一）封装（encapsulation） 理解：“ 该露的露，该藏的藏”。 概念：“ 高内聚，低耦合”。用户无需知道对象内部方法的实现细节，但可以根据对象提供的外部接口(对象名和参数)访问该对象。 作用： 1...
xml
Hello_zbs的博客
04-12 201
xml解析 1. 概念 可扩展标记语言，xml是互联网数据传输的重要工具，它可以跨越互联网任何的平台，不受编程语言和操作系统的 限制，可以说它是一个拥有互联网最高级别通行证的数据携带者。xml是当前处理结构化文档信息中相当给力的技 术，xml有助于在服务器之间穿梭结构化数据，这使得开发人员更加得心应手的控制数据的存储和传输。 Xml用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Qt界面多线程opencv调用摄像头
05-09
本代码是在qt平台下opencv利用多线程调用摄像头进行实时的视频显示在gui界面上，利用的时QThread的方法，是本人用了一年时间在维护的代码，需要的可以前来下载。当然我这也有qt上位机部分的代码，有需要的可以在评论...
FreeMarker 数据类型 基础语法
Hello_zbs的博客
09-07 1057
FreeMarker 数据类型 Freemarker 模板中的数据类型由如下⼏种： 布尔型：等价于 Java 的 Boolean 类型，不同的是不能直接输出，可转换为字符串输出 ⽇期型：等价于 java 的 Date 类型，不同的是不能直接输出，需要转换成字符串再输出 数值型：等价于 java 中的 int,float,double 等数值类型 有三种显示形式：数值型(默认)、货币型、百分⽐型 字符型：等价于 java 中的字符串，有很多内置函数 sequence 类型：等价于 java 中的数组，list
容器2
Hello_zbs的博客
04-05 215
目录 容器操作 Stream的操作 三个步骤 Stream的中间操作 终止操作 容器操作 1.Collection工具类 类 java.util.Collections 提供了对容器操作的工具方法，与 Arrays 使用差不多。 2.常用方法 void sort(List) //对 List 容器内的元素排序,按照升序进行排序。 void shuffle(List) //对 List 容器内的元...
数据库基础用法查找
Hello_zbs的博客
07-13 355
数据库 数据库是“按照数据结构来组织、存储和管理数据的仓库”。是一个长期存储在计算机内的、有组织的、可共享的、统一管理的大量数据的集合。 通过一门专门语言来操作数据库，SQL结构化查询语言(Structured Query Language)简称SQL，是一种特殊目的的编程语言，是一种数据库查询和程序设计语言，用于存取数据以及查询、更新和管理关系数据库系统。 SQL语言的分类：数据查询语言DQL，数据操纵语言DML，数据定义语言DDL，数据控制语言DCL。 SQL(DQL)的学习 了解表：文件，存储数据的文
容器
Hello_zbs的博客
04-02 237
容器 数组远远不能满足我们的需求。我们需要一种灵活的，容量可以随时扩充的容器来装载我们的对象。这就是 我们今天要学习的容器类，或者叫集合框架。 集合框架的简单的体系结构如下: Collection 接口是一组允许重复的对象。 Set 接口继承 Collection，无序不允许重复，使用自己内部的一个排列机制。 List 接口继承 Collection，有序允许重复，以元素安插的次序来放置元素， ...
网页编程设计
Hello_zbs的博客
04-23 1078
B/S 架构 B Browser 浏览器 S Server 服务器 HTML、CSS 与 JS 的关系 HTML 与 CSS 1. 主要内容 2. HTML HTML（HyperText Markup Language）就是超⽂本标记语⾔。“超⽂本"就是表示⻚⾯内可以包含 ⾮⽂字元素，如：图⽚、链接、⾳乐等等。 它是⼀种建⽴⽹⻚⽂件的语⾔，通过标记式的指令（Tag），将影像、声⾳、图⽚、⽂字等...
IDEA 打开最近已经使用过的项目
Hello_zbs的博客
09-19 767
File—> Open Recent
HTML-CSS
Hello_zbs的博客
08-28 457
HTML HTML（HyperText Markup Language）就是超⽂本标记语⾔。"超⽂本"就是表示⻚⾯内可以包含⾮⽂ 字元素，如：图⽚、链接、⾳乐等等。 它是⼀种建⽴⽹⻚⽂件的语⾔，通过标记式的指令（Tag），将影像、声⾳、图⽚、⽂字等链接显示出 来。这种标记性语⾔是因特⽹上⽹⻚的主要语⾔。 HTML ⽹⻚⽂件可以使⽤记事本、写字板、HBuilder、Sublime 等编辑⼯具来编写，以 .htm 或 .html 为 ⽂件后缀名保存。将 HTML ⽹⻚⽂件⽤浏览器打开显示，若测试没有问题则可以放
反射 注解
Hello_zbs的博客
04-09 170
反射 反射的介绍 “程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”，如Python，Ruby是动态语言；显然C++，Java，C#不是动态语言，但是JAVA有着一个非常突出的动态相关机制：Reflection。 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方...
Servlet之Cookie对象
Angletank的博客
09-04 209
Cookie对象 1.Cookie概述 Cookie作为浏览器提供的一种技术，将一些内容保存在客户端，保存在本地计算机上，不需要通过网络传输，提高网页的处理效率,减少服务器的负载量.由于信息保存在客户端,安全性较差.例如常见的记住密码则可以通过 Cookie 来实现。 有一个专门操作Cookie的类 javax.servlet.http.Cookie。 随着服务器端的响应发送给客户端，保存在浏览器。当下次再访问服务器时把Cookie再带回服务器。 Cookie 的格式： 键值对用“=”链接， 多个键值对
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值