飘香一剑
飘香一剑

Java设计模式——Comparable接口&&Comparator（CC系）策略模式的应用

Comparable接口&&Comparator接口：突然想起了民国时期的CC系，哈哈^_^

转自：http://www.cnblogs.com/baizhanshi/p/6201875.html

Comparable

Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口。compareTo方法的返回值是int，有三种情况：

1、比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数

2、比较者等于被比较者，那么返回0

3、比较者小于被比较者，那么返回负整数

实现了这个接口说明该对象具有可比性；

写个很简单的例子：

复制代码
复制代码 
public class Domain implements Comparable
{
    private String str;

    public Domain(String str)
    {
        this.str = str;
    }

    public int compareTo(Domain domain)
    {
        if (this.str.compareTo(domain.str) > 0)
            return 1;
        else if (this.str.compareTo(domain.str) == 0)
            return 0;
        else 
            return -1;
    }
    
    public String getStr()
    {
        return str;
    }
}
复制代码
复制代码
复制代码
复制代码 
public static void main(String[] args)
    {
        Domain d1 = new Domain("c");
        Domain d2 = new Domain("c");
        Domain d3 = new Domain("b");
        Domain d4 = new Domain("d");
        System.out.println(d1.compareTo(d2));
        System.out.println(d1.compareTo(d3));
        System.out.println(d1.compareTo(d4));
    }
复制代码
复制代码

运行结果为：

0
1
-1

注意一下，前面说实现Comparable接口的类是可以支持和自己比较的，但是其实代码里面Comparable的泛型未必就一定要是Domain，将泛型指定为String或者指定为其他任何任何类型都可以----只要开发者指定了具体的比较算法就行。

 

Comparator

Comparator可以认为是是一个外比较器，个人认为有两种情况可以使用实现Comparator接口的方式：

1、一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较

2、一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式

Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：

1、o1大于o2，返回正整数

2、o1等于o2，返回0

3、o1小于o3，返回负整数

实现了这个接口说明想自定义比较的策略

写个很简单的例子，上面代码的Domain不变（假设这就是第2种场景，我对这个compareTo算法实现不满意，要自己写实现）：

复制代码
复制代码 
public class DomainComparator implements Comparator
{
    public int compare(Domain domain1, Domain domain2)
    {
        if (domain1.getStr().compareTo(domain2.getStr()) > 0)
            return 1;
        else if (domain1.getStr().compareTo(domain2.getStr()) == 0)
            return 0;
        else 
            return -1;
    }
}
复制代码
复制代码
复制代码
复制代码 
public static void main(String[] args)
{
    Domain d1 = new Domain("c");
    Domain d2 = new Domain("c");
    Domain d3 = new Domain("b");
    Domain d4 = new Domain("d");
    DomainComparator dc = new DomainComparator();
    System.out.println(dc.compare(d1, d2));
    System.out.println(dc.compare(d1, d3));
    System.out.println(dc.compare(d1, d4));
}
复制代码
复制代码

看一下运行结果：

0
1
-1

当然因为泛型指定死了，所以实现Comparator接口的实现类只能是两个相同的对象（不能一个Domain、一个String）进行比较了，因此实现Comparator接口的实现类一般都会以"待比较的实体类+Comparator"来命名.

在自己的项目中获取对象集合中如果在sql中没有进行预排序，可以在这儿进行排序，例如：

1
2
3
4
5
6
7
List partAreaDtoList = ruleService.getPartAreaList();
        Collections.sort(partAreaDtoList,  new  Comparator() {
            @Override
            public  int  compare(PartAreaDto o1, PartAreaDto o2) {
                return  o2.getAreaCode().compareTo(o1.getAreaCode());
            }
        });

　

1
Collections.sort这样比较以后 list集合就会按照areaCode 进行正序排列，如果是Collections.reverse()则会按照areaCode进行倒序排列。　

总结

总结一下，两种比较器Comparable和Comparator，后者相比前者有如下优点：

1、如果实现类没有实现Comparable接口，又想对两个类进行比较（或者实现类实现了Comparable接口，但是对compareTo方法内的比较算法不满意），那么可以实现Comparator接口，自定义一个比较器，写比较算法

2、实现Comparable接口的方式比实现Comparator接口的耦合性要强一些，如果要修改比较算法，要修改Comparable接口的实现类，而实现Comparator的类是在外部进行比较的，不需要对实现类有任何修改。从这个角度说，其实有些不太好，尤其在我们将实现类的.class文件打成一个.jar文件提供给开发者使用的时候。实际上实现Comparator接口的方式后面会写到就是一种典型的策略模式。

当然，这不是鼓励用Comparator，意思是开发者还是要在具体场景下选择最合适的那种比较器而已。

转自：http://blog.csdn.net/acmman/article/details/46634355

在遍历容器元素的时候，有很多初学者在疑惑，为什么返回一个iterator我就能够去遍历这个容器了呢？

今天我们就来深入剖析一下迭代器iterator的设计模式(循序渐进的剖析，一定要耐心看完)

iterator是"四人帮"所定义的23种设计模式之一(不太难，也不是非常重要，只是在遍历容器的时候能够用到)

首先需要读这个总结的同志掌握面向对象的思想。

1.我们先自己写一个可以动态添加对象的容器
建立一个新的Java工程：Iterator
创建一个包：cn.edu.hpu.iterator
在包下创建类ArrayList：
我们要在容器内首先添加一个add方法，用于向容器内添加元素
再写一个size方法，用于查找容器元素个数

ArrayList.java:

[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public class ArrayList {  
  4.     //我们要用数组模拟一个可以添加任意大小元素的容器  
  5.     //首先我们固定一个数组空间，再添加元素的时候，我们去判断  
  6.     //这个空间是不是满了，如果满了再在此基础上再添加一个固定空间  
  7.     //往下依次类推，这样就有了可以添加任意大小元素的容器  
  8.     //当然，容器大小一定不可能超过计算机内存的大小  
  9.     Object[] objects=new Object[10];   
  10.     int index=0;//代表objects的下一个空的位置在哪里  
  11.       
  12.     //添加元素方法  
  13.     public void add(Object o){  
  14.         if(index==objects.length){  
  15.             //原来的数组已满，要做扩展(原长度X2)  
  16.             Object[] newObjects=new Object[objects.length*2];  
  17.             //把objects内容拷贝到新的数组newObjects上  
  18.             System.arraycopy(objects, 0, newObjects, 0, objects.length);//数组拷贝函数  
  19.             objects=newObjects;//之后把newObjects拷贝给objects数组  
  20.         }  
  21.         objects[index]=o;  
  22.         index++;  
  23.     }  
  24.       
  25.     //获取容器元素个数方法  
  26.     public int size(){  
  27.         return index;  
  28.     }  
  29. }  


测试:

[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. import cn.edu.hpu.iterator.ArrayList;  
  4.   
  5. public class ArrayListTest {  
  6.     public static void main(String[] args) {  
  7.         ArrayList al=new ArrayList();  
  8.         for(int i=0;i<20;i++){  
  9.             al.add(new Object());  
  10.         }  
  11.         System.out.println(al.size());  
  12.     }  
  13. }  
测试结果:20

我们就完成了这样一个容器，这个容器是用数组来实现的。容器比数组好在哪里呢？使用容器就不需要考虑到数组的边界问题了，容器可以动态拓展。想往里面装就add就行了，想知道大小直接size就可以了。

2.我们加一个辅助类Cat
Cat.java:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public class Cat {  
  4.     private int id;  
  5.   
  6.   
  7.     public Cat(int id) {  
  8.         super();  
  9.         this.id = id;  
  10.     }  
  11.       
  12.     public int getId() {  
  13.         return id;  
  14.     }  
  15.       
  16.     public void setId(int id) {  
  17.         this.id = id;  
  18.     }  
  19. }  

以后添加元素就添加这个就可以了，因为可以通过id值知道添加了哪些数据
如测试:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. import cn.edu.hpu.iterator.ArrayList;  
  4.   
  5. public class ArrayListTest {  
  6.     public static void main(String[] args) {  
  7.         ArrayList al=new ArrayList();  
  8.         for(int i=0;i<20;i++){  
  9.             al.add(new Cat(i));  
  10.         }  
  11.         System.out.println(al.size());  
  12.     }  
  13. }  


3.OK，现在我腻歪了，不想用ArrayList容器了，我想用其它容器去装Cat，这个新的容器我们底层不用数组实现了，我们用链表来实现。（需要你先了解数据结构中的链表概念）
建立一个新容器类LinkedList,一个节点类Node
LinkedList.java:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public class LinkedList {  
  4.     Node head=null;//头节点(以后的元素通过next得到)  
  5.     Node tail=null;//尾节点  
  6.     int size=0;  
  7.     public void add(Object o){  
  8.         Node n=new Node(o,null);  
  9.         if(head==null){  
  10.             head=n;  
  11.             tail=n;  
  12.         }  
  13.         tail.setNext(n);  
  14.         tail=n;  
  15.         size++;  
  16.           
  17.     }  
  18.       
  19.     public int size(){  
  20.         return size;  
  21.     }  
  22. }  


Node.java:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public class Node {  
  4.     private Object data;  
  5.     private Node next;  
  6.       
  7.       
  8.     public Node(Object data, Node next) {  
  9.         super();  
  10.         this.data = data;  
  11.         this.next = next;  
  12.     }  
  13.       
  14.     public Object getData() {  
  15.         return data;  
  16.     }  
  17.       
  18.     public void setData(Object data) {  
  19.         this.data = data;  
  20.     }  
  21.       
  22.     public Node getNext() {  
  23.         return next;  
  24.     }  
  25.       
  26.     public void setNext(Node next) {  
  27.         this.next = next;  
  28.     }  
  29.       
  30. }  

测试:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. import cn.edu.hpu.iterator.LinkedList;  
  4.   
  5. public class LinkedListTest {  
  6.     public static void main(String[] args) {  
  7.         LinkedList ll=new LinkedList();  
  8.         for(int i=0;i<20;i++){  
  9.             ll.add(new Cat(i));  
  10.         }  
  11.         System.out.println(ll.size());  
  12.     }  
  13. }  
测试结果:20


我们实现了两个内部原理完全不同的容器，那么下面我们来看:

4.考虑容器的可替换性
什么叫做可替换性？考虑我们使用容器的客户端类，想使这些容器可以任意的替换，其它代码不用改变，这就需要我们把所有容器的对外提供的方法统一起来。
解决方案:
我们写一个统一的接口Collection，定义一些统一的规范，让所有容器去实现这个接口。
Collection.java:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public interface Collection {  
  4.     void add(Object o);  
  5.     int size();  
  6. }  

ArrayList.java:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public class ArrayList implements Collection{  
  4.       
  5.     Object[] objects=new Object[10];   
  6.     int index=0;  
  7.     public void add(Object o){  
  8.         if(index==objects.length){  
  9.               
  10.             Object[] newObjects=new Object[objects.length*2];  
  11.               
  12.             System.arraycopy(objects, 0, newObjects, 0, objects.length);  
  13.             objects=newObjects;  
  14.         }  
  15.         objects[index]=o;  
  16.         index++;  
  17.     }  
  18.       
  19.     public int size(){  
  20.         return index;  
  21.     }  
  22. }  

LinkedList.java:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public class LinkedList implements Collection{  
  4.     Node head=null;  
  5.     Node tail=null;  
  6.     int size=0;  
  7.     public void add(Object o){  
  8.         Node n=new Node(o,null);  
  9.         if(head==null){  
  10.             head=n;  
  11.             tail=n;  
  12.         }  
  13.         tail.setNext(n);  
  14.         tail=n;  
  15.         size++;  
  16.           
  17.     }  
  18.       
  19.     public int size(){  
  20.         return size;  
  21.     }  
  22. }  

这样我们就用Collection接口来实现对不同容器对外方法的统一。
在我们测试的时候就可以使用这种方式来实现容器:
Collection c=new ArrayList();
我对ArrayList不满意，就可以改成
Collection c=new LinkedList();

小结：针对接口编程就不需要考虑具体的实现类是什么，所以你的程序会更加灵活，要替换其它实现的时候，只需换一个位置(当然如果你写在配置文件上，你连代码都不用改)。

5.接下来重点来了，我们的容器需要一个非常非常重要的功能-------遍历
我想遍历容器中的所有元素，如何去做？
当然可以这样来写:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. import cn.edu.hpu.iterator.ArrayList;  
  4. import cn.edu.hpu.iterator.Collection;  
  5.   
  6. public class ArrayListTest {  
  7.     public static void main(String[] args) {  
  8.         Collection c=new ArrayList();  
  9.         for(int i=0;i<20;i++){  
  10.             c.add(new Cat(i));  
  11.         }  
  12.         System.out.println(c.size());  
  13.           
  14.         ArrayList al=(ArrayList)c;  
  15.         for(int i=0;i
  16.             Cat cat=(Cat)al.objects[i];  
  17.             System.out.print(cat.getId()+" ");  
  18.         }  
  19.     }  
  20. }  
结果:
20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 

但是，当我们将Collection的实现改为LinkedList的时候下面的遍历方法就不行了。
这个时候就需要一种统一的遍历方式。

每一种容器都应该有它自己的一种遍历方式，我们要想方设法的给他们统一起来，但是每种容器的遍历器的实现又不一样，所以统一遍历方式只能用一种共同的实现方式，接口或抽象类的方式。

所以我们这么写：
定义一个接口Iterator：
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public interface Iterator {  
  4.     Object next();  
  5.     boolean hasNext();  
  6. }  

其中有两个未实现的方法:next和hasNext。
我要求任何一个容器都必须给我一个实现了这个接口的类的对象，
具体的实现交给具体的容器自己去实现。实现完了之后，我肯定知道，
这个对象就实现这两个方法了，有了这两个方法，我就可以实现对这
个容器的遍历了。

我们在Collection中加入返回Iterator的未实现方法
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public interface Collection {  
  4.     void add(Object o);  
  5.     int size();  
  6.     Iterator iterator();  
  7. }  

ArrayList实现了iterator()这个方法
[java]  view plain  copy
 
  1. public Iterator iterator(){  
  2.         return null;  
  3.     }  

测试:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. import cn.edu.hpu.iterator.ArrayList;  
  4. import cn.edu.hpu.iterator.Collection;  
  5. import cn.edu.hpu.iterator.Iterator;  
  6.   
  7. public class ArrayListTest {  
  8.     public static void main(String[] args) {  
  9.         Collection c=new ArrayList();  
  10.         for(int i=0;i<20;i++){  
  11.             c.add(new Cat(i));  
  12.         }  
  13.         System.out.println(c.size());  
  14.           
  15.         /*之前的方法 
  16.                 ArrayList al=(ArrayList)c; 
  17.         for(int i=0;i 
  18.             Cat cat=(Cat)al.objects[i]; 
  19.             System.out.print(cat.getId()+" "); 
  20.         }*/  
  21.   
  22.                 //使用统一遍历器的遍历方法  
  23.                 ArrayList al=(ArrayList)c;  
  24.         Iterator it=c.iterator();  
  25.         while(it.hasNext()){  
  26.             Object o=it.next();  
  27.             Cat cat=(Cat)o;  
  28.             System.out.print(cat.getId()+" ");  
  29.         }  
  30.     }  
  31. }  
这样我们怎么改变Collection的实现类，都不影响遍历方式。

6.当然我没还没有写Iterator的实现，我们来写实现：
我们在ArrayList中写一个内部类ArrayListIterator，实现Iterator接口：
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. public class ArrayList implements Collection{  
  4.   
  5.     Object[] objects=new Object[10];   
  6.     int index=0;  
  7.       
  8.     public void add(Object o){  
  9.         if(index==objects.length){  
  10.               
  11.             Object[] newObjects=new Object[objects.length*2];  
  12.       
  13.             System.arraycopy(objects, 0, newObjects, 0, objects.length);  
  14.             objects=newObjects;  
  15.         }  
  16.         objects[index]=o;  
  17.         index++;  
  18.     }  
  19.       
  20.     public int size(){  
  21.         return index;  
  22.     }  
  23.       
  24.     public Iterator iterator(){  
  25.         return new ArrayListIterator();  
  26.     }  
  27.       
  28.     private class ArrayListIterator implements Iterator{  
  29.   
  30.   
  31.         private int currentIndex=0;  
  32.           
  33.         @Override  
  34.         public boolean hasNext() {  
  35.             if(currentIndex>index) return false;  
  36.             else return true;  
  37.         }  
  38.   
  39.         @Override  
  40.         public Object next() {  
  41.             Object o=objects[currentIndex];  
  42.             currentIndex++;  
  43.             return o;  
  44.         }  
  45.           
  46.     }  
  47. }  

测试:
[java]  view plain  copy
 
  1. package cn.edu.hpu.iterator;  
  2.   
  3. import cn.edu.hpu.iterator.ArrayList;  
  4. import cn.edu.hpu.iterator.Collection;  
  5. import cn.edu.hpu.iterator.Iterator;  
  6.   
  7.   
  8. public class ArrayListTest {  
  9.     public static void main(String[] args) {  
  10.         Collection c=new ArrayList();  
  11.         for(int i=0;i<20;i++){  
  12.             c.add(new Cat(i));  
  13.         }  
  14.         System.out.println(c.size());  
  15.   
  16.   
  17.                 //使用统一遍历器的遍历方法  
  18.         ArrayList al=(ArrayList)c;  
  19.         Iterator it=c.iterator();  
  20.         while(it.hasNext()){  
  21.             Object o=it.next();  
  22.             Cat cat=(Cat)o;  
  23.             System.out.print(cat.getId()+" ");  
  24.         }  
  25.     }  
  26. }  
测试结果:
20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 

在我们的JavaAPI中的ArrayList也实现了Java的Collection接口，同样提供了一个方法，
叫iterator()，这个方法返回了一个实现了Iterator接口的对象。

现在大家明白iterator()方法到底是干什么用的，它返回的接口又是什么意思了吧？

作业:
这个LinkedList也需要写一个iterator方法，返回一个实现了Iterator的对象。该如何写？

这是我自己写的: http://blog.csdn.net/acmman/article/details/43924261

感谢马士兵老师的"设计模式"视频提供的帮助
转载请注明出处:http://blog.csdn.net/acmman/article/details/43920153


你可能感兴趣的:(Java_J2SE)

  • springmvc 下 freemarker页面枚举的遍历输出 杨白白 enumfreemarker
    spring mvc freemarker 中遍历枚举 1枚举类型有一个本地方法叫values（），这个方法可以直接返回枚举数组。所以可以利用这个遍历。 enum public enum BooleanEnum { TRUE(Boolean.TRUE, "是"), FALSE(Boolean.FALSE, "否");
  • 实习简要总结 byalias 工作
    来白虹不知不觉中已经一个多月了，因为项目还在需求分析及项目架构阶段，自己在这段 时间都是在学习相关技术知识，现在对这段时间的工作及学习情况做一个总结： （1）工作技能方面 大体分为两个阶段，Java Web 基础阶段和Java EE阶段 1）Java Web阶段 在这个阶段，自己主要着重学习了 JSP, Servlet, JDBC, MySQL，这些知识的核心点都过 了一遍，也
  • Quartz——DateIntervalTrigger触发器 eksliang quartz
    转载请出自出处：http://eksliang.iteye.com/blog/2208559 一.概述 simpleTrigger 内部实现机制是通过计算间隔时间来计算下次的执行时间，这就导致他有不适合调度的定时任务。例如我们想每天的 1：00AM 执行任务，如果使用 SimpleTrigger，间隔时间就是一天。注意这里就会有一个问题，即当有 misfired 的任务并且恢复执行时，该执行时间
  • Unix快捷键 18289753290 unixUnix；快捷键;
    复制，删除，粘贴： dd:删除光标所在的行                             &nbs
  • 获取Android设备屏幕的相关参数 酷的飞上天空 android
    包含屏幕的分辨率  以及 屏幕宽度的最大dp 高度最大dp   TextView text = (TextView)findViewById(R.id.text); DisplayMetrics dm = new DisplayMetrics(); text.append("getResources().ge
  • 要做物联网？先保护好你的数据 蓝儿唯美 数据
    根据Beecham Research的说法，那些在行业中希望利用物联网的关键领域需要提供更好的安全性。 在Beecham的物联网安全威胁图谱上，展示了那些可能产生内外部攻击并且需要通过快速发展的物联网行业加以解决的关键领域。 Beecham Research的技术主管Jon Howes说：“之所以我们目前还没有看到与物联网相关的严重安全事件，是因为目前还没有在大型客户和企业应用中进行部署，也就
  • Java取模（求余）运算 随便小屋 java
            整数之间的取模求余运算很好求，但几乎没有遇到过对负数进行取模求余，直接看下面代码： /** * * @author Logic * */ public class Test { public static void main(String[] args) { // TODO A
  • SQL注入介绍 aijuans sql注入
    二、SQL注入范例 这里我们根据用户登录页面 <form action="" > 用户名：<input type="text" name="username"><br/> 密 码：<input type="password" name="passwor
  • 优雅代码风格 aoyouzi 代码
    总结了几点关于优雅代码风格的描述： 代码简单：不隐藏设计者的意图，抽象干净利落，控制语句直截了当。 接口清晰：类型接口表现力直白，字面表达含义，API 相互呼应以增强可测试性。 依赖项少：依赖关系越少越好，依赖少证明内聚程度高，低耦合利于自动测试，便于重构。 没有重复：重复代码意味着某些概念或想法没有在代码中良好的体现，及时重构消除重复。 战术分层：代码分层清晰，隔离明确，
  • 布尔数组 百合不是茶 java布尔数组
      androi中提到了布尔数组;   布尔数组默认的是false,  并且只会打印false或者是true   布尔数组的例子;  根据字符数组创建布尔数组 char[] c = {'p','u','b','l','i','c'}; //根据字符数组的长度创建布尔数组的个数 boolean[] b = new bool
  • web.xml之welcome-file-list、error-page bijian1013 javaweb.xmlservleterror-page
    welcome-file-list 1.定义： <welcome-file-list> <welcome-file>login.jsp</welcome> </welcome-file-list>  2.作用：用来指定WEB应用首页名称。   error-page1.定义： <error-page&g
  • richfaces 4 fileUpload组件删除上传的文件 sunjing clearRichfaces 4fileupload
     页面代码               <h:form id="fileForm">            <rich:
  • 技术文章备忘 bit1129 技术文章
    Zookeeper http://wenku.baidu.com/view/bab171ffaef8941ea76e05b8.html http://wenku.baidu.com/link?url=8thAIwFTnPh2KL2b0p1V7XSgmF9ZEFgw4V_MkIpA9j8BX2rDQMPgK5l3wcs9oBTxeekOnm5P3BK8c6K2DWynq9nfUCkRlTt9uV
  • org.hibernate.hql.ast.QuerySyntaxException: unexpected token: on near line 1解决方案 白糖_ Hibernate
    文章摘自：http://blog.csdn.net/yangwawa19870921/article/details/7553181   在编写HQL时，可能会出现这种代码： select a.name,b.age from TableA a left join TableB b on a.id=b.id  如果这是HQL，那么这段代码就是错误的，因为HQL不支持
  • sqlserver按照字段内容进行排序 bozch 按照内容排序
    在做项目的时候，遇到了这样的一个需求：           从数据库中取出的数据集，首先要将某个数据或者多个数据按照地段内容放到前面显示，例如:从学生表中取出姓李的放到数据集的前面；          select * fro
  • 编程珠玑-第一章-位图排序 bylijinnan java编程珠玑
    import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.Writer; import java.util.Random; public class BitMapSearch {
  • Java关于==和equals chenbowen00 java
    关于==和equals概念其实很简单，一个是比较内存地址是否相同，一个比较的是值内容是否相同。虽然理解上不难，但是有时存在一些理解误区，如下情况： 1、 String a = "aaa"; a=="aaa"; ==> true 2、 new String("aaa")==new String("aaa
  • [IT与资本]软件行业需对外界投资热情保持警惕 comsci it
          我还是那个看法,软件行业需要增强内生动力,尽量依靠自有资金和营业收入来进行经营,避免在资本市场上经受各种不同类型的风险,为企业自主研发核心技术和产品提供稳定,温和的外部环境...       如果我们在自己尚未掌握核心技术之前,企图依靠上市来筹集资金,然后使劲往某个领域砸钱,然
  • oracle 数据块结构 daizj oracle块数据块块结构行目录
    oracle 数据块是数据库存储的最小单位，一般为操作系统块的N倍。其结构为： 块头－－〉空行－－〉数据，其实际为纵行结构。 块的标准大小由初始化参数DB_BLOCK_SIZE指定。具有标准大小的块称为标准块（Standard Block）。块的大小和标准块的大小不同的块叫非标准块（Nonstandard Block）。同一数据库中，Oracle9i及以上版本支持同一数据库中同时使用标
  • github上一些觉得对自己工作有用的项目收集 dengkane github
    github上一些觉得对自己工作有用的项目收集 技能类 markdown语法中文说明 回到顶部 全文检索 elasticsearch bigdesk elasticsearch管理插件 回到顶部 nosql mapdb 支持亿级别map, list, 支持事务. 可考虑做为缓存使用 C
  • 初二上学期难记单词二 dcj3sjt126com englishword
    dangerous 危险的 panda 熊猫 lion 狮子 elephant 象 monkey 猴子 tiger 老虎 deer 鹿 snake 蛇 rabbit 兔子 duck 鸭 horse 马 forest 森林 fall 跌倒；落下 climb 爬；攀登 finish 完成；结束 cinema 电影院；电影 seafood 海鲜；海产食品 bank 银行
  • 8、mysql外键(FOREIGN KEY)的简单使用 dcj3sjt126com mysql
    一、基本概念 1、MySQL中“键”和“索引”的定义相同，所以外键和主键一样也是索引的一种。不同的是MySQL会自动为所有表的主键进行索引，但是外键字段必须由用户进行明确的索引。用于外键关系的字段必须在所有的参照表中进行明确地索引，InnoDB不能自动地创建索引。 2、外键可以是一对一的，一个表的记录只能与另一个表的一条记录连接，或者是一对多的，一个表的记录与另一个表的多条记录连接。 3、如
  • java循环标签 Foreach shuizhaosi888 标签java循环foreach
    1. 简单的for循环 public static void main(String[] args) { for (int i = 1, y = i + 10; i < 5 && y < 12; i++, y = i * 2) { System.err.println("i=" + i + " y="
  • Spring Security（05）——异常信息本地化 234390216 exceptionSpring Security异常信息本地化
    异常信息本地化          Spring Security支持将展现给终端用户看的异常信息本地化，这些信息包括认证失败、访问被拒绝等。而对于展现给开发者看的异常信息和日志信息（如配置错误）则是不能够进行本地化的，它们是以英文硬编码在Spring Security的代码中的。在Spring-Security-core-x
  • DUBBO架构服务端告警Failed to send message Response javamingtingzhao 架构DUBBO
     废话不多说，警告日志如下，不知道有哪位遇到过，此异常在服务端抛出(服务器启动第一次运行会有这个警告)，后续运行没问题，找了好久真心不知道哪里错了。    WARN 2015-07-18 22:31:15,272 com.alibaba.dubbo.remoting.transport.dispatcher.ChannelEventRunnable.run(84)
  • JS中Date对象中几个用法 leeqq JavaScriptDate最后一天
    近来工作中遇到这样的两个需求 1. 给个Date对象，找出该时间所在月的第一天和最后一天 2. 给个Date对象，找出该时间所在周的第一天和最后一天   需求1中的找月第一天很简单，我记得api中有setDate方法可以使用 使用setDate方法前，先看看getDate var date = new Date(); console.log(date); // Sat J
  • MFC中使用ado技术操作数据库 你不认识的休道人 sqlmfc
    1.在stdafx.h中导入ado动态链接库 #import"C:\Program Files\Common Files\System\ado\msado15.dll" no_namespace rename("EOF","end")2.在CTestApp文件的InitInstance()函数中domodal之前写::CoIniti
  • Android Studio加速 rensanning android studio
    Android Studio慢、吃内存！启动时后会立即通过Gradle来sync & build工程。 （1）设置Android Studio a) 禁用插件 File -> Settings...  Plugins 去掉一些没有用的插件。 比如：Git Integration、GitHub、Google Cloud Testing、Google Cloud
  • 各数据库的批量Update操作 tomcat_oracle javaoraclesqlmysqlsqlite
    MyBatis的update元素的用法与insert元素基本相同，因此本篇不打算重复了。本篇仅记录批量update操作的 sql语句，懂得SQL语句，那么MyBatis部分的操作就简单了。 　　注意：下列批量更新语句都是作为一个事务整体执行，要不全部成功，要不全部回滚。 MSSQL的SQL语句 　WITH R AS（ 　　SELECT 'John' as name, 18 as
  • html禁止清除input文本输入缓存 xp9802 input
    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。如果不想让浏览器缓存input的值，有2种方法： 方法一： 在不想使用缓存的input中添加 autocomplete="off"; eg: <input type="text" autocomplete="off" name
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他