Java 数组
1, 数组是有序数据的集合, 数组中的每个元素具有相同的数组名和下标来做唯一标识
数组声明形式:
形式一: type arrayName[];
形式二: type[] arrayName;
为数组分配内存空间:
1, 为数组分配内存空间, 如果不分配内存, 将不能访问他的任何元素, 我们使用new关键字来为数组分配内存空间
代码:
int[] score; //数组的声明
score = new int[3];//为数组开辟内存空间, 实例化
for (int i = 0; i < score.length; i++) {//为数组赋值
score[i] = i*2+1;
}
for (int i = 0; i < score.length; i++) {//输出数组的值
System.out.println(score[i]);
}
数组的静态初始化
1, 数组初始化方式有两种: 动态初始化和静态初始化
2, 静态初始化: 在数组创建之初直接为其指定内容
int score[] = {1,2,3};//声明
代码: 求一组数的最大值与最小值
int score[] = {43, 34,5, 66,12};//声明
int max, min;
max = min = score[0];
for (int i = 0; i < score.length; i++) {
if (score[i] > max) {
max = score[i];
}
if (score[i] < min) {
min = score[i];
}
}
System.out.println("最大值"+max +" 最小值"+min);
代码: 冒泡排序
int score[] = {12,45,23,10,300};
for (int i = 0; i < score.length-1; i++) {
for (int j = i + 1; j < score.length; j++) {
if (score[i]<score[j]){
int temp = score[i];
score[i] = score[j];
score[j] = temp;
}
}
}
for (int i = 0; i < score.length; i++) {
System.out.println(score[i]);
}
二维数组:
1, 如果把一维数组看成是线性图形, 那么二维数组就是一个平面图形
2 , 二维数组的声明和一维数组类似, 内存分配也是使用new关键字
3, 声明与分配内存: 声明: type arrayName[][]; 初始化: arrayName[][] = new type[行][列];
代码: 二维数组静态初始化并输出
int score[][] = {{1,2},{3,4},{2,3,4},{4,5,6,7,7},{1,2}};
for (int i = 0; i < score.length; i++) {
for (int j = 0; j < score[i].length; j++) {
System.out.print(score[i][j] + " ");
}
System.out.println();
}
Java多线程
线程与进程
1, 线程: 程序中单独顺序的控制流, 线程本身依靠程序进行运行, 线程是程序中的顺序控制流, 只能使用分配给程序的资源和环境
2, 进程: 执行中的程序 一个进程可以包含一个或多个线程 , 一个进程至少要包含一个线程
3,单线程: 程序中只存在一个线程, 实际上主方法就是一个主线程
4, 多线程: 多线程是在一个程序中运行多个任务, 多线程的目的是更好的使用CPU资源
线程的实现:
1, 在Java中,线程的实现由2中: (1):继承Thread类 (2): 实现Runnable接口
2,Thread类: Thread类是在java.lang包中定义的, 继承Thread类必须重写run()方法
定义格式: class className extends Thread{run(){};}
线程的启动时通过start()方法
3, Runnable接口
runnable接口不存在启动的方法, 要通过thread类
MyRunnable run1 = new MyRunnable("A");
MyRunnable run2 = new MyRunnable("B");
//runnable接口不存在启动的方法, 要通过thread类
Thread t1 = new Thread(run1);
Thread t2 = new Thread(run2);
t1.start();
t2.start();
线程的状态:
1, 线程也有固定的操作状态
创建状态: 准备好了一个多线程的对象
就绪状态: 调用了start()方法, 等待CPU进行调度
运行状态: 执行run()方法
阻塞状态: 暂时停止执行, 可能将资源交给其他线程使用
终止状态(死亡状态): 线程销毁
线程的常用方法
1, 获取线程名称 getName()
2, 取得当前线程对象 currentThread()
3, 判断线程是否启动 isAlive()
4, 线程的强制运行 join()
5, 线程的休眠 sleep()
6, 线程的礼让 yield();
代码: 关于以上线程常用方法的案例
class RunnableDemo implements Runnable{
private String name;
public RunnableDemo(String name) {
this.name = name;
}
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println(name+":"+i);
//线程的礼让:
if (i == 10) {
System.out.println("礼让:");
Thread.yield();
}
//线程的休眠, 单位是毫秒
// try {
// Thread.sleep(1000);
// System.out.println(name+":"+i);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
//Thread.currentThread()获取当前线程
// System.out.println("当前线程对象"+Thread.currentThread().getName());
}
}
}
public class ThreadDemo03 {
public static void main(String[] args) {
RunnableDemo r = new RunnableDemo("A");
RunnableDemo r2 = new RunnableDemo("B");
Thread t = new Thread(r);
Thread t2 = new Thread(r2);
//isAlive() 判断线程是否启动
// System.out.println(t.isAlive());
t.start();
// System.out.println(t.isAlive());
t2.start();
//线程的强制运行
// for (int i = 0; i < 50; i++) {
// if (i>10) {
// try {
// t.join();
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// }
// System.out.println("主线程"+i);
// }
}
}
线程的优先级
优先级顺序设置: 1-MIN_PRIORITY 10-MAX_PRIORITY 5-NORM_PRIORITY 如果什么都不设置默认值是5
代码:
class ThRun implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 3; i++) {
try {
Thread.sleep(1000);
//打印当前线程名称
System.out.println(Thread.currentThread().getName()+":"+i);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public class ThreadDemo04 {
public static void main(String[] args) {
Thread t1 = new Thread(new ThRun(), "A");
Thread t2 = new Thread(new ThRun(), "B");
Thread t3 = new Thread(new ThRun(), "C");
//设置线程优先级
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.NORM_PRIORITY);
t3.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();
t3.start();
}
}
线程同步
1, 同步代码块: 在代码块上加上"synchronized"关键字, 则此代码块就称为同步代码块
2, 同步代码块格式: synchronized(同步对象){ 需要同步的代码块;}
3, 同步方法 除了代码块可以同步, 方法也是可以同步的
4, 方法同步格式: synchronized void 方法名称(){}
代码:
class MyThreadDemo implements Runnable{
private int ticket = 5;
public void run() {
for (int i = 0; i < 10; i++) {
//同步代码块解决共享问题
// synchronized (this) {
// if (ticket > 0) {
// try {
// Thread.sleep(500);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// System.out.println("车票"+":"+ticket--);
// }
// }
}
}
//同步方法解决共享问题
public synchronized void tell(){
if (ticket > 0) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("车票"+":"+ticket--);
}
}
}
public class ThreadDemo05 {
public static void main(String[] args) {
MyThreadDemo m = new MyThreadDemo();
Thread t1 = new Thread(m);
Thread t2 = new Thread(m);
Thread t3 = new Thread(m);
t1.start();
t2.start();
t3.start();
}
}
线程的生命周期:
