java

连接超时，看看你数据库服务打开没有，代码对不对。

只要在detail的参数里加上一句话就行了，把这个job设置成有状态的job<property name="concurrent" value="false" /> 扩展：通过concurrent属性指定任务的类型，默认情况下封装为无状态的任务，如果希望目标封装为有状态的任务，仅需要将concurrent设置为false就可以了。Spring通过名为concurrent的属性指定任务的类型，能够更直接地描述到任务执行的方式（有状态的任务不能并发执行，无状态的任务可并发执行）

a＞bc c＞d

把这句：Thread.yield();去掉试试

用foreach遍历集合或数组时，修改集合的值会报并发修改异常，建议用for循环

ThreadPoolExecutor 是线程池， 这里的错误说明线程池中的某个线程出现问题而被终止，但不会影响其他线程以及主线程。

1.java并发编程是什么 1， 保证线程安全的三种方法： a， 不要跨线程访问共享变量b， 使共享变量是final类型的c， 将共享变量的操作加上同步 2， 一开始就将类设计成线程安全的， 比在后期重新修复它，更容易。 3， 编写多线程程序， 首先保证它是正确的， 其次再考虑性能。 4， 无状态或只读对象永远是线程安全的。 5， 不要将一个共享变量 *** 在多线程环境下（无同步或不可变性保护） 6， 多线程环境下的延迟加载需要同步的保护， 因为延迟加载会造成对象重复实例化 7， 对于volatile声明的数值类型变量进行运算， 往往是不安全的（volatile只能保证可见性，不能保证原子性）。 详见volatile原理与技巧中， 脏数据问题讨论。 8， 当一个线程请求获得它自己占有的锁时（同一把锁的嵌套使用）， 我们称该锁为可重入锁。在jdk1。5并发包中， 提供了可重入锁的java实现-ReentrantLock。 9， 每个共享变量，都应该由一个唯一确定的锁保护。 创建与变量相同数目的ReentrantLock， 使他们负责每个变量的线程安全。 10，虽然缩小同步块的范围， 可以提升系统性能。 但在保证原子性的情况下， 不可将原子操作分解成多个synchronized块。 11， 在没有同步的情况下， 编译器与处理器运行时的指令执行顺序可能完全出乎意料。 原因是， 编译器或处理器为了优化自身执行效率， 而对指令进行了的重排序（reordering）。 12， 当一个线程在没有同步的情况下读取变量， 它可能会得到一个过期值， 但是至少它可以看到那个线程在当时设定的一个真实数值。 而不是凭空而来的值。 这种安全保证， 称之为最低限的安全性（out-of-thin-air safety） 在开发并发应用程序时， 有时为了大幅度提高系统的吞吐量与性能， 会采用这种无保障的做法。 但是针对， 数值的运算， 仍旧是被否决的。 13, volatile变量，只能保证可见性， 无法保证原子性。 14， 某些耗时较长的网络操作或IO， 确保执行时， 不要占有锁。 15， 发布（publish）对象， 指的是使它能够被当前范围之外的代码所使用。 （引用传递）对象逸出（escape）， 指的是一个对象在尚未准备好时将它发布。 原则： 为防止逸出， 对象必须要被完全构造完后， 才可以被发布（最好的解决方式是采用同步） this关键字引用对象逸出 例子： 在构造函数中， 开启线程， 并将自身对象this传入线程， 造成引用传递。 而此时， 构造函数尚未执行完， 就会发生对象逸出了。 16， 必要时， 使用ThreadLocal变量确保线程封闭性（封闭线程往往是比较安全的， 但一定程度上会造成性能损耗）封闭对象的例子在实际使用过程中， 比较常见， 例如 hibernate openSessionInView机制， jdbc的connection机制。 17， 单一不可变对象往往是线程安全的（复杂不可变对象需要保证其内部成员变量也是不可变的）良好的多线程编程习惯是： 将所有的域都声明为final， 除非它们是可变的。 2.Java线程并发协作是什么 线程发生死锁可能性很小，即使看似可能发生死锁的代码，在运行时发生死锁的可能性也是小之又小。 发生死锁的原因一般是两个对象的锁相互等待造成的。 在《Java线程：线程的同步与锁》一文中，简述死锁的概念与简单例子，但是所给的例子是不完整的，这里给出一个完整的例子。 /** * Java线程：并发协作-死锁 * * @author Administrator 2009-11-4 22:06:13 */ public class Test { public static void main(String[] args) { DeadlockRisk dead = new DeadlockRisk(); MyThread t1 = new MyThread(dead, 1, 2); MyThread t2 = new MyThread(dead, 3, 4); MyThread t3 = new MyThread(dead, 5, 6); MyThread t4 = new MyThread(dead, 7, 8); t1。 start(); t2。 start(); t3。start(); t4。 start(); } } class MyThread extends Thread { private DeadlockRisk dead; private int a, b; MyThread(DeadlockRisk dead, int a, int b) { this。 dead = dead; this。 a = a; this。b = b; } @Override public void run() { dead。 read(); dead。write(a, b); } } class DeadlockRisk { private static class Resource { public int value; }。 3.如何学习Java高并发 1.学习 *** 并发框架的使用，如ConcurrentHashMAP,CopyOnWriteArrayList/Set等2.几种并发锁的使用以及线程同步与互斥，如ReentainLock,synchronized,Lock,CountDownLatch,Semaphore等3.线程池如Executors,ThreadPoolExecutor等4.Runable,Callable,RescureTask,Future,FutureTask等5.Fork-Join框架以上基本包含完了，如有缺漏请原谅。 4.并发编程的Java抽象有哪些呢 一、机器和OS级别抽象 （1）冯诺伊曼模型 经典的顺序化计算模型，貌似可以保证顺序化一致性，但是没有哪个现代的多处理架构会提供顺序一致性，冯氏模型只是现代多处理器行为的模糊近似。 这个计算模型，指令或者命令列表改变内存变量直接契合命令编程泛型，它以显式的算法为中心，这和声明式编程泛型有区别。 就并发编程来说，会显著的引入时间概念和状态依赖 所以所谓的函数式编程可以解决其中的部分问题。 （2）进程和线程 进程抽象运行的程序，是操作系统资源分配的基本单位，是资源cpu，内存，IO的综合抽象。 线程是进程控制流的多重分支，它存在于进程里，是操作系统调度的基本单位，线程之间同步或者异步执行，共享进程的内存地址空间。 （3）并发与并行 并发，英文单词是concurrent，是指逻辑上同时发生，有人做过比喻，要完成吃完三个馒头的任务，一个人可以这个馒头咬一口，那个馒头咬一口，这样交替进行，最后吃完三个馒头，这就是并发，因为在三个馒头上同时发生了吃的行为，如果只是吃完一个接着吃另一个，这就不是并发了，是排队，三个馒头如果分给三个人吃，这样的任务完成形式叫并行，英文单词是parallel。 回到计算机概念，并发应该是单CPU时代或者单核时代的说法，这个时候CPU要同时完成多任务，只能用时间片轮转，在逻辑上同时发生，但在物理上是串行的。 现在大多数计算机都是多核或者多CPU，那么现在的多任务执行方式就是物理上并行的。 为了从物理上支持并发编程，CPU提供了相应的特殊指令，比如原子化的读改写，比较并交换。 （4）平台内存模型 在可共享内存的多处理器体系结构中，每个处理器都有它自己的缓存，并且周期性的与主存同步，为什么呢？因为处理器通过降低一致性来换取性能，这和CAP原理通过降低一致性来获取伸缩性有点类似，所以大量的数据在CPU的寄存器中被计算，另外CPU和编译器为了性能还会乱序执行，但是CPU会提供存储关卡指令来保证存储的同步，各种平台的内存模型或者同步指令可能不同，所以这里必须介入对内存模型的抽象，JMM就是其中之一。 二、编程模型抽象 （1）基于线程模型 （2）基于Actor模型 （3）基于STM软件事务内存 …… Java体系是一个基于线程模型的本质编程平台，所以我们主要讨论线程模型。 三、并发单元抽象 大多数并发应用程序都是围绕执行任务进行管理的，任务是抽象，离散的工作单元，所以编写并发程序，首要工作就是提取和分解并行任务。 一旦任务被抽象出来，他们就可以交给并发编程平台去执行，同时在任务抽象还有另一个重要抽象，那就是生命周期，一个任务的开始，结束，返回结果，都是生命周期中重要的阶段。 那么编程平台必须提供有效安全的管理任务生命周期的API。 四、线程模型 线程模型是Java的本质模型，它无所不在，所以Java开发必须搞清楚底层线程调度细节，不搞清楚当然就会有struts1,struts2的原理搞不清楚的基本灾难（比如在struts2的action中塞入状态，把struts2的action配成单例）。 用线程来抽象并发编程，是比较低级别的抽象，所以难度就大一些，难度级别会根据我们的任务特点有以下几个类别 （1）任务非常独立，不共享，这是最理想的情况，编程压力为0。 (2)共享数据，压力开始增大，必须引入锁，Volatile变量，问题有活跃度和性能危险。 （3）状态依赖，压力再度增大，这时候我们基本上都是求助jdk 提供的同步工具。 五、任务执行 任务是一个抽象体，如果被抽象了出来，下一步就是交给编程平台去执行，在Java中，描述任务的一个基本接口是Runnable，可是这个抽象太有限了，它不能返回值和抛受检查异常，所以Jdk5。 0有另外一个高级抽象Callable。 任务的执行在Jdk中也是一个底级别的Thread，线程有好处，但是大量线程就有大大的坏处，所以如果任务量很多我们并不能就创建大量的线程去服务这些任务，那么Jdk5。 0在任务执行上做了抽象，将任务和任务执行隔离在接口背后，这样我们就可以引入比如线程池的技术来优化执行，优化线程的创建。 任务是有生命周期的，所以Jdk5。 0提供了Future这个对象来描述对象的生命周期，通过这个future可以取到任务的结果甚至取消任务。 六、锁 当然任务之间共享了数据，那么要保证数据的安全，必须提供一个锁机制来协调状态，锁让数据访问原子，但是引入了串行化，降低了并发度，锁是降低程序伸缩性的原罪，锁是引入上下文切换的主要原罪，锁是引入死锁，活锁，优先级倒置的绝对原罪，但是又不能没有锁，在Java中，锁是一个对象，锁提供原子和内存可见性，Volatile变量提供内存可见性不提供原子，原子变量提供可见性和原子，通过原子变量可以构建无锁算法和无锁数据结构，但是这需要高高手才可以办到。 5.Java高并发入门要怎么学习 1、如果不使用框架，纯原生Java编写，是需要了解Java并发编程的，主要就是学习Doug Lea开发的那个java.util.concurrent包下面的API;2、如果使用框架，那么我的理解，在代码层面确实不会需要太多的去关注并发问题，反而是由于高并发会给系统造成很大压力，要在缓存、数据库操作上要多加考虑。 3、但是即使是使用框架，在工作中还是会用到多线程，就拿常见的CRUD接口来说，比如一个非常耗时的save接口，有多耗时呢？我们假设整个save执行完要10分钟，所以，在save的时候，就需要采用异步的方式，也就是单独用一个线程去save，然后直接给前端返回200。 6.Java如何进行并发多连接socket编程呢 Java多个客户端同时连接服务端，在现实生活中用得比较多。 同时执行多项任务，第一想到的当然是多线程了。下面用多线程来实现并发多连接。 import java。。 *; import java。io。 *; public class ThreadServer extends Thread { private Socket client; public ThreadServer(Socket c) { this。 client=c; } public void run() { try { BufferedReader in=new BufferedReader(new InputStreamReader(client。 getInputStream())); PrintWriter out=new PrintWriter(client。 getOutputStream()); Mutil User but can"t parallel while (true) { String str=in。 readLine(); System。out。 println(str); out。 println("has receive。 "); out。 flush(); if (str。equals("end")) break; } client。 close(); } catch (IOException ex) { } finally { } } public static void main(String[] args)throws IOException { ServerSocket server=new ServerSocket(8000); while (true) { transfer location change Single User or Multi User ThreadServer mu=new ThreadServer(server。 accept()); mu。 start(); } } }J。 7.如何掌握java多线程,高并发,大数据方面的技能 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换开销小。 （线程是cpu调度的最小单位）线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。多进程是指操作系统能同时运行多个任务（程序）。 多线程是指在同一程序中有多个顺序流在执行。在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口.（其实准确来讲，应该有三种，还有一种是实现Callable接口，并与Future、线程池结合使用。 8.java工程师需要掌握哪些知识 1.Core Java，就是Java基础、JDK的类库，很多童鞋都会说，JDK我懂，但是懂还不足够，知其然还要知其所以然，JDK的源代码写的非常好，要经常查看，对使用频繁的类，比如String， *** 类（List,Map,Set）等数据结构要知道它们的实现，不同的 *** 类有什么区别，然后才能知道在一个具体的场合下使用哪个 *** 类更适合、更高效，这些内容直接看源代码就OK了2.多线程并发编程，现在并发几乎是写服务端程序必须的技术，那对Java中的多线程就要有足够的熟悉，包括对象锁机制、synchronized关键字，concurrent包都要非常熟悉，这部分推荐你看看《Java并发编程实践》这本书，讲解的很详细3.I/O,Socket编程，首先要熟悉Java中Socket编程，以及I/O包，再深入下去就是Java NIO，再深入下去是操作系统底层的Socket实现，了解Windows和Linux中是怎么实现socket的4.JVM的一些知识，不需要熟悉，但是需要了解，这是Java的本质，可以说是Java的母体， 了解之后眼界会更宽阔，比如Java内存模型（会对理解Java锁、多线程有帮助）、字节码、JVM的模型、各种垃圾收集器以及选择、JVM的执行参数（优化JVM）等等，这些知识在《深入Java虚拟机》这本书中都有详尽的解释，或者去oracle网站上查看具体版本的JVM规范.5.一些常用的设计模式，比如单例、模板方法、代理、适配器等等，以及在Core Java和一些Java框架里的具体场景的实现，这个可能需要慢慢积累，先了解有哪些使用场景，见得多了，自己就自然而然会去用。 6.常用数据库（Oracle、MySQL等）、SQL语句以及一般的优化7.JavaWeb开发的框架，比如Spring、iBatis等框架，同样他们的原理才是最重要的，至少要知道他们的大致原理。8.其他一些有名的用的比较多的开源框架和包，ty网络框架，Apache mon的N多包，Google的Guava等等，也可以经常去Github上找一些代码看看。 暂时想到的就这么多吧，1-4条是Java基础，全部的这些知识没有一定的时间积累是很难搞懂的，但是了解了之后会对Java有个彻底的了解，5和6是需要学习的额外技术，7-8是都是基于1-4条的，正所谓万变不离其宗，前4条就是Java的灵魂所在，希望能对你有所帮助9.（补充）学会使用Git。如果你还在用SVN的话，赶紧投入Git的怀抱吧。 9.java 多线程的并发到底是什么意思 一、多线程1、操作系统有两个容易混淆的概念，进程和线程。 进程：一个计算机程序的运行实例，包含了需要执行的指令；有自己的独立地址空间，包含程序内容和数据；不同进程的地址空间是互相隔离的；进程拥有各种资源和状态信息，包括打开的文件、子进程和信号处理。线程：表示程序的执行流程，是CPU调度执行的基本单位；线程有自己的程序计数器、寄存器、堆栈和帧。 同一进程中的线程共用相同的地址空间，同时共享进进程锁拥有的内存和其他资源。2、Java标准库提供了进程和线程相关的API，进程主要包括表示进程的java.lang.Process类和创建进程的java.lang.ProcessBuilder类；表示线程的是java.lang.Thread类，在虚拟机启动之后，通常只有Java类的main方法这个普通线程运行，运行时可以创建和启动新的线程；还有一类守护线程（damon thread），守护线程在后台运行，提供程序运行时所需的服务。 当虚拟机中运行的所有线程都是守护线程时，虚拟机终止运行。3、线程间的可见性：一个线程对进程 *** 享的数据的修改，是否对另一个线程可见可见性问题：a、CPU采用时间片轮转等不同算法来对线程进行调度[java] view plaincopypublic class IdGenerator{ private int value = 0; public int getNext(){ return value++； } } 对于IdGenerator的getNext（)方法，在多线程下不能保证返回值是不重复的：各个线程之间相互竞争CPU时间来获取运行机会，CPU切换可能发生在执行间隙。 以上代码getNext（)的指令序列：CPU切换可能发生在7条指令之间，多个getNext的指令交织在一起。

/*** 普通thread* 这是最常见的，创建一个thread，然后让它在while循环里一直运行着，* 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：* @author GT**/public class Task1 {public static void main(String[] args) {// run in a secondfinal long timeInterval = 1000;Runnable runnable = new Runnable() {public void run() {while (true) {// ------- code for task to runSystem.out.println("Hello !!");// ------- ends heretry {Thread.sleep(timeInterval);} catch (InterruptedException e) {e.printStackTrace();}}}};Thread thread = new Thread(runnable);thread.start();}} [java] view plain copyimport java.util.Timer;import java.util.TimerTask;/**** 于第一种方式相比，优势 1>当启动和去取消任务时可以控制 2>第一次执行任务时可以指定你想要的delay时间** 在实现时，Timer类可以调度任务，TimerTask则是通过在run()方法里实现具体任务。 Timer实例可以调度多任务，它是线程安全的。* 当Timer的构造器被调用时，它创建了一个线程，这个线程可以用来调度任务。 下面是代码：** @author GT**/public class Task2 {public static void main(String[] args) {TimerTask task = new TimerTask() {@Overridepublic void run() {// task to run goes hereSystem.out.println("Hello !!!");}};Timer timer = new Timer();long delay = 0;long intevalPeriod = 1 * 1000;// schedules the task to be run in an intervaltimer.scheduleAtFixedRate(task, delay, intevalPeriod);} // end of main} [java] view plain copyimport java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;/***** ScheduledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。* 相比于上两个方法，它有以下好处：* 1>相比于Timer的单线程，它是通过线程池的方式来执行任务的* 2>可以很灵活的去设定第一次执行任务delay时间* 3>提供了良好的约定，以便设定执行的时间间隔** 下面是实现代码，我们通过ScheduledExecutorService#scheduleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间。*** @author GT**/public class Task3 {public static void main(String[] args) {Runnable runnable = new Runnable() {public void run() {// task to run goes hereSystem.out.println("Hello !!");}};ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();// 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间service.scheduleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);}}

ArrayList 是非线程安全的，这点已经在文档中指出来了。如果你想要一个线程安全的就用 CopyOnWriteArrayList。它在修改时把数据复制一份再来修改，因此后续修改不影响正在跑迭代的其它线程。如果你需要一个同步的就可以直接 List synchronizedList = Collections.synchronizedList(new ArrayList());每种实现类都有它的优势和缺点，按我们的需要选择一个合适的就可以了。

java.util.concurrent.Executors里有很多方法创建固定个数的线程池使用线程池应该可以吧

有必要，因为get方法会一直等待资源返回，可以用isDone判断 Future.get()方法会一直阻塞，直到有数据返回，这时候isDone()是true.那么在get()之前判断isDone()是否有必要？如下： if (!future.isCancelled()) { HotelSearchResponse response = ...

有必要，因为get方法会一直等待资源返回，可以用isDone判断Future.get()方法会一直阻塞，直到有数据返回，这时候isDone()是true.那么在get()之前判断isDone()是否有必要？如下：if (!future.isCancelled()){ HotelSearchResponse response = null; if (future.isDone()) //这里有没有必要判断 { if (future.get() != null) { response = future.get(); } else { while (!future.isDone())//这个while有没有必要 { if (future.get() != null) { response = future.get(); } } }}

有个CopyOnWriteArrayList

java是编程语言里比较难学的一门，如果有心从事编程方向的工作，最好到专业机构学习并有更多的项目实践，更贴近市场，这样更有利于将来的发展。

因为String不是基础类型，而是对象，且是个Value Object(值对象)。你无法改变一个String对象的内容，你只能用另一个String的对象来替换原有的引用。例如：int i = 0;i++;//改变了原来的值String s = "xxx";//你无法改变原来的值s = "abc";//只能使用另外一个对象来替换因此atomic封装的String没有任何用处。atomic包是工具包，只是提供一个方便处理并发计数、改变标志的工具类，不能替代原来的基础类型和对象使用。

原子访问和更新的内存效果一般遵循以下可变规则：get 具有读取 volatile 变量的内存效果。set 具有写入（分配） volatile 变量的内存效果。weakCompareAndSet 以原子方式读取和有条件地写入变量，并对于该变量上的其他内存操作进行排序，否则将充当普通的非可变内存操作。compareAndSet 和所有其他的读取和更新操作（如 getAndIncrement）都有读取和写入 volatile 变量的内存效果。除了包含表示单个值的类之外，此包还包含 Updater 类，该类可用于获取任意选定类的任意选定 volatile 字段上的 compareAndSet 操作。AtomicReferenceFieldUpdater、AtomicIntegerFieldUpdater 和 AtomicLongFieldUpdater 是基于反射的实用工具，可以提供对关联字段类型的访问。它们主要用于原子数据结构中，该结构中同一节点（例如，树节点的链接）的几个 volatile 字段都独立受原子更新控制。这些类在如何以及何时使用原子更新方面具有更大的灵活性，但相应的弊端是基于映射的设置较为拙笨、使用不太方便，而且在保证方面也较差。AtomicIntegerArray、AtomicLongArray 和 AtomicReferenceArray 类进一步扩展了原子操作，对这些类型的数组提供了支持。这些类在为其数组元素提供 volatile 访问语义方面也引人注目，这对于普通数组来说是不受支持的。AtomicMarkableReference 类将单个布尔值与引用关联起来。例如，可以在数据结构内部使用此位，这意味着引用的对象在逻辑上已被删除。AtomicStampedReference 类将整数值与引用关联起来。例如，这可用于表示与更新系列对应的版本号。

你包引错了吧，让他自动引，如果还没有就是版本低了，要1.5还是1.6后面才有这个

即使是线程安全的集合，使用iterator()进行迭代都是不安全的，必须手动地进行同步，下面是JavaDoc的说明：Itisimperativethattheusermanuallysynchronizeonthereturnedmapwheniteratingoveranyofitscollectionviews:Mapm=Collections.synchronizedMap(newHashMap());Sets=m.keySet();//Needn"tbeinsynchronizedblocksynchronized(m){//Synchronizingonm,nots!Iteratori=s.iterator();//Mustbeinsynchronizedblockwhile(i.hasNext())foo(i.next());}如果不使用同步块进行迭代，当在迭代时，如果存在另外一个线程对集合进行删除或者添加元素，则会报ConcurrentModificationException

http://hi.baidu.com/zpsailor/blog/item/6918f41696e1d9084b90a737.html 这是我之前写的一个计算器程序，注解不多，但很简单易懂，希望对你有帮助，如果有什么问题你可以问我哈 邮箱zpsailor@163.com

强制转换为Double试试

for（int i=1；i<=1000;i++） {1+（-1）n次方*1/n+2}

import java.awt.*;import javax.swing.*;// Create a simple GUI windowpublic class TopLevelWindow {private static void createWindow() { java.util.Scanner sc = new java.util.Scanner(System.in); System.out.println("请输入第一个数："); double X = sc.nextDouble(); System.out.println("请输入第二个数 ："); double Y = sc.nextDouble(); System.out.println("X + Y = " + (X+Y)); System.out.println("X - Y = " + (X-Y));JFrame frame = new JFrame("计算器");frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);JLabel textLabel = new JLabel("X + Y = "+(X+Y)+" X - Y = "+ (X-Y),SwingConstants.CENTER);textLabel.setPreferredSize(new Dimension(300, 100));frame.getContentPane().add(textLabel, BorderLayout.CENTER);frame.setLocationRelativeTo(null);frame.pack();frame.setVisible(true);}public static void main(String[] args) {createWindow();}}

for(int i = 0; i < NUMBER_OF_ELEMENTS; i++){ for(int j=i+1; j<NUMBER_OF_ELEMENTS; j++){ if(string1[i] > string1[j]){ double n = string1[i]; string1[i] = string1[j]; string1[j] = n; } } }既然都定义了类，怎麽全用表态的定义的呢

第20行和第21行的输出代码写错了，j和k应该不要引号，才是输出j和k的值。第20行应该这样写： System.out.println(j);第21行应该这样写：System.out.println(k);改过之后即可。拓展内容：Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等

双精度精确到后十五位，所以是那个数，输出的时候格式化一下就行了，用printf()函数输出，格式列表就和c语言一样%0.1f

double

你好，程序如下： import java.io.*; public class b{ public static double sqrt(int i){ return Math.sqrt(i); } public static void main(String[] args) throws IOException { BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in)); System.out.println("请输入一个数字: "); String str = bfr.readLine(); int i = Integer.parseInt(str); double j = b.sqrt(i); System.out.println(i+"的开方等于: "+j); } } 有疑问提出 望采纳

求助java压缩图片存储大小的方法可以使用Draw这个类,通过改变像素来改变存储大小,实例如下:public_tatic_oolean_ompressPic(String_rcFilePath,_tring_escFilePath)_hrows_OException_____File_ile=_ull;____BufferedImage_rc=_ull;____FileOutputStream_ut=_ull;____ImageWriter_mgWrier;____ImageWriteParam_mgWriteParams;____//_付ㄐ赐计姆绞轿_jpg____imgWrier=("jpg").next();____imgWriteParams=_ew(________null);____//_褂醚顾,必须指定压缩方式为MODE_EXPLICIT____(_EXPLICIT);____//_饫镏付ㄑ顾醯某潭,参数qality是取值0~1范围内,____((float)1);____(_DISABLED);____ColorModel_olorModel=(new_ile(srcFilePath)).getColorModel();//();____//_付ㄑ顾跏笔褂玫纳誓J//____(new(//________colorModel,(16,16)));____(new(________colorModel,(16,16)));____try_______if(isBlank(srcFilePath))_________return_alse;______}_lse_________file=_ew_ile(srcFilePath);(());________src=(file);________out=_ew_ileOutputStream(descFilePath);________();________//_匦胂戎付_out值,才能调用write方法,_mageOutputStream可以通过任何________//_utputStream构造________((out));________//_饔_rite方法,就可以向输入流写图片________(null,_ew_IOImage(src,_ull,_ull),____________imgWriteParams);________();________();______}____}_atch(Exception_)_______e.printStackTrace();______return_alse;____}____return_rue;__}public_tatic_oolean_sBlank(String_tring)_____if(string==_ull_|()==0_|().equals(""))_______return_rue;____}____return_alse;__}javathumbnails压缩图片占用内存过大缩小即可。javathumbnails压缩图片占用内存过大的解决办法:1、打开压缩图网站,点击选择图片压缩按钮。2、图片上传前网站默认的压缩等级是70,图片上传后会自动按照当前设置的压缩等级进行压缩,如果压缩后的大小不合要求,可再次设置图片的宽高尺寸、压缩等级等参数,宽高留空时默认按照原图尺寸进行压缩,压缩等级越小则压缩后的图片体积越小,最后点击开始压缩按钮重新压缩。3、图片压缩后,我们就能明显的看到图片压缩后的体积缩小了很多,点击“保存图片”即可。java如何实现把一个大图片压缩到指定大小的图片且长宽比不变java要实现把一个大图片压缩到指定大小的图片且长宽比不变可以尝试以下操作:建立一个AffineTransformAffineTransform(doublem00,doublem10,doublem01,doublem11,doublem02,doublem12)转换矩阵,缩放比较简单(矩阵可以干很多事情,想做图像处理软件可以研究下)[x"][m00m01m02][x][m00x+m01y+m02][y"]=[m10m11m12][y]=[m10x+m11y+m12][1][001][1][1]10倍比较难算(根号10啊,当然你想算也行),9倍好点(9的开方是3),m00为1/3,m01为0,m02为0,m10为0,m11为1/3,m12为0。再建一个AffineTransformOp,把上面的转换传进去AffineTransformOp(AffineTransformxform,intinterpolationType)最后调用AffineTransformOp的BufferedImagefilter(BufferedImagesrc,BufferedImagedst),src传原图片,返回值就是想要的Image,注意是返回值,不是dst,不明白可以看下JavaAPI

java是怎么实现等比例缩小图片而不失真的啊？按照等比例的长宽进行缩放就可以了呀,就好像你打开一个图片,一般都有缩放功能,原理是一样的,等比例的缩放,关键像素还是存在的。java如何实现把一个大图片压缩到指定大小的图片且长宽比不变也就是图片压缩,可以不修改任何大小的压缩(速度快),也可等比例修改大小压缩(较慢)下面这是一段等比例缩小图片的方法。publicStringcompressPic(StringinputDir,StringoutputDir,StringinputFileName,StringoutputFileName,intwidth,intheight,booleangp,Stringhzm){try{if(!()){return"";}Imageimg=(image);//判断图片格式是否正确if((null)==-1){return"no";}else{intnewWidth;intnewHeight;//判断是否是等比缩放if(gp==true){//为等比缩放计算输出的图片宽度及高度doublerate1=((double)(null))/(double)width;doublerate2=((double)(null))/(double)height;//根据缩放比率大的进行缩放控制doublerate=rate1>rate2?rate1:rate2;newWidth=(int)(((double)(null))/rate);newHeight=(int)(((double)(null))/rate);}else{newWidth=(null);//输出的图片宽度newHeight=(null);//输出的图片高度}BufferedImagetag=newBufferedImage((int)newWidth,(int)newHeight,_INT_RGB);/**_SMOOTH的缩略算法生成缩略图片的平滑度的*优先级比速度高生成的图片质量比较好但速度慢*/Imageim=(newWidth,newHeight,_SMOOTH);().drawImage(im,0,0,null);FileOutputStreamout=newFileOutputStream(outputDir+outputFileName);//JPEGImageEncoder可适用于其他图片类型的转换JPEGImageEncoderencoder=(out);(tag);();}}catch(IOExceptionex){();}return"ok";}求助java压缩图片存储大小的方法可以使用Draw这个类,通过改变像素来改变存储大小,实例如下:public_tatic_oolean_ompressPic(String_rcFilePath,_tring_escFilePath)_hrows_OException_____File_ile=_ull;____BufferedImage_rc=_ull;____FileOutputStream_ut=_ull;____ImageWriter_mgWrier;____ImageWriteParam_mgWriteParams;____//_付ㄐ赐计姆绞轿_jpg____imgWrier=("jpg").next();____imgWriteParams=_ew(________null);____//_褂醚顾,必须指定压缩方式为MODE_EXPLICIT____(_EXPLICIT);____//_饫镏付ㄑ顾醯某潭,参数qality是取值0~1范围内,____((float)1);____(_DISABLED);____ColorModel_olorModel=(new_ile(srcFilePath)).getColorModel();//();____//_付ㄑ顾跏笔褂玫纳誓J//____(new(//________colorModel,(16,16)));____(new(________colorModel,(16,16)));____try_______if(isBlank(srcFilePath))_________return_alse;______}_lse_________file=_ew_ile(srcFilePath);(());________src=(file);________out=_ew_ileOutputStream(descFilePath);________();________//_匦胂戎付_out值,才能调用write方法,_mageOutputStream可以通过任何________//_utputStream构造________((out));________//_饔_rite方法,就可以向输入流写图片________(null,_ew_IOImage(src,_ull,_ull),____________imgWriteParams);________();________();______}____}_atch(Exception_)_______e.printStackTrace();______return_alse;____}____return_rue;__}public_tatic_oolean_sBlank(String_tring)_____if(string==_ull_|()==0_|().equals(""))_______return_rue;____}____return_alse;__}

釆纳就写

性，男性，女性

你可以查看一下SOAP，简单对象访问协议，采用这种方式来操作，看看可否。

java中manager类是变量及方法。根据查询公开信息显示，在java定义中，Manager类被定义，具有Employee所拥有的所有变量及方法。

* 回复内容中包含的链接未经审核，可能存在风险，暂不予完整展示！ 详解如下：https://help.a****.com/document_detail/29426.html?spm=5176.product29412.3.1.7dq3BJ

java.applet 提供创建 applet 所必需的类和 applet 用来与其 applet 上下文通信的类。 java.awt 包含用于创建用户界面和绘制图形图像的所有类。 java.awt.color 提供用于颜色空间的类。 java.awt.datatransfer 提供在应用程序之间和在应用程序内部传输数据的接口和类。 java.awt.dnd Drag 和 Drop 是一种直接操作动作，在许多图形用户界面系统中都会遇到它，它提供了一种机制，能够在两个与 GUI 中显示元素逻辑相关的实体之间传输信息。 java.awt.event 提供处理由 AWT 组件所激发的各类事件的接口和类。 java.awt.font 提供与字体相关的类和接口。 java.awt.geom 提供用于在与二维几何形状相关的对象上定义和执行操作的 Java 2D 类。 java.awt.im 提供输入方法框架所需的类和接口。 java.awt.im.spi 提供启用可以与 Java 运行时环境一起使用的输入方法开发的接口。 java.awt.image 提供创建和修改图像的各种类。 java.awt.image.renderable 提供用于生成与呈现无关的图像的类和接口。 java.awt.print 为通用的打印 API 提供类和接口。 java.beans 包含与开发 beans 有关的类，即基于 JavaBeansTM 架构的组件。 java.beans.beancontext 提供与 bean 上下文有关的类和接口。 java.io 通过数据流、序列化和文件系统提供系统输入和输出。 java.lang 提供利用 Java 编程语言进行程序设计的基础类。 java.lang.annotation 为 Java 编程语言注释设施提供库支持。 java.lang.instrument 提供允许 Java 编程语言代理检测运行在 JVM 上的程序的服务。 java.lang.management 提供管理接口，用于监视和管理 Java 虚拟机以及 Java 虚拟机在其上运行的操作系统。 java.lang.ref 提供了引用对象类，支持在某种程度上与垃圾回收器之间的交互。 java.lang.reflect 提供类和接口，以获得关于类和对象的反射信息。 java.math 提供用于执行任意精度整数算法 (BigInteger) 和任意精度小数算法 (BigDecimal) 的类。 java.net 为实现网络应用程序提供类。 java.nio 定义作为数据容器的缓冲区，并提供其他 NIO 包的概述。 java.nio.channels 定义了各种通道，这些通道表示到能够执行 I/O 操作的实体（如文件和套接字）的连接；定义了用于多路复用的、非阻塞 I/O 操作的选择器。 java.nio.channels.spi 用于 java.nio.channels 包的服务提供者类。 java.nio.charset 定义用来在字节和 Unicode 字符之间转换的 charset、解码器和编码器。 java.nio.charset.spi java.nio.charset 包的服务提供者类。 java.rmi 提供 RMI 包。 java.rmi.activation 为 RMI 对象激活提供支持。 java.rmi.dgc 为 RMI 分布式垃圾回收提供了类和接口。 java.rmi.registry 提供 RMI 注册表的一个类和两个接口。 java.rmi.server 提供支持服务器端 RMI 的类和接口。 java.security 为安全框架提供类和接口。 java.security.acl 此包中的类和接口已经被 java.security 包中的类取代。 java.security.cert 提供用于解析和管理证书、证书撤消列表 (CRL) 和证书路径的类和接口。 java.security.interfaces 提供的接口用于生成 RSA Laboratory Technical Note PKCS#1 中定义的 RSA（Rivest、Shamir 和 Adleman AsymmetricCipher 算法）密钥，以及 NIST 的 FIPS-186 中定义的 DSA（数字签名算法）密钥。 java.security.spec 提供密钥规范和算法参数规范的类和接口。 java.sql 提供使用 JavaTM 编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的 API。 java.text 提供以与自然语言无关的方式来处理文本、日期、数字和消息的类和接口。 java.text.spi java.text 包中类的服务提供者类。 java.util 包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。 java.util.concurrent 在并发编程中很常用的实用工具类。 java.util.concurrent.atomic 类的小工具包，支持在单个变量上解除锁的线程安全编程。 java.util.concurrent.locks 为锁和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。 java.util.jar 提供读写 JAR (Java ARchive) 文件格式的类，该格式基于具有可选清单文件的标准 ZIP 文件格式。 java.util.logging 提供 JavaTM 2 平台核心日志工具的类和接口。 java.util.prefs 此包允许应用程序存储并获取用户和系统首选项和配置数据。 java.util.regex 用于匹配字符序列与正则表达式指定模式的类。 java.util.spi java.util 包中类的服务提供者类。 java.util.zip 提供用于读写标准 ZIP 和 GZIP 文件格式的类。 javax.accessibility 定义了用户界面组件与提供对这些组件进行访问的辅助技术之间的协定。 javax.crypto 为加密操作提供类和接口。 javax.crypto.interfaces 根据 RSA Laboratories" PKCS #3 的定义，提供 Diffie-Hellman 密钥接口。 javax.crypto.spec 为密钥规范和算法参数规范提供类和接口。 javax.imageio Java Image I/O API 的主要包。 javax.imageio.event Java Image I/O API 的一个包，用于在读取和写入图像期间处理事件的同步通知。 javax.imageio.metadata 用于处理读写元数据的 Java Image I/O API 的包。 javax.imageio.plugins.bmp 包含供内置 BMP 插件使用的公共类的包。 javax.imageio.plugins.jpeg 支持内置 JPEG 插件的类。 javax.imageio.spi 包含用于 reader、writer、transcoder 和流的插件接口以及一个运行时注册表的 Java Image I/O API 包。 javax.imageio.stream Java Image I/O API 的一个包，用来处理从文件和流中产生的低级别 I/O。 javax.management 提供 Java Management Extensions 的核心类。 javax.management.loading 提供实现高级动态加载的类。 javax.management.modelmbean 提供了 ModelMBean 类的定义。 javax.management.monitor 提供 monitor 类的定义。 javax.management.openmbean 提供开放数据类型和 Open MBean 描述符类。 javax.management.relation 提供 Relation Service 的定义。 javax.management.remote 对 JMX MBean 服务器进行远程访问使用的接口。 javax.management.remote.rmi RMI 连接器是供 JMX Remote API 使用的一种连接器，后者使用 RMI 将客户端请求传输到远程 MBean 服务器。 javax.management.timer 提供对 Timer MBean（计时器 MBean）的定义。 javax.naming 为访问命名服务提供类和接口。 javax.naming.directory 扩展 javax.naming 包以提供访问目录服务的功能。 javax.naming.event 在访问命名和目录服务时提供对事件通知的支持。 javax.naming.ldap 提供对 LDAPv3 扩展操作和控件的支持。 javax.naming.spi 提供一些方法来动态地插入对通过 javax.naming 和相关包访问命名和目录服务的支持。 javax.net 提供用于网络应用程序的类。 javax.net.ssl 提供用于安全套接字包的类。 javax.print 为 JavaTM Print Service API 提供了主要类和接口。 javax.print.attribute 提供了描述 JavaTM Print Service 属性的类型以及如何分类这些属性的类和接口。 javax.print.attribute.standard 包 javax.print.attribute.standard 包括特定打印属性的类。 javax.print.event 包 javax.print.event 包含事件类和侦听器接口。 javax.rmi 包含 RMI-IIOP 的用户 API。 javax.rmi.CORBA 包含用于 RMI-IIOP 的可移植性 API。 javax.rmi.ssl 通过安全套接字层 (SSL) 或传输层安全 (TLS) 协议提供 RMIClientSocketFactory 和 RMIServerSocketFactory 的实现。 javax.security.auth 此包提供用于进行验证和授权的框架。 javax.security.auth.callback 此包提供与应用程序进行交互所必需的类，以便检索信息（例如，包括用户名和密码的验证数据）或显示信息（例如，错误和警告消息）。 javax.security.auth.kerberos 此包包含与 Kerberos 网络验证协议相关的实用工具类。 javax.security.auth.login 此包提供可插入的验证框架。 javax.security.auth.spi 此包提供用于实现可插入验证模块的接口。 javax.security.auth.x500 此包包含应该用来在 Subject 中存储 X500 Principal 和 X500 Private Crendentials 的类。 javax.security.cert 为公钥证书提供类。 javax.security.sasl 包含用于支持 SASL 的类和接口。 javax.sound.midi 提供用于 MIDI（音乐乐器数字接口）数据的 I/O、序列化和合成的接口和类。 javax.sound.midi.spi 在提供新的 MIDI 设备、MIDI 文件 reader 和 writer、或音库 reader 时提供服务提供者要实现的接口。 javax.sound.sampled 提供用于捕获、处理和回放取样的音频数据的接口和类。 javax.sound.sampled.spi 在提供新音频设备、声音文件 reader 和 writer，或音频格式转换器时，提供将为其创建子类的服务提供者的抽象类。 javax.sql 为通过 JavaTM 编程语言进行服务器端数据源访问和处理提供 API。 javax.sql.rowset JDBC RowSet 实现的标准接口和基类。 javax.sql.rowset.serial 提供实用工具类，允许 SQL 类型与 Java 编程语言数据类型之间的可序列化映射关系。 javax.sql.rowset.spi 第三方供应商在其同步提供者的实现中必须使用的标准类和接口。 javax.swing 提供一组“轻量级”（全部是 Java 语言）组件，尽量让这些组件在所有平台上的工作方式都相同。 javax.swing.border 提供围绕 Swing 组件绘制特殊边框的类和接口。 javax.swing.colorchooser 包含供 JColorChooser 组件使用的类和接口。 javax.swing.event 供 Swing 组件触发的事件使用。 javax.swing.filechooser 包含 JFileChooser 组件使用的类和接口。 javax.swing.plaf 提供一个接口和许多抽象类，Swing 用它们来提供自己的可插入外观功能。 javax.swing.plaf.basic 提供了根据基本外观构建的用户界面对象。 javax.swing.plaf.metal 提供根据 Java 外观（曾经代称为 Metal）构建的用户界面对象，Java 外观是默认外观。 javax.swing.plaf.multi 提供了组合两个或多个外观的用户界面对象。 javax.swing.plaf.synth Synth 是一个可更换皮肤 (skinnable) 的外观，在其中可委托所有绘制。 javax.swing.table 提供用于处理 javax.swing.JTable 的类和接口。 javax.swing.text 提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。 javax.swing.text.html 提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。 javax.swing.text.html.parser 提供默认的 HTML 解析器以及支持类。 javax.swing.text.rtf 提供一个类 (RTFEditorKit)，用于创建富文本格式（Rich-Text-Format）的文本编辑器。 javax.swing.tree 提供处理 javax.swing.JTree 的类和接口。 javax.swing.undo 允许开发人员为应用程序（例如文本编辑器）中的撤消/恢复提供支持。 javax.transaction 包含解组期间通过 ORB 机制抛出的三个异常。 javax.transaction.xa 提供定义事务管理器和资源管理器之间的协定的 API，它允许事务管理器添加或删除 JTA 事务中的资源对象（由资源管理器驱动程序提供）。 javax.xml 根据 XML 规范定义核心 XML 常量和功能。 javax.xml.bind 为包含解组、编组和验证功能的客户端应用程序提供运行时绑定框架。 javax.xml.bind.annotation 定义将 Java 程序元素定制成 XML 模式映射的注释。 javax.xml.bind.annotation.adapters XmlAdapter 及其规范定义的子类允许任意 Java 类与 JAXB 一起使用。 javax.xml.bind.attachment 此包由基于 MIME 的包处理器实现，该处理器能够解释并创建基于 MIME 的包格式的已优化的二进制数据。 javax.xml.bind.helpers 仅由 JAXB 提供者用于： 提供某些 javax.xml.bind 接口的部分默认实现。 javax.xml.bind.util 有用的客户端实用工具类。 javax.xml.crypto 用于 XML 加密的通用类。 javax.xml.crypto.dom javax.xml.crypto 包的特定于 DOM 的类。 javax.xml.crypto.dsig 用于生成和验证 XML 数字签名的类。 javax.xml.crypto.dsig.dom javax.xml.crypto.dsig 包特定于 DOM 的类。 javax.xml.crypto.dsig.keyinfo 用来解析和处理 KeyInfo 元素和结构的类。 javax.xml.crypto.dsig.spec XML 数字签名的参数类。 javax.xml.datatype XML/Java 类型映射关系。 javax.xml.namespace XML 名称空间处理。 javax.xml.parsers 提供允许处理 XML 文档的类。 javax.xml.soap 提供用于创建和构建 SOAP 消息的 API。 javax.xml.stream javax.xml.stream.events javax.xml.stream.util javax.xml.transform 此包定义了用于处理转换指令，以及执行从源到结果的转换的一般 API。 javax.xml.transform.dom 此包实现特定于 DOM 的转换 API。 javax.xml.transform.sax 此包实现特定于 SAX2 的转换 API。 javax.xml.transform.stax 提供特定于 StAX 的转换 API。 javax.xml.transform.stream 此包实现特定于流和 URI 的转换 API。 javax.xml.validation 此包提供了用于 XML 文档验证的 API。 javax.xml.ws 此包包含核心 JAX-WS API。 javax.xml.ws.handler 该包定义用于消息处理程序的 API。 javax.xml.ws.handler.soap 该包定义用于 SOAP 消息处理程序的 API。 javax.xml.ws.http 该包定义特定于 HTTP 绑定的 API。 javax.xml.ws.soap 该包定义特定于 SOAP 绑定的 API。 javax.xml.ws.spi 该包定义用于 JAX-WS 2.0 的 SPI。 javax.xml.xpath 此包提供了用于 XPath 表达式的计算和访问计算环境的 object-model neutral API。 org.ietf.jgss 此包提供一个框架，该框架允许应用程序开发人员通过利用统一的 API 使用一些来自各种基础安全机制（如 Kerberos）的安全服务，如验证、数据完整性和和数据机密性。 org.omg.CORBA 提供 OMG CORBA API 到 JavaTM 编程语言的映射，包括 ORB 类，如果已实现该类，则程序员可以使用此类作为全功能对象请求代理（Object Request Broker，ORB）。 org.omg.CORBA_2_3 CORBA_2_3 包定义对 Java[tm] Standard Edition 6 中现有 CORBA 接口所进行的添加。 org.omg.CORBA_2_3.portable 提供输入和输出值类型的各种方法，并包含 org/omg/CORBA/portable 包的其他更新。 org.omg.CORBA.DynAnyPackage 提供与 DynAny 接口一起使用的异常（InvalidValue、Invalid、InvalidSeq 和 TypeMismatch）。 org.omg.CORBA.ORBPackage 提供由 ORB.resolve_initial_references 方法抛出的异常 InvalidName，以及由 ORB 类中的动态 Any 创建方法抛出的异常 InconsistentTypeCode。 org.omg.CORBA.portable 提供可移植性层，即可以使一个供应商生成的代码运行在另一个供应商 ORB 上的 ORB API 集合。 org.omg.CORBA.TypeCodePackage 提供用户定义的异常 BadKind 和 Bounds，它们将由 TypeCode 类中的方法抛出。 org.omg.CosNaming 为 Java IDL 提供命名服务。 org.omg.CosNaming.NamingContextExtPackage 此包包含以下在 org.omg.CosNaming.NamingContextExt 中使用的类： AddressHelper StringNameHelper URLStringHelper InvalidAddress 包规范 有关 Java[tm] Platform, Standard Edition 6 ORB 遵守的官方规范的受支持部分的明确列表，请参阅 Official Specifications for CORBA support in Java[tm] SE 6。 org.omg.CosNaming.NamingContextPackage 此包包含 org.omg.CosNaming 包的 Exception 类。 org.omg.Dynamic 此包包含 OMG Portable Interceptor 规范 http://cgi.omg.org/cgi-bin/doc?ptc/2000-08-06 的第 21.9 小节中指定的 Dynamic 模块。 org.omg.DynamicAny 提供一些类和接口使得在运行时能够遍历与 any 有关联的数据值，并提取数据值的基本成分。 org.omg.DynamicAny.DynAnyFactoryPackage 此包包含 DynamicAny 模块的 DynAnyFactory 接口中的类和异常，该模块在 OMG The Common Object Request Broker: Architecture and Specification http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 的第 9.2.2 小节中指定。 org.omg.DynamicAny.DynAnyPackage 此包包含 DynAny 模块的 DynAnyFactory 接口中的类和异常，该模块在 OMG The Common Object Request Broker: Architecture and Specification http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 的第 9.2 小节中指定。 org.omg.IOP 此包包含在 OMG 文档 The Common Object Request Broker: Architecture and Specification http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 的 13.6.小节中指定的 IOP 模块。 org.omg.IOP.CodecFactoryPackage 此包包含 IOP::CodeFactory 接口中指定的异常（作为 Portable Interceptor 规范的一部分）。 org.omg.IOP.CodecPackage 此包根据 IOP::Codec IDL 接口定义生成。 org.omg.Messaging 此包包含 OMG Messaging Interceptor 规范 http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 中指定的 Messaging 模块。 org.omg.PortableInterceptor 提供一个注册 ORB 钩子 (hook) 的机制，通过这些钩子 ORB 服务可以截取执行 ORB 的正常流。 org.omg.PortableInterceptor.ORBInitInfoPackage 此包包含 OMG Portable Interceptor 规范 http://cgi.omg.org/cgi-bin/doc?ptc/2000-08-06 的第 21.7.2 小节中指定的 PortableInterceptor 模块的 ORBInitInfo 本地接口中的异常和 typedef。 org.omg.PortableServer 提供一些类和接口，用来生成跨多个供应商 ORB 的可移植应用程序的服务器端。 org.omg.PortableServer.CurrentPackage 提供各种方法实现，这些实现能够访问调用方法的对象的身份。 org.omg.PortableServer.POAManagerPackage 封装 POA 关联的处理状态。 org.omg.PortableServer.POAPackage 允许程序员构造可在不同 ORB 产品间移植的对象实现。 org.omg.PortableServer.portable 提供一些类和接口，用来生成跨多个供应商 ORB 的可移植应用程序的服务器端。 org.omg.PortableServer.ServantLocatorPackage 提供定位 servant 的类和接口。 org.omg.SendingContext 为值类型的编组提供支持。 org.omg.stub.java.rmi 包含用于 java.rmi 包中出现的 Remote 类型的 RMI-IIOP Stub。 org.w3c.dom 为文档对象模型 (DOM) 提供接口，该模型是 Java API for XML Processing 的组件 API。 org.w3c.dom.bootstrap org.w3c.dom.events org.w3c.dom.ls org.xml.sax 此包提供了核心 SAX API。 org.xml.sax.ext 此包包含适合的 SAX 驱动程序不一定支持的 SAX2 设施的接口。 org.xml.sax.helpers 此包包含“帮助器”类，其中包括对引导基于 SAX 的应用程序的支持。 想要书用上面的包都要弄明白才行

Map的接口Map－－－实现MapMap.Entry－－Map的内部类，描述Map中的按键/数值对。SortedMap---扩展Map，使按键保持升序排列下面以HashMap为例。public static void main(String args[]){HashMap hashmap = new HashMap();hashmap.put("Item0", "Value0");hashmap.put("Item1", "Value1");hashmap.put("Item2", "Value2");hashmap.put("Item3", "Value3");Set set = hashmap.entrySet();Iterator iterator = set.iterator();while (iterator.hasNext(){Map.Entry mapentry = (Map.Entry) iterator.next();System.out.println(mapentry.getkey() + "/" + mapentry.getValue());}}注意，这里Map的按键必须是唯一的，比如说不能有两个按键都为null。如果用过它，就会知道它的用处了。资料:java.util 中的集合类包含 Java 中某些最常用的类。 最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。 从概念上而言，您可以将 List 看作是具有数值键的 Map。 而实际上，除了 List 和 Map 都在定义 java.util 中外，两者并没有直接的联系。本文将着重介绍核心 Java 发行套件中附带的 Map，同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用 Map。了解Map 接口和方法Java 核心类中有很多预定义的 Map 类。 在介绍具体实现之前，我们先介绍一下 Map 接口本身，以便了解所有实现的共同点。 Map 接口定义了四种类型的方法，每个 Map 都包含这些方法。 下面，我们从两个普通的方法（表1）开始对这些方法加以介绍。表1： 覆盖的方法。 我们将这 Object 的这两个方法覆盖，以正确比较 Map 对象的等价性。equals(Object o)比较指定对象与此 Map 的等价性hashCode()返回此 Map 的哈希码Map 构建Map 定义了几个用于插入和删除元素的变换方法（表2）。表2： Map 更新方法： 可以更改 Map 内容。clear()从Map 中删除所有映射remove(Object key)从Map 中删除键和关联的值put(Object key, Object value)将指定值与指定键相关联clear()从Map 中删除所有映射putAll(Map t)将指定 Map 中的所有映射复制到此 map尽管您可能注意到，纵然假设忽略构建一个需要传递给 putAll() 的 Map 的开销，使用 putAll() 通常也并不比使用大量的 put() 调用更有效率，但 putAll() 的存在一点也不稀奇。 这是因为，putAll() 除了迭代 put() 所执行的将每个键值对添加到 Map 的算法以外，还需要迭代所传递的 Map 的元素。 但应注意，putAll() 在添加所有元素之前可以正确调整 Map 的大小，因此如果您未亲自调整 Map 的大小（我们将对此进行简单介绍），则 putAll() 可能比预期的更有效。查看Map迭代Map 中的元素不存在直接了当的方法。 如果要查询某个 Map 以了解其哪些元素满足特定查询，或如果要迭代其所有元素（无论原因如何），则您首先需要获取该 Map 的“视图”。 有三种可能的视图（参见表3）所有键值对 — 参见 entrySet()所有键 — 参见 keySet()所有值 — 参见 values()前两个视图均返回 Set 对象，第三个视图返回 Collection 对象。 就这两种情况而言，问题到这里并没有结束，这是因为您无法直接迭代 Collection 对象或 Set 对象。要进行迭代，您必须获得一个 Iterator 对象。 因此，要迭代 Map 的元素，必须进行比较烦琐的编码Iterator keyValuePairs = aMap.entrySet().iterator();Iterator keys = aMap.keySet().iterator();Iterator values = aMap.values().iterator();值得注意的是，这些对象（Set、Collection 和 Iterator）实际上是基础 Map 的视图，而不是包含所有元素的副本。 这使它们的使用效率很高。 另一方面，Collection 或 Set 对象的 toArray() 方法却创建包含 Map 所有元素的数组对象，因此除了确实需要使用数组中元素的情形外，其效率并不高。我运行了一个小测试（随附文件中的 Test1），该测试使用了 HashMap，并使用以下两种方法对迭代 Map 元素的开销进行了比较：int mapsize = aMap.size();Iterator keyValuePairs1 = aMap.entrySet().iterator();for (int i = 0; i < mapsize; i++){ Map.Entry entry = (Map.Entry) keyValuePairs1.next(); Object key = entry.getKey(); Object value = entry.getValue(); ...}Object[] keyValuePairs2 = aMap.entrySet().toArray();for (int i = 0; i < rem; i++) {{ Map.Entry entry = (Map.Entry) keyValuePairs2[i]; Object key = entry.getKey();Profilers in Oracle JDeveloperOracle JDeveloper 包含一个嵌入的监测器，它测量内存和执行时间，使您能够快速识别代码中的瓶颈。 我曾使用 Jdeveloper 的执行监测器监测 HashMap 的 containsKey() 和 containsValue() 方法，并很快发现 containsKey() 方法的速度比 containsValue() 方法慢很多（实际上要慢几个数量级！）。 （参见图1 和图2，以及随附文件中的 Test2 类）。 Object value = entry.getValue(); ...}此测试使用了两种测量方法： 一种是测量迭代元素的时间，另一种测量使用 toArray 调用创建数组的其他开销。 第一种方法（忽略创建数组所需的时间）表明，使用已从 toArray 调用中创建的数组迭代元素的速度要比使用 Iterator 的速度大约快 30%-60%。 但如果将使用 toArray 方法创建数组的开销包含在内，则使用 Iterator 实际上要快 10%-20%。 因此，如果由于某种原因要创建一个集合元素的数组而非迭代这些元素，则应使用该数组迭代元素。 但如果您不需要此中间数组，则不要创建它，而是使用 Iterator 迭代元素。表3： 返回视图的 Map 方法： 使用这些方法返回的对象，您可以遍历 Map 的元素，还可以删除 Map 中的元素。entrySet()返回Map 中所包含映射的 Set 视图。 Set 中的每个元素都是一个 Map.Entry 对象，可以使用 getKey() 和 getValue() 方法（还有一个 setValue() 方法）访问后者的键元素和值元素keySet()返回Map 中所包含键的 Set 视图。 删除 Set 中的元素还将删除 Map 中相应的映射（键和值）values()返回map 中所包含值的 Collection 视图。 删除 Collection 中的元素还将删除 Map 中相应的映射（键和值）访问元素表4 中列出了 Map 访问方法。Map 通常适合按键（而非按值）进行访问。 Map 定义中没有规定这肯定是真的，但通常您可以期望这是真的。 例如，您可以期望 containsKey() 方法与 get() 方法一样快。 另一方面，containsValue() 方法很可能需要扫描 Map 中的值，因此它的速度可能比较慢。表4： Map 访问和测试方法： 这些方法检索有关 Map 内容的信息但不更改 Map 内容。get(Object key)返回与指定键关联的值containsKey(Object key)如果Map 包含指定键的映射，则返回 truecontainsValue(Object value)如果此 Map 将一个或多个键映射到指定值，则返回 trueisEmpty()如果Map 不包含键-值映射，则返回 truesize()返回Map 中的键-值映射的数目对使用 containsKey() 和 containsValue() 遍历 HashMap 中所有元素所需时间的测试表明，containsValue() 所需的时间要长很多。 实际上要长几个数量级！ （参见图1 和图2，以及随附文件中的 Test2）。 因此，如果 containsValue() 是应用程序中的性能问题，它将很快显现出来，并可以通过监测您的应用程序轻松地将其识别。 这种情况下，我相信您能够想出一个有效的替换方法来实现 containsValue() 提供的等效功能。 但如果想不出办法，则一个可行的解决方案是再创建一个 Map，并将第一个 Map 的所有值作为键。

Map用于保存具有映射关系的数据，Map里保存着两组数据：key和value，它们都可以使任何引用类型的数据，但key不能重复。所以通过指定的key就可以取出对应的value。Map接口定义了如下常用的方法：1、void clear():删除Map中所以键值对。2、boolean containsKey(Object key):查询Map中是否包含指定key，如果包含则返回true。3、boolean containsValue(Object value):查询Map中是否包含指定value，如果包含则返回true。4、Set entrySet():返回Map中所包含的键值对所组成的Set集合，每个集合元素都是Map.Entry对象(Entry是Map的内部类)。5、Object get(Object key):返回指定key所对应的value，如Map中不包含key则返回null。6、boolean isEmpty():查询Map是否为空，如果空则返回true。7、Set keySet():返回该Map中所有key所组成的set集合。8、Object put(Object key,Object value):添加一个键值对，如果已有一个相同的key值则新的键值对覆盖旧的键值对。9、void putAll(Map m):将指定Map中的键值对复制到Map中。10、Object remove(Object key):删除指定key所对应的键值对，返回可以所关联的value，如果key不存在，返回null。11、int size():返回该Map里的键值对的个数。12、Collection values():返回该Map里所有value组成的Collection。Map中包含一个内部类：Entry。该类封装了一个键值对，它包含了三个方法：1、Object getKey():返回该Entry里包含的key值。2、Object getValeu():返回该Entry里包含的value值。3、Object setValue(V value):设置该Entry里包含的value值，并返回新设置的value值。HashMap和Hashtable实现类：HashMap与HashTable的区别：1、 同步性：Hashtable是同步的，这个类中的一些方法保证了Hashtable中的对象是线程安全的。而HashMap则是异步的，因此HashMap中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用HashMap是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销，从而提高效率。2、 值：HashMap可以让你将空值作为一个表的条目的key或value，但是Hashtable是不能放入空值的。HashMap最多只有一个key值为null，但可以有无数多个value值为null。注意：1、用作key的对象必须实现hashCode和equals方法。2、不能保证其中的键值对的顺序3、尽量不要使用可变对象作为它们的key值。 LinkedHashMap： 它的父类是HashMap，使用双向链表来维护键值对的次序，迭代顺序与键值对的插入顺序保持一致。LinkedHashMap需要维护元素的插入顺序，so性能略低于HashMap，但在迭代访问元素时有很好的性能，因为它是以链表来维护内部顺序。TreeMap: Map接口派生了一个SortMap子接口，SortMap的实现类为TreeMap。TreeMap也是基于红黑树对所有的key进行排序，有两种排序方式：自然排序和定制排序。Treemap的key以TreeSet的形式存储，对key的要求与TreeSet对元素的要求基本一致。1、Map.Entry firstEntry():返回最小key所对应的键值对，如Map为空，则返回null。2、Object firstKey():返回最小key，如果为空，则返回null。3、Map.Entry lastEntry():返回最大key所对应的键值对，如Map为空，则返回null。4、Object lastKey():返回最大key，如果为空，则返回null。5、Map.Entry higherEntry(Object key):返回位于key后一位的键值对，如果为空，则返回null。6、Map.Entry lowerEntry(Object key):返回位于key前一位的键值对，如果为空，则返回null。7、Object lowerKey(Object key):返回位于key前一位key值，如果为空，则返回null。8、NavigableMap subMap(Object fromKey,boolean fromlnclusive,Object toKey,boolean toInciusive):返回该Map的子Map，其key范围从fromKey到toKey。9、SortMap subMap(Object fromKey,Object toKey );返回该Map的子Map，其key范围从fromkey（包括）到tokey（不包括）。10、SortMap tailMap（Object fromkey ,boolean inclusive）:返回该Map的子Map，其key范围大于fromkey（是否包括取决于第二个参数）的所有key。11、 SortMap headMap（Object tokey ,boolean inclusive）:返回该Map的子Map，其key范围小于tokey（是否包括取决于第二个参数）的所有key。WeakHashMap： WeakHashMap与HashMap的用法基本相同，区别在于：后者的key保留对象的强引用，即只要HashMap对象不被销毁，其对象所有key所引用的对象不会被垃圾回收，HashMap也不会自动删除这些key所对应的键值对对象。但WeakHashMap的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被回收。WeakHashMap中的每个key对象保存了实际对象的弱引用，当回收了该key所对应的实际对象后，WeakHashMap会自动删除该key所对应的键值对。 public static void main(String[] args) { // TODO Auto-generated method stub WeakHashMap w1=new WeakHashMap(); //添加三个键值对，三个key都是匿名字符串，没有其他引用 w1 .put("语文", "良好"); w1 .put("数学", "及格"); w1 .put("英语", "中等"); w1 .put("java", "good");//该key是一个系统缓存的字符串对象

官方的非官方的Map事先有好几百个(hibernate、spring、apache等都有实现)。官方的主要用到的就三大类：HashMap(最常见的，内部无序的)、TreeMap(排过序的)及WeakMap（这个用于内存自动释放的）；还有一类是多线程时使用的并发Map。 如需查看具体Map子类。装个Eclipse，ctrl+shit+t输入Map后，在Map的class名那里按ctrl+T可以查看到Map所有的实现类。

public static String getSubstring(String pStr,int pStart,int pEnd){ byte[] b=pStr.getBytes(); pStr=""; for(int i=pStart-1,point=pStart-1;i<pEnd;){ if(i>=b.length)break; if(i==pEnd-1&&b[i]<0){ int length=i-point+1; if(length%2==1)length--; pStr+=new String(b,point,length); } i++; if(b[i]<0){ continue; } else{ pStr+=new String(b,point,i-point); point=i; } } return pStr; }楼主，用你的数据测试了没问题，你自己拿去试试看，有问题我们再讨论，祝楼主成功

实例package test;import java.io.BufferedReader;import java.io.File;import java.io.FileOutputStream;import java.io.FileReader;import java.io.IOException;import java.util.ArrayList;import java.util.List;class Test { private static BufferedReader bw; public static void main(String[] args) { String ss = null; List<TestPo> list = new ArrayList<TestPo>(); try{ File file=new File("E:\test.txt"); FileOutputStream out=new FileOutputStream(new File("E:\test1.txt"),true); bw=new BufferedReader(new FileReader(file)); boolean flag = true; int[] temps = null; while((ss=bw.readLine())!=null){ String[] mark = ss.split(":"); int sum =0; TestPo po = new TestPo(); int[] temp = new int[mark.length-1]; temps = new int[mark.length-1]; for (int i = 1;i< mark.length;i++) { temp[i-1] = Integer.parseInt(mark[i].trim()); sum += temp[i-1]; if (flag) { temps[i-1] = 0; } } flag = false; po.setMark(temp); po.setName(mark[0]); po.setAvg(sum/(mark.length-1)); list.add(po); out.write((" "+ss).getBytes()); } bw.close(); out.close(); int row = list.size(); int[][] marks = new int[row+1][]; for (int i = 0; i < row; i++) { marks[i] = list.get(i).getMark(); } marks[row] = temps; int sumTemp =0 ; int count = list.get(0).getMark().length; for (int i = 0; i < count; i++) { for (int j = 0; j < row; j++) { sumTemp += marks[j][i]; } marks[row][i] = sumTemp/row; sumTemp = 0; } for (int[] is : marks) { for (int i : is) { System.out.print(i+" "); } System.out.println(); } }catch(IOException e){ e.printStackTrace(); } for (TestPo po : list) { System.out.println("Name:"+po.getName()+" AVG:"+po.getAvg()); } }}class TestPo{ private String name; private Integer avg; private int[] mark; public int[] getMark() { return mark; } public void setMark(int[] mark) { this.mark = mark; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAvg() { return avg; } public void setAvg(Integer avg) { this.avg = avg; }}

Comparable,flag=this.weight.compareTo(o.weight.compareTo);Arrays.sort(ps);

第二个选D

说到primitive，必然也会提到它相对应的wrapped：primitive type: 基本类型，像int、double就是。wrapped type：包装类型，int—>Integer，double—>Decimal基本类型跟就是不可实例化的，可以直接初始化、赋值、运算。不可调用方法，不可放入容器（要求必须是类实例才行）。int i=10;i++;包装类型就是把基本类型变成一个类实例，一定要new才产生，可以调用方法，可以放入容器。int tt=100;tt++;Integer kk=new Integer(tt); //tt的包装类实例System.out.println(kk.intValue()); //还是101HashMap m=new HashMap();m.put("abc",kk);String是特殊的，可以像基本类型这样用，但其实它是类实例来的,可以调用它的方法，也可以放入到容器里面。JVM对String作了特殊处理。String s="123456";System.out.println(s.substring(0,1));HashMap m=new HashMap();m.put("abc",s);

double 的wrapper class type 应该是 Double， 详情可见http://en.wikipedia.org/wiki/Primitive_wrapper_class

Java的数据类型分为两类：primitive和reference类型 Java虽然是个面向对象的语言，也声称“Everything is object”- 一切都是对象。但是，我觉得还不够纯粹和彻底，和ruby或者python比较一下就知道了。在Java中，数字和布尔类型就不被看做对象，而是被称为primitive类型。不过也不见的就不好，本文也不是想对此评论和分析。本文是想阐述Java的数据类型。 Java的数据类型Java的数据类型分为两类：primitive和reference类型。我们可以从hold数据这个角度来说。primitive类型可以hold数字和布尔数据；reference类型可以hold对象，接口和数组类型的数据的指针。可以想象后一种数据比较复杂，往往是一段数据，不像primitive的数据是比较单纯的数据单元，比如int，float和boolean。

是传的map参数，具体代表什么意思。就在方法和sql语句中。自己去看了。

没有看懂是什么意思

public class Employee{String companyName; // 单位名称String name; // 姓名String address; // 街道地址String city; // 城市String mailCode; // 邮编char sex; // 性别void change_name(String name){name = "需要修改的名字";this.name = name;}void display(){System.out.println("单位名称："+this.companyName+"，姓名："+this.name+"，街道地址："+this.address+"，性别："+this.sex+"，邮编："+this.mailCode+"，城市："+this.city );}}

用来保存文件的啊，各种各样的文件的啊，这个是文件夹的意思啊，文件夹不是保存文件的么？？楼主为何有此一问呢？？难道没有用过电脑么

第一，判读MD5值或SHA-1，以MD5为例，// 计算文件的 MD5 值publicstatic String getFileMD5(File file) {if (!file.isFile()) {return null;}MessageDigest digest = null;FileInputStream in = null;byte buffer[] = newbyte[8192];int len;try {digest =MessageDigest.getInstance("MD5");in = new FileInputStream(file);while ((len = in.read(buffer)) != -1) {digest.update(buffer, 0, len);}BigInteger bigInt = new BigInteger(1, digest.digest());return bigInt.toString(16);} catch (Exception e) {e.printStackTrace();return null;} finally {try {in.close();} catch (Exception e) {e.printStackTrace();}}}第二，直接判读内容，代码如下：public class IOOperation { public static void main(String[] args) { FileInputStream File1 = null; FileInputStream File2 = null; BufferedReader in = null; String sFile; if(args.length != 2) { System.out.println("The command line should be: java IOOperation testX.txt testX.txt"); System.out.println("X should be one of the array: 1, 2, 3"); System.exit(0); } try { File1 = new FileInputStream(args[0]); File2 = new FileInputStream(args[1]); try { if(File1.available() != File2.available()) { //长度不同内容肯定不同 System.out.println(args[0] + " is not equal to " + args[1]); } else { boolean tag = true; while( File1.read() != -1 && File2.read() != -1) { if(File1.read() != File2.read()) { tag = false; break; } } if(tag == true) System.out.println(args[0] + " equals to " + args[1]); else System.out.println(args[0] + " is not equal to " + args[1]); } } catch(IOException e) { System.out.println(e); } } catch (FileNotFoundException e) { System.out.println("File can"t find.."); } finally { try { if(File1 != null) File1.close(); if(File2 != null) File2.close(); } catch (IOException e) { System.out.println(e); } } } } 这里因为使用了第二种方法所以直接用了main函数，代码结构可以再优化。MD5方法用到了以前没有接触到的知识，如MessageDigest、BigInteger等，个人觉得要想了解这些方法最好的方法就是读API文档。

javascript不能操作文件

import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class MyCopy { public void fileCopy(String sFile, String oFile) { File file = new File(sFile); if (!file.exists()) { System.out.println(sFile + " not have"); return; } File fileb = new File(oFile); if (file.isFile()) { FileInputStream fis = null; FileOutputStream fos = null; try { fis = new FileInputStream(file); fos = new FileOutputStream(fileb); byte[] bb = new byte[ (int) file.length()]; fis.read(bb); fos.write(bb); } catch (IOException e) { e.printStackTrace(); } finally { try { fis.close(); fos.close(); } catch (IOException e) { e.printStackTrace(); } } } else if (file.isDirectory()) { if (!fileb.exists()) { fileb.mkdir(); } String[] fileList; fileList = file.list(); for (int i = 0; i < fileList.length; i++) { fileCopy(sFile + "/" + fileList[i], oFile + "/" + fileList[i]); } } } public static void main(String[] args) { MyCopy myCopy = new MyCopy();// myCopy.fileCopy(args[0], args[1]);//dos myCopy.fileCopy("f:\qq.txt", "e:\w.txt"); }}

你要填空格的地方要用 代替

方法/步骤mac默认打开spotlight的快捷键是command+空格该快捷键可以在 系统偏好设置->spotlight界面的下端可以设置打开或者关闭或者点击右上角的放大镜图标打开搜索框用快捷键或者按钮图标打开spotlight的搜索框在输入框填上需要在mac电脑中搜索的内容关键字

注解 注册成spring的组件~~~~~~~~

while(boolean){//循环内容}

spring中的注解；@Repository用于标注数据访问组件，即DAO组件；例:@Repository public class VentorDaoImpl implements iVentorDao { } 在一个稍大的项目中，如果组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找以及维护起来也不太方便。 Spring2.5为我们引入了组件自动扫描机制，他在类路径下寻找标注了上述注解的类，并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用bean节点配置组件时一样的。要使用自动扫描机制，我们需要打开以下配置信息：<?xml version="1.0" encoding="UTF-8" ?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"> <context:component-scan base-package=”com.eric.spring”> </beans>

public class Rmb {String a[]={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};String c[]={"","亿","千","百","拾","万","千","百","拾","亿","千","百","拾","万","千","百","拾","元"};String d[]={"","角","分","厘",""};String rmb,rmbstrtemp;String rmbint,rmbdec; void setrmb(String rmbstr) { rmbstrtemp=rmbstr; } String getrmb() { StringBuffer rmbstrResult=new StringBuffer(); StringBuffer rmbstrall=new StringBuffer(); if((rmbstrtemp.indexOf(".")>0)&&(rmbstrtemp.length()-rmbstrtemp.indexOf(".")>3))/*整理输入的数据通过判断输入的字符串是否有小数位而且小数位数大于3位，以确保小数位只有两位；*/ { rmbstrtemp=rmbstrtemp.substring(0, rmbstrtemp.length()-((rmbstrtemp.length()-rmbstrtemp.indexOf("."))-3)); //12345.123 9-((9-6)-3) 9-(3-3) 9-(0) 9 //12345.1234 10-((10-6)-3) 10-(4-3) 10-1 9 //12345.12345 11-((11-6)-3) 11-(5-3) 11-2 9 } rmbstrall.append(rmbstrtemp); if(rmbstrtemp.indexOf(".")<0 )//判断输入的字符串有没有小数点如果是加“.00”； { rmbstrall.append(".00"); } if((rmbstrtemp.length()-rmbstrtemp.indexOf("."))==1)/*判断输入的字符串是不是只带小数点不带小数位如果是在后面加"00"；*/ { rmbstrall.append("00"); } rmb=rmbstrall.toString(); rmbint=rmb.substring(0,rmb.indexOf("."));//取出整数部分 rmbdec=rmb.substring(rmb.indexOf(".")+1,rmb.length());//取出小数部分 String rmbchar; int rmbdic,rmbcom; rmbcom=c.length-(rmbint.length());//判断整数的单位开始位置 for(int i=0;i<rmbint.length();i++) { rmbchar=rmbint.substring(i,i+1);//取出整数的每一个位的字符从左往右 rmbdic=Integer.parseInt(rmbchar);//将每一个位的字符转换为整数 rmbstrResult.append(a[rmbdic]);/*将每一个位的整数与a［］数组下标对应的中文大写字符存入rmbstrResult*/ rmbstrResult.append(c[rmbcom]);//将单位跟在大写字符后面 rmbcom++; } for(int i=0;i<rmbdec.length();i++) { rmbchar=rmbdec.substring(i,i+1); rmbdic=Integer.parseInt(rmbchar); rmbstrResult.append(a[rmbdic]); rmbstrResult.append(d[i+1]); } return rmbstrResult.toString(); }public static void main(String[] args){Rmb r=new Rmb();r.setrmb("100.01");System.out.println(r.getrmb());}}

匹配13 或者15开头的11位手机号

不需要，jdk自带的，最简单的就是String的matches方法，如果需要比较高级的功能来处理字符串，就需要java.util.regex里面的类了。class a{ public static void main(String[] s){ String str = "str"; System.out.println(str.matches(".*"));//这里任何字符串都会返回true }}

for%%iin(%code%)docall,set"str=%%str:%%i=%%i%%"这句意思是文本替换，把第一行定义的小写的str变量字符替换成大写的;简单说下循环过程；变量%%i是从大写的a-z循环；首先第一次循环%%i=a那么替换过去就是setstr=%str:a=a%很明显是把原小写str变量里所有字符是a小写的，全部换成大写a；第二次循环%%i=b；setstr=%str:b=b%很明显是把所有带b的替换成大写b；以此类推将会把所有小写都换成大写了~set/p=%str:~,1%评论00加载更多

完整的应该是Pattern.matches("[\d]{10,12}","111122223333")正则表达式代表后一个参数是否满足前一个参数所代表的意思[\d]代表数字（即0－9），{10-12}代表有10个到12个数字

match 是用一个字符串去匹配一个正则表达式 而你的yyyy-MM-dd hh:mm:ss 这个不是正则表达式，楼上给你正解了，换成那个就行了，具体都代表了什么，正则式怎么写需要你去学一下 很快的 网上有专门的视频、教程

可以Pattern.compile(regex, CASE_INSENSITIVE | DOTALL);多个值 罗辑或 请参考

正则表达式在java中需要编译运行Pattern search = Pattern.compile("ab");Matcher from = p.matcher("aaaaab");boolean b = Pattern.matches(search, from);string.matches写法是错误的

str.matches("\d+")\d就是一位数字的意思,用一个+加号就行了,是一个以上的意思

返回boolen值

java.util.Matcherboolean find()Attempts to find the next subsequence of the input sequence that matches the pattern.java.util.Patternstatic boolean matches(String regex, CharSequence input)Compiles the given regular expression and attempts to match the given input against it.

正则表达式，自己去百度搜索资料吧。

[a-z,A-Z]{1,10}是一个正则表达式，意思是：匹配1到10个英文字母（大小写不限），还有,号。如果是匹配1-10个不限大小写的英文字母，正则表达式应该为：[a-zA-Z]{1,10}

正确的写法String value2=" ";String value3="[\s\S]";System.out.println(value2.matches(value3));正则中的‘点"表示匹配出 以外的任何字符

String.contains与字符串,句点一起使用。它不适用于正则表达式。它将检查指定的确切字符串是否出现在当前字符串中。

a.matches(".*char.*|.*int.*");

考的都是java的基础,基础好的话很容易进入公司,一般都会问String,StringBuffer,StringBudilder区别ArrayList,vector 等的区别hashMap,hashTable 的区别多线程的实现方式和方法了传参数方面的 考传的是本身还是副本 如 a(String value); a方法的value参数是传本身还是副本其它的问题都是最基本的,基本能答上来还有就是框架的知识了,比如spring 依赖注入,事务深入点的话 拦截器等考其它框架的话 基本上问的都是比较基础的 难的话很少问到db方面的话 简单考下你的sql , 可能会写几个表 要查什么让你写sql 主要考 多表连接查询,分组,分组后的查询,排序,取最大最小之类的 看你sql熟练否我面试过10多间公司 基本都是上面我说到的问题

matches是正则匹配不是任何对象都有matches方法的

match好像参数应该用正则表达。你的意思应该是用substring

1.find()方法是部分匹配，是查找输入串中与模式匹配的子串，如果该匹配的串有组还可以使用group()函数。matches()是全部匹配，是将整个输入串与模式匹配，如果要验证一个输入的数据是否为数字类型或其他类型，一般要用matches()。2.Pattern pattern= Pattern.compile(".*?,(.*)");Matcher matcher = pattern.matcher(result);if (matcher.find()) {return matcher.group(1);}3.详解：matchespublic static boolean matches(String regex, CharSequence input)编译给定正则表达式并尝试将给定输入与其匹配。 调用此便捷方法的形式 Pattern.matches(regex, input);Pattern.compile(regex).matcher(input).matches() ;如果要多次使用一种模式，编译一次后重用此模式比每次都调用此方法效率更高。参数：regex - 要编译的表达式input - 要匹配的字符序列 抛出： PatternSyntaxException - 如果表达式的语法无效findpublic boolean find()尝试查找与该模式匹配的输入序列的下一个子序列。 此方法从匹配器区域的开头开始，如果该方法的前一次调用成功了并且从那时开始匹配器没有被重置，则从以前匹配操作没有匹配的第一个字符开始。 如果匹配成功，则可以通过 start、end 和 group 方法获取更多信息。 matcher.start() 返回匹配到的子字符串在字符串中的索引位置.matcher.end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置.matcher.group()返回匹配到的子字符串返回：当且仅当输入序列的子序列匹配此匹配器的模式时才返回 true。4.部分JAVA正则表达式实例①字符匹配Pattern p = Pattern.compile(expression); // 正则表达式Matcher m = p.matcher(str); // 操作的字符串boolean b = m.matches(); //返回是否匹配的结果System.out.println(b);Pattern p = Pattern.compile(expression); // 正则表达式Matcher m = p.matcher(str); // 操作的字符串boolean b = m. lookingAt (); //返回是否匹配的结果System.out.println(b);Pattern p = Pattern.compile(expression); // 正则表达式Matcher m = p.matcher(str); // 操作的字符串boolean b = m..find (); //返回是否匹配的结果System.out.println(b);②分割字符串Pattern pattern = Pattern.compile(expression); //正则表达式String[] strs = pattern.split(str); //操作字符串 得到返回的字符串数组③替换字符串Pattern p = Pattern.compile(expression); // 正则表达式Matcher m = p.matcher(text); // 操作的字符串String s = m.replaceAll(str); //替换后的字符串④查找替换指定字符串Pattern p = Pattern.compile(expression); // 正则表达式Matcher m = p.matcher(text); // 操作的字符串StringBuffer sb = new StringBuffer();int i = 0;while (m.find()) {m.appendReplacement(sb, str);i++; //字符串出现次数}m.appendTail(sb);//从截取点将后面的字符串接上String s = sb.toString();⑤查找输出字符串Pattern p = Pattern.compile(expression); // 正则表达式Matcher m = p.matcher(text); // 操作的字符串while (m.find()) {matcher.start() ;matcher.end();matcher.group(1);}

format应该是一个正则表达式String format = "\d-\d-\d \d:\d:\d";

数字必须重复九次

这个我是真的不会，