实验十六 线程技术
实验时间 2017-12-8
1、实验目的与要求
(1) 掌握线程概念;
‐多线程 是进程执行过中产生的多条线索。 是进程执行过中产生的多条线索。 是进程执行过中产生的多条线索。 是进程执行过中产生的多条线索。
‐线程是比进执行更小的单位。
‐线程不能独立存在,必须于进 中同一线程不能独立存在,必须于进 中同一线程不能独立存在,必须于进 中同一线程不能独立存在,必须于进 中同一程的各线间共享进空数据。 程的各线间共享进空数据。
‐每个线程有它自身的产生、存在和消亡过, 每个线程有它自身的产生、存在和消亡过, 每个线程有它自身的产生、存在和消亡过, 每个线程有它自身的产生、存在和消亡过, 是一个动态的概念。
‐多线程意味着一个序的行语句可以看上去几 多线程意味着一个序的行语句可以看上去几 多线程意味着一个序的行语句可以看上去几 多线程意味着一个序的行语句可以看上去几 乎在同一时间内运行。
‐线程创建、销毁和切换的负荷远小于进,又称 线程创建、销毁和切换的负荷远小于进,又称 线程创建、销毁和切换的负荷远小于进,又称 线程创建、销毁和切换的负荷远小于进,又称 为轻量级进程( lightweight process lightweight process lightweight process )。
(2) 掌握线程创建的两种技术;
Java 实现多线程有两种途径:
‐创建 Thread 类的子
首先需从 Thread 类派生出一个子, 在该子类中 重写 run() 方法。
例:
class class hand extends Thread hand extends Thread hand extends Threadhand extends Thread hand extends Thread hand extends Thread hand extends Thread hand extends Thread hand extends Thread hand extends Thread
{
public void run() public void run() public void run() public void run() public void run()
{……} {……}
}
然后用创建该子类的对象
Lefthand left=new Lefthand ();
Righthand right=new Righthand ();
. 最后用 start() 方法启动线程
left.start ();
right.start ();
‐在程序中定义实现 Runnable 接口的类
首先设计一个实现 Runnable Runnable 接口的类; 接口的类; 接口的类; 接口的类; 接口的类;
. 然后在类中根据需要重写 run 方法;
. 再创建该类对象,以此为参数立 再创建该类对象,以此为参数立 ThreadThread Thread类的对象;
. 调用 Thread Thread Thread 类对象的 start start start方法启动线程,将 方法启动线程,将 方法启动线程,将 方法启动线程,将 方法启动线程,将 方法启动线程,将 方法启动线程,将 方法启动线程,将 CPU 执 行权转交到 run 方法。 方法。 方法。
用Runnable() (见教材 (见教材 (见教材 632 页) 接口实现线程 接口实现线程 接口实现线程 接口实现线
(3) 理解和掌握线程的优先级属性及调度方法;
Java 提供一个 线程调度器 来监控程序启动后进入 来监控程序启动后进入 来监控程序启动后进入 来监控程序启动后进入 来监控程序启动后进入 来监控程序启动后进入 来监控程序启动后进入 来监控程序启动后进入 监控程序启动后进入 来监控程序启动后进入 可运行状态的 所有线程。调度器按照可运行状态的 所有线程。调度器按照可运行状态的 所有线程。调度器按照可运行状态的 所有线程。调度器按照优先级决定应调 度 哪些线程来执行。 优先级决定应调度哪些线程来执行。
– 处于可运行状态的线程首先进入 就绪队 列排就绪队 列排就绪队 列排就绪队 列排就绪队 列排就绪队 列排等 候处理器资源,同一时刻在就绪队列中的线程可 候处理器资源,同一时刻在就绪队列中的线程可 候处理器资源,同一时刻在就绪队列中的线程可 候处理器资源,同一时刻在就绪队列中的线程可 能有多个。 Java 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 的多线程系统会给每个自动 分配一个线程的优先级。
Java 的线程调度采用优先级策略 :
优先级高的执行,低后;
多线程系统会自动为每个分配一优先级,缺省时,继承其父类的优先级;
任务紧急的线程,其优先级较高;
同优先级的线程按“进出”队列原则;
多线程调度
(4) 掌握线程同步的概念及实现技术;
多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 多线程并发运行不确定性问题解决方案: 引入线 引入线 引入线 程同步机制 程同步机制 程同步机制 程同步机制 程同步机制 ,使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 使得另一线程要用该方法 ,就只 能等待 。
在Java 中解决多线程同步问题 的方法有两种: 的方法有两种: 的方法有两种: 的方法有两种: 的方法有两种: 的方法有两种: 的方法有两种:
-Java SE 5.0中引入 ReentrantLock ReentrantLock ReentrantLockReentrantLock ReentrantLock类(P 648648648页)。
-在共享内存的类方法前加 在共享内存的类方法前加 在共享内存的类方法前加 在共享内存的类方法前加 在共享内存的类方法前加 在共享内存的类方法前加 在共享内存的类方法前加 在共享内存的类方法前加 在共享内存的类方法前加 在共享内存的类方法前加 在共享内存的类方法前加 synchronizedsynchronizedsynchronized synchronized synchronized synchronizedsynchronized修饰符 修饰符 修饰符 。
2、实验内容和步骤
实验1:测试程序并进行代码注释。
测试程序1:
l 在elipse IDE中调试运行ThreadTest,结合程序运行结果理解程序;
l 掌握线程概念;
l 掌握用Thread的扩展类实现线程的方法;
l 利用Runnable接口改造程序,掌握用Runnable接口创建线程的方法。
class Lefthand extends Thread { public void run() { for(int i=0;i<=5;i++) { System.out.println("You are Students!"); try{ sleep(500); } catch(InterruptedException e) { System.out.println("Lefthand error.");} } } } class Righthand extends Thread { public void run() { for(int i=0;i<=5;i++) { System.out.println("I am a Teacher!"); try{ sleep(300); } catch(InterruptedException e) { System.out.println("Righthand error.");} } } } public class ThreadTest { static Lefthand left; static Righthand right; public static void main(String[] args) { left=new Lefthand(); right=new Righthand(); left.start(); right.start(); } } |
1 package test; 2 3 class Lefthand extends Thread { 4 public void run() 5 { 6 for(int i=0;i<=5;i++) 7 { System.out.println("You are Students!"); 8 try{ sleep(500); } 9 catch(InterruptedException e) 10 { System.out.println("Lefthand error.");} 11 } 12 } 13 } 14 class Righthand extends Thread { 15 public void run() 16 { 17 for(int i=0;i<=5;i++) 18 { System.out.println("I am a Teacher!"); 19 try{ sleep(300); } 20 catch(InterruptedException e) 21 { System.out.println("Righthand error.");} 22 } 23 } 24 } 25 public class ThreadTest 26 { 27 static Lefthand left; 28 static Righthand right; 29 public static void main(String[] args) 30 { Runnable left1 = new Lefthand(); 31 Runnable right1 = new Righthand() ; 32 Thread left = new Thread(left1); 33 Thread right = new Thread(right1); 34 left.start(); 35 right.start(); 36 37 } 38 }
测试程序2:
l 在Elipse环境下调试教材625页程序14-1、14-2 、14-3,结合程序运行结果理解程序;
l 在Elipse环境下调试教材631页程序14-4,结合程序运行结果理解程序;
l 对比两个程序,理解线程的概念和用途;
l 掌握线程创建的两种技术。
1 package bounce; 2 3 import java.awt.geom.*; 4 5 /** 6 * A ball that moves and bounces off the edges of a rectangle 7 * @version 1.33 2007-05-17 8 * @author Cay Horstmann 9 */ 10 public class Ball 11 { 12 private static final int XSIZE = 15; 13 private static final int YSIZE = 15; 14 private double x = 0; 15 private double y = 0; 16 private double dx = 1; 17 private double dy = 1; 18 19 /** 20 * Moves the ball to the next position, reversing direction if it hits one of the edges 21 */ 22 public void move(Rectangle2D bounds) 23 { 24 x += dx; 25 y += dy; 26 if (x < bounds.getMinX()) 27 { 28 x = bounds.getMinX(); 29 dx = -dx; 30 } 31 if (x + XSIZE >= bounds.getMaxX()) 32 { 33 x = bounds.getMaxX() - XSIZE; 34 dx = -dx; 35 } 36 if (y < bounds.getMinY()) 37 { 38 y = bounds.getMinY(); 39 dy = -dy; 40 } 41 if (y + YSIZE >= bounds.getMaxY()) 42 { 43 y = bounds.getMaxY() - YSIZE; 44 dy = -dy; 45 } 46 } 47 48 /** 49 * Gets the shape of the ball at its current position. 50 */ 51 public Ellipse2D getShape() 52 { 53 return new Ellipse2D.Double(x, y, XSIZE, YSIZE); 54 } 55 }
1 package bounce; 2 3 import java.awt.*; 4 import java.util.*; 5 import javax.swing.*; 6 7 /** 8 * The component that draws the balls. 9 * @version 1.34 2012-01-26 10 * @author Cay Horstmann 11 */ 12 public class BallComponent extends JPanel 13 { 14 private static final int DEFAULT_WIDTH = 450; 15 private static final int DEFAULT_HEIGHT = 350; 16 17 private java.util.List<Ball> balls = new ArrayList<>(); 18 19 /** 20 * Add a ball to the component. 21 * @param b the ball to add 22 */ 23 public void add(Ball b) 24 { 25 balls.add(b); 26 } 27 28 public void paintComponent(Graphics g) 29 { 30 super.paintComponent(g); // erase background 31 Graphics2D g2 = (Graphics2D) g; 32 for (Ball b : balls) 33 { 34 g2.fill(b.getShape()); 35 } 36 } 37 38 public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); } 39 }
1 package bounce; 2 3 import java.awt.*; 4 import java.awt.event.*; 5 import javax.swing.*; 6 7 /** 8 * Shows an animated bouncing ball. 9 * @version 1.34 2015-06-21 10 * @author Cay Horstmann 11 */ 12 public class Bounce 13 { 14 public static void main(String[] args) 15 { 16 EventQueue.invokeLater(() -> { 17 JFrame frame = new BounceFrame(); 18 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 19 frame.setVisible(true); 20 }); 21 } 22 } 23 24 /** 25 * The frame with ball component and buttons. 26 */ 27 class BounceFrame extends JFrame 28 { 29 private BallComponent comp; 30 public static final int STEPS = 1000; 31 public static final int DELAY = 3; 32 33 /** 34 * Constructs the frame with the component for showing the bouncing ball and 35 * Start and Close buttons 36 */ 37 public BounceFrame() 38 { 39 setTitle("Bounce"); 40 comp = new BallComponent(); 41 add(comp, BorderLayout.CENTER); 42 JPanel buttonPanel = new JPanel(); 43 addButton(buttonPanel, "Start", event -> addBall()); 44 addButton(buttonPanel, "Close", event -> System.exit(0)); 45 add(buttonPanel, BorderLayout.SOUTH); 46 pack(); 47 } 48 49 /** 50 * Adds a button to a container. 51 * @param c the container 52 * @param title the button title 53 * @param listener the action listener for the button 54 */ 55 public void addButton(Container c, String title, ActionListener listener) 56 { 57 JButton button = new JButton(title); 58 c.add(button); 59 button.addActionListener(listener); 60 } 61 62 /** 63 * Adds a bouncing ball to the panel and makes it bounce 1,000 times. 64 */ 65 public void addBall() 66 { 67 try 68 { 69 Ball ball = new Ball(); 70 comp.add(ball); 71 72 for (int i = 1; i <= STEPS; i++) 73 { 74 ball.move(comp.getBounds()); 75 comp.paint(comp.getGraphics()); 76 Thread.sleep(DELAY); 77 } 78 } 79 catch (InterruptedException e) 80 { 81 } 82 } 83 }
1 package bounceThread; 2 3 import java.awt.geom.*; 4 5 /** 6 A ball that moves and bounces off the edges of a 7 rectangle 8 * @version 1.33 2007-05-17 9 * @author Cay Horstmann 10 */ 11 public class Ball 12 { 13 private static final int XSIZE = 15; 14 private static final int YSIZE = 15; 15 private double x = 0; 16 private double y = 0; 17 private double dx = 1; 18 private double dy = 1; 19 20 /** 21 Moves the ball to the next position, reversing direction 22 if it hits one of the edges 23 */ 24 public void move(Rectangle2D bounds) 25 { 26 x += dx; 27 y += dy; 28 if (x < bounds.getMinX()) 29 { 30 x = bounds.getMinX(); 31 dx = -dx; 32 } 33 if (x + XSIZE >= bounds.getMaxX()) 34 { 35 x = bounds.getMaxX() - XSIZE; 36 dx = -dx; 37 } 38 if (y < bounds.getMinY()) 39 { 40 y = bounds.getMinY(); 41 dy = -dy; 42 } 43 if (y + YSIZE >= bounds.getMaxY()) 44 { 45 y = bounds.getMaxY() - YSIZE; 46 dy = -dy; 47 } 48 } 49 50 /** 51 Gets the shape of the ball at its current position. 52 */ 53 public Ellipse2D getShape() 54 { 55 return new Ellipse2D.Double(x, y, XSIZE, YSIZE); 56 } 57 }
1 package bounceThread; 2 3 import java.awt.*; 4 import java.util.*; 5 import javax.swing.*; 6 7 /** 8 * The component that draws the balls. 9 * @version 1.34 2012-01-26 10 * @author Cay Horstmann 11 */ 12 public class BallComponent extends JComponent 13 { 14 private static final int DEFAULT_WIDTH = 450; 15 private static final int DEFAULT_HEIGHT = 350; 16 17 private java.util.List<Ball> balls = new ArrayList<>(); 18 19 /** 20 * Add a ball to the panel. 21 * @param b the ball to add 22 */ 23 public void add(Ball b) 24 { 25 balls.add(b); 26 } 27 28 public void paintComponent(Graphics g) 29 { 30 Graphics2D g2 = (Graphics2D) g; 31 for (Ball b : balls) 32 { 33 g2.fill(b.getShape()); 34 } 35 } 36 37 public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); } 38 }
1 package bounceThread; 2 3 import java.awt.*; 4 import java.awt.event.*; 5 6 import javax.swing.*; 7 8 /** 9 * Shows animated bouncing balls. 10 * @version 1.34 2015-06-21 11 * @author Cay Horstmann 12 */ 13 public class BounceThread 14 { 15 public static void main(String[] args) 16 { 17 EventQueue.invokeLater(() -> { 18 JFrame frame = new BounceFrame(); 19 frame.setTitle("BounceThread"); 20 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 21 frame.setVisible(true); 22 }); 23 } 24 } 25 26 /** 27 * The frame with panel and buttons. 28 */ 29 class BounceFrame extends JFrame 30 { 31 private BallComponent comp; 32 public static final int STEPS = 1000; 33 public static final int DELAY = 5; 34 35 36 /** 37 * Constructs the frame with the component for showing the bouncing ball and 38 * Start and Close buttons 39 */ 40 public BounceFrame() 41 { 42 comp = new BallComponent(); 43 add(comp, BorderLayout.CENTER); 44 JPanel buttonPanel = new JPanel(); 45 addButton(buttonPanel, "Start", event -> addBall()); 46 addButton(buttonPanel, "Close", event -> System.exit(0)); 47 add(buttonPanel, BorderLayout.SOUTH); 48 pack(); 49 } 50 51 /** 52 * Adds a button to a container. 53 * @param c the container 54 * @param title the button title 55 * @param listener the action listener for the button 56 */ 57 public void addButton(Container c, String title, ActionListener listener) 58 { 59 JButton button = new JButton(title); 60 c.add(button); 61 button.addActionListener(listener); 62 } 63 64 /** 65 * Adds a bouncing ball to the canvas and starts a thread to make it bounce 66 */ 67 public void addBall() 68 { 69 Ball ball = new Ball(); 70 comp.add(ball); 71 Runnable r = () -> { 72 try 73 { 74 for (int i = 1; i <= STEPS; i++) 75 { 76 ball.move(comp.getBounds()); 77 comp.repaint(); 78 Thread.sleep(DELAY); 79 } 80 } 81 catch (InterruptedException e) 82 { 83 } 84 }; 85 Thread t = new Thread(r); 86 t.start(); 87 } 88 }
测试程序3:分析以下程序运行结果并理解程序。
class Race extends Thread { public static void main(String args[]) { Race[] runner=new Race[4]; for(int i=0;i<4;i++) runner[i]=new Race( ); for(int i=0;i<4;i++) runner[i].start( ); runner[1].setPriority(MIN_PRIORITY); runner[3].setPriority(MAX_PRIORITY);} public void run( ) { for(int i=0; i<1000000; i++); System.out.println(getName()+"线程的优先级是"+getPriority()+"已计算完毕!"); } } |
测试程序4
l 教材642页程序模拟一个有若干账户的银行,随机地生成在这些账户之间转移钱款的交易。每一个账户有一个线程。在每一笔交易中,会从线程所服务的账户中随机转移一定数目的钱款到另一个随机账户。
l 在Elipse环境下调试教材642页程序14-5、14-6,结合程序运行结果理解程序;
1 package unsynch; 2 3 import java.util.*; 4 5 /** 6 * A bank with a number of bank accounts. 7 * @version 1.30 2004-08-01 8 * @author Cay Horstmann 9 */ 10 public class Bank 11 { 12 private final double[] accounts; 13 14 /** 15 * Constructs the bank. 16 * @param n the number of accounts 17 * @param initialBalance the initial balance for each account 18 */ 19 public Bank(int n, double initialBalance) 20 { 21 accounts = new double[n]; 22 Arrays.fill(accounts, initialBalance); 23 } 24 25 /** 26 * Transfers money from one account to another. 27 * @param from the account to transfer from 28 * @param to the account to transfer to 29 * @param amount the amount to transfer 30 */ 31 public void transfer(int from, int to, double amount) 32 { 33 if (accounts[from] < amount) return; 34 System.out.print(Thread.currentThread()); 35 accounts[from] -= amount; 36 System.out.printf(" %10.2f from %d to %d", amount, from, to); 37 accounts[to] += amount; 38 System.out.printf(" Total Balance: %10.2f%n", getTotalBalance()); 39 } 40 41 /** 42 * Gets the sum of all account balances. 43 * @return the total balance 44 */ 45 public double getTotalBalance() 46 { 47 double sum = 0; 48 49 for (double a : accounts) 50 sum += a; 51 52 return sum; 53 } 54 55 /** 56 * Gets the number of accounts in the bank. 57 * @return the number of accounts 58 */ 59 public int size() 60 { 61 return accounts.length; 62 } 63 }
1 package unsynch; 2 3 /** 4 * This program shows data corruption when multiple threads access a data structure. 5 * @version 1.31 2015-06-21 6 * @author Cay Horstmann 7 */ 8 public class UnsynchBankTest 9 { 10 public static final int NACCOUNTS = 100; 11 public static final double INITIAL_BALANCE = 1000; 12 public static final double MAX_AMOUNT = 1000; 13 public static final int DELAY = 10; 14 15 public static void main(String[] args) 16 { 17 Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE); 18 for (int i = 0; i < NACCOUNTS; i++) 19 { 20 int fromAccount = i; 21 Runnable r = () -> { 22 try 23 { 24 while (true) 25 { 26 int toAccount = (int) (bank.size() * Math.random()); 27 double amount = MAX_AMOUNT * Math.random(); 28 bank.transfer(fromAccount, toAccount, amount); 29 Thread.sleep((int) (DELAY * Math.random())); 30 } 31 } 32 catch (InterruptedException e) 33 { 34 } 35 }; 36 Thread t = new Thread(r); 37 t.start(); 38 } 39 } 40 }
综合编程练习
编程练习1
- 设计一个用户信息采集程序,要求如下:
1 package project1; 2 3 import java.awt.*; 4 import java.awt.event.*; 5 import javax.swing.*; 6 import javax.swing.border.*; 7 8 public class test extends JFrame { 9 public test() { 10 JPanel panel1 = new JPanel(); 11 panel1.setPreferredSize(new Dimension(700, 45)); 12 panel1.setLayout(new GridLayout(1, 4)); 13 JLabel label1 = new JLabel("Name:"); 14 JTextField j1 = new JTextField(""); 15 JLabel label2 = new JLabel("Qualification:"); 16 JComboBox<Object> j2 = new JComboBox<>(); 17 j2.addItem("Graduate"); 18 j2.addItem("Not Graduate"); 19 panel1.add(label1); 20 panel1.add(j1); 21 panel1.add(label2); 22 panel1.add(j2); 23 24 JPanel panel2 = new JPanel(); 25 panel2.setPreferredSize(new Dimension(700, 50)); 26 panel2.setLayout(new GridLayout(1, 4)); 27 JLabel label3 = new JLabel("Address:"); 28 JTextArea j3 = new JTextArea(); 29 JLabel label4 = new JLabel("Hobby:"); 30 JPanel p = new JPanel(); 31 p.setLayout(new GridLayout(3, 1)); 32 p.setBorder(BorderFactory.createLineBorder(null)); 33 JCheckBox c1 = new JCheckBox("Reading"); 34 JCheckBox c2 = new JCheckBox("Singing"); 35 JCheckBox c3 = new JCheckBox("Dancing"); 36 p.add(c1); 37 p.add(c2); 38 p.add(c3); 39 panel2.add(label3); 40 panel2.add(j3); 41 panel2.add(label4); 42 panel2.add(p); 43 44 JPanel panel3 = new JPanel(); 45 panel3.setPreferredSize(new Dimension(700, 150)); 46 FlowLayout flowLayout1 = new FlowLayout(FlowLayout.CENTER, 50, 10); 47 panel3.setLayout(flowLayout1); 48 JLabel label5 = new JLabel("Sex:"); 49 JPanel p1 = new JPanel(); 50 p1.setLayout(new GridLayout(2, 1)); 51 p1.setBorder(BorderFactory.createLineBorder(null)); 52 ButtonGroup bu = new ButtonGroup(); 53 JRadioButton jr1 = new JRadioButton("Male"); 54 JRadioButton jr2 = new JRadioButton("Female"); 55 bu.add(jr1); 56 bu.add(jr2); 57 p1.add(jr1); 58 p1.add(jr2); 59 panel3.add(label5); 60 panel3.add(p1); 61 add(panel1); 62 add(panel2); 63 add(panel3); 64 65 JPanel panel4 = new JPanel(); 66 panel4.setPreferredSize(new Dimension(700, 150)); 67 JButton b1 = new JButton("Validate"); 68 panel4.add(b1); 69 JButton b2 = new JButton("Reset"); 70 panel4.add(b2); 71 add(panel4); 72 73 FlowLayout flowLayout = new FlowLayout(); 74 this.setLayout(flowLayout); 75 this.setTitle("Students Detail"); 76 this.setBounds(200, 200, 800, 400); 77 this.setVisible(true); 78 this.setDefaultCloseOperation(DISPOSE_ON_CLOSE); 79 80 b1.addActionListener(new ActionListener() { 81 82 @Override 83 public void actionPerformed(ActionEvent e) { 84 String xueli = j2.getSelectedItem().toString(); 85 System.out.println("Name:" + j1.getText()); 86 System.out.println("Qualification:" + xueli); 87 String hobbystring = "Hobby:"; 88 if (c1.isSelected()) { 89 hobbystring += "Reading"; 90 } 91 if (c2.isSelected()) { 92 hobbystring += "Singing"; 93 } 94 if (c3.isSelected()) { 95 hobbystring += "Dancing"; 96 } 97 System.out.println("Address:" + j3.getText()); 98 if (jr1.isSelected()) { 99 System.out.println("Sex:Male"); 100 } 101 if (jr2.isSelected()) { 102 System.out.println("Sex:Female"); 103 } 104 System.out.println(hobbystring); 105 } 106 }); 107 b2.addActionListener(new ActionListener() { 108 109 @Override 110 public void actionPerformed(ActionEvent e) { 111 j1.setText(null); 112 j3.setText(null); 113 j2.setSelectedIndex(0); 114 c1.setSelected(false); 115 c2.setSelected(false); 116 c3.setSelected(false); 117 bu.clearSelection(); 118 } 119 }); 120 } 121 122 public static void main(String args[]) { 123 new test(); 124 } 125 126 }
(1) 用户信息输入界面如下图所示:
(2) 用户点击提交按钮时,用户输入信息显示控制台界面;
(3) 用户点击重置按钮后,清空用户已输入信息;
(4) 点击窗口关闭,程序退出。
2.创建两个线程,每个线程按顺序输出5次“你好”,每个“你好”要标明来自哪个线程及其顺序号。
1 package project2; 2 3 class Lefthand implements Runnable { 4 public void run() { 5 for (int i = 0; i < 5; i++) { 6 System.out.println(i + 1 + ":a.你好!"); 7 try { 8 Thread.sleep(500); 9 } catch (InterruptedException e) { 10 System.out.println("Lefthand error."); 11 } 12 } 13 } 14 } 15 16 class Righthand implements Runnable { 17 public void run() { 18 for (int i = 0; i < 5; i++) { 19 System.out.println(i + 1 + ":b.你好!"); 20 try { 21 Thread.sleep(300); 22 } catch (InterruptedException e) { 23 System.out.println("Righthand error."); 24 } 25 } 26 } 27 } 28 29 public class test { 30 public static void main(String[] args) { 31 Runnable left = new Lefthand(); 32 Thread l = new Thread(left); 33 Runnable right = new Righthand(); 34 Thread r = new Thread(right); 35 l.start(); 36 r.start(); 37 } 38 }
3. 完善实验十五 GUI综合编程练习程序。
练习一:
1 package project3; 2 3 public class Student implements Comparable<Student> { 4 5 private String name; 6 private String number ; 7 private String sex ; 8 private int age; 9 private String province; 10 11 public String getName() { 12 return name; 13 } 14 public void setName(String name) { 15 this.name = name; 16 } 17 public String getnumber() { 18 return number; 19 } 20 public void setnumber(String number) { 21 this.number = number; 22 } 23 public String getsex() { 24 return sex ; 25 } 26 public void setsex(String sex ) { 27 this.sex =sex ; 28 } 29 public int getage() { 30 31 return age; 32 } 33 public void setage(int age) { 34 // int a = Integer.parseInt(age); 35 this.age= age; 36 } 37 38 public String getprovince() { 39 return province; 40 } 41 public void setprovince(String province) { 42 this.province=province ; 43 } 44 45 public int compareTo(Student o) { 46 return this.name.compareTo(o.getName()); 47 } 48 49 public String toString() { 50 return name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n"; 51 } 52 }
1 package project3; 2 3 import java.io.BufferedReader; 4 import java.io.File; 5 import java.io.FileInputStream; 6 import java.io.InputStreamReader; 7 import java.io.FileNotFoundException; 8 import java.io.IOException; 9 import java.util.ArrayList; 10 import java.util.Arrays; 11 import java.util.Collections; 12 import java.util.Scanner; 13 import java.awt.*; 14 import javax.swing.*; 15 import java.awt.event.*; 16 17 public class Main extends JFrame { 18 private static ArrayList<Student> studentlist; 19 private static ArrayList<Student> list; 20 private JPanel panel; 21 private JPanel buttonPanel; 22 private static final int DEFAULT_WITH = 600; 23 private static final int DEFAULT_HEIGHT = 300; 24 25 public Main() { 26 studentlist = new ArrayList<>(); 27 Scanner scanner = new Scanner(System.in); 28 File file = new File("C:\\Users\\ASUS\\Desktop\\身份证号.txt"); 29 try { 30 FileInputStream fis = new FileInputStream(file); 31 BufferedReader in = new BufferedReader(new InputStreamReader(fis)); 32 String temp = null; 33 while ((temp = in.readLine()) != null) { 34 35 Scanner linescanner = new Scanner(temp); 36 37 linescanner.useDelimiter(" "); 38 String name = linescanner.next(); 39 String number = linescanner.next(); 40 String sex = linescanner.next(); 41 String age = linescanner.next(); 42 String province = linescanner.nextLine(); 43 Student student = new Student(); 44 student.setName(name); 45 student.setnumber(number); 46 student.setsex(sex); 47 int a = Integer.parseInt(age); 48 student.setage(a); 49 student.setprovince(province); 50 studentlist.add(student); 51 52 } 53 } catch (FileNotFoundException e) { 54 System.out.println("学生信息文件找不到"); 55 e.printStackTrace(); 56 } catch (IOException e) { 57 System.out.println("学生信息文件读取错误"); 58 e.printStackTrace(); 59 } 60 panel = new JPanel(); 61 panel.setLayout(new BorderLayout()); 62 JTextArea jt = new JTextArea(); 63 panel.add(jt); 64 add(panel, BorderLayout.NORTH); 65 buttonPanel = new JPanel(); 66 buttonPanel.setLayout(new GridLayout(1, 7)); 67 JButton jButton = new JButton("字典排序"); 68 JButton jButton1 = new JButton("年龄最大和年龄最小"); 69 JLabel lab = new JLabel("猜猜你的老乡"); 70 JTextField jt1 = new JTextField(); 71 JLabel lab1 = new JLabel("找找同龄人(年龄相近):"); 72 JTextField jt2 = new JTextField(); 73 JLabel lab2 = new JLabel("输入你的身份证号码:"); 74 JTextField jt3 = new JTextField(); 75 JButton jButton2 = new JButton("退出"); 76 jButton.setBounds(110, 90, 60, 30); 77 jButton1.setBounds(110, 90, 60, 30); 78 jt1.setBounds(110, 90, 60, 30); 79 jt2.setBounds(110, 90, 60, 30); 80 jt3.setBounds(110, 90, 60, 30); 81 jButton2.setBounds(110, 90, 60, 30); 82 jButton.addActionListener(new ActionListener() { 83 public void actionPerformed(ActionEvent e) { 84 Collections.sort(studentlist); 85 jt.setText(studentlist.toString()); 86 } 87 }); 88 jButton1.addActionListener(new ActionListener() { 89 public void actionPerformed(ActionEvent e) { 90 int max = 0, min = 100; 91 int j, k1 = 0, k2 = 0; 92 for (int i = 1; i < studentlist.size(); i++) { 93 j = studentlist.get(i).getage(); 94 if (j > max) { 95 max = j; 96 k1 = i; 97 } 98 if (j < min) { 99 min = j; 100 k2 = i; 101 } 102 103 } 104 jt.setText("年龄最大:" + studentlist.get(k1) + "年龄最小:" + studentlist.get(k2)); 105 } 106 }); 107 jButton2.addActionListener(new ActionListener() { 108 public void actionPerformed(ActionEvent e) { 109 dispose(); 110 System.exit(0); 111 } 112 }); 113 jt1.addActionListener(new ActionListener() { 114 public void actionPerformed(ActionEvent e) { 115 String find = jt1.getText(); 116 String text=""; 117 String place = find.substring(0, 3); 118 for (int i = 0; i < studentlist.size(); i++) { 119 if (studentlist.get(i).getprovince().substring(1, 4).equals(place)) { 120 text+="\n"+studentlist.get(i); 121 jt.setText("老乡:" + text); 122 } 123 } 124 } 125 }); 126 jt2.addActionListener(new ActionListener() { 127 public void actionPerformed(ActionEvent e) { 128 String yourage = jt2.getText(); 129 int a = Integer.parseInt(yourage); 130 int near = agenear(a); 131 int value = a - studentlist.get(near).getage(); 132 jt.setText("年龄相近:" + studentlist.get(near)); 133 } 134 }); 135 jt3.addActionListener(new ActionListener() { 136 public void actionPerformed(ActionEvent e) { 137 list = new ArrayList<>(); 138 Collections.sort(studentlist); 139 String key = jt3.getText(); 140 for (int i = 1; i < studentlist.size(); i++) { 141 if (studentlist.get(i).getnumber().contains(key)) { 142 list.add(studentlist.get(i)); 143 jt.setText("emmm!你可能是:\n" + list); 144 //System.out.println("可能的人:" + studentlist.get(i)); 145 //jt.setText("可能的人:" + studentlist.get(i)); 146 } 147 } 148 } 149 }); 150 buttonPanel.add(jButton); 151 buttonPanel.add(jButton1); 152 buttonPanel.add(lab); 153 buttonPanel.add(jt1); 154 buttonPanel.add(lab1); 155 buttonPanel.add(jt2); 156 buttonPanel.add(lab2); 157 buttonPanel.add(jt3); 158 buttonPanel.add(jButton2); 159 add(buttonPanel, BorderLayout.SOUTH); 160 setSize(DEFAULT_WITH, DEFAULT_HEIGHT); 161 } 162 163 public static int agenear(int age) { 164 int min = 53, value = 0, k = 0; 165 for (int i = 0; i < studentlist.size(); i++) { 166 value = studentlist.get(i).getage() - age; 167 if (value < 0) 168 value = -value; 169 if (value < min) { 170 min = value; 171 k = i; 172 } 173 } 174 return k; 175 } 176 177 }
1 package project3; 2 3 import java.awt.*; 4 import javax.swing.*; 5 6 public class ButtonTest { 7 public static void main(String[] args) { 8 EventQueue.invokeLater(() -> { 9 JFrame frame = new Main(); 10 frame.setTitle("身份证"); 11 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 12 frame.setVisible(true); 13 }); 14 } 15 }
练习二:
1 package project4; 2 3 import java.awt.*; 4 import java.awt.event.ActionEvent; 5 import java.awt.event.ActionListener; 6 import java.io.BufferedOutputStream; 7 import java.io.File; 8 import java.io.FileOutputStream; 9 import java.io.IOException; 10 import java.util.ArrayList; 11 12 import javax.swing.*; 13 14 public class MyExGUI extends JFrame { 15 ArrayList<String> user_zongti = new ArrayList<String>(); 16 ArrayList<String> user_zonganswer = new ArrayList<String>(); 17 ArrayList<String> user_answer = new ArrayList<String>(); 18 ArrayList<String> true_answer = new ArrayList<String>(); 19 ArrayList<String> jta_timu = new ArrayList<String>(); 20 ArrayList<String> jta_zong = new ArrayList<String>(); 21 ArrayList<Integer> user_fenshu = new ArrayList<Integer>(); 22 JMenuBar jm; // 菜单条组件 23 JMenu menu;// 菜单 24 JMenuItem item1, item2;// 菜单项 25 JMenu build; // 二级菜单 26 JMenuItem file, project; 27 TextArea answer_all = new TextArea(); 28 TextField jta = new TextField(); 29 TextField jta_answer = new TextField(); 30 JLabel num_answer = new JLabel(); 31 JLabel answer; 32 JToolBar jtb;// 工具条 33 JButton jb1, jb2, jb3, jb4, jb5, jb6, jb7, jb_next; 34 int answer_count; 35 int answer_fenshu; 36 37 public MyExGUI() { 38 // 创建菜单 39 jm = new JMenuBar(); 40 41 menu = new JMenu("文件(F)"); 42 menu.setMnemonic('f'); // 助记符 43 44 build = new JMenu("新建"); 45 46 file = new JMenuItem("文件"); 47 project = new JMenuItem("答题"); 48 item1 = new JMenuItem("保存(S)"); 49 item2 = new JMenuItem("退出"); 50 51 answer = new JLabel("第 1 题"); 52 53 // 添加菜单项至菜单上 54 build.add(file); 55 build.add(project); 56 57 menu.add(build); 58 menu.add(item1); 59 menu.add(item2); 60 menu.addSeparator(); 61 // 将菜单加入至菜单栏 62 jm.add(menu); 63 64 JPanel contentPanel = new JPanel(); 65 contentPanel.setLayout(null); 66 JLabel daan = new JLabel("答案"); 67 JLabel dengyu = new JLabel("="); 68 num_answer = answer; 69 num_answer.setFont(new Font("宋体", Font.BOLD, 22)); 70 jb_next = new JButton("下一题"); 71 jta.setFont(new Font("宋体", Font.BOLD, 22)); 72 jta_answer.setFont(new Font("宋体", Font.BOLD, 22)); 73 jb_next.setFont(new Font("宋体", Font.BOLD, 22)); 74 daan.setFont(new Font("宋体", Font.BOLD, 22)); 75 dengyu.setFont(new Font("宋体", Font.BOLD, 22)); 76 77 contentPanel.add(num_answer); 78 contentPanel.add(daan); 79 contentPanel.add(dengyu); 80 contentPanel.add(jta); 81 82 contentPanel.add(jta_answer); 83 contentPanel.add(answer_all); 84 contentPanel.add(jb_next); 85 86 num_answer.setBounds(90, 20, 130, 50); 87 daan.setBounds(250, 20, 90, 50); 88 jta.setBounds(50, 70, 150, 30); 89 dengyu.setBounds(205, 70, 20, 20); 90 jta_answer.setBounds(230, 70, 100, 30); 91 jb_next.setBounds(350, 70, 110, 30); 92 answer_all.setBounds(50, 120, 400, 300); 93 94 this.setJMenuBar(jm); // 添加菜单栏,不能设定位置,会自动放在最上部 95 this.add(contentPanel); 96 97 this.setTitle("在线答题系统"); 98 this.setSize(600, 500); 99 this.setVisible(true); 100 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 101 item1.addActionListener(new ActionListener() { 102 public void actionPerformed(ActionEvent arg0) { 103 FileOutputStream outSTr = null; 104 BufferedOutputStream Buff = null; 105 boolean flag = true; 106 File file; 107 // String test ; 108 do { 109 // test = "test"+count; 110 111 String inputValue = JOptionPane.showInputDialog("Please input file name"); 112 file = new File(inputValue + "test.txt"); 113 if (!file.exists()) { 114 // 创建文件 115 try { 116 117 flag = file.createNewFile(); 118 119 } catch (IOException e) { 120 e.printStackTrace(); 121 122 } 123 flag = false; 124 } else { 125 126 JOptionPane.showMessageDialog(null, "该文件名已存在,请重新输入", "ERROR", JOptionPane.ERROR_MESSAGE); 127 flag = true; 128 } 129 } while (flag); 130 // 写入文件 131 String u_answer; 132 try { 133 outSTr = new FileOutputStream(file); 134 Buff = new BufferedOutputStream(outSTr); 135 System.out.println("选择是后执行的代码" + user_zongti.size() + user_answer.size()); 136 for (int i = 0; i < user_zongti.size(); i++) { 137 try { 138 Buff.write(user_zongti.get(i).getBytes()); 139 Buff.write(" ".getBytes()); 140 u_answer = user_answer.get(i); 141 if (u_answer.equals("")) 142 u_answer = "没有作答"; 143 144 Buff.write(u_answer.getBytes()); 145 Buff.write("\r\n".getBytes()); 146 } catch (IOException e) { 147 e.printStackTrace(); 148 i--; 149 } 150 } 151 Buff.flush(); 152 Buff.close(); 153 154 } catch (IOException e) { 155 e.printStackTrace(); 156 } 157 try { 158 outSTr.close(); 159 } catch (IOException e) { 160 e.printStackTrace(); 161 } 162 user_zongti.clear(); 163 user_answer.clear(); 164 } 165 }); 166 167 project.addActionListener(new ActionListener() { 168 public void actionPerformed(ActionEvent arg0) { 169 arithmetic art = new arithmetic(); 170 true_answer = art.list_answer; 171 jta_timu = art.list_timu; 172 jta_zong = art.list; 173 answer_count = 1; 174 answer_all.setText(""); 175 for (int i = 0; i < art.list_timu.size(); i++) { 176 user_zongti.add(jta_zong.get(i)); 177 answer_all.append(jta_timu.get(i)); 178 answer_all.append("\r\n"); 179 } 180 num_answer.setText("第 " + answer_count + " 题"); 181 jta.setText(jta_timu.get(answer_count - 1)); 182 answer_count++; 183 184 } 185 }); 186 jb_next.addActionListener(new ActionListener() { 187 public void actionPerformed(ActionEvent arg0) { 188 String temp; 189 temp = jta_answer.getText(); 190 191 if (jta.getText().equals("")) { 192 JOptionPane.showMessageDialog(null, "错误,请导入题库", "错误", JOptionPane.ERROR_MESSAGE); 193 return; 194 } 195 jta_answer.setText(""); 196 if (answer_count <= 10) { 197 if (isInteger(temp)) { 198 199 user_answer.add(temp); 200 System.out.println("选择否后执行的代码" + temp + "user_size" + user_answer.size()); 201 num_answer.setText("第 " + answer_count + " 题"); 202 jta.setText(jta_timu.get(answer_count - 1)); 203 answer_count++; 204 } else { 205 JOptionPane.showMessageDialog(null, "错误", "请输入数字", JOptionPane.ERROR_MESSAGE); 206 } 207 } else { 208 user_answer.add(temp); 209 System.out.println("选择否后执行的代码" + temp + "user_size" + user_answer.size()); 210 answer_fenshu = 0; 211 for (int i = 0; i < user_answer.size(); i++) { 212 if (user_answer.get(i).equals(true_answer.get(i))) 213 answer_fenshu += 5; 214 } 215 user_fenshu.add(answer_fenshu); 216 Object[] options = { "是", "取消" }; 217 int res = JOptionPane.showOptionDialog(null, "是否查看成绩", "答题完毕", JOptionPane.DEFAULT_OPTION, 218 JOptionPane.YES_NO_OPTION, null, options, options[0]); 219 if (res == JOptionPane.YES_OPTION) { 220 chart ct = new chart(user_fenshu); 221 ct.setVisible(true); 222 223 } else { 224 Object[] option = { "是", "取消" }; 225 int res1 = JOptionPane.showOptionDialog(null, "是否退出程序", "终止框", JOptionPane.DEFAULT_OPTION, 226 JOptionPane.YES_NO_OPTION, null, option, option[0]); 227 228 if (res1 == JOptionPane.YES_OPTION) { 229 dispose(); 230 System.exit(0); 231 232 } else { 233 234 } 235 236 } 237 238 } 239 240 } 241 }); 242 243 item2.addActionListener(new ActionListener() { 244 public void actionPerformed(ActionEvent e) { 245 dispose(); 246 System.exit(0); 247 } 248 }); 249 250 } 251 252 public static boolean isInteger(String str) { 253 for (int i = str.length(); --i >= 0;) { 254 if (!Character.isDigit(str.charAt(i))) { 255 return false; 256 } 257 } 258 return true; 259 } 260 261 }
1 package project4; 2 3 public class Main { 4 5 public static void main(String[] args) { 6 MyExGUI lg = new MyExGUI(); 7 //new MyExGUI(); 8 9 } 10 11 }
1 package project4; 2 3 import java.io.BufferedOutputStream; 4 import java.io.File; 5 import java.io.FileOutputStream; 6 import java.io.IOException; 7 import java.util.ArrayList; 8 import java.util.Random; 9 import java.util.Scanner; 10 11 public class arithmetic { 12 ArrayList<String> list = new ArrayList<String>(); 13 ArrayList<String> list_timu = new ArrayList<String>(); 14 ArrayList<String> list_answer = new ArrayList<String>(); 15 16 public arithmetic() { 17 FileOutputStream outSTr = null; 18 BufferedOutputStream Buff = null; 19 int number_n = 10, count; 20 21 ArrayList<String> list_temp = new ArrayList<String>(); 22 String[] operator = new String[] { "+", "-", "*", "/" }; 23 24 Random rand = new Random(); 25 File file1 = new File("test.txt"); 26 if (file1.exists()) { 27 // 创建文件 28 try { 29 file1.createNewFile(); 30 } catch (IOException e) { 31 e.printStackTrace(); 32 } 33 } 34 35 while (number_n > 0) { 36 int[] number_temp = new int[rand.nextInt(2) + 3]; 37 String[] str_temp = new String[number_temp.length - 1]; 38 for (int i = 0; i < number_temp.length; i++) { 39 if (i < number_temp.length - 1) { 40 number_temp[i] = rand.nextInt(100); 41 list_temp.add(String.valueOf(number_temp[i])); 42 str_temp[i] = operator[rand.nextInt(4)]; 43 list_temp.add(str_temp[i]); 44 45 } 46 47 else { 48 number_temp[i] = rand.nextInt(100); 49 list_temp.add(String.valueOf(number_temp[i])); 50 } 51 } 52 53 count = calculate_RPN(produce_RPN(list_temp)); 54 if (count != -1) { 55 list_timu.add(transform_string(list_temp)); 56 list_answer.add(String.valueOf(count)); 57 list_temp.add(" = " + count); 58 list.add(transform_string(list_temp)); 59 number_n--; 60 list_temp.clear(); 61 } else 62 list_temp.clear(); 63 System.out.println(number_n); 64 65 } 66 try { 67 outSTr = new FileOutputStream(file1); 68 Buff = new BufferedOutputStream(outSTr); 69 for (int i = 0; i < list.size(); i++) { 70 try { 71 Buff.write(list.get(i).getBytes()); 72 Buff.write("\r\n".getBytes()); 73 } catch (IOException e) { 74 e.printStackTrace(); 75 i--; 76 } 77 } 78 Buff.flush(); 79 Buff.close(); 80 81 } catch (IOException e) { 82 e.printStackTrace(); 83 } 84 // Buff.close(); 85 try { 86 outSTr.close(); 87 } catch (IOException e) { 88 e.printStackTrace(); 89 } 90 91 for (int i = 0; i < list.size(); i++) { 92 System.out.print(list.get(i)); 93 System.out.println(); 94 } 95 System.out.print("计算完毕!"); 96 97 } 98 99 public static int calculate_RPN(ArrayList<String> list_temp) { 100 int i = 0, t; 101 double a = 0, b = 0; 102 String l_temp; 103 Stack sk = new Stack(10); 104 for (t = 0; t < list_temp.size(); t++) { 105 l_temp = list_temp.get(i++); 106 if (!isInteger(l_temp)) { 107 b = sk.mypop(); 108 a = sk.mypop(); 109 switch (l_temp) { 110 case "+": 111 sk.mypush(a + b); 112 break; 113 case "-": 114 if(!(a<b)) { 115 sk.mypush(a - b); 116 } 117 else 118 return -1; 119 break; 120 case "*": 121 sk.mypush(a * b); 122 break; 123 case "/": 124 if (b == 0||a<b) 125 return -1; 126 sk.mypush(a / b); 127 break; 128 } 129 System.out.println("st.mytop: " + sk.mypeek()); 130 } else { 131 sk.mypush((double) Integer.parseInt(l_temp)); 132 } 133 134 } 135 if (!sk.myisempty()) { 136 a = sk.mypop(); 137 b = a - (int) a; 138 System.out.println("a: " + a); 139 if (a > 0 && b == 0) { 140 return (int) a; 141 } else 142 return -1; 143 } else 144 return -1; 145 146 } 147 148 public static ArrayList<String> produce_RPN(ArrayList<String> list_temp) { 149 int t = 0, i = 0; 150 String tmp; 151 Tack mytack = new Tack(10); 152 ArrayList<String> lt_temp = new ArrayList<String>(); 153 while (true) { 154 tmp = list_temp.get(i++); 155 if (isInteger(tmp)) { 156 lt_temp.add(tmp); 157 } else { 158 if (mytack.myisempty()) { 159 mytack.mypush(tmp); 160 } 161 162 else { 163 if (isCPriority(tmp, mytack.mypeek())) 164 mytack.mypush(tmp); 165 else { 166 lt_temp.add(mytack.mypop()); 167 mytack.mypush(tmp); 168 } 169 170 } 171 } 172 if (i >= list_temp.size()) { 173 while (!mytack.myisempty()) 174 lt_temp.add(mytack.mypop()); 175 System.out.println(transform_string(list_temp)); 176 list_temp = lt_temp; 177 System.out.println(list_temp); 178 return list_temp; 179 } 180 } 181 182 } 183 184 public static boolean isInteger(String str) { 185 for (int i = str.length(); --i >= 0;) { 186 if (!Character.isDigit(str.charAt(i))) { 187 return false; 188 } 189 } 190 return true; 191 } 192 193 public static boolean isCPriority(String str, String s) { 194 if ((str + s).equals("*+") || (str + s).equals("*-") || (str + s).equals("/+") || (str + s).equals("/-")) 195 return true; 196 else 197 return false; 198 } 199 200 public static String transform_string(ArrayList<String> list_temp) { 201 String s = ""; 202 for (int i = 0; i < list_temp.size(); i++) { 203 s += list_temp.get(i); 204 } 205 return s; 206 207 } 208 209 static class Stack { 210 int mytop; 211 double stk[]; 212 213 public Stack(int num) { 214 mytop = -1; 215 stk = new double[num]; 216 } 217 218 /* 出栈 */ 219 double mypop() { 220 double peek = stk[mytop]; 221 mytop--; 222 return peek; 223 } 224 225 /* 入栈 */ 226 void mypush(double x) { 227 mytop++; 228 stk[mytop] = x; 229 230 } 231 232 /* 判空 */ 233 Boolean myisempty() { 234 if (mytop == -1) 235 return true; 236 else 237 return false; 238 } 239 240 /* 取栈顶元素 */ 241 double mypeek() { 242 double peek = stk[mytop]; 243 return peek; 244 } 245 246 /* 栈大小 */ 247 int mysize() { 248 return mytop + 1; 249 } 250 } 251 252 static class Tack { 253 int mytop; 254 String tk[]; 255 256 public Tack(int num) { 257 mytop = -1; 258 tk = new String[num]; 259 } 260 261 /* 出栈 */ 262 String mypop() { 263 String peek = tk[mytop]; 264 mytop--; 265 return peek; 266 } 267 268 /* 入栈 */ 269 void mypush(String x) { 270 mytop++; 271 tk[mytop] = x; 272 273 } 274 275 /* 判空 */ 276 Boolean myisempty() { 277 if (mytop == -1) 278 return true; 279 else 280 return false; 281 } 282 283 /* 取栈顶元素 */ 284 String mypeek() { 285 String peek = tk[mytop]; 286 return peek; 287 } 288 289 /* 栈大小 */ 290 int mysize() { 291 return mytop + 1; 292 } 293 294 } 295 }
实验总结:
通过这一周的学习,掌握了线程的概念,线程创建的两种技术,以及多线程运行的原理,理解和掌握了线程的优先级属性及调度方法,线程同步的概念及实现技术。
在编程中布局方面的问题较为困难,展现出来的界面看起来不是很美观,对布局的内容还有待进一步的理解。