包含javafront的词条

admin 2023-01-10 17:30:14 715

本篇文章给大家谈谈javafront，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、写一个java层次遍历二叉树,简单点就可以,我要的是代码,不是纯文字说明
2、java语言中用LinkList实现堆栈
3、java连接数据库：已知地址、用户名和密码，怎样看到该用户下的所有数据库和表信息，就像Mysql-front
4、我想要找一份关于java数据结构二叉树的实例详解（所有基本操作，包括二叉树的高度和节点总数）
5、JAVA 编写一个带有窗口的应用程序
6、反编译工具 java jad怎么使用方法

写一个java层次遍历二叉树,简单点就可以,我要的是代码,不是纯文字说明

public class BinaryNode {

Object element;

BinaryNode left;

BinaryNode right;

}

import java.util.*;

public class Queue {

protected LinkedList list;

// Postcondition: this Queue object has been initialized.

public Queue() {

list = new LinkedList();

} // default constructor

// Postcondition: the number of elements in this Queue object has been

// returned.

public int size() {

return list.size();

} // method size

// Postcondition: true has been returned if this Queue object has no

// elements. Otherwise, false has been returned.

public boolean isEmpty() {

return list.isEmpty();

} // method isEmpty

// Postconditon: A copy of element has been inserted at the back of this

// Queue object. The averageTime (n) is constant and

// worstTime (n) is O (n).

public void enqueue(Object element) {

list.addLast(element);

} // method enqueue

// Precondition: this Queue object is not empty. Otherwise,

// NoSuchElementException will be thrown.

// Postcondition: The element that was at the front of this Queue object -

// just before this method was called -- has been removed

// from this Queue object and returned.

public Object dequeue() {

return list.removeFirst();

} // method dequeue

// Precondition: this Queue object is not empty. Otherwise,

// NoSuchElementException will be thrown.

// Postcondition: the element at index 0 in this Queue object has been

// returned.

public Object front() {

return list.getFirst();

} // method front

} // Queue class

import java.io.IOException;

public class BinaryTree {

BinaryNode root;

public BinaryTree() {

super();

// TODO 自动生成构造函数存根

root=this.createPre();

}

public BinaryNode createPre()

//按照先序遍历的输入方法，建立二叉树

{

BinaryNode t=null;

char ch;

try {

ch = (char)System.in.read();

if(ch==' ')

t=null;

else

{

t=new BinaryNode();

t.element=(Object)ch;

t.left=createPre();

t.right=createPre();

}

} catch (IOException e) {

// TODO 自动生成 catch 块

e.printStackTrace();

}

return t;

}

public void inOrder()

{

this.inOrder(root);

}

public void inOrder(BinaryNode t)

//中序遍历二叉树

{

if(t!=null)

{

inOrder(t.left);

System.out.print(t.element);

inOrder(t.right);

}

public void postOrder()

{

this.postOrder(root);

}

public void postOrder(BinaryNode t)

//后序遍历二叉树

{

if(t!=null)

{

postOrder(t.left);

System.out.print(t.element);

postOrder(t.right);

}

public void preOrder()

{

this.preOrder(root);

}

public void preOrder(BinaryNode t)

//前序遍历二叉树

{

if(t!=null)

{

System.out.print(t.element);

preOrder(t.left);

preOrder(t.right);

}

public void breadthFirst()

{

Queue treeQueue=new Queue();

BinaryNode p;

if(root!=null)

treeQueue.enqueue(root);

while(!treeQueue.isEmpty())

{

System.out.print(((BinaryNode)(treeQueue.front())).element);

p=(BinaryNode)treeQueue.dequeue();

if(p.left!=null)

treeQueue.enqueue(p.left);

if(p.right!=null)

treeQueue.enqueue(p.right);

}

public class BinaryTreeTest {

/**

* @param args

public static void main(String[] args) {

// TODO 自动生成方法存根

BinaryTree tree = new BinaryTree();

System.out.println("先序遍历：");

tree.preOrder();

System.out.println();

System.out.println("中序遍历：");

tree.inOrder();

System.out.println();

System.out.println("后序遍历：");

tree.postOrder();

System.out.println();

System.out.println("层次遍历：");

tree.breadthFirst();

System.out.println();

}

java语言中用LinkList实现堆栈

栈和队列是两种特殊的线性表，它们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制，故又称它们为运算受限的线性表。

LinkedList数据结构是一种双向的链式结构，每一个对象除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素，和数组的顺序存储结构（如：ArrayList）相比，插入和删除比较方便，但速度会慢一些。

栈的定义

栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。

(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。

(2)当表中没有元素时称为空栈。

(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。

栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。

实现代码：

package com.weisou.dataStruct;

import java.util.LinkedList;

@SuppressWarnings("unchecked")

public class MyStack {

LinkedList linkList = new LinkedListObject();

public void push(Object object) {

linkList.addFirst(object);

}

public boolean isEmpty() {

return linkList.isEmpty();

}

public void clear() {

linkList.clear();

}

// 移除并返回此列表的第一个元素

public Object pop() {

if (!linkList.isEmpty())

return linkList.removeFirst();

return "栈内无元素";

}

public int getSize() {

return linkList.size();

}

public static void main(String[] args) {

MyStack myStack = new MyStack();

myStack.push(2);

myStack.push(3);

myStack.push(4);

System.out.println(myStack.pop());

}

队列定义

队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表

（1）允许删除的一端称为队头（Front）。

（2）允许插入的一端称为队尾（Rear）。

（3）当队列中没有元素时称为空队列。

（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。

实现代码：

package com.weisou.dataStruct;

import java.util.LinkedList;

/**

* @author gf

* @date 2009-11-13

public class MyQueue {

LinkedList linkedList = new LinkedList();

//队尾插

public void put(Object o){

linkedList.addLast(o);

//队头取取完并删除

public Object get(){

if(!linkedList.isEmpty())

return linkedList.removeFirst();

else

return "";

}

public boolean isEmpty(){

return linkedList.isEmpty();

}

public int size(){

return linkedList.size();

}

public void clear(){

linkedList.clear();

}

/**

* @param args

public static void main(String[] args) {

MyQueue myQueue= new MyQueue();

myQueue.put(1);

myQueue.put(2);

myQueue.put(3);

System.out.println(myQueue.get());

}

java连接数据库：已知地址、用户名和密码，怎样看到该用户下的所有数据库和表信息，就像Mysql-front

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.Statement;

public class JdbcTest {

/**

* @param args

* @throws Exception

public static void main(String[] args) throws Exception {

// TODO Auto-generated method stub

JdbcTest jdbcTest=new JdbcTest();

jdbcTest.connect();

}

void connect() throws Exception{

Class.forName("com.mysql.jdbc.Driver");//数据库的驱动类名

Connection connection= DriverManager.getConnection //打开连接("jdbc:mysql://localhost:3306/Test","root","123456");//Test是你要连接的数据库，root是用户名，123456是密码

Statement st=connection.createStatement(); 创建语句

ResultSet rs= st.executeQuery("select * from user");执行语句，查看user表中的内容

while(rs.next()){//循环遍历

System.out.println(rs.getObject(1)+" :"+rs.getObject(2)+" :"+rs.getObject(3));

}

迅速的给你写了一个jdbc连接mysql的例子，没有优化，上面有注释的。

我想要找一份关于java数据结构二叉树的实例详解（所有基本操作，包括二叉树的高度和节点总数）

#includestdio.h

#includestring.h

#includestdlib.h

#define Max 20 //结点的最大个数

typedef struct node{

char data;

struct node *lchild,*rchild;

}BinTNode; //自定义二叉树的结点类型

typedef BinTNode *BinTree; //定义二叉树的指针

int NodeNum,leaf; //NodeNum为结点数，leaf为叶子数

//基于先序遍历算法创建二叉树

//要求输入先序序列，其中加入虚结点"#"以示空指针的位置

BinTree CreatBinTree(void){

BinTree T;

char ch;

if((ch=getchar())=='#')

return(NULL); //读入#，返回空指针

else{

T=(BinTNode *)malloc(sizeof(BinTNode)); //生成结点

T-data=ch;

T-lchild=CreatBinTree(); //构造左子树

T-rchild=CreatBinTree(); //构造右子树

return(T);

}

//先序遍历

void Preorder(BinTree T){

if(T){

printf("%c",T-data); //访问结点

Preorder(T-lchild); //先序遍历左子树

Preorder(T-rchild); //先序遍历右子树

}

//中序遍历

void Inorder(BinTree T){

if(T){

Inorder(T-lchild); //中序遍历左子树

printf("%c",T-data); //访问结点

Inorder(T-rchild); //中序遍历右子树

}

//后序遍历

void Postorder(BinTree T){

if(T){

Postorder(T-lchild); //后序遍历左子树

Postorder(T-rchild); //后序遍历右子树

printf("%c",T-data); //访问结点

}

//采用后序遍历求二叉树的深度、结点数及叶子数的递归算法

int TreeDepth(BinTree T){

int hl,hr,max;

if(T){

hl=TreeDepth(T-lchild); //求左深度

hr=TreeDepth(T-rchild); //求右深度

max=hlhr? hl:hr; //取左右深度的最大值

NodeNum=NodeNum+1; //求结点数

if(hl==0hr==0) leaf=leaf+1; //若左右深度为0，即为叶子。

return(max+1);

}

else return(0);

}

//主函数

void main(){

BinTree root;

int i,depth;

printf("\n");

printf("Creat Bin_Tree； Input preorder:"); //输入完全二叉树的先序序列，

// 用#代表虚结点，如ABD###CE##F##

root=CreatBinTree(); //创建二叉树，返回根结点

do{ //从菜单中选择遍历方式，输入序号。

printf("\t********** select ************\n");

printf("\t1: Preorder Traversal\n");

printf("\t2: Iorder Traversal\n");

printf("\t3: Postorder traversal\n");

printf("\t4: PostTreeDepth,Node number,Leaf number\n");

printf("\t0: Exit\n");

printf("\t*******************************\n");

scanf("%d",i); //输入菜单序号（0-4）

switch (i){

case 1: printf("Print Bin_tree Preorder: ");

Preorder(root); //先序遍历

break;

case 2: printf("Print Bin_Tree Inorder: ");

Inorder(root); //中序遍历

break;

case 3: printf("Print Bin_Tree Postorder: ");

Postorder(root); //后序遍历

break;

case 4: depth=TreeDepth(root); //求树的深度及叶子数

printf("BinTree Depth=%d BinTree Node number=%d",depth,NodeNum);

printf(" BinTree Leaf number=%d",leaf);

break;

case 5: printf("LevePrint Bin_Tree: ");

Levelorder(root); //按层次遍历

break;

default: exit(1);

}

printf("\n");

}while(i!=0);

}

//按层遍历

Levelorder( BinTNode *root){

BinTNode * q[Max]; //定义BinTNode类型的队列用于存放节点队列长最大为20个元素

int front=0,rear=0; //初始化队列为空

BinTNode *p; //临时节点指针

if(root!=NULL){ //将根节点进队

rear=(rear+1)%Max;

q[rear]=root;

}

while(front!=rear){

front=(front+1)%Max;

p=q[front]; //删除队首的元素让两个节点（左右节点）孤立

printf("%c",p-data); //输出队列首元素的值

if(p-left!=null){ //如果存在左孩子节点，则左孩子节点进入队列

rear=(rear+1)%Max;

q[rear]=p-left;

}

if(p-right!=null){ //如果存在右孩子节点，则右孩子节点进入队列

rear=(rear+1)%Max;

q[rear]=p-right;

}

JAVA 编写一个带有窗口的应用程序

这样：

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import java.awt.Graphics;

public class MainClass extends JFrame {

public JComboBox box;

int flag = 0;

jpNewPanel jpNewPanel;

public static void main(String[] args) {

MainClass frame = new MainClass();

frame.setBounds(650,300,550,550);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setTitle("信号灯");

frame.setVisible(true);

}

public MainClass() {

box = new JComboBox();

box.addItem("请选择");

box.addItem("红灯");

box.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

flag = box.getSelectedIndex();

jpNewPanel.repaint();

}

});

box.addItem("黄灯");

box.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

flag = box.getSelectedIndex();

jpNewPanel.repaint();

}

});

box.addItem("绿灯");

box.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

flag = box.getSelectedIndex();

jpNewPanel.repaint();

}

});

add(box, BorderLayout.NORTH);

jpNewPanel = new jpNewPanel();

add(jpNewPanel, BorderLayout.CENTER);

}

class jpNewPanel extends JPanel {

protected void paintComponent(Graphics g) {

super.paintComponent(g);

g.drawOval(150, 0, 120, 120);

if (flag == 1) {

g.setColor(Color.RED);

g.fillOval(150, 0, 120, 120);

} else if (flag == 2) {

g.setColor(Color.YELLOW);

g.fillOval(150, 0, 120, 120);

} else if (flag == 3) {

g.setColor(Color.GREEN);

g.fillOval(150, 0, 120, 120);

}

扩展资料：

注意事项

每个Road对象都有一个name成员变量来代表方向，有一个vehicles成员变量来代表方向上的车辆集合。

在Road对象的构造方法中启动一个线程每隔一个随机的时间向vehicles集合中增加一辆车（用一个“路线名_id”形式的字符串进行表示）。

在Road对象的构造方法中启动一个定时器，每隔一秒检查该方向上的灯是否为绿，是则打印车辆集合和将集合中的第一辆车移除掉。

反编译工具 java jad怎么使用方法

下好以后解压就可以用了，软件就只有一个exe文件和一个帮助文件，为了方便使用，我直接将exe文件放到JDK的bin目录里了：）

下面先来看看从网上搜集来的介绍：在众多的JAVA反编译工具中，有几种非常著名的工具使用了相同的核心引擎——JAD，其中主要包括：Front

End Plus、mDeJava、Decafe Pro、Cavaj Java Decompiler、DJ Java

Decompiler、NMI’s Java Class Viewer和国产的JAVA源代码反编译专家。

JAD本身是一个命令行工具，没有图形界面，上述的这些工具大多是在JAD内核的基础之上加了一个图形界面而已。这么多种产品的共同选择，足可证明JAD

在JAVA反编译领域中的尊贵地位。 JAD是使用Microsoft Visual

C++开发的，运行速度非常快，可以处理很复杂的JAVA编译文件。众多的参数使JAD可以灵活应付多种加密手段，令反编译的代码更加优化和易读。由于

JAD参数太多，没必要一一解释，其中有几个最常用的如下：

-d dir - 用于指定输出文件的目录

-s ext - 输出文件扩展名(默认为: .jad)，通常都会把输出文件扩展名直接指定为.java，以方便修改的重新编译。

-8 - 将Unicode字符转换为ANSI字符串，如果输出字符串是中文的话一定要加上这个参数才能正确显示。

最常用的反编译指令如下所示：

Jad -d c:\test -s .java -8 HelloWorld.class

这将当前目录下的HelloWorld.class反编译为HelloWorld.java并保存在c:\test目录里，其中的提示输出为中文，

而不是Unicode代码。

附件：对下载后的说明文档的简单翻译，希望对你有所帮助（mathsfan修改于2006.10.29,翻译的不好请见谅）0、1略去2、怎样使用JAD

反编译一个简单的java class文件'example1.class'用如下命令： jad example1.class

这个命令将在当前目录下创建一个'example1.jad'文件，假如当前目录下存在这个文件，则JAD会提示你覆盖它与否。选项

-o 允许覆盖时没有任何提示。选项 -s ext允许改变输出文件的后缀名： jad -sjava example1.class

这个命令将要创建'example1.java'文件。在一起使用-o 和

-sjava选项时请小心，因为JAD会附带的重写你的源文件。JAD使用JAVA

class的名字作为输出文件的名字。例如，假如class文件'example1.class'包含JAVA class

'test1'那么JAD将会创建文件'test1.jad'而不是'example1.jad'。假如你想具体指明你的输出文件的名字使用输出重命名：

jad -p example1.class myexm1.java

选项 –d允许你具体指明另外的输出文件目录，不管这个目录是新建的、默认的或者当前目录。例如：

jad -o -dtest -sjava *.class

(或者 jad -o -d test -s java *.class, 这个有同样的效果)

这个命令将在当前目录下反编译所有的.class文件并在'test'文件夹下建立所有扩展名为.java的输出文件。

假如你想反编译整个目录树下的JAVA classes，使用如下命令：

jad -o -r -sjava -dsrc tree/**/*.class

这个命令将反编译当前目录树里所有的.class文件并且在当前目录下建立src文件夹后根据包的名字来输出文件。例如，假如有一个文件

'tree/a/b/c.class'在包'a.b'下包含了class 'c'，那么输出文件的名字为'src/a/b/c.java'。

在先前的命令上将通配符那里注释掉。则它是用JAD来处理而不是command壳，所以在UNIX上的最后一次参数将会被单独引用。

jad -o -r -sjava -dsrc 'tree/**/*.class'

你想检查编译后的文件的正确性或者出于好奇的情况下,这里有一个选项 –a 将会告诉JAD给输出的JAVA虚拟字节码注解。

javafront的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、javafront的信息别忘了在本站进行查找喔。

标签：javafront