2012上半年总结

 

转眼间，2012年已经过去一半了，回想一下自己做了些什么呢？可保存的画图板—>弹球游戏 —> 连连看 —> 黄金矿工 —>哈弗曼压缩—>

小学期开始学通信方面的内容，做了简单的群聊

画图板的保存打开：原来画图板的基础上添加了一个FileUtil类

 

package 画图板可保存重绘;

 

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

 

public class FileUtil implements Config {

 

/**

* 将图片数据保存到指定的位置

* 

* @param path

*            : 要保存数据的位置

*/

public static void saveFile(String path) {

try {

// 创建文件输出流对象

FileOutputStream fos = new FileOutputStream(path);

// 将输出流包装成可写基本类型的数据流

DataOutputStream dos = new DataOutputStream(fos);

// 写图片的高度和宽度

dos.writeInt(DrawListener.data.length);

dos.writeInt(DrawListener.data[0].length);

 

// 遍历二维数组，写数据

for (int i = 0; i < DrawListener.data.length; i++) {

for (int j = 0; j < DrawListener.data[i].length; j++) {

int num = DrawListener.data[i][j];

// 写数据

dos.writeInt(num);

}

}

            //将输出流清空

dos.flush();

//将输出流关闭

fos.close();

 

} catch (Exception ef) {

ef.printStackTrace();

}

 

}

 

/**

* 读取文件中的数据

* 

* @param path

*            要读取的文件

* @return 将读取到的数据作为二位数组返回

*/

public static int[][] readFile(String path) {

 

// 创建文件输入流

try {

//创建文件输入流对象

FileInputStream fis = new FileInputStream(path);

//将文件输入流包装成可写基本类型的数据流

DataInputStream dis = new DataInputStream(fis);

// 读取高度和宽度

int height = dis.readInt();

int width = dis.readInt();

 

// 定义二维数组

int[][] readData = new int[height][width];

//循环读取每个像素点

for (int i = 0; i < height; i++) {

for (int j = 0; j < width; j++) {

// 将数据读入数组

readData[i][j] = dis.readInt();

}

}

//关闭输入流

fis.close();

//返回二维数组

return readData;

} catch (Exception ef) {

ef.printStackTrace();

}

return null;

}

 

}

 

在界面上保存打开的按钮，并添加监听器

在DrawListener中添加了将drawPanel在屏幕上占据的区域的像素点保存成数组

 

        // 调用画图形的方法

shape.draw(g);

// 每绘制一次就将整个drawPanel区域内的所有像素点保存起来

// 得到事件源对象

Object obj = e.getSource();

JPanel drawPanel = (JPanel) obj;

 

// 得到drawPanel的左上角的点

Point point = drawPanel.getLocationOnScreen();

// 得到drawPanel的大小

Dimension dim = drawPanel.getPreferredSize();

 

// 创建矩形区域对象,刚好截取drawPanel在屏幕上所占据的区域

Rectangle rect = new Rectangle(point, dim);

// 从屏幕上获取像素区域，得到一个缓存区的图像对象

BufferedImage img = robot.createScreenCapture(rect);

 

data = new int[dim.height][dim.width];

// 将缓存区的图像对象中的每一个像素的颜色保存起来

for (int i = 0; i < data.length; i++) {

for (int j = 0; j < data[i].length; j++) {

// 得到每个点的颜色（用数字表示的颜色）,存入二维数组

data[i][j] = img.getRGB(j, i);

}

}

 

 

连连看之囧事连连

这个游戏设计我认为界面比较可爱，代码部分没有新颖之处，剩余时间用了简单的线程来控制，代码量主要集中在对相同图片是否可以相互消掉的判断上，就是一些逻辑算法，自己的逻辑要清楚，否则会出现错误判断。

界面展示：

 

 

线程游戏—>黄金矿工

这是一个多线程游戏，仿照黄金矿工游戏进行模仿设计的

这个游戏实现经过了比较长的时间

用到了三个线程控制，每个线程只能操作自己的对象，不能对其他类的对象进行操作。

其中比较好的部分是运用rotate();方法对钩子进行摆动控制

以及一些boolean型变量的运用，使得各个阶段可以有效控制

 

 

钩子线程类

 

package 黄金矿工;

 

import javax.swing.ImageIcon;

import javax.swing.JOptionPane;

 

/**

 * 钩子的线程

 * 

 * @author Administrator

 * 

 */

public class HookThread extends Thread {

public static boolean isCatch = false;

public static boolean isWrite = false;

double xx, yy;// 金块或石头的坐标点

double x, y;// 钩子的坐标点

double xc, yc;// 钩子，金块石头每次移动的横纵坐标改变量

double arc = Math.PI / 4;// 钩子的角度.

double arcx = Math.PI / 16;

ImageIcon icon;

static int money = 0;// 金钱数

static int gameTime = 60;// 倒计时

public static int biggolden = 500;

public static int middlegolden = 200;

public static int smallgolden = 50;

public static int stone = 25;

public static int pocket = 250;

public static int num;

 

public boolean isDown = true;

 

boolean isStop = false;

 

public HookThread(ImageIcon icon, int x, int y) {

this.x = x;

this.y = y;

this.icon = icon;

}

 

public void run() {

 

tocatch();

// 设置一个布尔型变量，当时间为0时，toCatch()结束，开始执行下面的语句

if (HookThread.money < 1500) {

JOptionPane.showMessageDialog(null, "ＧＡＭＥ　ＯＶＥＲ    未达到目标分数o(╯□╰)o");

isStop = true;

}

if (HookThread.money >= 1500) {

JOptionPane.showMessageDialog(null, "达到目标分数~~顺利完成任务O(∩_∩)O");

isStop = true;

}

}

 

// 钩子向下运动

public void tocatch() {

long time = 10;

 

xc = -Math.sin(arc);

yc = Math.abs(Math.cos(arc));

while (!isStop) {

if (gameTime == 0) {

isStop = true;

}

 

if (isCatch) {

 

if (isDown) {

// 钩子到达边界抓空

if (x < 4 || x > 625 || y > 440) {

System.out.println("碰边了");

xc = -xc;

yc = -yc;

num = -1;

isDown = false;

 

}

 

// 如果抓到金矿，则返回

if (isDown) {

 

// 鉤子向下運動時，遍历一遍金矿和石头

for (int i = 0; i < GameUI.gases.size(); i++) {

GoldenAndStoneThread gs = GameUI.gases.get(i);

 

// 钩子在运动的过程中，是否可以抓取到东西

// 可以抓取则将钩子的运动位移量赋给金块或石头

 

if (i == 1 || i == 5 || i == 6 || i == 10) {// biggolden

double a = x + 13 - gs.xx;

double b = Math.abs(gs.yy + 5 - y);

if (a > 6 && a < 88 && b < 5) {

xc = -xc;

yc = -yc;

gs.xxc = xc;

gs.yyc = yc;

num = i;

System.out.println("1,5,6,10");

isDown = false;

break;

}

}

if (i == 3 || i == 7 || i == 8 || i == 0 || i == 11) {// middllegolden

// stone

// pocket

double c = x + 13 - gs.xx;

double d = Math.abs(gs.yy + 5 - y);

if (c > 1 && c < 27 && d < 8) {

xc = -xc;

yc = -yc;

gs.xxc = xc;

gs.yyc = yc;

num = i;

System.out.println("3,7,8,0,11");

isDown = false;

break;

}

}

if (i == 2 || i == 4) {// middllegolden

double e = x + 13 - gs.xx;

double f = Math.abs(gs.yy + 5 - y);

if (e > 0 && e < 22 && f < 5) {

xc = -xc;

yc = -yc;

gs.xxc = xc;

gs.yyc = yc;

num = i;

System.out.println("2,4");

isDown = false;

break;

}

}

if (i == 9) {// stone

double g = x + 13 - gs.xx;

double h = Math.abs(gs.yy + 5 - y);

if (g > 0 && g < 57 && h < 5) {

xc = -xc;

yc = -yc;

gs.xxc = xc;

gs.yyc = yc;

num = i;

System.out.println("9");

isDown = false;

break;

}

}

 

}

}

 

}

 

if (!isDown) {

// 返回顶部时加分，金块消失，钩子 开始旋转

if (y < 65) {

 

// 判断金块石头的钱数，响应加分

HookThread.isCatch();

System.out.println(num);

if (num != -1) {

GameUI.gases.remove(num);

}

 

// 改变移动变量，使钩子可以继续伸出去

// 加分

if (num == 0) {// 1

money += pocket;

} else if (num == 1) {// 5

money += biggolden;

} else if (num == 2) {// 4

money += smallgolden;

} else if (num == 3) {// 3

money += middlegolden;

} else if (num == 4) {// 4

money += smallgolden;

} else if (num == 5) {// 5

money += biggolden;

} else if (num == 6) {// 5

money += biggolden;

} else if (num == 7) {// 3

money += middlegolden;

} else if (num == 8) {// 2

money += stone;

} else if (num == 9) {// 6

money += stone;

} else if (num == 10) {// 5

money += biggolden;

} else if (num == 11) {// 1

money += pocket;

} else if (num == 12) {

 

}

 

isDown = true;

}

}

 

// 钩子移动

x += xc;

y += yc;

 

time = 10;

} else {// 钩子旋转

arc += arcx;

xc = -Math.sin(arc);

yc = Math.abs(Math.cos(arc));

if (arc > Math.PI / 4) {

arcx = -arcx;

}

if (arc < -Math.PI / 4) {

arcx = -arcx;

}

time = 100;

}

 

try {

Thread.sleep(time);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

 

/**

* 钩子抓东西时停止转动恢復轉動的方法

*/

public static void isCatch() {

// TODO Auto-generated method stub

isCatch = !isCatch;

}

 

}

金块石头线程类

 

package 黄金矿工;

 

import java.util.ArrayList;

import java.util.Random;

 

import javax.swing.ImageIcon;

 

 

/**

 * 金块与石头的线程

 */

public class GoldenAndStoneThread extends Thread {

double xx, yy;// 金块与石头的坐标点

double xxc = 0, yyc = 0;// 金块与石头的位移量

ImageIcon icon;

int width,height;//图片的高宽

public static Random random = new Random();

public static ArrayList<GoldenAndStoneThread> gases = new ArrayList<GoldenAndStoneThread>();

    public GoldenAndStoneThread(ImageIcon icon,int xx,int yy){

    this.xx=xx;

    this.yy=yy;

    this.icon=icon;

    this.width = icon.getIconWidth();

    this.height = icon.getIconHeight();

   }

 

public void run() {

go();

}

 

public void go() {

while (true) {

xx+=xxc;

yy+=yyc;

try {

Thread.sleep(10);

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

 

时间线程类

 

package 黄金矿工;

 

 

/**

 * 时间线程

 * @author Administrator

 *

 */

public class TimeThread extends Thread {

public TimeThread(){

}

public void run() {

// TODO Auto-generated method stub

while(HookThread.gameTime!=0){

HookThread.gameTime--;//减一秒

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

 

界面展示：非常感谢龙哥的抠图哦~~

 

里面那几个大金块是我自己扣的，貌似比较丑~~囧哪~~

哈弗曼压缩&解压

实现了压缩和解压的功能，但是经过检测，他的效率好低啊~~不过简单测试可以保证它压缩和解压是正确的

过程中最大功劳应该是Test类，每做一步都要对其进行检测，否则一股脑做到最后结果不正确，都不晓得自己是哪一步出错了。。。

压缩步骤：

 

1.读取文件，统计每个字节出现的个数，存入到一个int[256]数组中

如：int[97]=1;(a出现一次)

    int[98]=2;(b出现两次)

2.TreeNode{

  byte b;//字节(a)

  int count;//权值(1)

  String str="";//左0右1

}

将数组中的次数作为权值构造节点，将节点放入优先队列

3.将字节出现的次数作为权值构造哈弗曼树

4.找到所有的叶子节点，得到每个叶子节点的哈弗曼01编码，将01编码存入到String[256]中（码表）

如：String[97]="110"

5.读取文件，将每个字节用相应的01编码表示，得到一个完整长01字符串s

如：s="11011111110101010000"

6.将字符串每八位转为一个整数，作为字节存入到byte[]b=new byte[length]中（length的大小由是否能被8整除决定）

length=20/8+2

最后一位存储补0的个数

倒数第二位存储除8后剩余的编码

7.将码表和byte数组写入到压缩文件中

 

解压步骤反向进行

 

 压缩和解压共同的TreeNode类

 

public class TreeNode {

Object obj;//节点中存储的元素

int value;//权值

String str;//左孩子0右孩子1

TreeNode parent;//父节点

TreeNode leftChild;//左孩子节点

TreeNode rightChild;//右孩子节点

/**

* 构造函数

* @param obj

* @param value

*/

public TreeNode(Object obj,int value,String str){

this.obj=obj;

this.value=value;

this.str=str="";

}

 

 

压缩Compress类

 

package 哈弗曼压缩;

 

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Comparator;

import java.util.PriorityQueue;

 

/**

 * 压缩文件类

 * 

 * @author Administrator

 * 

 */

 

public class Compress {

 

// 创建文件输出流对象

FileOutputStream fos;

 

/**

* 1.统计指定文件中每个字节出现的次数

* 

* @param path

*/

public int[] count(String path) {

int[] byteCount = new int[255];

try {

 

// 创建文件输出流对象

FileInputStream fis = new FileInputStream(path);

// 将输出流包装成可写的基本类型的流

DataInputStream dis = new DataInputStream(fis);

try {

while (dis.available() > 0) {

int i = dis.read();

byteCount[i]++;

// System.out.println(byteCount[i]);

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

 

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

 

return byteCount;

 

}

 

/**

* 将数组中的次数作为权值构造节点，将节点放入优先队列

* 

* @param arr

* @return

*/

public PriorityQueue<TreeNode> array2Queue(int[] byteCount) {

// 创建排序队列对象，需要自己指定比较器

PriorityQueue<TreeNode> queue = new PriorityQueue<TreeNode>(11,

new MyComparator());

for (int i = 0; i < byteCount.length; i++) {

if (byteCount[i] != 0) {

// 循环创建节点对象

TreeNode node = new TreeNode(i, byteCount[i], "");

queue.add(node);

}

}

return queue;

}

 

/**

* 根据节点优先队列构造哈弗曼树

* 

* @param queue

* @return

*/

public TreeNode creatHfmTree(PriorityQueue<TreeNode> queue) {

while (queue.size() > 1) {

// 取两个权值较小的节点

TreeNode node1 = queue.poll();

TreeNode node2 = queue.poll();

// 根据两个节点的权值和构造一个根节点

TreeNode root = new TreeNode(null, (node1.value + node2.value), "");

// 建立孩子节点与父节点的关系

root.leftChild = node1;

node1.str = "0";

root.rightChild = node2;

node2.str = "1";

node1.parent = root;

node2.parent = root;

 

// 将该根节点存入队列中

queue.add(root);

 

}

// 如果循环结束后，证明队列中还有一个节点，该节点为根节点

TreeNode root = queue.poll();

root.str = "";

 

return root;

}

 

/**

* 得到每一个叶子节点的哈弗曼编码

* 

* @param child

* @param s

* @return

*/

 

public String[] getByteCode(TreeNode root, String s) {

// 码表

String[] SaveString = new String[256];

// 调用得到编码的方法

getCode(SaveString, root, s);

// 打印码表

for (int i = 0; i < SaveString.length; i++)

System.out.println(i + "<>" + SaveString[i]);

return SaveString;

}

 

// 从下向上找

private void getCode(String[] SaveString, TreeNode root, String s) {

if (root != null) {

if (root.obj != null) {

int index = (Integer) root.obj;

SaveString[index] = s;

}

TreeNode left = root.leftChild;

if (left != null)

getCode(SaveString, left,s+left.str);

 

TreeNode right = root.rightChild;

if (right != null)

getCode(SaveString, right, s+ right.str);

 

}

 

}

 

/*

* 读取文件，将文件中的内容转化为01字符串

*/

public String change(String SaveString[], String path) {

String string = "";

try {

// 创建文件输出流对象

FileInputStream fis = new FileInputStream(path);

// 将输出流包装成可写的基本类型的流

DataInputStream dis = new DataInputStream(fis);

try {

while (dis.available() > 0) {

int i = dis.read();

String a = SaveString[i];

string = string + a;

// System.out.println(byteCount[i]);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

 

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return string;

}

 

/**

* 将一个八位的字符串转成一个整数

* 

* @param s

* @return

*/

public byte changeString(String s) {

return (byte) (((byte) s.charAt(0) - 48) * 128

+ ((byte) s.charAt(1) - 48) * 64 + ((byte) s.charAt(2) - 48)

* 32 + ((byte) s.charAt(3) - 48) * 16

+ ((byte) s.charAt(4) - 48) * 8 + ((byte) s.charAt(5) - 48) * 4

+ ((byte) s.charAt(6) - 48) * 2 + ((byte) s.charAt(7) - 48));

}

 

/**

* 将字符串每八位转为一个整数后，作为字节存入到byte[]b=new byte[length]中

* @param string

* @return

*/

public byte[] StringToByteArray(String string) {

// 得到01字符串的长度

char[] c = string.toCharArray();// 将字节串str转化为字符数组c

int len = c.length;// 字符串字符的个数

int more = len % 8;// 余数

int length = len / 8;// 商

byte[] b;

String x = "";// 每八个01的编码

// 如果可以被8整除

if (more == 0) {

b = new byte[length+1];

 

for (int i = 0; i < length; i++) {

for (int j = i * 8; j < (i + 1) * 8; j++) {

x = x + c[j];

}

System.out.println("===================" + x);

b[i] = changeString(x);

x="";

}

b[length]=0;//补了零个0；

} else {//不可以被8整除

b = new byte[length + 2];

for(int i=0;i<length;i++){

for(int j=i*8;j<(i+1)*8;j++){

x=x+c[j];

}

System.out.println(">>>>>>>>>>>>>>>>>>>>"+x);

b[i]=changeString(x);

x="";

}

for(int a=0;a<more;a++){

x=x+c[length*8+a];

}

for(int d=more;d<8;d++){

x=x+"0";

}

System.out.println(">>>==========>>>>>>>"+x);

b[length]=changeString(x);

b[length+1]=(byte)(8-more);

}

 

return b;

}

/**

* 将码表和byte数组写入到压缩文件中 SaveString 和b

* @param path

* @param SaveString

* @param b

*/

public void writeIn(String path,String [] SaveString,byte[] b,TreeNode root) {

try {

// 创建文件输出流对象

FileOutputStream fos = new FileOutputStream(path);

// 将输出流包装成可写基本类型的数据流

DataOutputStream dos = new DataOutputStream(fos);

// //写入哈弗曼树

// printTree(root);

// dos.writeBytes(root);

//写入SaveString有多少字节不是空的

int num = 0;

for(int i=0;i<255;i++){

if(SaveString[i]!=null){

num++;

}

}

System.out.println("_____________________________________________________________________"+num);

dos.writeInt(num);

//先写入SaveString

for(int i=0;i<255;i++){

if(SaveString[i]!=null){

System.out.println("OK"+SaveString[i].length());

int l=SaveString[i].length();

//写入97,3,110

dos.writeByte(i);

dos.writeInt(l);

dos.writeBytes(SaveString[i]);

System.out.println("HAHA"+i+" "+l+" "+SaveString[i]);

}

}

//写入 b

   for(int j=0;j<b.length;j++){

    dos.writeByte(b[j]);

    System.out.println("GOGO"+b[j]);

   }

 

            //将输出流清空

dos.flush();

//将输出流关闭

fos.close();

 

} catch (Exception ef) {

ef.printStackTrace();

}

 

}

 

 

/**

* 实现的比较器类

* 

* @author Administrator

* 

*/

class MyComparator implements Comparator<TreeNode> {

 

@Override

public int compare(TreeNode o1, TreeNode o2) {

// TODO Auto-generated method stub

return o1.value - o2.value;

}

 

}

 

/**

* 遍历树的方法（先序遍历）

* 

* @param root

*/

public void printTree(TreeNode root) {

// 只要数不空就执行

if (root != null) {

// 得到根节点的元素

int va = root.value;

System.out.println(va + "<>" + root.str);

// 得到根节点的左孩子节点

TreeNode leftNode = root.leftChild;

// 递归左树

printTree(leftNode);

// 得到根节点的右孩子节点

TreeNode rightNode = root.rightChild;

// 递归右树

printTree(rightNode);

 

}

}

 

}

 

解压Decompress类

 

package Decompress解压1;

 

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.util.Comparator;

import java.util.HashMap;

import java.util.PriorityQueue;

 

public class Decompress {

 

/**

* 读取byte[] b

*/

 

public byte[] readBytes(String path) {

byte[] b = null;

try {

// 创建文件输出流对象

FileInputStream fis = new FileInputStream(path);

// 将输出流包装成可写的基本类型的流

DataInputStream dis = new DataInputStream(fis);

 

int lenZ = dis.available();

System.out.println();

// 先跳过256个Int

dis.skip(256 * 4);

 

int len = dis.available();

 

b = new byte[len];

 

for (int i = 0; i < b.length; i++) {

b[i] = dis.readByte();

}

 

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return b;

}

 

/**

* 读取码表

* 

* @param path

* @return

*/

public int[] readCount(String path) {

int[] byteCount = new int[256];

try {

// 创建文件输出流对象

FileInputStream fis = new FileInputStream(path);

// 将输出流包装成可写的基本类型的流

DataInputStream dis = new DataInputStream(fis);

 

// System.out.println("WOW");

for (int i = 0; i < 256; i++) {

byteCount[i] = dis.readInt();

}

 

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return byteCount;

}

 

/**

* 将8位10字符串前面缺0的补上0

* 

* @param str

* @return

*/

public String addZero(String str) {

int strLen = str.length();

int zeroNum;

if (strLen < 8) {// 若字符串长度小于8则补0

zeroNum = 8 - strLen;

for (int i = 0; i < zeroNum; i++) {

str = "0" + str;

}

}

return str;

}

 

/**

* 将整型数组还原成之前的10串，即文件内容的哈夫曼编码

* 

* @param n

* @return

*/

public String InttoBinaryString(byte[] bs) {

 

String BinaryStr = "";

for (int i = 0; i < bs.length - 1; i++) {

String str = Integer.toBinaryString(bs[i]);

if (str.length() < 8) {

 

for (int j = 0; j < 8 - str.length(); j++) {

str = "0" + str;

}

 

} else if (str.length() > 8) {

 

str=str.substring(str.length()-8);

}

 

BinaryStr = BinaryStr + str;

}

int BinaryStrLen = BinaryStr.length();// 得到为减0前的字符串大小

byte zeroSub = bs[bs.length - 1];// 之前在末尾补0的个数，现在减去

System.out.println(bs[bs.length - 1]);

BinaryStr = BinaryStr.substring(0, BinaryStrLen - zeroSub);

System.out.println("<BinaryStr>"+BinaryStr);

return BinaryStr;

}

 

/**

* 

* @param path

*            解压的路径

* @param BinaryStr

*            01串

* @param SaveString

*            码表

*/

public void writeIn(String path, String BinaryStr,

HashMap<String, Integer> SaveString) {

// 创建文件输出流对象

 

try {

FileOutputStream fos = new FileOutputStream(path);

DataOutputStream dos = new DataOutputStream(fos);

String str = "";

int index = 0;

// System.out.println(BinaryStr);

while (index < BinaryStr.length()) {

str += BinaryStr.charAt(index);

// 如果码表中包含该01串

if (SaveString.containsKey(str)) {

// System.out.println(">>"+str);

// 就得到01传对应的字节

int b = SaveString.get(str);

dos.write(b);

str = "";

}

index++;

 

}

// 将输出流清空

dos.flush();

// 将输出流关闭

fos.close();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

// 将输出流包装成可写基本类型的数据流

 

}

 

/**

* 将数组中的次数作为权值构造节点，将节点放入优先队列

* 

* @param arr

* @return

*/

public PriorityQueue<TreeNode> array2Queue(int[] byteCount) {

// 创建排序队列对象，需要自己指定比较器

PriorityQueue<TreeNode> queue = new PriorityQueue<TreeNode>(11,

new MyComparator());

for (int i = 0; i < byteCount.length; i++) {

if (byteCount[i] != 0) {

// 循环创建节点对象

TreeNode node = new TreeNode(i, byteCount[i], "");

queue.add(node);

}

}

return queue;

}

 

/**

* 根据节点优先队列构造哈弗曼树

* 

* @param queue

* @return

*/

public TreeNode creatHfmTree(PriorityQueue<TreeNode> queue) {

while (queue.size() > 1) {

// 取两个权值较小的节点

TreeNode node1 = queue.poll();

TreeNode node2 = queue.poll();

// 根据两个节点的权值和构造一个根节点

TreeNode root = new TreeNode(null, (node1.value + node2.value), "");

// 建立孩子节点与父节点的关系

root.leftChild = node1;

node1.str = "0";

root.rightChild = node2;

node2.str = "1";

node1.parent = root;

node2.parent = root;

 

// 将该根节点存入队列中

queue.add(root);

 

}

// 如果循环结束后，证明队列中还有一个节点，该节点为根节点

TreeNode root = queue.poll();

root.str = "";

 

return root;

}

 

/**

* 得到每一个叶子节点的哈弗曼编码

* 

* @param child

* @param s

* @return

*/

 

public HashMap<String, Integer> getByteCode(TreeNode root, String s) {

// 码表

HashMap<String, Integer> SaveString = new HashMap<String, Integer>();

// 调用得到编码的方法

getCode(SaveString, root, s);

return SaveString;

}

 

// 从下向上找

private void getCode(HashMap<String, Integer> SaveString, TreeNode root,

String s) {

if (root != null) {

if (root.obj != null) {

int index = (Integer) root.obj;

SaveString.put(s, index);

}

TreeNode left = root.leftChild;

if (left != null)

getCode(SaveString, left, s + left.str);

 

TreeNode right = root.rightChild;

if (right != null)

getCode(SaveString, right, s + right.str);

 

}

 

}

 

/**

* 实现的比较器类

* 

* @author Administrator

* 

*/

class MyComparator implements Comparator<TreeNode> {

 

@Override

public int compare(TreeNode o1, TreeNode o2) {

// TODO Auto-generated method stub

return o1.value - o2.value;

}

 

}

 

/**

* 遍历树的方法（先序遍历）

* 

* @param root

*/

public void printTree(TreeNode root) {

// 只要数不空就执行

if (root != null) {

// 得到根节点的元素

int va = root.value;

System.out.println(va + "<>" + root.str);

// 得到根节点的左孩子节点

TreeNode leftNode = root.leftChild;

// 递归左树

printTree(leftNode);

// 得到根节点的右孩子节点

TreeNode rightNode = root.rightChild;

// 递归右树

printTree(rightNode);

 

}

}

 

}

通信群聊

要分清客户端与服务器之间的关系，以及各自方法的使用

服务器

ChatServer类

 

package tx0630服务器2;

 

import java.net.ServerSocket;

import java.net.Socket;

import java.util.ArrayList;

 

public class ChatServer {

 

// 保存处理进处连结的线程对象

public static ArrayList<ServerThread> cts = new ArrayList<ServerThread>();

 

/**

* 在指定端口上创建服务器

* 

* @param port

*            服务器所在的端口号

*/

public void setServer(int port) {

 

try {

// 创建一个服务器对象

ServerSocket s = new ServerSocket(port);

while (true) {

// 等待连结进入

Socket chatClient = s.accept();

// 创建线程对象，去处理

ServerThread ct = new ServerThread(chatClient);

ct.start();

cts.add(ct);// 保存到队列中

}

 

} catch (Exception ef) {

ef.printStackTrace();

}

 

}

 

/**

* @param args

*/

public static void main(String[] args) {

ChatServer ss = new ChatServer();

ss.setServer(1000);

 

}

 

}

 

 

ServerThread类

 

package tx0630服务器2;

 

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

import java.util.ArrayList;

import java.util.Date;

 

//处理进入的连结对象的线程，:每进入一个连结，就创建一个处理线程对象

//每个客户端，在服务器端，都由一个处理线程对象代表

public class ServerThread extends Thread {

public static native long currentTimeMillis();

 

private Socket socket;

private OutputStream ous;

 

public ServerThread(Socket socket) {

try {

this.socket = socket;

ous = socket.getOutputStream();

} catch (Exception ef) {

ef.printStackTrace();

}

}

 

// 给我所代表的客户机发送一条消息

public void sendMsg2Me(String msg) {

try {

msg += "\r\n";

ous.write(msg.getBytes());

 

} catch (Exception ef) {

ef.printStackTrace();

}

 

}

 

// 服务器统计在线人数

public int Count() {

int num = ChatServer.cts.size();

return num;

}

 

public void run() {

// 处理通信过程：

processChat(this.socket);

}

 

/**

* 处理进入的客户端连结对象:处理通信流程

* 

* @param client

*/

private void processChat(Socket chatClient) {

try {

// 得取输入输出流，读写数据

InputStream ins = chatClient.getInputStream();

 

// 通信流程实现阶段：最简流程

String msg = "hello!欢迎进入QQChat";// 发给连结上来的客户机

sendMsg2Me(msg);

int num = Count();

for (int i = 0; i < ChatServer.cts.size(); i++) {

ServerThread ct = ChatServer.cts.get(i);

ct.sendMsg2Me("当前在线人数" + num);

}

 

String inMsg = "";

while (!"*".equals(inMsg)) {

inMsg = readMsg(ins);

System.out.println("recive Msg:" + inMsg);

 

// 遍历cts中的每一个对象,发送消息

for (int i = 0; i < ChatServer.cts.size(); i++) {

ServerThread ct = ChatServer.cts.get(i);

Date d = new Date();

// 在默认时区下输出日期和时间值

System.out.println(d);

ct.sendMsg2Me(d + inMsg);

}

if(inMsg=="over"){

msg = "有人要下线了，通信结束!";// 发给连结上来的客户机

sendMsg2Me(msg);

ins.close();

ous.close();

chatClient.close();

}

}

 

} catch (Exception ef) {

ef.printStackTrace();

}

}

 

 

/**

* 从输入流上读取字节，直到读到以*字节结尾的，将读到的字节转为字符串返回

* 

* @param ins

*            :读取的输入流对象

* @return 读到的字符串

*/

private String readMsg(InputStream ins) {

try {

// 读取：

int t = ins.read();

ArrayList<Byte> ds = new ArrayList();

while (t != '~') {

System.out.println("读取的字节是: " + t);

ds.add((byte) t);

t = ins.read();

}

// 将前面收到的字节，都转成一个字符串:

byte[] dd = new byte[ds.size()];

for (int i = 0; i < dd.length; i++) {

dd[i] = ds.get(i);

}

// 转为字符串

String inMsg = new String(dd);

return inMsg;

} catch (Exception ef) {

ef.printStackTrace();

System.out.println("从输入流上读取字符串时出错!");

}

return "error";

}

 

}

客户机

MainClientUI()界面设计代码略

 

 

package tx0630客户机2;

 

import java.awt.TextArea;

import java.io.BufferedReader;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.net.Socket;

 

 

/**

 * 客户端

 */

public class NetClient extends Thread {

private String UserName;

private String serverIP;//服务器IP

private int port;//服务器端口

private OutputStream out;//到服务器的输出流

private BufferedReader brd;//到服务器的输入流，以\r\n结尾

private TextArea jta_recived;//从界面上传来的显示接收到的消息的组件

/**

* 构造函数，传入服务器的IP和端口和显示组件

* @param serverIP

* @param port

* @param jta_input

*/

public NetClient(String UserName,String serverIP,int port,TextArea jta_input){

this.UserName=UserName;

this.serverIP=serverIP;

this.port=port;

this.jta_recived=jta_input;

}

public String getUserName(){

return UserName;

}

/**

* 连接并判断连接服务器是否成功

* @return

*/

public boolean conn2Server(){

try{

//创建一个服务端的SOCKET对象

Socket client=new Socket(this.serverIP,this.port);

//获取输入输出流

InputStream ins=client.getInputStream();

brd=new BufferedReader(new InputStreamReader(ins));

out=client.getOutputStream();

return true;

}catch(Exception ef){

ef.printStackTrace();

}

return false;

}

/**

* 注册服务器

*/

public boolean registerServer(String name,String pwd){

 

try{

//发送登陆

out.write("register\r\n".getBytes());

//发送用户名

name+="\r\n";

out.write(name.getBytes());

out.flush();

//发送密码

pwd+="\r\n";

out.write(pwd.getBytes());

out.flush();

String register=brd.readLine();

if(register.equals("false")){

return false;

}else{

return true;

}

}catch(Exception ef){

ef.printStackTrace();

}

return false;

}

/**

* 登陆服务器

* @param name

* @param pwd

* @return

*/

public boolean loginServer(String name,String pwd){

try{

//发送登陆

out.write("login\r\n".getBytes());

//发送用户名

name+="\r\n";

out.write(name.getBytes());

out.flush();

//发送密码

pwd+="\r\n";

out.write(pwd.getBytes());

out.flush();

String login=brd.readLine();

if(login.equals("false")){

return false;

}else{

return true;

}

}catch(Exception ef){

ef.printStackTrace();

}

return false;

}

/**

* 找回密码

*/

public String backpwd(String name){

try{

//发送登陆

out.write("backpwd\r\n".getBytes());

//发送用户名

name+="\r\n";

out.write(name.getBytes());

out.flush();

String backpwd=brd.readLine();

return backpwd;

}catch(Exception ef){

ef.printStackTrace();

}

return "用户名不存在";

}

/**

* 线程处理读取服务器的阻塞问题

*/

public void run(){

while(true){

this.readFromServer();

}

}

/**

* 读消息

*/

public void readFromServer(){

try{

String input=brd.readLine();

//将收到的消息显示到界面上

jta_recived.append(input+"\r\n");

//jta_recived.setLineWrap(true);

}catch(Exception ef){

ef.printStackTrace();

}

}

/**

* 发消息

*/

public void sendMsg(String msg){

try{

msg=msg+"~\r\n";

this.out.write(msg.getBytes());

this.out.flush();

}catch(Exception ef){

ef.printStackTrace();

}

}

 

}

 

 

这段时间自己独立完成的东西比较少，很多都是在老师的帮助指导下完成的，以后我会自己多动脑，一步步锻炼自己，挖掘自己的潜力，独立完成一个项目。