java

这是编译器的自动装箱/拆箱转换引起的问题,自动装箱/拆箱的特性，只要一个运算中有不同的类型，涉及到类型转换，那么编译器会往下（基本类型）转型，再进行运算。 就是说，如果运算中有int和Integer，Integer会先转成int再计算。所以你的代码中，最后一行i = StringUtils.isEmpty(ComNo)?RecordType:0;实际的运行会是这样 i = StringUtils.isEmpty(ComNo)?RecordType.intValue():0;RecordType为null，所以会报错。可以改成：i = StringUtils.isEmpty(ComNo) ? RecordType : Integer.valueOf(0);保持类型的一致就不会自动转型了

参见https://www.tah1986.com/1382.html，以表格的形式详细描述，并且附有代码。

MyEclipse 中自动插入作者、注释日期等de快捷键方法依次打开然后找到 Window -->Preferences->Java->Editor->Templates，在这里new一个自己的插入注释的快捷方式名称，具体设置如下：Name处输入 author1 (任意你喜欢的名称)context处选 java 后边勾选Automatically insert复选框Description 这里可以任意输入描述Pattern :(比较多)/*** @author ${user}* @date : ${date} ${time}*/到这里全部设置完毕，下面 OK,找个java类,找个空白处测试一下, 输入author1(前面写的那个Name名称), 再alt+/ 应该按一下就能看到刚才的pattern的内容了。方式二：这个在类的定义上一行加上 /** 再按快捷键 ctrl+/ 就ok了！

一般放在类中，用来修饰属性的，为了提高程序的独立性，减少耦合度,通常配合 setter 与getter方法来使用

一般放在类中，用来修饰属性的，为了提高程序的独立性，减少耦合度。private表示一个类的私有属性，只能在本类中访问到，在其他的类中无法进行访问。Java简介：是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，Java特点：Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。可编写的程序：Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

域可以是private,类不行

private作为一种权限修饰符可以修饰类，属性和方法，用private修饰的类属性，方法，只能自己使用，对别的类是不能访问的，也就是说对于别的类来说是隐藏不可见的，private一般不修饰类，但是可以修饰内部类

private在英文里是私人的意思．众所周知，JAVA是面向对象的一门语言，每个对象都有各自的属性和方法．但是有的属性涉及安全因素或秘密因素不能让外面的程序调用，所以就用到了private,经过它定义的变量只能在此对象内部调用，外部程序就无法调用，也就是说只能供其自身调用，比如某个人是一个对象，那么他的血液就肯定是私有变量，只能供其自身调用来维持人的状态．而如果将血液定义成public(公共的)的话，随便其他人都可以改变他血液的状态，你随便把他的血液值设为逆流，那他不就挂了．

java类中的成员变量，用private修饰，是因为这个类是封装的，被封装的东西自然应该是此类私有的。一句话，体现了封装性。新手可以把它理解为这是一种规范。

private在英文里是私人的意思．众所周知，JAVA是面向对象的一门语言，每个对象都有各自的属性和方法．但是有的属性涉及安全因素或秘密因素不能让外面的程序调用，所以就用到了private,经过它定义的变量只能在此对象内部调用，外部程序就无法调用，也就是说只能供其自身调用，比如某个人是一个对象，那么他的血液就肯定是私有变量，只能供其自身调用来维持人的状态．而如果将血液定义成public(公共的)的话，随便其他人都可以改变他血液的状态，你随便把他的血液值设为逆流，那他不就挂了．

在说明这四个关键字之前，我想就class之间的关系做一个简单的定义，对于继承自己的class，base class可以认为他们都是自己的子女，而对于和自己一个目录下的classes，认为都是自己的朋友。1.首先是public修饰符来修饰的函数，是指这个函数可以被其他的类来调用，也可以被自己类里的函数来调用。2.再看protected修饰符来修饰的函数，是指这个函数可以被继承类调用，也可以被自己类里的函数调用，但不能被其他的类调用。3.用private修饰符来修饰的函数，就具有更少的权限了，只能被自己类里的其他函数调用，其他的一概不能调用。

因为它的参数其实是正则表达式

不允许外部访问和继承

private在英文里是私人的意思．众所周知，JAVA是面向对象的一门语言，每个对象都有各自的属性和方法．但是有的属性涉及安全因素或秘密因素不能让外面的程序调用，所以就用到了private,经过它定义的变量只能在此对象内部调用，外部程序就无法调用，也就是说只能供其自身调用，比如某个人是一个对象，那么他的血液就肯定是私有变量，只能供其自身调用来维持人的状态．而如果将血液定义成public(公共的)的话，随便其他人都可以改变他血液的状态，你随便把他的血液值设为逆流，那他不就挂了．

1、private修饰词，表示成员是私有的，只有自身可以访问； 2、protected，表示受保护权限，体现在继承，即子类可以访问父类受保护成员，同时相同包内的其他类也可以访问protected成员。 3、无修饰词（默认），表示包访问权限（friendly， java语言中是没有friendly这个修饰符的，这样称呼应该是来源于c++ ），同一个包内可以访问，访问权限是包级访问权限； 4、public修饰词，表示成员是公开的，所有其他类都可以访问；

私有的

public，protected，private是Java里定义成员的访问权限例如：private a;public :无论它所处在的包定义在哪，该类（接口、成员）都是可访问的private ：成员只可以在定义它的类中被访问protected ：成员只能在定义它的包中被访问，如果在其他包中被访问，则实现这个方法的类必须是该成员所属类的子类。http://www.cnblogs.com/android-html5/archive/2011/10/23/2534102.html

环绕通知ProceedingJoinPoint 执行proceed方法的作用是让目标方法执行，这也是环绕通知和前置、后置通知方法的一个最大区别。这是Spring框架最基础的部分，它提供了依赖注入（DependencyInjection）特征来实现容器对Bean的管理。这里最基本的概念是BeanFactory，它是任何Spring应用的核心。BeanFactory是工厂模式的一个实现，它使用IoC将应用配置和依赖说明从实际的应用代码中分离出来。扩展资料：轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。参考资料来源：百度百科-spring框架

在加50分 帮你做了 能敲就敲嘛

在etc下面的profile添加 。当然在etc下面的profile添加地址时，需要和jdk的环境变量保持一致。首先在profile下面配置jdk的环境变量，然后 查看本机是否有默认的JDK，导致环境变量中的被覆盖 ，最后经过检查没有的时候再进行添加环境变量。

是问号搞的鬼，你把第二个问号处理下就可以了

java初学者,一定对从键盘输入数据感到困难,使用下面的类Input,可以方便的从键盘输入数据:使用方法举例: String s=Input.readString(); 读入字符串 int i=Input.readInt(); 读入整数下面是java输入输出基本类Input类的源代码:最后以从键盘输入10个整数为例说明之。import java.io.*;class Input{static InputStreamReader in;<br/> static BufferedReader reader;<br/> static<br/> {in=new InputStreamReader(System.in);<br/> reader=new BufferedReader(in);<br/> }static String readString() {String s="";<br/> try<br/> { s=reader.readLine();<br/> <br/> } catch(IOException e) {System.out.println(e);<br/> System.exit(0);<br/> } return s; } static char readChar() {char ch="a";<br/> try<br/> {<br/> String s=readString();<br/> ch=s.charAt(0);<br/> <br/> } catch(Exception e) {System.out.println("输入的数据类型不对，程序将退出");<br/> System.exit(0);<br/> } return ch; }static int readInt() {String s=readString();<br/> int i=0;<br/> try{<br/> i=Integer.parseInt(s);<br/> } catch(Exception e) {System.out.println("输入的数据类型不对，程序将退出");<br/> System.exit(0);<br/> } return i; } static double readDouble() {String s=readString();<br/> double d=0.0;<br/> try<br/> {d=Double.parseDouble(s);<br/> } catch(Exception e) {System.out.println("输入的数据类型不对，程序将退出");<br/> System.exit(0);<br/> } return d; } static float readFloat() { String s=readString(); float f=0.0f; try { f=Float.parseFloat(s); } catch(Exception e) { System.out.println("输入的数据类型不对，程序将退出"); System.exit(0); } return f; }}/*用法举例,从键盘输入十个整数:*/class InoutData{public static void main(String args[])<br/> { int a[]=new int[10];<br/> for(int i=0;i<10;i++)<br/> { System.out.println("请输入第"+(i+1)+"个数:");<br/> a[i]=Input.readInt();<br/> } for(int i=0;i<10;i++) System.out.println("a["+i+"]="+a[i]); }}

你去死.....................................................................................................................................

public static void main(String[] args) { Scanner sc=new Scanner(System.in); int a; int b; while(true){ System.out.println("请输入a"); a=sc.nextInt(); System.out.println("请输入b"); b=sc.nextInt(); System.out.println("a+b="+a+b); } }

还有下一个，你还输入了

package com;import java.util.Scanner;public class Demo {public static void main(String[] argss) {Scanner sc = new Scanner (System.in);System.out.println("请输入第一个数");int nextInt = sc.nextInt();System.out.println("请输入第二个数");int nextInt2 = sc.nextInt();if(nextInt < nextInt2){int n = nextInt2 - nextInt;System.out.println("第二个数比第一个数大："+n);}else if(nextInt > nextInt2){int d = nextInt - nextInt2;System.out.println("第二个数比第一个数小："+d);}else {System.out.println("这两个数相等");}}}没用使用复杂逻辑判断，只用了简单的if else 希望能满足需求

答题来了。

使用instance of

代码点击下载

我按你的代码写了一遍结果正常执行啊，，

import java.util.*;public class Test {public static void main (String[] args) {Scanner sc=new Scanner(System.in);List<Integer> al=new ArrayList<Integer>();int a,b,i,j;a=sc.nextInt();b=sc.nextInt();a=a>1 ? a : 2;for(i=a;i<=b;i++) {for(j=2;j<i;j++)if(i%j==0)break;if(j>=i)al.add(i);}if(al.size()>0) { for(i=0;i<al.size()-1;i++) System.out.printf("%d,",al.get(i)); System.out.println(al.get(i));}sc.close();}}

不是应该有个ID吗？如果页面上不用文本框的话，你可以通过ID来查询这条记录，再从中取出来。这样可以实现，期待更好的做法。

JDK 中的 Properties 类 Properties 类存在于胞 Java.util 中，该类继承自 Hashtable ，它提供了几个主要的方法： 1． getProperty ( String key) ， 用指定的键在此属性列表中搜索属性。也就是通过参数 key ，得到 key 所对应的 value。2． load ( InputStream inStream) ，从输入流中读取属性列表（键和元素对）。通过对指定的文件（比如说上面的 test.properties 文件）进行装载来获取该文件中的所有键 - 值对。以供 getProperty ( String key) 来搜索。3． setProperty ( String key, String value) ，调用 Hashtable 的方法 put 。他通过调用基类的put方法来设置 键 - 值对。4． store ( OutputStream out, String comments) ， 以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。与 load 方法相反，该方法将键 - 值对写入到指定的文件中去。5． clear () ，清除所有装载的 键 - 值对。该方法在基类中提供。

1.javabean 说白了 就是你数据库表对象 一张表对应一个javabean 在MVC设计模型中是model，又称模型层，在一般的程序中，我们称它为数据层，就是用来设置数据的属性和一些行为，然后我会提供获取属性和设置属性的get/set方法2.javabeans 就是javabean 你可以去 百度百科 搜一下 虽写的不一样 意思都是一个意思

是同一个东西，大部分情况下都说JavaBean 但是有时候有些人会写成JavaBeans

实体bean企业bean会话beanbean是对封装数据的类的称呼bean的中文意思是豆子

从 v1.4 开始，java.beans 包提供了对长期持久性 的支持，即以其属性值的文本表示形式读取或写入 bean。这些属性值被视为 bean，它们被递归地读取或写入，以捕获其公共可用状态。此方法适用于长期存储，因为它只依赖于公共 API 而不是很可能发生更改的私有实现。--------------------------------------------------------------------------------注： 持久性方案无法自动实例化自定义内部类，比如用于事件处理程序的类。通过使用 EventHandler 类而不是自定义事件处理程序的内部类，可以避免此问题。--------------------------------------------------------------------------------可分别使用 XMLDecoder 和 XMLEncoder 类读取和写入XML格式的 bean。持久性方案的一个显著特性是，读入 bean 不需要该 bean 的特定信息。另一方面，读出 bean 有时需要 bean 类型的特定信息。如果可以只使用属性的无参数构造方法以及公共 getter 和 setter 方法表达 bean 的状态，则无需 bean 的特定信息。否则，bean 需要一个自定义持久委托，即负责写出特殊类型的 bean 的对象。从 java.awt.Component 中遗传的JDK中提供的所有类及其所有属性都将自动拥有持久委托。如果需要（或选择）为 bean 提供持久委托，则可以通过使用 DefaultPersistenceDelegate 实例或通过创建自己的 PersistenceDelegate 子类来实现。如果 bean 需要持久委托的惟一原因是因为用户想调用 bean 使用属性值作为参数的构造方法，则可以使用无参数的 DefaultPersistenceDelegate 构造方法创建 bean 的持久委托。否则，用户需要实现自己的持久委托，对此，可能需要以下类：PersistenceDelegate这是一个抽象类，所有持久委托都是从它遗传的。子类应该使用它所知的 bean 类型信息来提供创建 bean 和恢复其状态所需的任何 Statement 和 Expression。Statement表示某一对象上的单个方法的调用。包括该方法的参数集合。Expression用于返回一个值的那些方法的 Statement 的子类。一旦创建了一个持久委托，就可以使用 XMLEncoder 的 setPersistenceDelegate 方法注册它。相关文档有关概述、架构和教程文档的信息，请参阅：JavaBeans，《The Java Tutorial》中的一部分。Long-Term Persistence，The Swing Connection 中的一篇文章

. 希望有人来解决

tomcat官网可以下载 tcnative-1.dll ，，，，放tomcat的bin目录中~~~~~~~~~~~

我也是自学的。Student实现了 Comparable接口，但是本身没有comparTo（）这个方法，所以你必须重写这个方法，要是是Integer，String等类本身就带有comparTo()这个方法就不用重写了。 。可能你还会碰到equals（）同样也要重写。

可以比较字符吗？

java里面的字符串比较要用equals所以if语句应该这么写if(密码.equals("724241002"))

因为a与A的ascii码相差32

重写compareTo方法，或者实现comparable接口，想怎么比就怎么比

你这个函数只是比较大小， this .lastTime > callLogNeedAllBean.lastTime 时反回正值；反之则返回负值。所以某种逻辑上，可以说是降序

compareTo(Character anotherCharacter)根据数字比较两个 Character 对象。 如果该 Character 等于此 Character，则返回 0；如果该 Character 的数值小于参数 Character，则返回小于 0 的值；如果该 Character 的数值大于参数 Character，则返回大于 0 的值（有符号比较）。注意，这是一次严格的数字比较；toLowerCase(char ch) 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。isLetter(char ch) 确定指定字符是否为字母isWhitespace(char ch) 确定指定字符依据 Java 标准是否为空白字符。

public class Card { private String face; private String suit; public String getFace() { return face; } public void setFace(String face) { this.face = face; } public String getSuit() { return suit; } public void setSuit(String suit) { this.suit = suit; } public Card(String face, String suit) { super(); this.face = face; this.suit = suit; } public Card() { // TODO Auto-generated constructor stub }----------------------------------------------------------------------------------public class Consts { public static final String BLACK = "3"; //黑桃 public static final String RED = "2"; //红桃 public static final String CLUB = "1"; //梅花 public static final String DIAMOND = "0";//方块 }------------------------------------------------------------------------------------public class OrderTool { public List<Card> doOrder(Card[] card_array) { List<Card> list = new ArrayList<Card>(); // 按类排序 if (card_array != null && card_array.length > 0) { Card temp = null; int flag = 0; for (int i = 0; i < card_array.length; i++) { if (flag > 0) { System.out.println("请检查传入的纸牌值！"); break; } for (int j = i + 1; j < card_array.length; j++) { int i_suit = this.convert(card_array[i].getFace()); int j_suit = this.convert(card_array[j].getFace()); if (i_suit == -1 || j_suit == -1) { flag++; break; } if (i_suit > j_suit) { temp = card_array[i]; card_array[i] = card_array[j]; card_array[j] = temp; } else if (i_suit == j_suit) { int i_face = Integer.parseInt(card_array[i].getSuit()); int j_face = Integer.parseInt(card_array[j].getSuit()); if (i_face < j_face) { temp = card_array[i]; card_array[i] = card_array[j]; card_array[j] = temp; } } } } for(Card card : card_array){ list.add(card); } } return list; } private int convert(String param) { int res = 0; try { res = Integer.parseInt(param); return res; } catch (Exception e) { if ("A".equalsIgnoreCase(param)) { return 1; } else if ("J".equalsIgnoreCase(param)) { return 11; } else if ("Q".equalsIgnoreCase(param)) { return 12; } else if ("K".equalsIgnoreCase(param)) { return 13; } else { System.out.println("拿的是王吧！"); return -1; } } } public static String faceTranslater(int face){ String res = ""; switch(face){ case 3:res = "黑桃";break; case 2:res = "红桃";break; case 1:res = "梅花";break; case 0:res = "方块";break; } return res; }//测试 public static void main(String[] args) { Card c0 = new Card("A",Consts.BLACK); Card c1 = new Card("2",Consts.BLACK); Card c2 = new Card("A",Consts.RED); Card c3 = new Card("5",Consts.CLUB); Card c4 = new Card("4",Consts.RED); Card c5 = new Card("3",Consts.DIAMOND); Card c6 = new Card("4",Consts.BLACK); Card[] c = {c0,c1,c2,c3,c4,c5,c6}; List<Card> list = new OrderTool().doOrder(c); for(Card card : list){ System.out.println("花色:"+OrderTool.faceTranslater(Integer.parseInt(card.getSuit()))+"&"+"牌面:"+card.getFace()); } }

使用 String.compareTo 方法：compareTo() 的返回值是int, 它是先比较对应字符的大小(ASCII码顺序)1、如果字符串相等返回值02、如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的差值（ascii码值）（负值前字符串的值小于后字符串，正值前字符串大于后字符串）3、如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方全比较完,这时就比较字符的长度. 例: String s1 = "abc"; String s2 = "abcd"; String s3 = "abcdfg"; String s4 = "1bcdfg"; String s5 = "cdfg"; System.out.println( s1.compareTo(s2) ); // -1 (前面相等,s1长度小1) System.out.println( s1.compareTo(s3) ); // -3 (前面相等,s1长度小3) System.out.println( s1.compareTo(s4) ); // 48 ("a"的ASCII码是97,"1"的的ASCII码是49,所以返回48) System.out.println( s1.compareTo(s5) ); // -2 ("a"的ASCII码是97,"c"的ASCII码是99,所以返回-2)

标准做法x0dx0aintr=big_decimal.compareTo(BigDecimal.Zero);//和0，Zero比较x0dx0aif(r==0)//等于x0dx0aif(r==1)//大于x0dx0aif(r==-1)//小于x0dx0ax0dx0a或者x0dx0aif(big_decimal.equals(BigDecimal.Zero))//是否等于0

Java中String类有一个compareTo方法，该方法返回一个int类型的数据。其比较规则是：拿出字符串的第一个字符与参数的第一个字符进行比较，如果两者不等，比较结束，返回两者的ascii差，即字符串的第一个字符减去参数的第一个字符的ascii码值，比如代码第五行的-1.如果相等，则比较第二个字符，以此类推。比较到最后还是相等的，方法返回值为0。x0dx0a这里有一点需要注意：如果两个字符串的长度不同，并且一个字符串与另一个字符串的前面N个字符相等，那么这个方法返回返回两个字符串长度之差。比如代码第七行返回值为3.x0dx0a举例如下:x0dx0aString s1 = "abcd"; x0dx0aString s2 = "abce"; x0dx0aString s3 = "Abc"; x0dx0aString s4 = "abcdefg"; x0dx0aSystem.out.println(s1.compareTo(s2)); x0dx0aSystem.out.println(s1.compareTo(s3)); x0dx0aSystem.out.println(s4.compareTo(s1)); x0dx0aSystem.out.println(s4.compareTo(s2)); x0dx0a输出：-1 32 3 -1

举例来说吧String ipAddr1 = 192.168.0.11;String ipAddr2 = 192.168.0.22;int result = ipAddr1.compareTo(ipAddr2);结果是result < 0 ，说明ipAddr1 < ipAddr2 。注：compareTo的作用如下如果参数字符串等于此字符串，则返回 0 值；如果按字典顺序此字符串小于字符串参数，则返回一个小于 0 的值；如果按字典顺序此字符串大于字符串参数，则返回一个大于 0 的值。

比较出大小之后 想要显示什么嘛？

compareTo()是两个字符串对象比较大小，返回一个整数值，如果调用字符串对象大，返回正整数，反之，返回负整数。相等则返回0。返回的值是两个串首次出现不同字符的ASCII的差值。

你说的 很不明确

int是简单类型，怎么后面会能跟方法呢eclipse里面直接编译不通过的

人家问你的是测试类创建对象后不需要对象名.方法去调用 是自动调用的比如说compareTo

首先，前者是传一个参数，后者是传两个参数

返回int型

public int compareTo(Double anotherDouble)从数字上比较两个 Double 对象。在应用到基本 double 值时，通过此方法进行的比较与通过 Java 语言的数值比较运算符（<、<=、== 和 >= >）进行的比较之间存在以下两方面的不同： 此方法认为 Double.NaN 等于它自身，且大于其他所有 double 值（包括 Double.POSITIVE_INFINITY）。 此方法认为 0.0d 大于 -0.0d。 这可以确保受此方法影响的 Double 对象的自然顺序 与 equals 方法一致。 指定者：接口 Comparable<Double> 中的 compareTo参数：anotherDouble - 要比较的 Double 值。 返回：如果 anotherDouble 在数字上等同于此 Double，则返回 0；如果 Double 在数字上小于此 anotherDouble，则返回小于 0 的值；如果 Double 在数字上大于此 anotherDouble，则返回大于 0 的值。

compareTo()方法很简单就实现这种功能。该方法用于判断一个字符串是大于、等于还是小于另一个字符串。判断字符串大小的依据是根据它们在字典中的顺序决定的。语法：Str1.compareTo(Str2);其返回的是一个int类型值。若Str1等于参数字符串Str2字符串，则返回0；若该Str1按字典顺序小于参数字符串Str2，则返回值小于0；若Str1按字典顺序大于参数字符串Str2，则返回值大于0。

只能接封装类的Integer

compareto()函数是比较的意思，不过他比较出来的结果一般是bool类型的，而你说的－32以及32事实上已经代表了false和ture的意思了。你要知道正数代表的就是ture，而负数代表的就是false。而之所以结果是32是这样的。计算机是不会识别你的字符串意思的，它要对两个字符串进行比较首先是将字符串的值转化成ASCII码，然后进行两者之间的计算（减法），得出来的结果就是一个ASCII码了，而你在定义结果的类型的时候估计定义的是int类型（数值）类型，所以显示的是32或者－32。希望能帮你。

TreeSet 采用的是红黑树技术，一种二叉排序树(BST)必须指定 compareTo方法或者是传入 Comparator对象就按指定的关系进行储存，二叉排序树是有序的容器。

如果你是针对数字型的String进行排序，在比较时，把他们转换成int型在比较就好了

string的compareto方法可以返回三种、0代表比较的两个字符串相同、返回正数表示调用方法的字符串不一样、这个正数可能是两个字母的asc差、也可是调用方法字符串长度和参数字符串长度的差、返回负数的话也是上面两种情况、

compareTo(T t)返回 负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。 并没有一定要返回-1，0，1除非你自己实现Comparable 自己从写这个方法比如你调用字符串的compareTo()方法String s1 = "a";String s2="c";s1.compareTo(s2);//得到-2说明s1在s2前两位s2.compareTo(s1);//得到2说明s2在s1后两位这个接口是对实现他的类自然排序，即常说的字典排序然后compareTo()返回的也就是排序位置的关系吧

s1.compareTo(s2); 是从s1到s2的顺序排序，相当于顺序。实现Comparator方法可以对集合、数组排序，具体的机制封装在里面

compareTo() 是 java.lang.Comparable 介面的唯一函式性质上与 Object 的 equals() 很相似不过在单纯的"相等比较"之外, 他还允许"次序比较"如果某个 class 实现了 Comparable, 便是暗示其实体具有内在次序关系在 Java 程式库里的所有 value classes 都实现了 Comparable以下是 Comparable 的规格书比较某个物件与另一指定物件的顺序. 当这个物件小於 等於 大於指定物件时, 分别传回负整数, 0, 正整数. 如果指定物件的型别不允许与这个物件进行比较, 就抛出 ClassCastException 异常实作者必须确保, 对於所有的 x,y,z, 都能够满足 sgn(x.compareTo(y)) == -sgn(y.compareTo(x))意味著 "x.compareTo(y) 抛出异常, 若且唯若(if and only if) y.compareTo(x) 抛出一个异常.实作者必须确保数值间的关系具有迁移性, 也就是说 (x.compareTo(y)> && y.compareTo(z)>0) 意味 x.compareTo(z)>0.实作者必须确保运算式 x.compareTo(y)==0 意味对於任意 z 而言, 运算式 sgn(x.compareTo(z)) == sgn(y.compareTo(z)) 永远成立. 强烈建议(但不要求)满足 (x.compareTo(y)==0) == (x.equals(y)), 一般而言, 任何实现 Comparable interface 却违反本项条件之某个 class, 都应当明确告诉用户这一事实, 以下是大家推荐的说明方式 "次序相等的物件并不一定相等"如果将 Comparable interface 与 Collection 的 package 相互应用, 我想是蛮强大的简单的一个 Array, 如果里面的物件都有实作 Comparable, 那只要用Arrays.sort(a);就可以搞定排序的问题了

num==s.num ? 0 : -1 的意思等同于private Object a(){ if(num==s.num){ return 0; }else{ return -1; }}记住 有返回值。。 这个三步运算的意义就是 判断的同时并返回结果

他们用的方法名是一样的 但是实际上方法是不一样的。你看看源码就知道了。数字之间的比较久很简单，前者大于后者输出是1，相等输出0，小于输出-1字符串就跟冰枫木同学说的一样建议你看看源码！

按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String 对象在参数字符串之前，则比较结果为一个负整数。如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为 0；compareTo 只有在方法 equals(Object) 返回 true 时才返回 0。 这是字典排序的定义。如果这两个字符串不同，则要么它们在某个索引处具有不同的字符，该索引对二者均为有效索引，要么它们的长度不同，或者同时具备上述两种情况。如果它们在一个或多个索引位置上具有不同的字符，假设 k 是这类索引的最小值；则按照 < 运算符确定的那个字符串在位置 k 上具有较小的值，其字典顺序在其他字符串之前。这种情况下，compareTo 返回这两个字符串在位置 k 处的两个不同的 char 值，即值： this.charAt(k)-anotherString.charAt(k)如果它们没有不同的索引位置，则较短字符串在字典顺序上位于较长字符串的前面。这种情况下，compareTo 返回这两个字符串长度的不同，即值： this.length()-anotherString.length()指定者： 接口 Comparable<String> 中的 compareTo 参数： anotherString - 要比较的 String。 返回： 如果参数字符串等于此字符串，则返回 0 值；如果按字典顺序此字符串小于字符串参数，则返回一个小于 0 的值；如果按字典顺序此字符串大于字符串参数，则返回一个大于 0 的值

这个简单，请让我娓娓道来：首先，比较的对象是ToDoItem,这个对象有primary，secondary和item三个属性。其次，比较过程是这样的，首先我们看返回值，是int型，并且返回值有三个状态，+1，-1和0。顾名思义，如果是两个状态就可以用布尔值。再次，首先判断的是传入对象是否小于当前对象的primary，小于则返回+1，不小于则往下执行代码，primary是当前对象值，args.primary是传入对象值。最后，后面的比较就是一个道理，自己看看 领悟领悟。

compareble接口

其实对于这种事情来说，要根据全方位的角度来看待。

顾名思义 就是公共的意思.就是说在public 里面定义的方法在别的类里面都是可以拿来用的.他是属于公共的方法,就这个意思.

Api上面没那么基础的东西...它们是访问标志符,表明了它修饰的对象或者成员被访问的权利说白了,就是用来封装的!不想让你看到使用的就用private允许你使用的就申明为public还有一种是默认的属于包内的public

公有的，可以在任何地方调用

公共类，可以被外部数据访问

顾名思义就是公共的意思.就是说在public里面定义的方法在别的类里面都是可以拿来用的.他是属于公共的方法,就这个意思.

意思就是共有的 作用就是所有方法等都可以访问