java代码执行链,链式调用 java

用java代码实现责任链模式的骨干代码

//----------------先写了个，功能是实现了，有待改进-----------

专注于为中小企业提供网站设计、成都网站制作服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业广西免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了成百上千家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

import java.util.ArrayList;

import java.util.List;

/**

* 现有ListSourceBean类型的List对象，

* 现在需要将该List对象中a是奇数或者b100的对象过滤掉，

* 请用责任链模式实现此段代码。

* @author Administrator

*

*/

public class Chain_test1 {

public static void main(String[] args) {

ListSourceBean list = new ArrayListSourceBean();

SourceBean bean1 = new SourceBean(1, 100);

SourceBean bean2 = new SourceBean(2, 200);

SourceBean bean3 = new SourceBean(3, 100);

SourceBean bean4 = new SourceBean(4, 100);

SourceBean bean5 = new SourceBean(5, 20);

SourceBean bean6 = new SourceBean(6, 200);

list.add(bean1);

list.add(bean2);

list.add(bean3);

list.add(bean4);

list.add(bean5);

list.add(bean6);

System.out.println("过滤前List中的内容");

printList(list);

// 装配 链条

Filter oddFilter = new OddFilter();

//为了保持Filter里面的逻辑不混乱，OddFilter仅过滤奇数，CompareFilter仅仅过滤b100

//这里对奇数过滤两次，

//即，过滤掉b100和a是奇数 共存的情形

Filter oddFilter2 = new OddFilter();

Filter compareFilter = new CompareFilter();

oddFilter.setFilter(null);

compareFilter.setFilter(oddFilter);

oddFilter2.setFilter(compareFilter);

// 进行过滤

oddFilter2.doFilter(list);

System.out.println("\n过滤后List中的内容");

printList(list);

}

public static void printList(ListSourceBean list){

for(SourceBean s: list){

System.out.print(s.toString());

}

}

}

class Filter{

private Filter filter;

public void doFilter(ListSourceBean list){

if (filter != null){

filter.doFilter(list);

}else{

System.out.println("处理结束");

}

}

public void setFilter(Filter filter){

this.filter = filter;

}

}

/**

* 仅仅过滤b100

*/

class CompareFilter extends Filter{

public void doFilter(ListSourceBean list){

for(int i= 0; i list.size(); i++){

if(list.get(i).getB() 100 ){//b100

list.remove(i);//移除该对象

}else{//交给其他Filter处理

super.doFilter(list);

}

}

}

}

/**

* 仅过滤a为奇数

*/

class OddFilter extends Filter{

public void doFilter(ListSourceBean list){

for(int i= 0; i list.size(); i++){

if(list.get(i).getA() % 2 != 0){//非偶数

list.remove(i);//移除该对象

}else{//交给其他Filter处理

super.doFilter(list);

}

}

}

}

class SourceBean {

private int a;

private int b;

public SourceBean(int a, int b){

this.a = a;

this.b = b;

}

public SourceBean(){

}

public String toString(){

return "[a="+a+", b="+b+"] ";

}

public int getA() {

return a;

}

public void setA(int a) {

this.a = a;

}

public void setB(int b) {

this.b = b;

}

public int getB() {

return b;

}

}

//------------------------执行结果----------------------------

过滤前List中的内容

[a=1, b=100] [a=2, b=200] [a=3, b=100] [a=4, b=100] [a=5, b=20] [a=6, b=200]

过滤后List中的内容

[a=4, b=100]

Java单向链表代码。

这是我写的一个差不多，你看一下吧：

package com.test.list;

import java.io.BufferedReader;

import java.io.InputStreamReader;

public class LinkedList {

public static void main(String[] args) {

MyList l = new MyList();

MyListNode node = l.createList();

l.printNode(node);

//l.searchNode(node, 4);

//node = l.insertNode(node, 3, "g");

//l.printNode(node);

node = l.deleteNode(node, "d");

l.printNode(node);

}

}

class MyListNode {

public String data;

public MyListNode nextNode;

}

class MyList {

public MyListNode createList() {

MyListNode node = new MyListNode();

MyListNode q ,p;

q = new MyListNode();

q = node;

while (true) {

String s = null;

try {

BufferedReader br = new BufferedReader(new InputStreamReader(

System.in));

System.out.println("请输入节点数据：");

s = br.readLine();

if (s.equals("0")) {

break;

} else {

p = new MyListNode();

p.data = s;

p.nextNode = null;

q.nextNode = p;

q = p;

}

} catch (Exception e) {

e.printStackTrace();

}

}

return node;

}

public void printNode(MyListNode node) {

MyListNode p = node.nextNode;

while (p!= null) {

System.out.print(" "+p.data);

p = p.nextNode;

}

}

public void searchNode(MyListNode node, int i){

MyListNode p = node.nextNode;

int j = 1;

while (p != null ji) {

p = p.nextNode;

j++;

}

if( p == null || ji) {

System.out.println("error");

}

System.out.println(" --"+p.data+"--");

}

public MyListNode insertNode(MyListNode node, int i ,String s) {

MyListNode p = node.nextNode;

int j = 1;

while (p != null ji-1) {

p = p.nextNode;

j++;

}

if( p == null || ji-1) {

System.out.println("error");

}

MyListNode n = new MyListNode();

n.data = s;

n.nextNode = p.nextNode;

p.nextNode = n;

return node;

}

public MyListNode deleteNode(MyListNode node ,String s) {

MyListNode p = node;

while(p.nextNode != null !p.nextNode.data.equals(s)) {

p = p.nextNode;

}

p.nextNode = p.nextNode.nextNode;

return node;

}

}

/*逆位序创建

public MyListNode createList() {

MyListNode node = new MyListNode();

node.nextNode = null;

while(true) {

String s = null;

try {

BufferedReader br = new BufferedReader(new InputStreamReader(

System.in));

System.out.println("请输入节点数据：");

s = br.readLine();

if(s.equals("0")) {

break;

}else {

MyListNode n = new MyListNode();

n.data = s;

n.nextNode = node.nextNode;

node.nextNode = n;

}

} catch (Exception e) {

e.printStackTrace();

}

}

return node;

}

*/

如何java代码实现首尾相连的两列数据生成所有的顺序链？

楼主说的是不是表格可以动态编辑修改啊？你是用servlet吗？这样的话页面上的可编辑表格你要用js实现，保存的信息你传到后台用request获取是数组格式的，顺序和你页面上显示的顺序一致，ID你在页面隐藏，然后遍历这几个数组就可以了

java如何实现链式编程

class A{

public B getB(){

return new B();

}

}

class B{

public a getA(){

return new A();

}

}

public static void main(String args[]){

B b = new A().getB().getA().getB(); //类似于这样的

}

如何优化JAVA代码及提高执行效率

网站优化通常包含两方面的内容：减小代码的体积和提高代码的运行效率。减小代码的体积已经写过太多这类的文章了，下面就简单讨论下如何提高代码的效率。一、不用new关键词创建类的实例用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。在使用设计模式(DesignPattern)的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。二、使用非阻塞I/O版本较低的JDK不支持非阻塞I/OAPI。为避免I/O阻塞，一些应用采用了创建大量线程的办法(在较好的情况下，会使用一个缓冲池)。这种技术可以在许多必须支持并发I/O流的应用中见到，如Web服务器、报价和拍卖应用等。然而，创建Java线程需要相当可观的开销。JDK1.4引入了非阻塞的I/O库(java.nio)。如果应用要求使用版本较早的JDK，需要支持非阻塞I/O的软件包。三、慎用异常异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地(Native)方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。四、不要重复初始化变量默认情况下，调用类的构造函数时，Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量(byte、short、int、long)设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中的所有构造函数都会被自动调用。五、尽量指定类的final修饰符带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联(inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%。六、尽量使用局部变量调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中，速度较快。其他变量，如静态变量、实例变量等，都在堆(Heap)中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化，望采纳，谢谢。

java工作原理

Java工作原理

由四方面组成：

（1）Java编程语言

（2）Java类文件格式

（3）Java虚拟机

（4）Java应用程序接口

当编辑并运行一个Java程序时，需要同时涉及到这四种方面。使用文字编辑软件（例如记事本、写字板、UltraEdit等）或集成开发环境（Eclipse、MyEclipse等）在Java源文件中定义不同的类 ，通过调用类（这些类实现了Java API）中的方法来访问资源系统，把源文件编译生成一种二进制中间码，存储在class文件中，然后再通过运行与操作系统平台环境相对应的Java虚拟机来运行class文件，执行编译产生的字节码，调用class文件中实现的方法来满足程序的Java API调用 。