devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java--花卉管理系统_鲜花管理系统

作者：秋刀鱼在做梦 | 2024-07-22 18:36:30

赞

踩

鲜花管理系统

这是一个稍微综合一点的小小小项目，算是给Java的学习画一个小结点

直接开门见山来看设计吧~

1.上传的这个版本是通过文本存储数据（PS：别问我为啥不用数据库，因为当时事情多.....懒得实现）

2.这个版本有欢迎界面、增加花卉界面、删除花卉界面、修改花卉信息界面、查询花卉界面。

3.对文本的增删查改过程全部定义在独立的类的方法中，通过对类中方法的调用来实现。

以下是代码的文件表：

在这个程序中的绝大多数提示我用的都是具有鲜明时代特色的表情包，哈哈哈哈哈哈

先让你们小小欣赏下（哈哈哈哈哈，前方小高能，非战斗人员请尽快撤退！！）：

1. 当有未填信息时

2. 当编号中包含非数字符时（单价非数字时等提示图片一样）

3.当输入正确时

  • 主函数代码（Test.java）：
  1. public class Test {
  2.       /**
  3.        * @param args
  4.        */
  5.       public static void main(String[] args) {
  6.             Enter enter = new Enter();
  7.             //AddFlower add = new AddFlower();
  8.             //SearchFlower s = new SearchFlower();
  9.             //DeleteFlower d = new DeleteFlower();
  10.             //ModifyFlower m = new ModifyFlower();
  11.       }
  12. }
  • 欢迎界面（Enter.java）：

  1. import javax.swing.*;
  2. import javax.swing.event.AncestorListener;
  3. import java.awt.*;
  4. import java.awt.event.*;
  5.  
  6.  
  7. public class Enter extends JFrame implements ActionListener
  8. {
  9. 	JLabel PhotoLabel = new JLabel(new ImageIcon("Flower.jpg"));
  10. 	JButton loginbt;//登录进入按钮
  11. 	JLabel InformationJLabel;//欢迎语
  12. 	
  13. 	public Enter()
  14. 	{
  15. 		this.setSize(500, 500);
  16. 		this.setTitle("花卉信息管理系统");
  17. 		this.setLocation(700,200);
  18. 		this.setVisible(true);
  19. 		this.setLayout(null);
  20. 		//设置照片为背景
  21. 		String Background = "Flower.jpg";
  22. 		ImageIcon background = new ImageIcon(Background);
  23. 		JLabel label = new JLabel(background);
  24. 		label.setBounds(0, 0,this.getWidth() , this.getHeight());
  25. 		JPanel imagePanel = (JPanel) this.getContentPane();
  26. 		imagePanel.setOpaque(false);
  27. 		this.getLayeredPane().add(label, new Integer(Integer.MIN_VALUE));
  28. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  29. 		this.init();
  30. 	}
  31. 	
  32. 	private void init()
  33. 	{
  34. 		loginbt=new JButton("登录");
  35. 		loginbt.setSize(100,50);
  36. 		loginbt.setLocation(180, 330);
  37. 		loginbt.addActionListener(this);
  38. 		this.add(loginbt);
  39. 		InformationJLabel = new JLabel("欢迎使用!");
  40. 		InformationJLabel.setFont(new Font("宋体", Font.BOLD | Font.ITALIC, 50));
  41. 		InformationJLabel.setSize(300, 50);
  42. 		InformationJLabel.setLocation(120,150);
  43. 		this.add(InformationJLabel);
  44. 		
  45. 	}
  46. 	
  47. 	@Override
  48. 	public void actionPerformed(ActionEvent e) {
  49. 	AddFlower addflower = new AddFlower(); 
  50. 		
  51. 	}
  52. 	
  53. }
  • 增加花卉界面（AddFlower.java）: 

  1. import javax.swing.*;
  2. import javax.swing.event.AncestorListener;
  3.  
  4. import java.awt.Font;
  5. import java.awt.event.*;
  6.  
  7. public class AddFlower extends JFrame implements ActionListener
  8. {
  9. 	JLabel tableLabel;
  10. 	
  11. 	JLabel NumLabel;//编号
  12. 	JLabel NameLabel;//名称
  13. 	JLabel PriceLabel;//单价
  14. 	JLabel UnitLabel;//计价单位
  15.  
  16. 	JTextField NumText;//编号文本框
  17. 	JTextField NameText;//名称文本框
  18. 	JTextField PriceText;//单价文本框
  19. 	JTextField UnitText;//计价单位文本框
  20. 	
  21. 	JButton[] rbts;//按钮数组对象
  22. 	ButtonGroup btGroup;//按钮组，从逻辑上来涵盖所有的单选按钮
  23. 	JButton Addbt;//增加按钮
  24. 	
  25. 	public AddFlower()
  26. 	{
  27. 		this.setSize(500, 500);
  28. 		this.setTitle("花卉信息管理系统");
  29. 		this.setLocation(700,200);
  30. 		this.setVisible(true);
  31. 		this.setLayout(null);
  32. 		this.init();
  33. 	}
  34. 	
  35. 	private void init()
  36. 	{
  37. 		//增删查改功能入口按钮
  38. 		btGroup=new ButtonGroup();
  39. 		rbts=new JButton[4];
  40. 		String[] strs = {"增加","删除","搜索","修改"};
  41. 		for(int i = 0;i<strs.length;i++)
  42. 		{
  43. 			rbts[i]=new JButton(strs[i]);
  44. 			rbts[i].setSize(70, 30);
  45. 			rbts[i].setLocation(100*i+60, 30);
  46. 			btGroup.add(rbts[i]);//从逻辑上将单选按钮添加到一个按钮数组中
  47. 			this.add(rbts[i]);//从物理位置上将单选按钮添加到窗体中
  48. 			rbts[i].addActionListener(this);
  49. 		}
  50. 		
  51. 		//编号
  52. 		NumLabel=new JLabel("编号");
  53. 		NumLabel.setFont(NumLabel.getFont().deriveFont(Font.BOLD, 18));
  54. 		NumLabel.setSize(90,30);
  55. 		NumLabel.setLocation(70, 110);
  56. 		this.add(NumLabel);
  57. 		NumText=new JTextField();
  58. 		NumText.setSize(180,30);
  59. 		NumText.setLocation(170, 110);
  60. 		this.add(NumText);
  61. 		
  62. 		//名称
  63. 		NameLabel=new JLabel("名称");
  64. 		NameLabel.setFont(NameLabel.getFont().deriveFont(Font.BOLD, 18));
  65. 		NameLabel.setSize(90,30);
  66. 		NameLabel.setLocation(70, 170);
  67. 		this.add(NameLabel);
  68. 		NameText=new JTextField();
  69. 		NameText.setSize(180,30);
  70. 		NameText.setLocation(170, 170);
  71. 		this.add(NameText);
  72. 		
  73. 		//单价
  74. 		PriceLabel=new JLabel("单价");
  75. 		PriceLabel.setFont(PriceLabel.getFont().deriveFont(Font.BOLD, 18));
  76. 		PriceLabel.setSize(90,30);
  77. 		PriceLabel.setLocation(70, 230);
  78. 		this.add(PriceLabel);
  79. 		PriceText=new JTextField();
  80. 		PriceText.setSize(180,30);
  81. 		PriceText.setLocation(170, 230);
  82. 		this.add(PriceText);
  83.  
  84. 		//计价单位
  85. 		UnitLabel=new JLabel("计价单位");
  86. 		UnitLabel.setFont(UnitLabel.getFont().deriveFont(Font.BOLD, 18));
  87. 		UnitLabel.setSize(90,30);
  88. 		UnitLabel.setLocation(70, 290);
  89. 		this.add(UnitLabel);
  90. 		UnitText=new JTextField();
  91. 		UnitText.setSize(180,30);
  92. 		UnitText.setLocation(170, 290);
  93. 		this.add(UnitText);
  94. 		
  95. 		//添加按钮
  96. 		Addbt=new JButton("添加");	
  97. 		Addbt.setSize(90,50);
  98. 		Addbt.setLocation(200, 360);
  99. 		Addbt.addActionListener(
  100. 				new ActionListener()
  101. 				{
  102. 					public void actionPerformed(ActionEvent e)
  103. 					{
  104. 						
  105. 						 if(!checkIsNull())
  106. 					      {
  107. 							  final ImageIcon icon3 = new ImageIcon("question.png");
  108. 							 JOptionPane.showMessageDialog(null,"有未填信息？", "提示", JOptionPane.INFORMATION_MESSAGE, icon3);
  109. 					      }else
  110. 					      {
  111. 					    	  if(!checkInput().equals(""))
  112. 					    	  {
  113. 					    		  final ImageIcon icon2 = new ImageIcon("NotOk.png");
  114. 									 JOptionPane.showMessageDialog(null,checkInput(), "提示", JOptionPane.INFORMATION_MESSAGE, icon2);
  115. 					    	  }else
  116. 					    	  {
  117. 					    		  FlowerDAO dao = new FlowerDAO();
  118. 					    		  //引用添加花朵信息的方法
  119. 					    		  StringBuffer FloInfo=new StringBuffer();
  120. 					    		  FloInfo.append(NumText.getText().trim()+",");
  121. 					    		  FloInfo.append(NameText.getText().trim()+",");
  122. 					    		  FloInfo.append(PriceText.getText().trim()+",");
  123. 					    		  FloInfo.append(UnitText.getText().trim());
  124. 					    		// dao.AddFlower(FloInfo);
  125. 					    		  if(dao.AddFlower(FloInfo.toString()))
  126. 									{
  127. 					    			  final ImageIcon icon = new ImageIcon("Ok2.png");
  128. 										JOptionPane.showMessageDialog(null,"添加成功", "提示", JOptionPane.INFORMATION_MESSAGE, icon);
  129. 										NumText.setText("");
  130. 										NameText.setText("");
  131. 										PriceText.setText("");
  132. 										UnitText.setText("");
  133. 									}
  134. 									else
  135. 									{
  136. 										final ImageIcon icon1 = new ImageIcon("NotOk2.png");
  137. 										JOptionPane.showMessageDialog(null,"信息重复", "提示", JOptionPane.INFORMATION_MESSAGE, icon1);
  138. 									}
  139. 					    	  }
  140. 					      }
  141. 					}
  142. 				}
  143. 		);
  144. 		this.add(Addbt);
  145. 	}
  146. 	@Override
  147. 	public void actionPerformed(ActionEvent e) {
  148. 		 String buttonName = e.getActionCommand();
  149.       if(buttonName.equals("增加")){
  150.     	  System.out.println("已处在增加界面上");
  151.       }else if(buttonName.equals("删除")){
  152.     	  DeleteFlower deleteflower = new DeleteFlower();
  153.       }else if(buttonName.equals("搜索")){
  154.     	  SearchFlower searchflower = new SearchFlower();
  155.       }else{
  156.     	  ModifyFlower modifyflower = new ModifyFlower();
  157.       }
  158.      
  159. 	}
  160.  
  161. 	private boolean checkIsNull() 
  162. 	{
  163. 		boolean flag=true;
  164. 		if(NumText.getText().trim().equals(""))
  165. 		{
  166. 			flag = false;
  167. 		}else if(NameText.getText().trim().equals(""))
  168. 		{
  169. 			flag=false;
  170. 		}else if(PriceText.getText().trim().equals(""))
  171. 		{
  172. 			flag=false;
  173. 		}else if(UnitText.getText().trim().equals(""))
  174. 		{
  175. 			flag=false;
  176. 		}
  177. 		return flag;
  178. 	}
  179. 	
  180. 	private Object checkInput() 
  181. 	{	
  182. 		String result="";
  183. 		String result1="";
  184. 			for(int i=0;i<NumText.getText().trim().length();i++)
  185. 			{
  186. 				char ch=NumText.getText().trim().charAt(i);
  187. 				if((ch<'0')||(ch>'9'))
  188. 				{
  189. 					result="编号中包含非数字字符";
  190. 					break;
  191. 				}
  192. 			}
  193. 			for(int i=0;i<PriceText.getText().trim().length();i++)
  194. 			{
  195. 				char ch=PriceText.getText().trim().charAt(i);
  196. 				if((ch<'0')||(ch>'9'))
  197. 				{
  198. 					result1="单价中包含非数字字符";
  199. 					break;
  200. 				}
  201. 			}
  202. 		if(result=="编号中包含非数字字符" && result1=="")
  203. 		{
  204. 			return result;
  205. 		}else if(result1=="单价中包含非数字字符" && result=="")
  206. 		{
  207. 			return result1;
  208. 		}else if(result=="编号中包含非数字字符" && result1=="单价中包含非数字字符")
  209. 		{
  210. 			return "编号和单价中均包含非数字字符";
  211. 		}else
  212. 		{
  213. 			return "";
  214. 		}
  215. 		
  216. 	}
  217.  
  218. 	
  219. }
  • 删除花卉界面（DeleteFlower.java）:

  1. import javax.swing.*;
  2.  
  3. import java.awt.Font;
  4. import java.awt.event.*;
  5. import java.util.ArrayList;
  6.  
  7. public class DeleteFlower extends JFrame implements ActionListener
  8. {
  9. 	JLabel tableLabel;//标题
  10. 	JScrollPane tablePane;//滚动视口
  11. 	JTable table;//花卉列表
  12. 	JLabel Labelnum;//删除提示
  13. 	
  14. 	JTextField DeleteText;//删除文本框
  15. 	JButton Deletebt;//删除按钮
  16. 	JButton[] rbts;//按钮数组对象
  17. 	ButtonGroup btGroup;//按钮组，从逻辑上来涵盖所有的单选按钮
  18. 	
  19. 	
  20. 	public DeleteFlower()
  21. 	{
  22. 		this.setLayout(null);
  23. 		this.setSize(700, 580);
  24. 		this.setTitle("花卉信息管理系统");
  25. 		this.setLocation(600,250);
  26. 		this.init();
  27. 		this.refreshTable();
  28. 		this.setVisible(true);
  29. 		new Thread().start();
  30. 	}
  31. 	private void init()
  32. 	{
  33. 		//增删查改功能入口按钮
  34. 		btGroup=new ButtonGroup();
  35. 		rbts=new JButton[4];
  36. 		String[] strs = {"增加","删除","搜索","修改"};
  37. 		for(int i = 0;i<strs.length;i++)
  38. 		{
  39. 			rbts[i]=new JButton(strs[i]);
  40. 			rbts[i].setSize(70, 30);
  41. 			rbts[i].setLocation(150*i+80, 10);
  42. 			btGroup.add(rbts[i]);//从逻辑上将单选按钮添加到一个按钮数组中
  43. 			this.add(rbts[i]);//从物理位置上将单选按钮添加到窗体中
  44. 			rbts[i].addActionListener(this);
  45. 		}
  46. 		
  47. 		Labelnum = new JLabel("编号");
  48. 		Labelnum.setFont(Labelnum.getFont().deriveFont(Font.BOLD, 16));
  49. 		Labelnum.setSize(100,30); 
  50. 		Labelnum.setLocation(100,70);
  51. 		this.add(Labelnum);
  52. 		
  53. 		DeleteText = new JTextField();
  54. 		DeleteText.setSize(180,30);
  55. 		DeleteText.setLocation(170, 70);
  56. 		this.add(DeleteText);
  57. 		
  58. 		Deletebt = new JButton("删除");
  59. 		Deletebt.setSize(70, 30);
  60. 		Deletebt.setLocation(380, 70);
  61. 		Deletebt.addActionListener(new ActionListener()
  62. 		{
  63. 			@Override
  64. 			public void actionPerformed(ActionEvent e) {
  65. 				int str=JOptionPane.showConfirmDialog(null, "是否删除？", "警告", JOptionPane.YES_NO_OPTION); 
  66. 				if(str==JOptionPane.YES_OPTION)
  67. 				{
  68. 					//System.out.println("进入");
  69. 					if(checkIsNull()){
  70. 						if(FlowerDAO.DeleteFlower(DeleteText.getText().trim()))
  71. 						{
  72. 							final ImageIcon icon = new ImageIcon("Ok.png");
  73. 							JOptionPane.showMessageDialog(null,"删除成功", "提示", JOptionPane.INFORMATION_MESSAGE, icon);
  74. 							DeleteText.setText("");
  75. 							refreshTable();
  76. 						}
  77. 						else
  78. 						{
  79. 							JOptionPane.showMessageDialog(null, "删除失败", "提示", JOptionPane.ERROR_MESSAGE);
  80. 						}
  81. 					}else{
  82. 						 final ImageIcon icon1 = new ImageIcon("黑人问号3.png");
  83. 						 JOptionPane.showMessageDialog(null,"未输入删除信息", "提示", JOptionPane.INFORMATION_MESSAGE, icon1);
  84. 					}
  85. 				}else{
  86. 					;
  87. 				}
  88. 					
  89. 			}
  90. 		}
  91. 					
  92. 		);
  93. 		this.add(Deletebt);	
  94. 		
  95. 		
  96. 	}
  97. 	
  98. 	private void refreshTable()
  99. 	{
  100. 		
  101. 		tableLabel = new JLabel("花卉列表");	
  102. 		tableLabel.setBounds(300,105, 100, 50);
  103. 		tableLabel.setFont(new Font("宋体", Font.BOLD , 20));
  104. 		this.add(tableLabel);
  105. 		String[] columnNames = {"编号","名称","单价","计价单位"};
  106. 		FlowerDAO dao=new FlowerDAO();
  107. 		ArrayList<String> flos=dao.findAllFlowers();
  108. 		Object[][] objs=new Object[flos.size()][4];
  109. 		for(int i=0;i<flos.size();i++)
  110. 		{
  111. 			String[] strs1=flos.get(i).split(",");
  112. 			objs[i][0]=strs1[0];
  113. 			objs[i][1]=strs1[1];
  114. 			objs[i][2]=strs1[2];
  115. 			objs[i][3]=strs1[3];
  116. 			System.out.println(strs1[0]);
  117. 		}
  118. 		
  119. 		table=new JTable(objs,columnNames);
  120. 		table.setSize(380,150);
  121. 		tablePane = new JScrollPane(table);
  122. 		tablePane.setSize(660, 350);
  123. 		tablePane.setLocation(10, 150);
  124. 		table.getTableHeader().setReorderingAllowed(false);
  125. 		table.getTableHeader().setResizingAllowed(false);
  126. 		table.enable(false);
  127. 		
  128. 		this.add(tablePane);
  129. 	}
  130. 	
  131. 	public void run() {
  132. 		while (true) {
  133. 			//每隔1秒钟更新JTable
  134. 			table.validate();
  135. 			table.updateUI();
  136. 			try {
  137. 				Thread.sleep(1000);
  138. 			} catch (InterruptedException e) {
  139. 				e.printStackTrace();
  140. 			}
  141. 		}
  142. 	}
  143.  
  144. 	@Override
  145. 	public void actionPerformed(ActionEvent e) {
  146. 		 String buttonName = e.getActionCommand();
  147. 	      if(buttonName.equals("增加")){
  148. 	    	  AddFlower addflower = new AddFlower(); 
  149. 	      }else if(buttonName.equals("删除")){
  150. 	    	  System.out.println("已处在删除界面上");
  151. 	      }else if(buttonName.equals("搜索")){
  152. 	    	  SearchFlower searchflower = new SearchFlower();
  153. 	      }else{
  154. 	    	  ModifyFlower modifyflower = new ModifyFlower();
  155. 	      }
  156. 		
  157. 	}
  158. 	
  159. 	private boolean checkIsNull() 
  160. 	{
  161. 		boolean flag=true;
  162. 		if(DeleteText.getText().trim().equals(""))
  163. 		{
  164. 			flag = false;
  165. 		}
  166. 		return flag;
  167. 	}
  168. 	
  169. 	private Object checkInput() 
  170. 	{	
  171. 		String result="";
  172. 		String result1="";
  173. 			for(int i=0;i<DeleteText.getText().trim().length();i++)
  174. 			{
  175. 				char ch=DeleteText.getText().trim().charAt(i);
  176. 				if((ch<'0')||(ch>'9'))
  177. 				{
  178. 					result="编号中包含非数字字符";
  179. 					break;
  180. 				}else
  181. 				{
  182. 					result="";
  183. 					break;
  184. 				}
  185. 			}
  186. 			return result;
  187. 		
  188. 	}
  189.  
  190. 	
  191. }
  • 搜索花卉界面（SearchFlower.java）：

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.*;
  4. import java.util.ArrayList;
  5.  
  6.  
  7.  
  8.  
  9. public class SearchFlower extends JFrame implements ActionListener
  10. {
  11.     
  12.     JLabel tableLabel;//标题
  13.     JScrollPane tablePane;//滚动视口
  14.     JTable table;//花卉列表
  15.     
  16.     JLabel NumLabel;//编号标题
  17.     JLabel NameLabel;//名称标题
  18.     JLabel PriceLabel;//单价标题
  19.     JLabel UnitLabel;//计价单位标题
  20.     JPanel panel;
  21.     JComboBox comboBox;//组合框
  22.     JTextField SearchText;//搜索文本框
  23.     JButton SearchButton;//搜索按键
  24.     /*
  25.     JTextField NumText;//编号文本框
  26.     JTextField NameText;//名称文本框
  27.     JTextField PriceText;//单价文本框
  28.     JTextField UnitText;//计价单位文本框
  29.     */
  30.     JButton[] rbts;//按钮数组对象
  31.     ButtonGroup btGroup;//按钮组，从逻辑上来涵盖所有的单选按钮
  32.     
  33.     public SearchFlower()
  34.     {
  35.         this.setLayout(null);
  36.         this.setSize(700, 580);
  37.         this.setTitle("花卉信息管理系统");
  38.         this.setLocation(600,250);
  39.         this.setBackground(Color.lightGray);
  40.         this.init();
  41.         this.refreshTable();
  42.         this.setVisible(true);
  43.     
  44.         
  45.     }
  46.     private void init()
  47.     {
  48.         //增删查改功能入口按钮
  49.         btGroup=new ButtonGroup();
  50.         rbts=new JButton[4];
  51.         String[] strs = {"增加","删除","搜索","修改"};
  52.         for(int i = 0;i<strs.length;i++)
  53.         {
  54.             rbts[i]=new JButton(strs[i]);
  55.             rbts[i].setSize(70, 30);
  56.             rbts[i].setLocation(150*i+80, 10);
  57.             btGroup.add(rbts[i]);//从逻辑上将单选按钮添加到一个按钮数组中
  58.             this.add(rbts[i]);//从物理位置上将单选按钮添加到窗体中
  59.             rbts[i].addActionListener(this);
  60.         }
  61.         
  62.         
  63.         String[] string = { "搜索条件", "编号", "名称" };
  64.         comboBox = new JComboBox(string);
  65.         comboBox.setSize(100,30);
  66.         comboBox.setLocation(50,70);
  67.         this.add(comboBox);
  68.         
  69.         SearchText = new JTextField();
  70.         SearchText.setSize(180,30);
  71.         SearchText.setLocation(170, 70);
  72.         this.add(SearchText);
  73.         
  74.         SearchButton = new JButton("搜索");
  75.         SearchButton.setSize(70, 30);
  76.         SearchButton.setLocation(380, 70);
  77.         SearchButton.addActionListener(new ActionListener()
  78.         {
  79.             @Override
  80.             public void actionPerformed(ActionEvent e) {
  81.                 String item = (String)comboBox.getSelectedItem();
  82.                 ArrayList<String> result=new ArrayList<String>();
  83.                 if("搜索条件".equals(item))
  84.                 {
  85.                     SearchText.setText("");
  86.                 }else if("编号".equals(item)){
  87.                     //根据编号进行查找的方法
  88.                     if(checkIsNull()){
  89.                         result.add(FlowerDAO.findFlowerBySno(SearchText.getText().trim()));
  90.                         JOptionPane.showMessageDialog(null, result.clone());
  91.                     }else{
  92.                         JOptionPane.showMessageDialog(null, "未输入查询信息","提示", JOptionPane.ERROR_MESSAGE);
  93.                     }
  94.                     
  95.                 }else if("名称".equals(item)){
  96.                     //根据名称进行查找的方法
  97.                     if(checkIsNull())
  98.                     {
  99.                         result.add(FlowerDAO.findFlowerBySname(SearchText.getText().trim()));
  100.                         JOptionPane.showMessageDialog(null, result.clone());
  101.                     }else{
  102.                         JOptionPane.showMessageDialog(null, "未输入查询信息", "提示", JOptionPane.ERROR_MESSAGE);
  103.                     }
  104.                 }
  105.             }
  106.         }
  107.                     
  108.         );
  109.         this.add(SearchButton);    
  110.     }
  111.     
  112.     private void refreshTable()
  113.     {
  114.         tableLabel = new JLabel("花卉列表");    
  115.         tableLabel.setBounds(300,105, 100, 50);
  116.         tableLabel.setFont(new Font("宋体", Font.BOLD , 20));
  117.         
  118.         String[] columnNames = {"编号","名称","单价","计价单位"};
  119.         FlowerDAO dao=new FlowerDAO();
  120.         ArrayList<String> flos=dao.findAllFlowers();
  121.         Object[][] objs=new Object[flos.size()][4];
  122.         for(int i=0;i<flos.size();i++)
  123.         {
  124.             String[] strs1=flos.get(i).split(",");
  125.             objs[i][0]=strs1[0];
  126.             objs[i][1]=strs1[1];
  127.             objs[i][2]=strs1[2];
  128.             objs[i][3]=strs1[3];
  129.             System.out.println(strs1[0]);
  130.         }
  131.         
  132.         table=new JTable(objs,columnNames);
  133.         table.setSize(380,150);
  134.         tablePane = new JScrollPane(table);
  135.         tablePane.setSize(660, 350);
  136.         tablePane.setLocation(10, 150);
  137.         table.getTableHeader().setReorderingAllowed(false);
  138.         table.getTableHeader().setResizingAllowed(false);
  139.         table.enable(false);
  140.         
  141.         //this.removeAll();
  142.         //this.init();
  143.         this.add(tableLabel);
  144.         this.add(tablePane);
  145.     }
  146.     
  147.     @Override
  148.     public void actionPerformed(ActionEvent e) {
  149.          String buttonName = e.getActionCommand();
  150.           if(buttonName.equals("增加")){
  151.               AddFlower addflower = new AddFlower();
  152.           }else if(buttonName.equals("删除")){
  153.               DeleteFlower deleteflower = new DeleteFlower();
  154.           }else if(buttonName.equals("搜索")){
  155.               System.out.println("已处在搜索界面上");
  156.           }else{
  157.               ModifyFlower modifyflower = new ModifyFlower();
  158.           }
  159.         
  160.     }
  161.     
  162.     private boolean checkIsNull()
  163.     {
  164.         boolean flag=true;
  165.         if(SearchText.getText().trim().equals(""))
  166.         {
  167.             flag = false;
  168.         }
  169.         return flag;
  170.     }
  171.     
  172.     private Object checkInput()
  173.     {    
  174.         String result="";
  175.         String result1="";
  176.             for(int i=0;i<SearchText.getText().trim().length();i++)
  177.             {
  178.                 char ch=SearchText.getText().trim().charAt(i);
  179.                 if((ch<'0')||(ch>'9'))
  180.                 {
  181.                     result="编号中包含非数字字符";
  182.                     break;
  183.                 }else
  184.                 {
  185.                     result="";
  186.                     break;
  187.                 }
  188.             }
  189.             return result;
  190.         
  191.     }
  192.  
  193.  
  194. }
  • 修改花卉界面（ModifyFlower.java）:

  1. import javax.swing.*;
  2.  
  3. import java.awt.Font;
  4. import java.awt.event.*;
  5. import java.util.ArrayList;
  6.  
  7. public class ModifyFlower extends JFrame implements ActionListener
  8. {
  9. 	JButton[] rbts;//按钮数组对象
  10. 	ButtonGroup btGroup;//按钮组，从逻辑上来涵盖所有的单选按钮
  11. 	
  12. 	JLabel tableLabel;//标题
  13. 	JScrollPane tablePane;//滚动视口
  14. 	JTable table;//花卉列表
  15.  
  16. 	JLabel NumLabel;//编号
  17. 	JLabel NameLabel;//名称
  18. 	JLabel PriceLabel;//单价
  19. 	JLabel UnitLabel;//计价单位
  20. 	
  21. 	JTextField NumText;//编号文本框
  22. 	JTextField NameText;//名称文本框
  23. 	JTextField PriceText;//单价文本框
  24. 	JTextField UnitText;//计价单位文本框
  25. 	
  26. 	JButton Modifybt;//修改按钮
  27. 	public ModifyFlower()
  28. 	{
  29. 		this.setLayout(null);
  30. 		this.setSize(700, 580);
  31. 		this.setTitle("花卉信息管理系统");
  32. 		this.setLocation(600,250);
  33. 		this.init();
  34. 		this.refreshTable();
  35. 		this.setVisible(true);
  36. 	}
  37. 	private void init()
  38. 	{
  39. 		//增删查改功能入口按钮
  40. 		btGroup=new ButtonGroup();
  41. 		rbts=new JButton[4];
  42. 		String[] strs = {"增加","删除","搜索","修改"};
  43. 		for(int i = 0;i<strs.length;i++)
  44. 		{
  45. 			rbts[i]=new JButton(strs[i]);
  46. 			rbts[i].setSize(70, 30);
  47. 			rbts[i].setLocation(150*i+80, 10);
  48. 			btGroup.add(rbts[i]);//从逻辑上将单选按钮添加到一个按钮数组中
  49. 			this.add(rbts[i]);//从物理位置上将单选按钮添加到窗体中
  50. 			rbts[i].addActionListener(this);
  51. 		}
  52. 		
  53. 		//编号
  54. 		NumLabel=new JLabel("编号");
  55. 		NumLabel.setFont(NumLabel.getFont().deriveFont(Font.BOLD, 16));
  56. 		NumLabel.setSize(80,30);
  57. 		NumLabel.setLocation(80, 60);
  58. 		this.add(NumLabel);
  59. 		NumText=new JTextField();
  60. 		NumText.setSize(100,30);
  61. 		NumText.setLocation(140, 60);
  62. 		this.add(NumText);
  63. 		
  64. 		//名称
  65. 		NameLabel=new JLabel("名称");
  66. 		NameLabel.setFont(NameLabel.getFont().deriveFont(Font.BOLD, 16));
  67. 		NameLabel.setSize(80,30);
  68. 		NameLabel.setLocation(300,60);
  69. 		this.add(NameLabel);
  70. 		NameText=new JTextField();
  71. 		NameText.setSize(100,30);
  72. 		NameText.setLocation(380, 60);
  73. 		this.add(NameText);
  74. 		
  75. 		//单价
  76. 		PriceLabel=new JLabel("单价");
  77. 		PriceLabel.setFont(PriceLabel.getFont().deriveFont(Font.BOLD, 16));
  78. 		PriceLabel.setSize(80,30);
  79. 		PriceLabel.setLocation(80, 100);
  80. 		this.add(PriceLabel);
  81. 		PriceText=new JTextField();
  82. 		PriceText.setSize(100,30);
  83. 		PriceText.setLocation(140, 100);
  84. 		this.add(PriceText);
  85.  
  86. 		//计价单位
  87. 		UnitLabel=new JLabel("计价单位");
  88. 		UnitLabel.setFont(UnitLabel.getFont().deriveFont(Font.BOLD, 16));
  89. 		UnitLabel.setSize(80,30);
  90. 		UnitLabel.setLocation(300, 100);
  91. 		this.add(UnitLabel);
  92. 		UnitText=new JTextField();
  93. 		UnitText.setSize(100,30);
  94. 		UnitText.setLocation(380, 100);
  95. 		this.add(UnitText);
  96. 		
  97. 		Modifybt = new JButton("修改");
  98. 		Modifybt.setSize(70, 30);
  99. 		Modifybt.setLocation(530, 100);
  100. 		Modifybt.addActionListener(new ActionListener()
  101. 		{
  102. 			@Override
  103. 			public void actionPerformed(ActionEvent e) {
  104. 				if(!checkIsNull())//如果用户输入为空的话
  105. 				{
  106. 					 final ImageIcon icon = new ImageIcon("黑人问号.png");
  107. 					 JOptionPane.showMessageDialog(null,"输入信息为空！", "提示", JOptionPane.INFORMATION_MESSAGE, icon);			}
  108. 				else
  109. 				{
  110. 					if(!checkInput().equals(""))
  111. 					{
  112. 						JOptionPane.showMessageDialog(null,checkInput());
  113. 					}
  114. 					else
  115. 					{
  116. 						FlowerDAO dao=new FlowerDAO();
  117. 						//创建一个操作学生信息文本文件的对象
  118. 						StringBuffer floInfo=new StringBuffer();
  119. 						floInfo.append(NumText.getText().trim()+",");
  120. 						floInfo.append(NameText.getText().trim()+",");
  121. 						floInfo.append(PriceText.getText().trim()+",");
  122. 						floInfo.append(UnitText.getText().trim());
  123. 						if(dao.ModifyFlower(floInfo.toString()))
  124. 						{
  125. 							final ImageIcon icon2 = new ImageIcon("OK2.png");
  126. 							JOptionPane.showMessageDialog(null,"修改成功", "提示", JOptionPane.INFORMATION_MESSAGE, icon2);
  127. 							NumText.setText("");
  128. 							NameText.setText("");
  129. 							PriceText.setText("");
  130. 							UnitText.setText("");
  131. 							refreshTable();
  132. 							//添加成功后刷新表格
  133. 						}
  134. 						else
  135. 						{
  136. 							JOptionPane.showMessageDialog(null,"修改记录失败");
  137. 						}
  138. 					}
  139. 				}
  140. 		}
  141. 		}		
  142. 		);
  143. 		this.add(Modifybt);
  144. 		
  145. 	}
  146. 	
  147. 	//表格
  148. 	private void refreshTable()
  149. 	{
  150. 		tableLabel = new JLabel("花卉列表");	
  151. 		tableLabel.setBounds(300,140, 100, 50);
  152. 		tableLabel.setFont(new Font("宋体", Font.BOLD , 20));
  153. 		
  154. 		String[] columnNames = {"编号","名称","单价","计价单位"};
  155. 		FlowerDAO dao=new FlowerDAO();
  156. 		ArrayList<String> flos=dao.findAllFlowers();
  157. 		Object[][] objs=new Object[flos.size()][4];
  158. 		for(int i=0;i<flos.size();i++)
  159. 		{
  160. 			String[] strs1=flos.get(i).split(",");
  161. 			objs[i][0]=strs1[0];
  162. 			objs[i][1]=strs1[1];
  163. 			objs[i][2]=strs1[2];
  164. 			objs[i][3]=strs1[3];
  165. 			System.out.println(strs1[0]);
  166. 		}
  167. 		
  168. 		table=new JTable(objs,columnNames);
  169. 		table.setSize(380,150);
  170. 		tablePane = new JScrollPane(table);
  171. 		tablePane.setSize(660, 320);
  172. 		tablePane.setLocation(10, 190);
  173. 		table.getTableHeader().setReorderingAllowed(false);
  174. 		table.getTableHeader().setResizingAllowed(false);
  175. 		table.enable(false);
  176. 		
  177. 		this.add(tableLabel);
  178. 		this.add(tablePane);
  179. 	}
  180. 	
  181. 	//刷新表格
  182. 	public void run() {
  183. 		while (true) {
  184. 			//每隔1秒钟更新JTable
  185. 			table.validate();
  186. 			table.updateUI();
  187. 			try {
  188. 				Thread.sleep(1000);
  189. 			} catch (InterruptedException e) {
  190. 				e.printStackTrace();
  191. 			}
  192. 		}
  193. 	}
  194. 	
  195. 	@Override
  196. 	public void actionPerformed(ActionEvent e) {
  197. 		 String buttonName = e.getActionCommand();
  198. 	      if(buttonName.equals("增加")){
  199. 	    	  AddFlower addflower = new AddFlower(); 
  200. 	      }else if(buttonName.equals("删除")){
  201. 	    	  DeleteFlower deleteflower = new DeleteFlower();
  202. 	      }else if(buttonName.equals("搜索")){
  203. 	    	  SearchFlower searchflower = new SearchFlower();
  204. 	      }else{
  205. 	    	  System.out.println("已处在修改界面上");
  206. 	      }
  207. 		
  208. 	}
  209.  
  210. 	private boolean checkIsNull() 
  211. 	{
  212. 		boolean flag=true;
  213. 		if(NumText.getText().trim().equals(""))
  214. 		{
  215. 			flag = false;
  216. 		}else if(NameText.getText().trim().equals(""))
  217. 		{
  218. 			flag=false;
  219. 		}else if(PriceText.getText().trim().equals(""))
  220. 		{
  221. 			flag=false;
  222. 		}else if(UnitText.getText().trim().equals(""))
  223. 		{
  224. 			flag=false;
  225. 		}
  226. 		return flag;
  227. 	}
  228. 	
  229. 	private Object checkInput() 
  230. 	{	
  231. 		String result="";
  232. 		String result1="";
  233. 			for(int i=0;i<NumText.getText().trim().length();i++)
  234. 			{
  235. 				char ch=NumText.getText().trim().charAt(i);
  236. 				if((ch<'0')||(ch>'9'))
  237. 				{
  238. 					result="编号中包含非数字字符";
  239. 					break;
  240. 				}
  241. 			}
  242. 			for(int i=0;i<PriceText.getText().trim().length();i++)
  243. 			{
  244. 				char ch=PriceText.getText().trim().charAt(i);
  245. 				if((ch<'0')||(ch>'9'))
  246. 				{
  247. 					result1="单价中包含非数字字符";
  248. 					break;
  249. 				}
  250. 			}
  251. 		if(result=="编号中包含非数字字符" && result1=="")
  252. 		{
  253. 			return result;
  254. 		}else if(result1=="单价中包含非数字字符" && result=="")
  255. 		{
  256. 			return result1;
  257. 		}else if(result=="编号中包含非数字字符" && result1=="单价中包含非数字字符")
  258. 		{
  259. 			return "编号和单价中均包含非数字字符";
  260. 		}else
  261. 		{
  262. 			return "";
  263. 		}
  264. 		
  265. 	}
  266.  
  267. }
  • 增删查改方法实现（FlowerDAO.java）：
  1. import java.io.*;
  2. import java.util.ArrayList;
  3.  
  4. public class FlowerDAO {
  5. 	//查找所有的花卉信息
  6. 	public ArrayList<String> findAllFlowers()
  7. 	{
  8. 		ArrayList<String> result=new ArrayList<String>();
  9. 		try {
  10. 			FileReader fr=new FileReader("Flower.txt");
  11. 			//产生了一个文件字符输入流对象
  12. 			BufferedReader br=new BufferedReader(fr);
  13. 			//以上一个对象作为参数来创建一个缓冲的字符输入流对象
  14. 			String str=br.readLine();//读取一行数据
  15. 			while(str!=null)
  16. 			{
  17. 				result.add(str);
  18. 				str=br.readLine();
  19. 			}
  20. 			br.close();
  21. 			fr.close();
  22. 		}
  23. 		catch (FileNotFoundException e) {
  24. 			// TODO Auto-generated catch block
  25. 			System.out.println("文件未找到");
  26. 		}
  27. 		catch (IOException e) {
  28. 			// TODO Auto-generated catch block
  29. 			System.out.println("文件读错误");
  30. 		}
  31. 		return result;
  32. 	}
  33. 	
  34. 	//通过编号来查找花朵的基本信息
  35. 	public static String findFlowerBySno(String sno)
  36. 	{
  37. 		String result="不存在这个花朵";
  38. 		try {
  39. 			FileReader fr=new FileReader("Flower.txt");
  40. 			//产生了一个文件字符输入流对象
  41. 			BufferedReader br=new BufferedReader(fr);
  42. 			//以上一个对象作为参数来创建一个缓冲的字符输入流对象
  43. 			String str=br.readLine();//读取一行数据
  44. 			boolean flag=true;
  45. 			while(flag)
  46. 			{
  47. 				if(str.startsWith(sno.trim()))
  48. 				{
  49. 					result=str;
  50. 					flag=false;
  51. 				}
  52. 				str=br.readLine();//继续读取下一行
  53. 				if(str==null)
  54. 				{
  55. 					flag=false;
  56. 				}
  57. 			}
  58. 			br.close();
  59. 			fr.close();
  60. 		}
  61. 		catch (FileNotFoundException e) {
  62. 			// TODO Auto-generated catch block
  63. 			System.out.println("文件未找到");
  64. 		}
  65. 		catch (IOException e) {
  66. 			// TODO Auto-generated catch block
  67. 			System.out.println("文件读错误");
  68. 		}
  69. 		return result;
  70. 	}
  71. 	
  72. 	
  73. 	//通过名称来查找花朵的基本信息
  74. 	public static String findFlowerBySname(String sname)
  75. 	{
  76. 		String result="不存在这个花朵";
  77. 		try {
  78. 			FileReader fr=new FileReader("Flower.txt");
  79. 			//产生了一个文件字符输入流对象
  80. 			BufferedReader br=new BufferedReader(fr);
  81. 			//以上一个对象作为参数来创建一个缓冲的字符输入流对象
  82. 			String str=br.readLine();//读取一行数据
  83. 			boolean flag=true;
  84. 			while(flag)
  85. 			{
  86. 				if(str.substring(4).startsWith(sname.trim()))
  87. 				{
  88. 					result=str;
  89. 					flag=false;
  90. 				}
  91. 				str=br.readLine();//继续读取下一行
  92. 				if(str==null)
  93. 				{
  94. 					flag=false;
  95. 				}
  96. 			}
  97. 			br.close();
  98. 			fr.close();
  99. 		}
  100. 		catch (FileNotFoundException e) {
  101. 			// TODO Auto-generated catch block
  102. 			System.out.println("文件未找到");
  103. 		}
  104. 		catch (IOException e) {
  105. 			// TODO Auto-generated catch block
  106. 			System.out.println("文件读错误");
  107. 		}
  108. 		return result;
  109. 	}
  110. 	
  111. 	//通过名称来查找花朵的基本信息
  112. 	public String findFlowerByname(boolean bool,String name)
  113. 	{
  114. 		String result="不存在这个花朵";
  115. 		try {
  116. 			FileReader fr=new FileReader("Flower.txt");
  117. 			//产生了一个文件字符输入流对象
  118. 			BufferedReader br=new BufferedReader(fr);
  119. 			//以上一个对象作为参数来创建一个缓冲的字符输入流对象
  120. 			String str=br.readLine();//读取一行数据
  121. 			boolean flag=true;
  122. 			while(flag)
  123. 			{
  124. 				String temp=str;
  125. 				if(!bool)
  126. 				{
  127. 					temp=str.substring(4);
  128. 				}
  129. 				if(temp.startsWith(name.trim()))
  130. 				{
  131. 					result=str;
  132. 					flag=false;
  133. 				}
  134. 				str=br.readLine();//继续读取下一行
  135. 				if(str==null)
  136. 				{
  137. 					flag=false;
  138. 				}
  139. 			}
  140. 			br.close();
  141. 			fr.close();
  142. 		}
  143. 		catch (FileNotFoundException e) {
  144. 			// TODO Auto-generated catch block
  145. 			System.out.println("文件未找到");
  146. 		}
  147. 		catch (IOException e) {
  148. 			// TODO Auto-generated catch block
  149. 			System.out.println("文件读错误");
  150. 		}
  151. 		return result;
  152. 	}
  153. 	
  154. 	//增加一条花朵记录
  155. 	public boolean AddFlower(String Floinfo)
  156. 	{
  157. 		String[] strs=Floinfo.split(",");
  158. 		if(!numIsExist(strs[0]) && !nameIsExist(strs[1]))
  159. 		{
  160. 		try {
  161. 			FileWriter fw=new FileWriter("Flower.txt",true);
  162. 			//创建一个文件的字符输出流,第二个参数表示是在文件尾部进行追加
  163. 			BufferedWriter bw=new BufferedWriter(fw);
  164. 			//以上面创建的对象为参数创建一个缓冲字符输出流
  165. 			bw.newLine();
  166. 			//创建新的一行
  167. 			bw.write(Floinfo);
  168. 			bw.close();
  169. 			fw.close();	
  170. 		}
  171. 		catch (FileNotFoundException e) {
  172. 			// TODO Auto-generated catch block
  173. 			System.out.println("文件未找到");
  174. 		}
  175. 		catch (IOException e) {
  176. 			// TODO Auto-generated catch block
  177. 			System.out.println("文件写错误");
  178. 		}
  179. 		return true;
  180. 		}
  181. 		else
  182. 		{
  183. 			return false;
  184. 		}
  185. 	}
  186. 	
  187. 	//判断是否已经存在重复的编号
  188. 	private boolean numIsExist(String num)
  189. 	{
  190. 		boolean result=false;
  191. 		try {
  192. 			FileReader fr=new FileReader("Flower.txt");
  193. 			//产生了一个文件字符输入流对象
  194. 			BufferedReader br=new BufferedReader(fr);
  195. 			//以上一个对象作为参数来创建一个缓冲的字符输入流对象
  196. 			String str=br.readLine();//读取一行数据
  197. 			while(str!=null)
  198. 			{
  199. 				if(str.startsWith(num))
  200. 				{
  201. 					result=true;
  202. 					break;
  203. 				}
  204. 				str=br.readLine();
  205. 			}
  206. 			
  207. 			br.close();
  208. 			fr.close();
  209. 		}
  210. 		catch (FileNotFoundException e) {
  211. 			// TODO Auto-generated catch block
  212. 			System.out.println("文件未找到");
  213. 		}
  214. 		catch (IOException e) {
  215. 			// TODO Auto-generated catch block
  216. 			System.out.println("文件读错误");
  217. 		}
  218. 		return result;
  219. 	}
  220. 	
  221. 	//判断名称是否重复
  222. 	private boolean nameIsExist(String name)
  223. 	{
  224. 		boolean result=false;
  225. 		try {
  226. 			FileReader fr=new FileReader("Flower.txt");
  227. 			//产生了一个文件字符输入流对象
  228. 			BufferedReader br=new BufferedReader(fr);
  229. 			//以上一个对象作为参数来创建一个缓冲的字符输入流对象
  230. 			String str=br.readLine();//读取一行数据
  231. 			while(str!=null)
  232. 			{
  233. 				if(str.startsWith(name))
  234. 				{
  235. 					result=true;
  236. 					break;
  237. 				}
  238. 				str=br.readLine();
  239. 			}
  240. 			
  241. 			br.close();
  242. 			fr.close();
  243. 		}
  244. 		catch (FileNotFoundException e) {
  245. 			// TODO Auto-generated catch block
  246. 			System.out.println("文件未找到");
  247. 		}
  248. 		catch (IOException e) {
  249. 			// TODO Auto-generated catch block
  250. 			System.out.println("文件读错误");
  251. 		}
  252. 		return result;
  253. 	}
  254. 	
  255. 	//增加多条花朵记录
  256. 	public int AddFlowers(String[] Flos)
  257. 	{
  258. 		int result=0;
  259. 		//定义一个变量来保存添加成功的花卉记录个数
  260. 		if(Flos!=null)
  261. 		{
  262. 			if(Flos.length>0)
  263. 			{
  264. 				for(int i=0;i<Flos.length;i++)
  265. 				{
  266. 					if(AddFlower(Flos[i]))
  267. 					{
  268. 						result++;
  269. 					}
  270. 				}
  271. 			}
  272. 		}
  273. 		return result;
  274. 	}
  275. 	
  276. 	//删除一条花朵记录的方法
  277. 	public static boolean DeleteFlower(String num)
  278. 	{
  279. 		boolean result=false;
  280. 		//保存删除是否成功的变量
  281. 		try
  282. 		{
  283. 			FileReader fr=new FileReader("Flower.txt");
  284. 			BufferedReader br=new BufferedReader(fr);
  285. 			String str=br.readLine();//读取一行数据
  286. 			ArrayList<String> list=new ArrayList<String>();
  287. 			//保存读入的花朵信息
  288. 			boolean flag=true;
  289. 			while(flag)
  290. 			{
  291. 				list.add(str);
  292. 				str=br.readLine();//再次读取一行数据
  293. 				if(str==null)
  294. 				{
  295. 					flag=false;
  296. 				}
  297. 			}
  298. 			br.close();
  299. 			fr.close();
  300. 			for(int i=0;i<list.size();i++)
  301. 			{
  302. 				if(list.get(i).startsWith(num))
  303. 				{
  304. 					list.remove(i);
  305. 					result=true;
  306. 					break;
  307. 				}
  308. 			}//将对应的花朵记录移除
  309. 			FileWriter fw=new FileWriter("Flower.txt");
  310. 			//创建一个文件的字符输出流,不需要追加
  311. 			BufferedWriter bw=new BufferedWriter(fw);
  312. 			//以上面创建的对象为参数创建一个缓冲字符输出流
  313. 			for(int i=0;i<list.size();i++)
  314. 			{
  315. 				bw.write(list.get(i));
  316. 				//分别写入花卉记录
  317. 			    bw.newLine();
  318. 			}
  319. 			bw.flush();
  320. 			bw.close();
  321. 			fw.close();
  322. 		}
  323. 		catch(IOException ex)
  324. 		{
  325. 			
  326. 		}
  327. 		return result;
  328. 	}
  329. 	//删除多条花朵记录的方法
  330. 	public int DeleteFlowers(String[] nums)
  331. 	{
  332. 		int result=0;
  333. 		//用来保存成功删除的花朵记录个数
  334. 		if(nums!=null)
  335. 		{
  336. 			if(nums.length>0)
  337. 			{
  338. 				for(int i=0;i<nums.length;i++)
  339. 				{
  340. 					if(DeleteFlower(nums[i]))
  341. 					{
  342. 						result++;
  343. 					}
  344. 				}
  345. 			}
  346. 		}
  347. 		return result;
  348. 	}
  349. 	
  350. 	//修改一条记录的方法
  351. 	public boolean ModifyFlower(String Floinfo)
  352. 	{
  353. 		String[] strs=Floinfo.split(",");
  354. 		if(numIsExist(strs[0]))
  355. 		{
  356. 			try
  357. 			{
  358. 				FileReader fr=new FileReader("Flower.txt");
  359. 				//产生了一个文件字符输入流对象
  360. 				BufferedReader br=new BufferedReader(fr);
  361. 				//以上一个对象作为参数来创建一个缓冲的字符输入流对象
  362. 				String str=br.readLine();//读取一行数据
  363. 				ArrayList<String> list=new ArrayList<String>();
  364. 				//保存读入的花朵信息
  365. 				boolean flag=true;
  366. 				while(flag)
  367. 				{
  368. 					list.add(str);
  369. 					str=br.readLine();//再次读取一行数据
  370. 					if(str==null)
  371. 					{
  372. 						flag=false;
  373. 					}
  374. 				}
  375. 				br.close();
  376. 				fr.close();
  377. 				
  378. 				for(int i=0;i<list.size();i++)
  379. 				{
  380. 					if(list.get(i).startsWith(strs[0]))
  381. 					{
  382. 						list.remove(i);
  383. 						//先从动态数组对象中移除
  384. 						list.add(Floinfo);
  385. 						//然后再添加修改后的花朵记录
  386. 						break;
  387. 					}
  388. 				}//将对应的花朵记录移除
  389. 				FileWriter fw=new FileWriter("Flower.txt");
  390. 				//创建一个文件的字符输出流,不需要追加
  391. 				BufferedWriter bw=new BufferedWriter(fw);
  392. 				//以上面创建的对象为参数创建一个缓冲字符输出流
  393. 				for(int i=0;i<list.size();i++)
  394. 				{
  395. 					bw.write(list.get(i));
  396. 					//分别写入花朵记录
  397. 				    bw.newLine();
  398. 				}
  399. 				bw.flush();
  400. 				bw.close();
  401. 				fw.close();
  402. 			}
  403. 			catch(IOException ex)
  404. 			{
  405. 				
  406. 			}
  407. 			return true;
  408. 		}
  409. 		else
  410. 		{
  411. 			return false;
  412. 		}
  413. 	}
  414. 	//修改多条花朵记录
  415. 	public int ModifyFlowers(String[] Flos)
  416. 	{
  417. 		int result=0;
  418. 		if(Flos!=null)
  419. 		{
  420. 			if(Flos.length>0)
  421. 			{
  422. 				for(int i=0;i<Flos.length;i++)
  423. 				{
  424. 					if(ModifyFlower(Flos[i]))
  425. 					{
  426. 						result++;
  427. 					}
  428. 				}
  429. 			}
  430. 		}
  431. 		return result;
  432. 	}
  433. 	
  434. }

这个代码量有点大，但难度倒不大。能看到这里都不容易，辛苦啦~

>>>如有问题，敬请指点，学艺不精，十分希望从各位大佬那里汲取经验。<<<

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/866375
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号