java文件剪切

⑴ java中文件移动问题，file.move

没看懂你的代码，java API是支持文件剪切的，如下
//移动e:/abc.txt 到e:/abc/abc.txt
java.io.File file = new java.io.File("e:/abc.txt");
file.renameTo(new java.io.File("e:/abc/abc.txt"));

⑵ java 问题

下面是我以前写的，发给你了，可以直接拿来用！
觉得可以，给我加点分吧，我太需要了！
剪贴其实就是复制，再删除！！呵呵

/**
* @author CaoShun
* @see 根据传递过来路径名，建立文件夹
* */
public static boolean createFolderbyName(String path)
{
boolean createOK=true;
File dirFile=null;
dirFile = new File(path);
if( dirFile.exists() == true ){
createOK=false;
}
else{
boolean bFile = dirFile.mkdir();
if( bFile == true ){
createOK=false;
}
else{
createOK=true;
}
}
return createOK;
}

/**
* @author CaoShun
* @see 复制文件夹包括文件夹里内容
* */
public static void Folder(String oldPath, String newPath) {//复制文件夹
try {
(new File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹
File a=new File(oldPath);
String[] file=a.list();
File temp=null;
for (int i = 0; i < file.length; i++) {
if(oldPath.endsWith(File.separator)){
temp=new File(oldPath+file[i]);
}
else{
temp=new File(oldPath+File.separator+file[i]);
}
if(temp.isFile()){
FileInputStream input = new FileInputStream(temp);
FileOutputStream output = new FileOutputStream(newPath + "/" +(temp.getName()).toString());
byte[] b = new byte[1024 * 5];
int len;
while ((len = input.read(b))!= -1) {
output.write(b, 0, len);
}
output.flush();
output.close();
input.close();
}
if(temp.isDirectory()){//如果是子文件夹
Folder(oldPath+"/"+file[i],newPath+"/"+file[i]);
}
}
}
catch (Exception e) {
System.out.println("复制整个文件夹内容操作出错");
e.printStackTrace();
}
}

/**
* @author CaoShun
* @see 删除文件夹及里面子文件
* */
public static void delAllFile(String path) {//删除所有文件
File file = new File(path);
if (!file.exists()) {
return;
}
if (!file.isDirectory()) {
return;
}
String[] tempList = file.list();
File temp = null;
for (int i = 0; i < tempList.length; i++) {
if (path.endsWith(File.separator)) {
temp = new File(path + tempList[i]);
}
else {
temp = new File(path + File.separator + tempList[i]);
}
if (temp.isFile()) {
temp.delete();
}
if (temp.isDirectory()) {
delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件
delFolder(path+"/"+ tempList[i]);//再删除空文件夹
}
}
}
public static void delFolder(String folderPath) {//删除目录
try {
delAllFile(folderPath); //删除完里面所有内容
String filePath = folderPath;
filePath = filePath.toString();
java.io.File myFilePath = new java.io.File(filePath);
myFilePath.delete(); //删除空文件夹
}
catch (Exception e) {
//System.out.println("删除文件夹操作出错");
e.printStackTrace();
}
}

⑶ 在配置Java环境变量时，原来系统有Path，应该怎么设置

JAVA程序能够顺利编译需要两个环境变量，一个是PATH(path)，一个是CLASSPATH(classpath)。那么这两个环境变量代表什么呢?或者说究竟在JAVA程序编译中有什么作用呢?这就要涉及到WINDOWS的基本知识了。

在WINDOWS环境中，每一条能用的指令都保存在硬盘的“某个角落”，比如说指令NOTEPAD(WINDOWS的记事本指令，在C: WINNT目录下)，那么在DOS命令提示符下直接输入NOTEPAD就可以打开记事本了。但是一旦我们把C:WINNT目录下的

NOTEPAD.EXE 这个可执行文件移开(比如说我们现在把它“剪切”到D盘根目录下)我们再在DOS提示符下直接输入NOTEPAD时就无法再打开记事本了，但是我们在DOS下改变路径输入 D:NOTEPAD(或者先输入cd D: 在输入NOTEPAD也行)就可以打开记事本了。

这就是说在我们直接输入NOTEPAD的时候，其实其默认路径就是C:WINN。假设我们要运行一个JAVA程序(hello.java)就要先把它的class文件移动到JAVA里的bin目录下然后打开DOS，把路径改到JAVA的BIN目录下执行java hello.class，一次无所谓但是每次都要这样去做未免太麻烦。

还好WINDOWS提供了一个PATH环境变量，他的作用就是现在这个变量的值路径中去找，如果找到了要运行的EXE就运行，否则失败。如果我们把JAVA里的bin目录这个路径赋给path那么下次我在运行java这个命令的时候，即便是直接输入DOS也能够在path变量中找到JAVA的bin目录下的java指令了。

⑷ java将一个文件复制到剪切板

首先要明白 “剪切板” 里面能放什么内容。 剪切板只能放 “文本内容”或者“文件路径”， 如果你选中文字，然后复制，那么放在剪切板就是文字内容；如果你选择一个文件，复制，那放在剪切板里面是 文件的路径。

你说的 文件复制到剪切板 是不合理的。

Java 通过 java.awt.datatransfer.Clipboard 访问剪切板。

⑸ Java中你常用到哪些快捷键

Eclipse的编辑功能非常强大，掌握了Eclipse快捷键功能，能够大大提高开发效率。Eclipse中有如下一些和编辑相关的快捷键。
1. 【ALT+/】
此快捷键为用户编辑的好帮手，能为用户提供内容的辅助，不要为记不全方法和属性名称犯愁，当记不全类、方法和属性的名字时，多体验一下【ALT+/】快捷键带来的好处吧。
2. 【Ctrl+O】
显示类中方法和属性的大纲，能快速定位类的方法和属性，在查找Bug时非常有用。
3. 【Ctrl+/】
快速添加注释，能为光标所在行或所选定行快速添加注释或取消注释，在调试的时候可能总会需要注释一些东西或取消注释，现在好了，不需要每行进行重复的注释。
4. 【Ctrl+D】
删除当前行，这也是笔者的最爱之一，不用为删除一行而按那么多次的删除键。
5. 【Ctrl+M】
窗口最大化和还原，用户在窗口中进行操作时，总会觉得当前窗口小（尤其在编写代码时），现在好了，试试【Ctrl+M】快捷键。
查看和定位快捷键
在程序中，迅速定位代码的位置，快速找到Bug的所在，是非常不容易的事，Eclipse提供了强大的查找功能，可以利用如下的快捷键帮助完成查找定位的工作。
1. 【Ctrl+K】、【Ctrl+Shift+K】
快速向下和向上查找选定的内容，从此不再需要用鼠标单击查找对话框了。
2. 【Ctrl+Shift+T】
查找工作空间（Workspace）构建路径中的可找到Java类文件，不要为找不到类而痛苦，而且可以使用“*”、“？”等通配符。
3. 【Ctrl+Shift+R】
和【Ctrl+Shift+T】对应，查找工作空间（Workspace）中的所有文件（包括Java文件），也可以使用通配符。
4. 【Ctrl+Shift+G】
查找类、方法和属性的引用。这是一个非常实用的快捷键，例如要修改引用某个方法的代码，可以通过【Ctrl+Shift+G】快捷键迅速定位所有引用此方法的位置。
5. 【Ctrl+Shift+O】
快速生成import，当从网上拷贝一段程序后，不知道如何import进所调用的类，试试【Ctrl+Shift+O】快捷键，一定会有惊喜。
6. 【Ctrl+Shift+F】
格式化代码，书写格式规范的代码是每一个程序员的必修之课，当看见某段代码极不顺眼时，选定后按【Ctrl+Shift+F】快捷键可以格式化这段代码，如果不选定代码则默认格式化当前文件（Java文件）。
7. 【ALT+Shift+W】
查找当前文件所在项目中的路径，可以快速定位浏览器视图的位置，如果想查找某个文件所在的包时，此快捷键非常有用（特别在比较大的项目中）。
8. 【Ctrl+L】
定位到当前编辑器的某一行，对非Java文件也有效。
9. 【Alt+←】、【Alt+→】
后退历史记录和前进历史记录，在跟踪代码时非常有用，用户可能查找了几个有关联的地方，但可能记不清楚了，可以通过这两个快捷键定位查找的顺序。
10. 【F3】
快速定位光标位置的某个类、方法和属性。
11. 【F4】
显示类的继承关系，并打开类继承视图。
调试快捷键
Eclipse中有如下一些和运行调试相关的快捷键。
1. 【Ctrl+Shift+B】：在当前行设置断点或取消设置的断点。
2. 【F11】：调试最后一次执行的程序。
3. 【Ctrl+F11】：运行最后一次执行的程序。
4. 【F5】：跟踪到方法中，当程序执行到某方法时，可以按【F5】键跟踪到方法中。
5. 【F6】：单步执行程序。
6. 【F7】：执行完方法，返回到调用此方法的后一条语句。
7. 【F8】：继续执行，到下一个断点或程序结束。
常用编辑器快捷键
通常文本编辑器都提供了一些和编辑相关的快捷键，在Eclipse中也可以通过这些快捷键进行文本编辑。
1. 【Ctrl+C】：复制。
2. 【Ctrl+X】：剪切。
3. 【Ctrl+V】：粘贴。
4. 【Ctrl+S】：保存文件。
5. 【Ctrl+Z】：撤销。
6. 【Ctrl+Y】：重复。
7. 【Ctrl+F】：查找。
8. 【Ctrl+H】:选中你需要查找字符的文件。
其他快捷键
Eclipse中还有很多快捷键，无法一一列举，用户可以通过帮助文档找到它们的使用方式，另外还有几个常用的快捷键如下。
1. 【Ctrl+F6】：切换到下一个编辑器。
2. 【Ctrl+Shift+F6】：切换到上一个编辑器。
3. 【Ctrl+F7】：切换到下一个视图。
4. 【Ctrl+Shift+F7】：切换到上一个视图。
5. 【Ctrl+F8】：切换到下一个透视图。
6. 【Ctrl+Shift+F8】：切换到上一个透视图。

⑹ java 切割wav音频

1.首先应该得到音乐文件的时长---这个可以网络,我也不会,但应该可以实现

2.然后得到文件大小,除以文件总分钟数
3.根据得到的大小切割文件(用二进制的方式读取文件)

⑺ java的系统剪切板如何获取一个文本的内容

需要导入包:import java.awt.*;
import java.awt.datatransfer.*; 将内容写入剪贴板:String temp1=text1.getSelectedText();
StringSelection ss = new StringSelection(temp1);
Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss, null); 读取剪贴板:
Transferable t = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);String readText = (String)t.getTransferData(DataFlavor.stringFlavor);

⑻ 用java编写记事本程序,可以实现新建、打开、保存、退出、复制、粘贴、剪切、全选。

import javax.swing.*;
import javax.swing.filechooser.FileFilter;

import java.awt.event.*;
import java.awt.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Hashtable;

public class MyText extends JFrame implements ActionListener{
private JLabel lb1;
private JMenuBar mb;
private JMenu 文件, 编辑, 格式, 帮助;
private JMenuItem 新建, 打开, 保存, 退出, 复制, 粘贴, 剪切, 全选, 字体, 关于;
private JTextArea editorArea;
private boolean isDirty = false;
private String strFileName = "未命名";
private static final String EDITOR_NAME = "MyText";

public MyText() {
super();
mb = new JMenuBar();
文件 = new JMenu("文件");
编辑 = new JMenu("编辑");
格式 = new JMenu("格式");
帮助 = new JMenu("帮助");
新建 = new JMenuItem("新建");
新建.addActionListener(this);
打开 = new JMenuItem("打开");
打开.addActionListener(this);
保存 = new JMenuItem("保存");
保存.addActionListener(this);
退出 = new JMenuItem("退出");
退出.addActionListener(this);
复制 = new JMenuItem("复制");
复制.addActionListener(this);
粘贴 = new JMenuItem("粘贴");
粘贴.addActionListener(this);
剪切 = new JMenuItem("剪切");
剪切.addActionListener(this);
全选 = new JMenuItem("全选");
全选.addActionListener(this);
字体 = new JMenuItem("字体");
字体.addActionListener(this);
关于 = new JMenuItem("关于");
关于.addActionListener(this);
mb.add(文件);
mb.add(编辑);
mb.add(格式);
mb.add(帮助);
文件.add(新建);
文件.add(打开);
文件.add(保存);
文件.add(退出);
编辑.add(复制);
编辑.add(粘贴);
编辑.add(剪切);
编辑.add(全选);
格式.add(字体);
帮助.add(关于);
setJMenuBar(mb);

Container container = getContentPane();
editorArea = new JTextArea();
editorArea.setLineWrap(true);
editorArea.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if(!isDirty()){
setDirty(true);
}
}
});
JScrollPane scrollPane = new JScrollPane(editorArea);
container.add(scrollPane);

addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
dispose();
}
});
setTitle(formatEditorTitle());
setSize(600, 400);
setVisible(true);
}

private boolean isDirty() {
return isDirty;
}

private void setDirty(boolean isDirty) {
this.isDirty = isDirty;
setTitle(formatEditorTitle());
}

public static void main(String args[]) {
@SuppressWarnings("unused")
MyText app = new MyText();
}

public void actionPerformed(ActionEvent e) {
JMenuItem item = (JMenuItem)e.getSource();
if(item.equals(新建)){
if(isDirty()){
int ret = JOptionPane.showConfirmDialog(getContentPane(), "文件内容已经变动，是否保存？", "MyText", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE);
if(ret == JOptionPane.OK_OPTION){
saveFile();
}else if(ret == JOptionPane.CANCEL_OPTION || ret == JOptionPane.CLOSED_OPTION){
return;
}
}
clearEditorArea();
setDirty(false);
}else if(item.equals(打开)){
if(isDirty()){
int ret = JOptionPane.showConfirmDialog(getContentPane(), "文件内容已经变动，是否保存？", "MyText", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE);
if(ret == JOptionPane.OK_OPTION){
saveFile();
}else if(ret == JOptionPane.CANCEL_OPTION || ret == JOptionPane.CLOSED_OPTION){
return;
}
}
openFile();
}else if(item.equals(保存)){
saveFile();
}else if(item.equals(退出)){
dispose();
}else if(item.equals(复制)){
editorArea.();
}else if(item.equals(剪切)){
editorArea.cut();
}else if(item.equals(粘贴)){
editorArea.paste();
}else if(item.equals(全选)){
editorArea.selectAll();
}else if(item.equals(字体)){
FontDialog font = new FontDialog(this, editorArea.getFont());
editorArea.setFont(font.getSelectedFont());
}else if(item.equals(关于)){
AboutDialog about = new AboutDialog(this);
about.setVisible(true);
}
}

private String getFileName() {
return strFileName;
}

private void setFileName(String strFileName) {
this.strFileName = strFileName;
}

public String formatEditorTitle(){
StringBuffer strFileNm = new StringBuffer(getFileName());
strFileNm.append(isDirty()?"*":"");
strFileNm.append(" - ");
strFileNm.append(EDITOR_NAME);
return strFileNm.toString();
}

private void clearEditorArea(){
editorArea.selectAll();
editorArea.replaceSelection("");
}

private void openFile(){
JFileChooser openDialog = new JFileChooser();
openDialog.setFileFilter(new TxtFileFilter());
if(openDialog.showOpenDialog(getContentPane()) == JFileChooser.APPROVE_OPTION){
File file = openDialog.getSelectedFile();
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader(file));
String buff = br.readLine();
clearEditorArea();
while(buff != null){
editorArea.append(buff);
editorArea.append("\n");
buff = br.readLine();
}
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
} finally{
try{
if(br != null)
br.close();
} catch (IOException ioe){
ioe.printStackTrace();
}
}
}
}

private void saveFile(){
JFileChooser saveDialog = new JFileChooser();
saveDialog.setFileFilter(new TxtFileFilter());
if(saveDialog.showSaveDialog(getContentPane()) == JFileChooser.APPROVE_OPTION){
File file = saveDialog.getSelectedFile();
BufferedWriter bw = null;
try {
bw = new BufferedWriter(new FileWriter(file));
String buff = editorArea.getText();
bw.write(buff);
} catch (IOException ioe) {
ioe.printStackTrace();
} finally{
try{
if(bw != null)
bw.close();
} catch (IOException ioe){
ioe.printStackTrace();
}
}
}
}

class TxtFileFilter extends FileFilter{

@Override
public boolean accept(File f) {
return f.isDirectory() || f.getName().toLowerCase().endsWith(".txt");
}

@Override
public String getDescription() {
return "*.txt(文本文件)";
}

}

class FontDialog extends JDialog{
private JComboBox cb_FontSize;
private JComboBox cb_FontStyle;
private JComboBox cb_FontNm;
private Font font;
Hashtable<Integer, String> style = new Hashtable<Integer, String>();

public FontDialog(){
this(null, null);
}

public FontDialog(Frame owner, Font font){
super(owner);
this.font = font == null?getFont():font;
setTitle("字体选择框");
setModal(true);
setResizable(false);
setSize(326, 164);
getContentPane().setLayout(null);

final JLabel lb_FontNm = new JLabel();
lb_FontNm.setText("字体名称");
lb_FontNm.setBounds(10, 10, 66, 16);
getContentPane().add(lb_FontNm);

cb_FontNm = new JComboBox();
cb_FontNm.setBounds(10, 28, 133, 25);
getContentPane().add(cb_FontNm);

cb_FontStyle = new JComboBox();
cb_FontStyle.setBounds(169, 28, 66, 25);
getContentPane().add(cb_FontStyle);

cb_FontSize = new JComboBox();
cb_FontSize.setBounds(258, 28, 53, 25);
getContentPane().add(cb_FontSize);

final JButton btn_OK = new JButton();
btn_OK.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {
int styleCode = 0;
for(Enumeration<Integer> i = style.keys();i.hasMoreElements();){
styleCode = i.nextElement();
if(style.get(styleCode).equals(cb_FontStyle.getSelectedItem()))
break;
}
Font font = new Font(cb_FontNm.getSelectedItem().toString(), styleCode, ((Integer)cb_FontSize.getSelectedItem()).intValue());
setSelectedFont(font);
dispose();
}
});
btn_OK.setText("确定");
btn_OK.setBounds(58, 83, 76, 26);
getContentPane().add(btn_OK);

final JButton btn_Cancel = new JButton();
btn_Cancel.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {
dispose();
}
});
btn_Cancel.setText("取消");
btn_Cancel.setBounds(169, 83, 76, 26);
getContentPane().add(btn_Cancel);

final JLabel lb_FontStyle = new JLabel();
lb_FontStyle.setText("字体样式");
lb_FontStyle.setBounds(169, 10, 66, 16);
getContentPane().add(lb_FontStyle);

final JLabel lb_FontSize = new JLabel();
lb_FontSize.setText("字体大小");
lb_FontSize.setBounds(258, 10, 66, 16);
getContentPane().add(lb_FontSize);

init();
setVisible(true);
}

private void init(){
GraphicsEnvironment gg=GraphicsEnvironment.getLocalGraphicsEnvironment();
String ss[]=gg.getAvailableFontFamilyNames();
for(String s : ss)
cb_FontNm.addItem(s);
if(font != null)
cb_FontNm.setSelectedItem(font.getFamily());

style.put(Font.PLAIN, "标准");
style.put(Font.BOLD, "粗体");
style.put(Font.ITALIC, "斜体");
style.put(Font.BOLD+Font.ITALIC, "粗体&斜体");

cb_FontStyle.addItem(style.get(Font.PLAIN));
cb_FontStyle.addItem(style.get(Font.BOLD));
cb_FontStyle.addItem(style.get(Font.ITALIC));
cb_FontStyle.addItem(style.get(Font.BOLD+Font.ITALIC));

if(font != null)
cb_FontStyle.setSelectedItem(style.get(font.getStyle()));

for(int i=8;i<23;i++)
cb_FontSize.addItem(i);
if(font != null)
cb_FontSize.setSelectedItem(font.getSize());

}

public Font getSelectedFont() {
return font;
}

public void setSelectedFont(Font font) {
this.font = font;
}
}

class AboutDialog extends JDialog{
public AboutDialog(JFrame owner){
super(owner);
setTitle("关于");
setSize(new Dimension(322, 163));
getContentPane().setLayout(null);

final JLabel version = new JLabel();
version.setText("MyText 1.0");
version.setBounds(74, 37, 66, 16);
getContentPane().add(version);

final JLabel right = new JLabel();
right.setText("Copyright (C) 2010");
right.setBounds(74, 59, 188, 16);
getContentPane().add(right);

final JSeparator separator = new JSeparator();
separator.setBounds(70, 90, 210, 2);
getContentPane().add(separator);

final JButton okButton = new JButton();
okButton.setBounds(235, 95, 50, 26);
getContentPane().add(okButton);
okButton.setText("Ok");
okButton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {
dispose();
}
});
}
}
}

⑼ Java 里用什么代码可以把一个 String 的内容复制到 Windows 剪切板

java 中的剪切板
通过操作系统的剪切板，可以实现在不同的程序中拷贝和粘贴数据。一些用Java写的程序例如很多开发环境也可以访问到剪切板，本文就是研究如何在Java程序中读写系统剪切板的数据。

Java中使用java.awt.datatransfer.Clipboard类来描述剪切板，并把剪切板分为两种类型：本地和系统，本地剪切板使用 Clipborad cp = new Clipboard("clip1"); 来构造；系统剪切板通过

Clipboard sysc = Toolkit.getDefaultToolkit().getSystemClipboard();

获取，下面我们给出几个常用的方法用于读写剪切板中的文本数据以及图像数据

1. 从指定的剪切板中获取文本内容

protected static String getClipboardText(Clipboard clip) throws Exception{
// 获取剪切板中的内容
Transferable clipT = clip.getContents(null);
if (clipT != null) {
// 检查内容是否是文本类型
if (clipT.isDataFlavorSupported(DataFlavor.stringFlavor))
return (String)clipT.getTransferData(DataFlavor.stringFlavor);
}
return null;
}

2. 往剪切板写文本数据

protected static void setClipboardText(Clipboard clip, String writeMe) {
Transferable tText = new StringSelection(writeMe);
clip.setContents(tText, null);
}

3. 从剪切板读取图像

public static Image getImageFromClipboard() throws Exception{
Clipboard sysc = Toolkit.getDefaultToolkit().getSystemClipboard();
Transferable cc = sysc.getContents(null);
if (cc == null)
return null;
else if(cc.isDataFlavorSupported(DataFlavor.imageFlavor))
return (Image)cc.getTransferData(DataFlavor.imageFlavor);
return null;
}

4. 写图像到剪切板

protected static void setClipboardImage2(final Image image) {
Transferable trans = new Transferable(){
public DataFlavor[] getTransferDataFlavors() {
return new DataFlavor[] { DataFlavor.imageFlavor };
}
public boolean isDataFlavorSupported(DataFlavor flavor) {
return DataFlavor.imageFlavor.equals(flavor);
}
public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
if(isDataFlavorSupported(flavor))
return image;
throw new UnsupportedFlavorException(flavor);
}

};
Toolkit.getDefaultToolkit().getSystemClipboard().setContents(trans, null);
}

有了这四个方法，你下面可以自己写一些程序来进行测试，利用它来实现与其他程序结合测试对剪切板数据的操作。这里给出一个用于显示图像的类，只要把Image实例作为参数传入即可。

/*
* Created on 2004-12-23
* 查看图形的窗口
*/
package javayou.clipboard;

import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/**
* @author Winter Lau 用于显示图形的窗口
*/
public class ImageViewer extends Frame {

private Image image;

/**
* 显示一个图像
* @param viewMe
*/
public ImageViewer(Image viewMe) {
image = viewMe;
MediaTracker mediaTracker = new MediaTracker(this);
mediaTracker.addImage(image, 0);
try {
mediaTracker.waitForID(0);
} catch (InterruptedException ie) {
ie.printStackTrace();
System.exit(1);
}
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
//窗口适应图像大小
setSize(image.getWidth(null), image.getHeight(null));
//窗口标题
setTitle("Viewing Image from Clipboard");
setVisible(true);
}

public void paint(Graphics graphics) {
graphics.drawImage(image, 0, 0, null);
}

/**
* 用于读取图像文件并生成Image对象
*/
public static Image getImageFromFile(String fileName) {
Toolkit toolkit = Toolkit.getDefaultToolkit();
Image image = toolkit.getImage(fileName);
return image;
}

}