堆栈
堆栈是一种"后进先出"的数据结构,只能只能在一端进行输出或输出数据的操作
向堆栈中输入数据称为"压栈",从堆栈中输出数据称为"弹栈"
可以使用Stack泛型类创建一个堆栈对象
Stack<E>stack = new Stack<E>();
堆栈对象的方法
public E push(E item)
//实现压栈操作public E pop()
//实现弹栈操作public boolean empty()
//判断堆栈是否还有数据public E peek()
//获取堆栈顶端的数据,但不删除public int search(Object data)
//获取数据在堆栈中的位置,最顶端的位置是1,依次往下增加,没有就返回-1
使用堆栈可以节省内存的开销,例如递归是一种很消耗内存的算法,可以借助堆栈消除大部分递归,达到和递归算法同样的目的
使用堆栈实现斐波那契数列 //好好理解
import java.util.Stack;
public class Example13_6 {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<Integer>();
stack.push(1); //压栈
stack.push(1);
int k = 1;
while(k < 11){
for (int i = 0; i <= 2 ; i++) {
int f1 = stack.pop(); //弹栈
int f2 = stack.pop(); //弹栈
int next = f1+f2;
System.out.print(" " + next);
stack.push(next);
stack.push(f2); //后进先出
k++;
}
}
}
}
运行结果
D:\HelloWorld\out\production\HelloJava Chapter_13.Part_3.Example13_6
2 3 5 8 13 21 34 55 89 144 233 377
进程已结束,退出代码 0
散列映射
HashMap<K,V>泛型类
HashMap<K,V>对象采用散列表这种数据结构存储数据,习惯上称HashMap<K,V>对象为散列映射
散列映射用于存储"键/值对",允许把任何数量的键值对存储在一起
对于数组表和链表两种数据结构,如果要查找他们存储的某个特定元素却不知道位置,则需要从头开始访问元素直到找到匹配位置,这时可以使用散列映射来存储要查找的数据,可以减少检索的开销
创建散列映射
HashMap<String,Student> hashMap = new HashMap<String,Student>()
HashMa<K,V>泛型类常用方法
- public void clear() //清空散列映射
- public Object clone() //返回当前散列映射的一个克隆
- public boolean containsKey(Obeject Key) //是否含有所指的键
- public boolean containsValue(Object Value) //是否含有所指的值
public V get(Object key)
//返回散列映射使用Key作为键的值- public boolean isEmpty() //散射列表是否含有键值对
- public V remove(Object key) //删除散列映射中指定的键值对,并返回键对应的值
- public int size() //返回散射列表的大小
public V put(K key,V value)
//添加键值对
遍历散列映射
利用 public Collectionvalues()方法返回一个实现Collection接口类创建的对象,可以使用接口回调技术,
Collection<BOOK> collection = hashMap.values();
Iterator<BOOK> iterator = collection.iterator();
基于散列映射查询的例子
import javax.swing.*;
import java.awt.*;
public class myWindow extends JFrame {
JTextField input,show;
myListener myListener;
myWindow(){
setTitle("英-汉小词典");
setLayout(new FlowLayout());
setBounds(300,300,400,400);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Container con = this.getContentPane();
con.setBackground(new Color(0xBE879B)); //设置背景颜色
setVisible(true);
input = new JTextField(10);
myListener = new myListener();
myListener.setMyWindow(this);
input.addActionListener(myListener);
add(input);
show = new JTextField(10);
show.setEditable(false);
add(show);
validate();
}
}
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.HashMap;
import java.util.Scanner;
public class myListener implements ActionListener {
File file = new File("C:\\Users\\Administrator\\Desktop", "小词典数据.txt");
Scanner scanner;
myWindow myWindow;
HashMap<String, String> myHash;
public void setMyWindow(Chapter_13.Part_3.myWindow myWindow) {
this.myWindow = myWindow;
}
myListener() {
try {
myHash = new HashMap<String, String>();
scanner = new Scanner(file);
while (scanner.hasNext()) {
String English = scanner.next();
String Chinese = scanner.next();
myHash.put(English, Chinese);
}
} catch (Exception E) {
}
}
@Override
public void actionPerformed(ActionEvent actionEvent) {
if (myHash.containsKey(myWindow.input.getText())) { //查看是否拥有该键
myWindow.show.setText(myHash.get(myWindow.input.getText()));
} else {
myWindow.show.setText("没有此单词");
}
}
}
public class Example13_7 {
public static void main(String[] args) {
myWindow myWindow = new myWindow();
}
}
运行结果
死锁的基本概念
当若干个进程竞争使用资源时,可能每个进程要求的资源都已被另一进程占用,于是也就没有一进程继续运行,这种情况称为死锁
产生死锁的四个必要条件
- 互斥 //进程互斥使用资源
- 不可剥夺 //资源未使用完成时不能被其他进程强行剥夺
- 请求保持 //申请新的资源时继续保持占用已分配的资源
- 循环等待 //
解决死锁的方法
- 死锁的预防 //根据4个必要条件,使其中之一不能成立
- 死锁的避免 //银行家算法
- 死锁的检测
- 死锁的解除 //采用资源剥夺法和撤销进程法解除死锁
CET4P183
- calculate
- confess
- virtually
- virtual
- draught
- meantime
- appointment
- perspective
- laundry
- violin
- violet
- appearance
- murder