JAVA实现报表打印？

一、JAVA实现报表打印？

采用报表打印插件是最好的方式。报表插件优势：报表插件在服务器端不驻留程序，服务器只要提供约定格式的 XML 数据就行了。所以有如下优势：

1、支持所有的WEB服务器平台。

2、报表的生成是在各自客户端电脑上，这样大大减轻了服务器的负载压力，能够做到更大的并发访问。

3、插件在客户端运行是电脑原生程序，与桌面程序具有一样的运行性能，并能开发出桌面程序类似的报表功能。

4、能驱动打印机直接进行打印，是WEB软件实现打印功能的最好方式。

二、Java实现彩票程序？

import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Random;public class Main { public static void main(String[] args) { //红球 33 选6 List<Integer> redBall = new ArrayList<Integer>(); for(int i=0;i<33;i++){ redBall.add(i+1); } System.out.println("开奖红球：" + select(redBall, 6)); //篮球16选1 List<Integer> blueBall = new ArrayList<Integer>(); for(int i=0;i<16;i++){ blueBall.add(i+1); } System.out.println("开奖蓝球：" + select(blueBall, 1)); } public static List<Integer> select(List<Integer> list,int count){ List<Integer> selectedList = new ArrayList<Integer>(); Random random = new Random(); for(int i=0;i<count;i++){ int index = random.nextInt(list.size()); Integer number = list.get(index); selectedList.add(number); list.remove(index); } Collections.sort(selectedList); return selectedList; }}

三、JAVA怎么实现循环输入？

您好，很高兴能回答你的问题。

java实现循环输入方法。

双for

Scanner sc = new Scanner(System.in);

int i,a,t = sc.nextInt();

for(;0<t;t--){

for(i=0;(i<n)&&(a<=10);i++) a = sc.nextInt();

if(10<a) System.out.println(n);

}

用getLine() 或者其他流类的getLine() 来读取就行了

四、java如何实现填充算法？

import javax.swing.JFrame;

public class EdgeFill {

public static void main(String args[]) {

// A(3,3)B(6,20)C(15,18)D(20,3)

// AB BD AC CD

new EdgeFill();

}

private TwoDimen env;

public EdgeFill() {

JFrame frame = new JFrame();

env = new TwoDimen();

frame.getContentPane().add(env);

frame.setBounds(100, 100, 600, 600);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setResizable(false);

frame.setVisible(true);

int[] x = new int[] { 3, 6, 20, 15 };

int[] y = new int[] { 3, 20, 3, 18 };

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

if (i < x.length - 1)

edgeFillOnce(x[i], y[i], x[i + 1], y[i + 1]);

else

edgeFillOnce(x[i], y[i], x[0], y[0]);

}

}

private void edgeFillOnce(int x1, int y1, int x2, int y2) {

int k, i, j;

float x, y, dx, dy;

k = Math.abs(x2 - x1);

if (Math.abs(y2 - y1) > k) {

k = Math.abs(y2 - y1);

}

dx = (float) (x2 - x1) / k;

dy = (float) (y2 - y1) / k;

x = (float) x1;

y = (float) y1;

for (i = 0; i < k+1; i++) {

// env.drawPoint((int)(x+0.5), (int)(y+0.5));

for (j = (int)

五、java远程调用，具体实现？

1、使用java代码通过ssh登陆linux并执行命令，正常情况下sshd服务都会有，知道用户密码就可以使用这种方式了。

2、要在远程linux服务器上执行命令，可以在linux服务器上启动一个服务做执行脚本的代理，不断接受来自你这个项目发来的脚本信息，然后执行，再把结果返回给你项目中去。

第一种：以消息队列的方式发送这些脚本信息，linux代理不断接受，并返回结果。项目同时要不断接受结果。

第二种：项目中产生的脚本，直接记录到数据库，linux上的代理访问这个数据库，获取脚本信息，并将执行结果写入数据库。项目中轮询执行结果。上面我说的消息队列可以采用activemq，或者rabbitmq这些。命令执行，java中直接Runtime.getRuntime().exec(command);就行了。

六、java中怎么实现定时功能？

我们可以使用Timer和TimerTask类在java中实现定时任务，详细说明如下：

1、基础知识java.util.Timer一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。此类是线程安全的：多个线程可以共享单个 Timer 对象而无需进行外部同步。java.util.TimerTask由 Timer 安排为一次执行或重复执行的任务。

2、示例代码该示例实现这样一个功能，在系统运行期间，每30分钟，系统自动检查连接池中的可用连接数，并输出到日志中。首先创建一个需要定时执行的任务类，这个任务类需要继承TimerTask，然后重写run()方法，run()方法体中的代码就是定时需要执行的操作，在本demo中，就是获取连接池中当前可用连接数，并输出到日志中，具体实现代码如下：public class TaskAvailableConnectNumber extends TimerTask { private Logger log = Logger.getLogger(TaskAvailableConnectNumber.class); private ConnectionPool pool=ConnectionPool.getInstance(); @Override publicvoid run() { log.debug("当前连接池中可用连接数"+pool.getAvailableConnectNumber()); }}下面定义一个监听器，负责在应用服务器启动时打开定时器，监听器需要实现ServletContextListener接口，并重写其中的contextInitialized()和contextDestroyed()方法，代码如下：public class OnLineListener implements ServletContextListener{ private Logger log = Logger.getLogger(OnLineListener.class); Timer timer = null; //在应用服务器启动时，会执行该方法 publicvoid contextInitialized(ServletContextEvent arg0) { //创建一个定时器，用于安排需要定时执行的任务。 timer = new Timer(); //为定时器安排需要定时执行的任务，该任务就是前面创建的任务类TaskAvailableConnectNumber，并指定该任务每30分钟执行一次。 timer.schedule(new TaskAvailableConnectNumber(), 0, 30*60*1000); log.debug("启动定时器"); } //应用服务器关闭时，会执行该方法，完成关闭定时器的操作。public void contextDestroyed(ServletContextEvent arg0) { if(timer!=null){ timer.cancel();//关闭定时器 log.debug("-----定时器销毁--------"); } }}监听器要想正常运行，需要在web.xml文件中进行配置，配置信息如下：<!-- 监听器配置开始 --> <listener> <listener-class> cn.sdfi.listen.OnLineListener </listener-class> </listener><!-- 监听器配置结束 -->以上步骤完成后，一个简单的定时器就算开发完成了。

七、JAVA如何用队列实现并发？

如果是抢资源，在不作弊的情况下 按照先来先得的规则 ，那么比较简单的实现就是队列 ，不管请求的并发多高，如果用线程来实现为用户服务，也就是说 来一个人请求资源那么就启动一个线程，那CPU执行线程总是有顺序的，比如 当前三个人（路人甲路人乙路人丙）请求A资源 ，那服务端就起了三个线程为这三个人服务，假设 这三个人不太幸运在请求的时候没有及时的获得CPU时间片，那么他们三个相当于公平竞争CPU资源，而CPU选择运行线程是不确定顺序的 ，又假设 选中了路人丙的线程运行那么将其放入队列就好了,路人乙，路人丙以此类推 ，那可能会想为什么不及时的处理呢 ，因为后续的操作可能是耗时操作对于线程的占用时间较长那请求资源的人多了服务端就可能挂了

八、Java中如何实现数字水印？

直接在图片上画呗，导入一张背景图片，在背景图片上画一个水印用graphics g，也就是frame的paint还是draw方法就可以实现

九、如何使用Java实现单链表？

单链表结构：

Java中单链表采用Node实体类类标识，其中data为存储的数据，next为下一个节点的指针：

package com.algorithm.link;

/**

* 链表结点的实体类

*

*/

public class Node {

Node next = null;//下一个结点

int data;//结点数据

public Node(int data){

this.data = data;

}

}

链表常见操作：

package com.algorithm.link;

import java.util.Hashtable;

/**

* 单链表常见算法

*

*/

public class MyLinkedList {

/**链表的头结点*/

Node head = null;

/**

* 链表添加结点:

* 找到链表的末尾结点，把新添加的数据作为末尾结点的后续结点

* @param data

*/

public void addNode(int data){

Node newNode = new Node(data);

if(head == null){

head = newNode;

return;

}

Node temp = head;

while(temp.next != null){

temp = temp.next;

}

temp.next = newNode;

}

/**

* 链表删除结点:

* 把要删除结点的前结点指向要删除结点的后结点，即直接跳过待删除结点

* @param index

* @return

*/

public boolean deleteNode(int index){

if(index<1 || index>length()){//待删除结点不存在

return false;

}

if(index == 1){//删除头结点

head = head.next;

return true;

}

Node preNode = head;

Node curNode = preNode.next;

int i = 1;

while(curNode != null){

if(i==index){//寻找到待删除结点

preNode.next = curNode.next;//待删除结点的前结点指向待删除结点的后结点

return true;

}

//当先结点和前结点同时向后移

preNode = preNode.next;

curNode = curNode.next;

i++;

}

return true;

}

/**

* 求链表的长度

* @return

*/

public int length(){

int length = 0;

Node curNode = head;

while(curNode != null){

length++;

curNode = curNode.next;

}

return length;

}

/**

* 链表结点排序,并返回排序后的头结点:

* 选择排序算法,即每次都选出未排序结点中最小的结点，与第一个未排序结点交换

* @return

*/

public Node linkSort(){

Node curNode = head;

while(curNode != null){

Node nextNode = curNode.next;

while(nextNode != null){

if(curNode.data > nextNode.data){

int temp = curNode.data;

curNode.data = nextNode.data;

nextNode.data = temp;

}

nextNode = nextNode.next;

}

curNode = curNode.next;

}

return head;

}

/**

* 打印结点

*/

public void printLink(){

Node curNode = head;

while(curNode !=null){

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

curNode = curNode.next;

}

System.out.println();

}

/**

* 去掉重复元素:

* 需要额外的存储空间hashtable，调用hashtable.containsKey()来判断重复结点

*/

public void distinctLink(){

Node temp = head;

Node pre = null;

Hashtable<Integer, Integer> hb = new Hashtable<Integer, Integer>();

while(temp != null){

if(hb.containsKey(temp.data)){//如果hashtable中已存在该结点，则跳过该结点

pre.next = temp.next;

}else{//如果hashtable中不存在该结点，将结点存到hashtable中

hb.put(temp.data, 1);

pre=temp;

}

temp = temp.next;

}

}

/**

* 返回倒数第k个结点,

* 两个指针，第一个指针向前移动k-1次，之后两个指针共同前进，

* 当前面的指针到达末尾时，后面的指针所在的位置就是倒数第k个位置

* @param k

* @return

*/

public Node findReverNode(int k){

if(k<1 || k>length()){//第k个结点不存在

return null;

}

Node first = head;

Node second = head;

for(int i=0; i<k-1; i++){//前移k-1步

first = first.next;

}

while(first.next != null){

first = first.next;

second = second.next;

}

return second;

}

/**

* 查找正数第k个元素

*/

public Node findNode(int k){

if(k<1 || k>length()){//不合法的k

return null;

}

Node temp = head;

for(int i = 0; i<k-1; i++){

temp = temp.next;

}

return temp;

}

/**

* 反转链表，在反转指针钱一定要保存下个结点的指针

*/

public void reserveLink(){

Node curNode = head;//头结点

Node preNode = null;//前一个结点

while(curNode != null){

Node nextNode = curNode.next;//保留下一个结点

curNode.next = preNode;//指针反转

preNode = curNode;//前结点后移

curNode = nextNode;//当前结点后移

}

head = preNode;

}

/**

* 反向输出链表，三种方式：

* 方法一、先反转链表，再输出链表，需要链表遍历两次

* 方法二、把链表中的数字放入栈中再输出，需要维护额外的栈空间

* 方法三、依据方法2中栈的思想，通过递归来实现，递归起始就是将先执行的数据压入栈中，再一次出栈

*/

public void reservePrt(Node node){

if(node != null){

reservePrt(node.next);

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

}

}

/**

* 寻找单链表的中间结点：

* 方法一、先求出链表的长度，再遍历1/2链表长度，寻找出链表的中间结点

* 方法二、：

* 用两个指针遍历链表，一个快指针、一个慢指针，

* 快指针每次向前移动2个结点，慢指针一次向前移动一个结点，

* 当快指针移动到链表的末尾，慢指针所在的位置即为中间结点所在的位置

*/

public Node findMiddleNode(){

Node slowPoint = head;

Node quickPoint = head;

//quickPoint.next == null是链表结点个数为奇数时，快指针已经走到最后了

//quickPoint.next.next == null是链表结点数为偶数时，快指针已经走到倒数第二个结点了

//链表结点个数为奇数时,返回的是中间结点；链表结点个数为偶数时，返回的是中间两个结点中的前一个

while(quickPoint.next != null && quickPoint.next.next != null){

slowPoint = slowPoint.next;

quickPoint = quickPoint.next.next;

}

return slowPoint;

}

/**

* 判断链表是否有环：

* 设置快指针和慢指针，慢指针每次走一步，快指针每次走两步

* 当快指针与慢指针相等时，就说明该链表有环

*/

public boolean isRinged(){

if(head == null){

return false;

}

Node slow = head;

Node fast = head;

while(fast.next != null && fast.next.next != null){

slow = slow.next;

fast = fast.next.next;

if(fast == slow){

return true;

}

}

return false;

}

/**

* 返回链表的最后一个结点

*/

public Node getLastNode(){

Node temp = head;

while(temp.next != null){

temp = temp.next;

}

return temp;

}

/**

* 在不知道头结点的情况下删除指定结点：

* 删除结点的重点在于找出其前结点，使其前结点的指针指向其后结点，即跳过待删除结点

* 1、如果待删除的结点是尾结点，由于单链表不知道其前结点，没有办法删除

* 2、如果删除的结点不是尾结点，则将其该结点的值与下一结点交换，然后该结点的指针指向下一结点的后续结点

*/

public boolean deleteSpecialNode(Node n){

if(n.next == null){

return false;

}else{

//交换结点和其后续结点中的数据

int temp = n.data;

n.data = n.next.data;

n.next.data = temp;

//删除后续结点

n.next = n.next.next;

return true;

}

}

/**

* 判断两个链表是否相交：

* 两个链表相交，则它们的尾结点一定相同，比较两个链表的尾结点是否相同即可

*/

public boolean isCross(Node head1, Node head2){

Node temp1 = head1;

Node temp2 = head2;

while(temp1.next != null){

temp1 = temp1.next;

}

while(temp2.next != null){

temp2 = temp2.next;

}

if(temp1 == temp2){

return true;

}

return false;

}

/**

* 如果链表相交，求链表相交的起始点：

* 1、首先判断链表是否相交，如果两个链表不相交，则求相交起点没有意义

* 2、求出两个链表长度之差：len=length1-length2

* 3、让较长的链表先走len步

* 4、然后两个链表同步向前移动，没移动一次就比较它们的结点是否相等，第一个相等的结点即为它们的第一个相交点

*/

public Node findFirstCrossPoint(MyLinkedList linkedList1, MyLinkedList linkedList2){

//链表不相交

if(!isCross(linkedList1.head,linkedList2.head)){

return null;

}else{

int length1 = linkedList1.length();//链表1的长度

int length2 = linkedList2.length();//链表2的长度

Node temp1 = linkedList1.head;//链表1的头结点

Node temp2 = linkedList2.head;//链表2的头结点

int len = length1 - length2;//链表1和链表2的长度差

if(len > 0){//链表1比链表2长，链表1先前移len步

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

temp1 = temp1.next;

}

}else{//链表2比链表1长，链表2先前移len步

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

temp2 = temp2.next;

}

}

//链表1和链表2同时前移,直到找到链表1和链表2相交的结点

while(temp1 != temp2){

temp1 = temp1.next;

temp2 = temp2.next;

}

return temp1;

}

}

}

测试类：

package com.algorithm.link;

/**

* 单链表操作测试类

* @author bjh

*

*/

public class Test {

public static void main(String[] args){

MyLinkedList myLinkedList = new MyLinkedList();

//添加链表结点

myLinkedList.addNode(9);

myLinkedList.addNode(8);

myLinkedList.addNode(6);

myLinkedList.addNode(3);

myLinkedList.addNode(5);

//打印链表

myLinkedList.printLink();

/*//测试链表结点个数

System.out.println("链表结点个数为：" + myLinkedList.length());

//链表排序

Node head = myLinkedList.linkSort();

System.out.println("排序后的头结点为：" + head.data);

myLinkedList.printLink();

//去除重复结点

myLinkedList.distinctLink();

myLinkedList.printLink();

//链表反转

myLinkedList.reserveLink();

myLinkedList.printLink();

//倒序输出/遍历链表

myLinkedList.reservePrt(myLinkedList.head);

//返回链表的中间结点

Node middleNode = myLinkedList.findMiddleNode();

System.out.println("中间结点的数值为："+middleNode.data);

//判断链表是否有环

boolean isRinged = myLinkedList.isRinged();

System.out.println("链表是否有环：" + isRinged);

//将链表的最后一个结点指向头结点，制造有环的效果

Node lastNode = myLinkedList.getLastNode();

lastNode.next = myLinkedList.head;

isRinged = myLinkedList.isRinged();

System.out.println("链表是否有环：" + isRinged);

//删除指定结点

Node nk = myLinkedList.findReverNode(3);

System.out.println(nk.data);

myLinkedList.deleteSpecialNode(nk);

myLinkedList.printLink();

//链表是否相交

//新链表

MyLinkedList myLinkedList1 = new MyLinkedList();

myLinkedList1.addNode(1);

myLinkedList1.addNode(2);

myLinkedList1.printLink();

System.out.println("链表一和链表二是否相交"+myLinkedList.isCross(myLinkedList.head, myLinkedList1.head));

//把第二个链表从第三个结点开始接在第二个链表的后面，制造相交的效果

myLinkedList1.findNode(2).next = myLinkedList.findNode(3);

myLinkedList1.printLink();

System.out.println("链表一和链表二是否相交"+myLinkedList.isCross(myLinkedList.head, myLinkedList1.head));

*/

//如果两个链表相交求链表相交的结点的值

MyLinkedList myLinkedList1 = new MyLinkedList();

myLinkedList1.addNode(1);

myLinkedList1.addNode(2);

myLinkedList1.findNode(2).next = myLinkedList.findNode(3);

myLinkedList1.printLink();

Node n = myLinkedList1.findFirstCrossPoint(myLinkedList, myLinkedList1);

if(n == null){

System.out.println("链表不相交");

}else{

System.out.println("两个链表相交，第一个交点的数值为：" + n.data);

}

}

}

十、内存池的实现原理java？

内存池是一种用于管理和分配内存的机制，它可以提高内存分配和释放的效率，减少内存碎片化。在Java中，内存池的实现原理如下：

1. 预先分配内存块：内存池在启动时会预先分配一定数量的内存块，并将它们保存在一个数据结构中，如链表、数组等。

2. 内存块的分配和释放：当需要分配内存时，内存池会从预先分配的内存块中选择一个合适的块来分配，通常采用首次适应或最佳适应算法。当内存块不再使用时，它将被标记为空闲状态，并返回到内存池中供下次分配使用。

3. 内存块的复用：内存池会尽量重复使用已分配的内存块，而不是频繁地向操作系统申请新的内存。这可以减少内存分配和释放的开销，提高程序的性能。

4. 内存块的管理：内存池还会对内存块进行管理，包括记录内存块的分配情况、大小等信息，以便于高效地分配和释放内存。

通过使用内存池，Java程序可以减少频繁的内存分配和释放操作，提高内存的利用率和性能。在实际应用中，可以使用Java的内存池框架，如Apache Commons Pool或Google Guava的对象池，来方便地实现内存池功能。