进阶中的码农
进阶中的码农

JAVA基础篇-深度认识Object对象

知识扫盲

Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implement the methods of this class.
Object对象是根对象,任何对象都是它的子类，包括数组的父类也是Object。

  • JDK环境:JDK1.8
  • OpenJdk:Openjdk8

感兴趣的朋友需要去下载OpenJdk源码，地址如下。
https://download.java.net/openjdk/jdk8u40/ri/openjdk-8u40-src-b25-10_feb_2015.zip

函数作用分析

函数 用途
registerNatives() 静态方法,用来注册Object类的JNI方法，放在Static{}代码块里面静态初始化了。提供clone(),notity()等JNI方法。
getClass() 返回运行时的字节对象,返回的类对象是由所表示类的静态同步方法锁定的对象。
hashCode() 返回对象的哈希码值,受益于Key-Value容器。
equals(Object other) 指示两个对象的值是否相等,必须满足自反性,对称性，传递性，一致性的特性。
clone() 返回对象的副本，亦可称之为浅度克隆(用于享元设计模式)。
toString() 返回对象的字符串表现形式 。
wait() 当前线程等待，直到另一个线程去唤醒它。
finalize() 当垃圾收集确定不再引用对象时，由对象上的垃圾收集器调用。
notify() 唤醒正在此对象监视器上等待的单个线程。
notifyAll() 唤醒正在此对象监视器上等待的所有线程。

先来看一下注册registerNativeJNI方法的OpenJdk源码，源码位置位于Object.C文件中(文件相對路徑:jdk/src/share/native/java/lang/Object.c)

//Native方法与OpenJdk中的对应关系,值得注意的是这里并没有注册//getClass
static JNINativeMethod methods[] = {
    {"hashCode",    "()I",                    (void *)&JVM_IHashCode},
    {"wait",        "(J)V",                   (void *)&JVM_MonitorWait},
    {"notify",      "()V",                    (void *)&JVM_MonitorNotify},
    {"notifyAll",   "()V",                    (void *)&JVM_MonitorNotifyAll},
    {"clone",       "()Ljava/lang/Object;",   (void *)&JVM_Clone},
};

JNIEXPORT void JNICALL
Java_java_lang_Object_registerNatives(JNIEnv *env, jclass cls)
{
    (*env)->RegisterNatives(env, cls,
                            methods, 
// result is :size() of array
sizeof(methods)/sizeof(methods[0]));
}

应用场景.

1)getClass()->得到运行时的对象，一个字节码对象，受益于反射机制。

  • 先来看一下OpenJdk中的源代码,位置位于openjdk\hotspot\src\share\vm\prims\jni.cpp


//getClass位于Object.c中
JNIEXPORT jclass JNICALL
Java_java_lang_Object_getClass(JNIEnv *env, jobject this)
{
    //this为空时抛出空指针异常
    if (this == NULL) {
        JNU_ThrowNullPointerException(env, NULL);
        return 0;
    } else {
        return (*env)->GetObjectClass(env, this);
    }
}

JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
  JNIWrapper("GetObjectClass");
#ifndef USDT2
  DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj);
#else /* USDT2 */
  HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(
                                   env, obj);
#endif /* USDT2 */
  /* 根据传入的java对象引用找到引用对象然后找到该对象类型的元数据 */
  Klass* k = JNIHandles::resolve_non_null(obj)->klass();
  /*根据元数据找到其镜像，也就是java程序中的Class对象实例*/
  jclass ret = (jclass) JNIHandles::make_local(env, k->java_mirror());
#ifndef USDT2
  DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret);
#else /* USDT2 */
  HOTSPOT_JNI_GETOBJECTCLASS_RETURN(
                                    ret);
#endif /* USDT2 */
  return ret;
JNI_END

Object a=new Object();
Object b=new Object();
System.out.println(a.getClass()==b.getClass())//输出true
System.out.println(Object.class.getClass()==b.getClass())//输出true
  1. hashCode()->返回一个对象的哈希值,是一个数值。在JAVA中,String的Final特性,并且hashCode有缓存机制（只需要计算一次后面就直接拿cache就好了),多数情况下建议选择String来做为HashMap的Key。
    字符串的哈希值计算公式是:s[0]31^(n-1) + s[1]31^(n-2) + ... + s[n-1]。
//字符串"abc"的哈希值是【96354】
"abc".getBytes()[0]*((int)Math.pow(31,2))+"abc".getBytes()[1]*((int)Math.pow(31,1))+"c".hashCode();

*********************贴一段字符串的计算hash的java代码******************************
//hash是私有变量,计算一次就会被cache.
 int h = hash;                                      
 if (h == 0 && value.length > 0) {                  
     char val[] = value;                            
                                                    
     for (int i = 0; i < value.length; i++) {       
         h = 31 * h + val[i];                       
     }                                              
     hash = h;                                      
 }                                                  
 return h; 
********************************************************************************    

  //贴出HashMap的hash算法
 static final int hash(Object key) {
        int h;
        //这里取对象的hashCode()做了亦或和无符号右移运算
       //看得出来哈希的重要性了吧。
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

补充,我们先来看一下hashCode源码。JVM_IHashCode方法指针在 openjdk\hotspot\src\share\vm\prims\jvm.cpp中定义为：

JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))  
  JVMWrapper("JVM_IHashCode");  
  // 句柄为空hashCode返回0
  return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;  
JVM_END

得知源码在synchronizer.cpp中.

  • hashCode==0 返回一个随机数
  • hashCode==1返回一个Park-Miller伪随机数生成器生成的随机数
  • hashCode==2测试敏感度
  • hashCode==3 返回一个自增长的序列号
  • hashCode==4 此类方案返回当前对象的内存地址
  • 其他 Marsaglia的xor-shift方案，具有特定于线程的状态，OpenJdk将来的版本可能会将这个方案设置为默认方案。
    备注:hashCode是VM参数,我们可以通过-XX:hashCode=4固定它的默认hash算法，不过多数情况下我们都是重写了hashCode()算法的。


static inline intptr_t get_next_hash(Thread * Self, oop obj) {
  intptr_t value = 0 ;
  if (hashCode == 0) {
     // This form uses an unguarded global Park-Miller RNG,
     // so it's possible for two threads to race and generate the same RNG.
     // On MP system we'll have lots of RW access to a global, so the
     // mechanism induces lots of coherency traffic.
     value = os::random() ;
  } else
  if (hashCode == 1) {
     // This variation has the property of being stable (idempotent)
     // between STW operations.  This can be useful in some of the 1-0
     // synchronization schemes.
     intptr_t addrBits = cast_from_oop(obj) >> 3 ;
     value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom ;
  } else
  if (hashCode == 2) {
     value = 1 ;            // for sensitivity testing
  } else
  if (hashCode == 3) {
     value = ++GVars.hcSequence ;
  } else
  if (hashCode == 4) {
     value = cast_from_oop(obj) ;
  } else {
     // Marsaglia's xor-shift scheme with thread-specific state
     // This is probably the best overall implementation -- we'll
     // likely make this the default in future releases.
     unsigned t = Self->_hashStateX ;
     t ^= (t << 11) ;
     Self->_hashStateX = Self->_hashStateY ;
     Self->_hashStateY = Self->_hashStateZ ;
     Self->_hashStateZ = Self->_hashStateW ;
     unsigned v = Self->_hashStateW ;
     v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
     Self->_hashStateW = v ;
     value = v ;
  }

  value &= markOopDesc::hash_mask;
  if (value == 0) value = 0xBAD ;
  assert (value != markOopDesc::no_hash, "invariant") ;
  TEVENT (hashCode: GENERATE) ;
  return value;
}
//
    }
    // If atomic operation failed, we must inflate the header
    // into heavy weight monitor. We could add more code here
    // for fast path, but it does not worth the complexity.
  } else if (mark->has_monitor()) {
    monitor = mark->monitor();
    temp = monitor->header();
    assert (temp->is_neutral(), "invariant") ;
    hash = temp->hash();
    if (hash) {
      return hash;
    }
    // Skip to the following code to reduce code size
  } else if (Self->is_lock_owned((address)mark->locker())) {
    temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned
    assert (temp->is_neutral(), "invariant") ;
    hash = temp->hash();              // by current thread, check if the displaced
    if (hash) {                       // header contains hash code
      return hash;
    }
    // WARNING:
    //   The displaced header is strictly immutable.
    // It can NOT be changed in ANY cases. So we have
    // to inflate the header into heavyweight monitor
    // even the current thread owns the lock. The reason
    // is the BasicLock (stack slot) will be asynchronously
    // read by other threads during the inflate() function.
    // Any change to stack may not propagate to other threads
    // correctly.
  }

  // Inflate the monitor to set hash code
  monitor = ObjectSynchronizer::inflate(Self, obj);
  // Load displaced header and check it has hash code
  mark = monitor->header();
  assert (mark->is_neutral(), "invariant") ;
  hash = mark->hash();
  if (hash == 0) {
    hash = get_next_hash(Self, obj);
    temp = mark->copy_set_hash(hash); // merge hash code into header
    assert (temp->is_neutral(), "invariant") ;
    test = (markOop) Atomic::cmpxchg_ptr(temp, monitor, mark);
    if (test != mark) {
      // The only update to the header in the monitor (outside GC)
      // is install the hash code. If someone add new usage of
      // displaced header, please update this code
      hash = test->hash();
      assert (test->is_neutral(), "invariant") ;
      assert (hash != 0, "Trivial unexpected object/monitor header usage.");
    }
  }
  // We finally get the hash
  return hash;

3）equals(Object other)-> 比较两个对象的值，不过需要注意的是Object的equals里面的比较是"==",建议重写equals()方法,重写比较逻辑。

  • 自反性 x.equals(x)==true
  • 对称性 x.equals(y) 等价于 y.equals(x)
  • 传递性 x.equals(y) y.equals(z)那么x.equals(z)
  • 一致性/持久性 x.eauls(y) 要么恒为真,要么恒为假。
"abc".equlas("abc");//输出true;
"abc".equals(new String("abc"));//输出true
"abc".equlas("abd");//输出false;
"abc".equlas(null);//输出false;
//自反性
String a="a"; a.equals(a)==true;
//chu
{
String a="a"; 
}
{String nvl=null;nvl.equals("other");//将抛出NPE}


******************************************************************************
//贴出String的equals方法
  public boolean equals(Object anObject) {
       //如果被比较的对象与当前对象都是指针指向或地址引用同一个对象的话,立马返回真。
        if (this == instance of this) {
            return true;
        }
       //如果被比较的对象是该对象的实例才比较字符串中的每个字符序列
       //这也是一种通用写法 anObject instance 
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

4)clone()->克隆出对象的副本，默认是浅度克隆,如果重写的话可以改变它的克隆程度,集合中很多容器都是重写了clone（）方法，直接化身成了深度克隆了。所以克隆的程度是相对性的,不过，克隆本质上只有两种方式:值传递克隆和引用传递克隆。

一起看下native方法 位于openjdk\hotspot\src\share\vm\prims\jvm.cpp中 JVM_Clone的实现。


JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
  JVMWrapper("JVM_Clone");
  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
  const KlassHandle klass (THREAD, obj->klass());
  JvmtiVMObjectAllocEventCollector oam;

#ifdef ASSERT
  // Just checking that the cloneable flag is set correct
  //数组默认是可被克隆的
  if (obj->is_array()) {
    guarantee(klass->is_cloneable(), "all arrays are cloneable");
  } else {
    guarantee(obj->is_instance(), "should be instanceOop");
    bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());
    guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
  }
#endif

// Check if class of obj supports the Cloneable interface.
  // All arrays are considered to be cloneable (See JLS 20.1.5)
  if (!klass->is_cloneable()) {
    ResourceMark rm(THREAD);
    THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
  }

  // Make shallow object copy
  const int size = obj->size();
  oop new_obj_oop = NULL;
//数组和对象都是调用CollectedHeap的克隆方法
  if (obj->is_array()) {
    const int length = ((arrayOop)obj())->length();
    new_obj_oop = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);
  } else {
    new_obj_oop = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);
  }

再看看collectedHeap.inline.hpp里面的分配方法

oop CollectedHeap::obj_allocate(KlassHandle klass, int size, TRAPS) {
  debug_only(check_for_valid_allocation_state());
  assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed");
  assert(size >= 0, "int won't convert to size_t");
  HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL);
  post_allocation_setup_obj(klass, obj, size);
  NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size));
  return (oop)obj;
}


oop CollectedHeap::array_allocate(KlassHandle klass,
                                  int size,
                                  int length,
                                  TRAPS) {
  debug_only(check_for_valid_allocation_state());
  assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed");
  assert(size >= 0, "int won't convert to size_t");
  HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL);
  post_allocation_setup_array(klass, obj, length);
  NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size));
  return (oop)obj;
}

接下来让我们一起欣赏java中ArrayList和HashMap实现的克隆写法。

      
        try {
            ArrayList v = (ArrayList) super.clone();
            //这里调用的是Arrays的copy对象方法，其实是浅度克隆
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        
    }
*************************************************************************
//为了证明ArrayList是浅度克隆(复制)，我们一起来做个实验
       //源头List[1,2]
        ArrayList sourceList=new ArrayList();
        sourceList.add(1);
        sourceList.add(2);

        ArrayList copiedList= (ArrayList) sourceList.clone();
        copiedList.remove(0);//移除第一个元素
        copiedList.set(0,2);//设置第一个元素
        //源没变，依然是长度为2
        System.out.println("sourceList.size()="+sourceList.size());//输出2
       //复制过来的集合长度减少了
        System.out.println("copiedList.size()="+copiedList.size());//输出1


        System.out.println("copiedList.get(0)="+copiedList.get(0));

*************************************************************************

 HashMap result;
        try {
            //拿到Super克隆过来的对象
            result = (HashMap)super.clone();
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
          //重置对象状态回到初始化状态
         result.reinitialize();
       //将当前的map实体以创建形式复制并放置到result中
        result.putMapEntries(this, false);
        return result;

  HashMap sourceMap=new HashMap();
 sourceMap.put("1",Integer.valueOf("1"));
 sourceMap.put("2",Integer.valueOf("2"));
//克隆一个Map
  HashMap cloneMap=（HashMap）sourceMap.clone();
 cloneMap.remove("2");//移除2;
System.out.print(sourceMap.get("2")==null)；//输出true

5)wait()->会释放对象锁,等待被持有该对象句柄映射的线程来唤醒它。为了能够理解它，我们将它结合notify(),notifyAll()在一块,看个例子。看完之后希望能理解(下面的例子已经极度接近于PV操作，所谓PV,换言之是生产消费者模式)。

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * 理解wait()和notify()与notifyAll();
 */
public class ObjectWait {

    boolean wait=true;
    private Object lockObject=new Object();


    public void waitForNotifyMe() throws InterruptedException {

        synchronized (lockObject) {
            while (wait)
            lockObject.wait();

        }
        //打印当前持有该对象的线程的唤醒状态
        System.out.println(Thread.currentThread().getName()+"被唤醒了");

    }

    public void waitForNotifyMe(String name) throws InterruptedException {
        synchronized (lockObject) {
            while (wait)
                lockObject.wait();
        }
        //打印当前持有该对象的线程的唤醒状态
        System.out.println(Thread.currentThread().getName()+"被唤醒了");
    }

    //唤醒一个一个线程
    public void notifyOne() throws InterruptedException {

        synchronized (lockObject) {
            this.wait=false;
            lockObject.notify();
        }
    }


    /**
     * 唤醒所有正在仅持有LockObject对象所的线程
     * @throws InterruptedException
     */
    public void notifyAllWaitThread() throws InterruptedException {

        synchronized (lockObject) {
            this.wait=false;
            lockObject.notifyAll();
        }
    }

    public static void main(String[] args) throws InterruptedException {

        ObjectWait testObjectWait=new ObjectWait();
       Thread holderLockObjectThreadA= new Thread(() -> {
           try {
               testObjectWait.waitForNotifyMe();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       });
       holderLockObjectThreadA.setName("等待被唤醒线程A");
       //启动线程A
       holderLockObjectThreadA.start();

      Thread holderLockObjectThreadB=  new Thread(() -> {
            try {
                testObjectWait.waitForNotifyMe("B");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });
        holderLockObjectThreadB.setName("等待被唤醒线程B");
        holderLockObjectThreadB.start();

       Thread notifySingleThread= new Thread(() -> {
            try {
                testObjectWait.notifyOne();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });
        notifySingleThread.setName("唤醒一个线程");
        notifySingleThread.start();

        Thread notifyALlThread=new Thread(() -> {
            try {
                testObjectWait.notifyAllWaitThread();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });
        notifyALlThread.setName("唤醒所有持有lockObject对象锁的线程");
        notifyALlThread.start();


    }
}

程序的输出结果是:

等待被唤醒线程A被唤醒了
等待被唤醒线程B被唤醒了

6)finalize()->垃圾回收器做清理工作时执行的方法,子类可以继承它来做清理系统资源,释放资源,对象复活等操作(有点像C++析构函数的作用)。这个方法在一定程度上解决内存泄漏问难题，如果当前类重写了finalize方法，且非空，需要把生成的对象封装成Finalizer（java.lang.ref.Finalizer）对象并添加到 Finalizer链表中，对象被GC时，如果是Finalizer对象，会将对象赋值到pending对象，gc时它会先删除掉finalizer中的存储对象的链表映射。
下面分享下JDK的Finalizer部分源代码

   //对象的引用队列
    private static ReferenceQueue queue = new ReferenceQueue<>();

    private static class FinalizerThread extends Thread {
        private volatile boolean running;
        FinalizerThread(ThreadGroup g) {
            super(g, "Finalizer");
        }
        public void run() {
            // in case of recursive call to run()
            if (running)
                return;

            // Finalizer thread starts before System.initializeSystemClass
            // is called.  Wait until JavaLangAccess is available
           //如果VM没有初始化，延时直到VM完成初始化
            while (!VM.isBooted()) {
                // delay until VM completes initialization
                try {
                    VM.awaitBooted();
                } catch (InterruptedException x) {
                    // ignore and continue
                }
            }
            final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
            running = true;
            for (;;) {
                try {
                    //
                    Finalizer f = (Finalizer)queue.remove();
                    f.runFinalizer(jla);
                } catch (InterruptedException x) {
                    // ignore and continue
                }
            }
        }
    }

    static {
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        for (ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent());
        Thread finalizer = new FinalizerThread(tg);
        finalizer.setPriority(Thread.MAX_PRIORITY - 2);
       //设置守护线程去回收对象的引用,注意就算JAVA对象实现了Finalizer,也有可能出现野指针现象,因为线程可能没执行
        finalizer.setDaemon(true);
        finalizer.start();
    }


我们一起看看下面这个gc时让对象复活的方法。


/**
 *测试finalize
 */
public class Finalizer {

    private static Finalizer holderThis;
  
   private void doCleanWork(){
     //关闭资源
}
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        doCleanWork();
        holderThis = this;
        System.out.println("finalize");
    }

    public static void main(String[] args) throws Throwable {
        holderThis = new Finalizer();
        holderThis = null;
        System.gc();
        //线程休眠一下,保证holderThis能够复活
        Thread.sleep(1);
        System.out.println(holderThis == null);//对象还存在，输出的是false
    }
}




分析下OpenJdk源码中的notify(),wait()方法
 请欣赏源代码


JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
  JVMWrapper("JVM_MonitorWait");
  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
  JavaThreadInObjectWaitState jtiows(thread, ms != 0);
  if (JvmtiExport::should_post_monitor_wait()) {
    JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);

    // The current thread already owns the monitor and it has not yet
    // been added to the wait queue so the current thread cannot be
    // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT
    // event handler cannot accidentally consume an unpark() meant for
    // the ParkEvent associated with this ObjectMonitor.
  }
  ObjectSynchronizer::wait(obj, ms, CHECK);
JVM_END


JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
  JVMWrapper("JVM_MonitorNotify");
  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
  ObjectSynchronizer::notify(obj, CHECK);
JVM_END


JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
  JVMWrapper("JVM_MonitorNotifyAll");
  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
  ObjectSynchronizer::notifyall(obj, CHECK);
JVM_END




    

  • 核心就是ObjectWaiter,ObjectMonitor,这两个类在openjdk\hotspot\agent\src\share\classes\sun\jvm\hotspot\runtime\ObjectSynchronizer.java
    • 







 JAVA基础篇-深度认识Object对象_第1张图片






image.png









 JAVA基础篇-深度认识Object对象_第2张图片






image.png





详情请参考:https://www.jianshu.com/p/f4454164c017,这篇大牛的博客写得很好，分析得很透彻。


谢谢您的读阅,如果觉得不错的话,可以点点赞,关注走一波，您的支持是我不断前进的动力~~///(^v^)\~~
























你可能感兴趣的:(JAVA基础篇-深度认识Object对象)






    

  • 我的相亲时代
王悦深

    我是一个80后但是被很多人认为是90后的小姐姐，因为自己之前的身体不是很好，以至于不知不觉的也变成了大龄未婚女青年，走在了又长又曲折的相亲大道上。每一次认真的投入都在我的生命里留下了一道口子，要好久才能愈合。也许一开始我就选择了一个不那么对的方向。自己最初的相亲就是父母托人介绍，然而介绍的对象我多半不喜欢，可能也跟我当时的状况有关系。我是一个特别孝顺的女生，总觉得父母做什么都是为我好，当然这要辩证
    

    • 

  • 灰度认知和黑白决策
龚小白大笨蛋

    小时候看电视总是会问粑粑麻麻里边的猪脚哪个是好人、哪个是坏人，唱的歌里也是白脸的曹操、红脸的关公，好像这世上的人都可以忠奸立辨。慢慢长大后，出了社会才渐渐明白好人也有坏的一面，坏人也有好的一面，因此要认识到这个世界其实是有很多的灰色地带，但是我们做事情确实绝对的——非黑即白。非黑即白意味着给外界明确的信息，和你相处是需要遵守一定原则的，有时候或许会被人认为是迂腐、顽固，然而在实际的交往中反而能降低
    

    • 

  • 关于爱情，我们无话可说6
清泉_9313

    6.是遗憾，还是无奈每当想起这些非常非常久远的故事，往生就觉得很多事情很简单，又很复杂。其实，往生的感觉没有错，很多很复杂的事情实际上很简单，很多很简单的事情实际上又是蛮复杂。往生想着这样绕口令一样的句子，不觉间把自己给逗笑了。话说，近一段时间以来，往生的生活中除了工作之外就是喝茶、看书，突然发现，自己已经很久都没有笑过了。别人说往生总是活得太认真，就连那个没有成功的相亲对象都觉得往生多愁善感，往
    

    • 

  • python(64) 内存的几个现象，主动释放内存
python开发笔记
Pythonpython

    1.主动释放内存的方式在Python中使用gc.collect()方法清除内存使用del语句清除Python中的内存gc.collect(generation=2)方法用于清除或释放Python中未引用的内存。未引用的内存是无法访问且无法使用的内存。可选参数generation是一个整数，值的范围是0到2。它使用gc.collect()方法指定要收集的对象的生成。在Python中，寿命短的对象存储
    

    • 

  • 2019-04-16
董友田

    你不必做个全才，但某些方面要足够优秀原创：董友田慢说漫话2018-12-27图片来自网络文｜董友田（微信公众号：慢说漫话）01我与邱哥认识不到两年，初次见面，他是作为我的面试经理。我们年龄相仿，好像他比我大一岁。可是他的经历和关于房地产方面的知识和见解，是我所不能及的。作为领导，他很随和。所以在一次的聊天中，我得以了解他以前的一些故事。邱哥没有特殊的家庭背景，也没有光鲜的履历文凭，身上倒是有广东人
    

    • 

  • pytorh基础知识和函数的学习：torchvision.transforms()
深蓝海拓
机器视觉和人工智能学习学习pytorch

    transforms是PyTorch的torchvision库中用于图像处理的一个模块。它提供了一组工具，用于在图像数据集上进行常见的预处理和数据增强操作，以便更好地训练深度学习模型。以下是一些常用的torchvision.transforms转换：基础图像转换：transforms.ToTensor():将PIL图像或NumPy数组转换为PyTorch的张量，并将像素值范围从[0,255]缩放到
    

    • 

  • 一个女大学生，因为暗地里结婚，不敢公开，瞒着父母，最后酿成了悲剧。
秦时明月wk

    一个女大学生，因为暗地里结婚，不敢公开，瞒着父母，最后酿成了悲剧。2014年，瑶瑶以优异的成绩考入河南某大学。瑶瑶性格开朗，聪明伶俐。考上大学后，瑶瑶经常在网上聊天，认识了不少网友。除了上课其他时间全都泡在网上。一天，瑶瑶又在上网聊天，一个春暖花开的网友主动加她为好友。开始瑶瑶并没有太在意这个网友，但聊着聊着，她发现这个春暖花开的网友，很幽默。谈吐文雅的春暖花开，给瑶瑶留下了很好的印象，之后，瑶瑶
    

    • 

  • 旅游方式有很多种，你喜欢的旅游方式是什么样的呢？
流浪阿紫

    文/流浪阿紫旅游方式有很多种，有人喜欢自助，有人喜欢跟团，有人喜欢深度。有人喜欢走马看花，有人喜欢热闹，有人喜欢大自然，有人喜欢城市，有人喜欢古迹，有人喜欢海岛，有人喜欢购物。你喜欢的旅游是什么样的呢？还记得我刚开始有能力出去玩的时候，只能到附近的景点游玩，时间也不能安排太长。难得有机会出去玩，当时的我深怕少玩了一点点，最好可以一天安排十来个景点，尽可能早起，非要玩到最后一班车才要回家。有一次和朋
    

    • 

  • 每日复盘 Day360
明明安安好

    3月14号复盘早起✅5：21完成每天三目标1.古筝✅2.听音频课✅3.完成第二周作业✅每日复盘向目标人物学习刚听了名师训练营易珉老师的第3讲:未来领导者的领导力深度修炼。金句摘录:1.信不信任他人，是表现自己自信的一方面。2.做决策是时候，也是要冒风险，要有承担的。3.你重复地说，坚持地说，不厌其烦地说，是对别人造成影响的。易珉老师说，领导力要从孩子抓起，让他学会承担，学会冒风险，做一个汉子，培养
    

    • 

  • 软考——简单记忆设计模式
Yeira
设计模式pythonjava

    抽象工厂模式（AbstractFactory）:提供一个接口，可以创建一系列相关或相互依赖的对象，而无需指定它们具体的类。（一个接口创建相关对象，无需具体的类）构建器模式（Builder）：将一个复杂类的表示与其构造相分离，使得相同的构建过程能够得出不同的表示。（相同是构造，不同的表示）工厂方法模式（FactoryMethod）：定义一个创建对象的接口，但由子类决定需要实例化哪一个类。工厂方法使得
    

    • 

  • Java 设计模式-状态模式
动物园首领
Java设计模式java设计模式状态模式

    目录一.概述二.主要角色三.代码示例四.优缺点优点：缺点：五.常见应用场景一.概述状态模式是一种行为设计模式，它允许一个对象在其内部状态改变时改变它的行为。对象看起来好像修改了它的类。状态模式把所有的与一个特定的状态相关的行为放到一个类中，并且将请求委托给当前状态对象来执行。在状态模式中，我们创建表示各种状态的对象和一个行为随状态对象改变而改变的Context对象。二.主要角色状态模式主要包含三个
    

    • 

  • 【软考】设计模式之抽象工厂模式
王佑辉
软考设计模式软考

    目录1.说明2.应用场景3.结构图4.构成5.适用性6.优点7.缺点8.java示例1.说明1.提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。2.抽象工厂模式（AbstractFactoryPattern）是一种创建型设计模式。3.抽象工厂模式用于系统的产品族，而不仅仅是一个等级结构；一个等级的抽象类只能创建一个等级的产品，而抽象工厂模式能创建多个等级的产品。2.应用场景1.
    

    • 

  • .NET/C#⾯试题汇总系列：集合、异常、泛型、LINQ、委托、EF！
微微的猪食小窝
c#.netlinq

    1.IList接⼝与List的区别是什么?‌定义与继承关系‌：IList是一个接口，定义了一组对象的集合，这些对象可以通过索引进行访问，并且支持插入、删除和搜索等操作。它继承自ICollection和IEnumerable，以及它们的非泛型版本。List是一个类，实现了IList接口。它提供了接口中定义的所有方法的具体实现，并添加了一些额外的功能，如排序、搜索等。‌功能与灵活性‌：使用IList接
    

    • 

  • ToList()和ToArray()的区别
微微的猪食小窝
.Net进阶.net后端开发语言linqc#

    以下是具体分析：1.返回类型ToList()：返回一个泛型列表List，其中T是列表中元素的类型。ToArray()：返回一个Object类型的数组。如果需要特定类型的数组，必须使用重载的ToArray(T[]a)方法，并传入一个该类型的数组作为参数。2.内部处理ToList()：直接创建一个新的List，并将元素添加到这个List中。ToArray()：根据传入的数组参数情况，可能会创建新数组或
    

    • 

  • 【小结】利用filter做统一编码转换
桌面很乱

    思路一：静态代理在filter中做一个内部类继承HttpServletRequestWrapper（此类采用了适配器模式，全部方法均为引用构造方法中传递的ServletRequest），进行静态代理（装饰者模式）。注意区分get和post请求的编码处理方式。加强（重写）request.getParameter(Stringkey)，最后将包装过的request对象(MyRequest)传递给ser
    

    • 

  • 浅谈C#之485通讯
CN.LG
C#网络

    一、基本介绍C#中实现485通讯，通常指的是使用RS-485串行通信接口。RS-485是一种半双工通信标准，常用于工业环境中的设备之间的通信。二、简单示例打开串口：首先，你需要创建一个SerialPort对象，并设置其参数，如端口名、波特率、数据位、停止位和奇偶校验位。然后打开串口。SerialPortsp=newSerialPort();sp.PortName="COM1";//串口名称sp.B
    

    • 

  • 深度学习驱动下的字符识别：挑战与创新
逼子歌
神经网络深度学习字符识别卷积神经网络图像处理特征提取

    一、引言1.1研究背景深度学习在字符识别领域具有至关重要的地位。随着信息技术的飞速发展，对字符识别的准确性和效率要求越来越高。字符识别作为计算机视觉领域的一个重要研究方向，其主要目的是将各种形式的字符转换成计算机可识别的文本信息。近年来，深度学习技术在字符识别领域取得了显著的进展。国内研究者主要使用基于模板匹配的方法、基于统计模型的方法、基于神经网络的方法等各种方法进行字符识别研究。目前，国内各大
    

    • 

  • Adam优化器：深度学习中的自适应方法
2401_85743969
深度学习人工智能

    引言在深度学习领域，优化算法是训练神经网络的核心组件之一。Adam（AdaptiveMomentEstimation）优化器因其自适应学习率调整能力而受到广泛关注。本文将详细介绍Adam优化器的工作原理、实现机制以及与其他优化器相比的优势。深度学习优化器概述优化器在深度学习中负责调整模型的参数，以最小化损失函数。常见的优化器包括SGD（随机梯度下降）、RMSprop、AdaGrad、AdaDelt
    

    • 

  • 写给未来自己的一封信
啊噗噗r

    写一封信给未来的自己的,可以从很多角度去写。比如时间,日常生活,以及对未来的憧憬等等。2.一、定时间当确定给未来的自己写一封信,要清楚认识到自己是要给多少年后的自己写一封信。3.二、描绘对未来的自己的夙愿可以描绘自己未来的夙愿。在信打开前,每一个阶段都有一...4.三、自己现在的生活状态把自己的生活状态,等时间到了,看这是否是自己追求的生活。...5.四、对未来的生活方式的描绘先描绘了现在的生活方
    

    • 

  • 【.NET全栈】ASP.NET开发Web应用——LINQ技术
JosieBook
#.NET全栈.netasp.netlinq

    文章目录一、LINQ基础1、LINQ简介2、延迟执行3、LINQ表达式简介1、基本查询语法2、投影新对象3、过滤和排序4、分组和聚合5、联合查询二、LINQtoDataSet操作内存表1、LINQtoDataSet简介2、类型化DataSet三、LINQtoSQL操作数据库1、数据实体类2、DataContext类介绍3、在ASP.NET中应用LINQtoSQL4、自动生成数据实体类5、生成存储过
    

    • 

  • 我想爱，请给我机会
棋中卒

    我们认识快三年了吧。那一年毫无预兆的你走进门口，说实话，那次你并没有走进我的心里，再后来的日子里，发现你慢慢地浸透到我的心里，那一刻觉得，一定要让你就记住我，必须让你记住我。于是那一次你喝醉后，我写了张小纸条，没想到你还竟然回复了我，那次真的很高兴，也很害怕。但还是被别人看到了，那个人还特意向我道了歉，可能因为我小心眼吧，我心里还是很不舒服。慢慢地就想，一定要引起你的注意。后来，文理要分，本来还在
    

    • 

  • 新学期阅读计划
抚松362王爱红

    “读书的厚度决定人生的高度，”近几年来，人们越来越认识到读书的重要性。培养孩子的阅读兴趣，提升孩子的阅读水平，已然成为一种时代的需要。作为一名老师，我有责任，有义务去引领孩子走进阅读，爱上阅读。对一个阅读教学经验欠缺的老师来说，我这个假期的收获颇多。阅读思想的转变，阅读方法的改进……在学习中真正有了改变，有了提高。为了让自己在阅读教学方面能更上层楼，我为孩子们制定了本学期的阅读计划。图片发自App
    

    • 

  • 【pytorch】register_buffer的使用
Aha_aho
pytorch人工智能python

    这篇文章讲解很清晰，以下内容仅做补充，探讨哪些对象需要手动注册，哪些会自动注册。在PyTorch中，哪些对象会自动注册为模型的一部分取决于它们的类型以及你如何定义它们。下面列出不需要手动注册、会自动注册的几种情况：1.nn.Parameter自动注册：任何你在nn.Module中定义为nn.Parameter的张量都会自动注册为模型的参数。它们会被视为模型的可训练参数，并且会被包含在模型的stat
    

    • 

  • 我好像失去了爱人的能力
冬日暖阳666

    我不适合谈恋爱只适合无聊的时候聊聊天别长期和我发展下去因为你会发现我是个很糟糕的人不是不给你信任是我太没安全感太敏感我怕你会离开怕你还有别人哪怕是一件很小很小的事情我都会胡思乱想所以啊别再给我温柔了之前经历过的我不想再去经历一次现在的我很怪不知道从什么时候起我的恋爱观变成了迟早会分我现在已经不想谈恋爱看的从新认识一个人再问名字再问年龄再每天维系我们之间的关系再了解再磨合一想到就非常累也很烦不知道是
    

    • 

  • 2-JavaObjectOriented
Goinhn

    Java面向对象设计类与对象、封装、构造方法类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。属性：就是该事物的状态信息。行为：就是该事物能够做什么。对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。类与对象的关系：类是对一类事物的描述，是抽象的。对象是一类事物的实例，是具体的。类是对象的模板，对象是类的实体。类的定义
    

    • 

  • 时间识人面，日久见人心
映日荷花Q_Q

    有句话说得很好：“这世上所有好的感情，都必然经得起时间的检验。”时间如镜，能显露心。人与人的交往始于五官，止于三观，谁都无法预料一段感情能维持多久，日久见人心，世界上有很多变数时刻在发生，我和婷姐是在刚进大学的时候认识的，两人同班，刚开始接触不多，只是点头之交。大一下学期考试月的时候，我经常在图书馆遇到她，我们都喜欢泡图书馆，于是中午一起约饭，交流沟通越来越多，彼此之间也越来越了解。到了大二上学期
    

    • 

  • 使用 i3.LayoutCell() 方法绘制版图并输出为 GDS 文件
勤奋的大熊猫
LucedaIPKISSAndKLayoutIPKISS芯片版图绘制

    使用i3.LayoutCell方法绘制版图并输出为GDS文件引言正文引言在IPKISSi3.SRef()函数一文中我们介绍了如何使用i3.SRef()函数将instance对象添加到i3.LayoutCell()创建的Cell对象上。但是当我们使用write_gdsii()输出版图时代码就会报错。这里我们将介绍如何解决这个问题。这里需要告诉大家的是，IPKISS官网给出的教程是错误的，无法正常运行
    

    • 

  • python字串节对象Bytes
局外人LZ
pythonpython

    一、简介字节串（bytes）是二进制数据的一种表示形式。它由一系列的字节组成，每个字节都是一个范围为0-255的整数。字节串可以用来表示二进制数据，例如图像、音频、视频、网络数据等。字节串与字符串（str）类型不同，字符串是由Unicode字符组成的文本数据。而字节串是原始的二进制数据，它不具备字符编码的概念，而是将数据以字节的形式进行存储和处理。在处理二进制数据时，字节串是非常有用的数据类型。它
    

    • 

  • 数据结构绪论题目
小黄瓜丹斯
数据结构#笔记数据结构数据结构

    绪论1.1数据结构的基本概念一、单项选择题1.可以用()定义一个完整的数据结构。A.数据元素B.数据对象C.数据关系D.抽象数据类型【解析】D抽象数据类型可以定义一个完整的数据结构。包括数据元素，数据元素之间的关系，以及可以进行的操作2.以下数据结构中，()是非线性数据结构。A.树B.字符串C.队列D.栈【解析】A知识点是非线性数据结构的定义。A是层次结构，为非线性数据结构；B、C、D均为线性数据
    

    • 

  • 【深度学习实战】行人检测追踪与双向流量计数系统【python源码+Pyqt5界面+数据集+训练代码】YOLOv8、ByteTrack、目标追踪、双向计数、行人检测追踪、过线计数
阿_旭
AI应用软件开发实战深度学习实战深度学习python行人检测行人追踪过线计数

    《博主简介》小伙伴们好，我是阿旭。专注于人工智能、AIGC、python、计算机视觉相关分享研究。✌更多学习资源，可关注公-仲-hao:【阿旭算法与机器学习】，共同学习交流~感谢小伙伴们点赞、关注！《------往期经典推荐------》一、AI应用软件开发实战专栏【链接】项目名称项目名称1.【人脸识别与管理系统开发】2.【车牌识别与自动收费管理系统开发】3.【手势识别系统开发】4.【人脸面部活体
    

    • 

  • apache ftpserver-CentOS config
gengzg
apache

    <server xmlns="http://mina.apache.org/ftpserver/spring/v1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://mina.apache.o
    

    • 

  • 优化MySQL数据库性能的八种方法
AILIKES
sqlmysql

    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
    

    • 

  • JeeSite 企业信息化快速开发平台
Kai_Ge
JeeSite

    JeeSite 企业信息化快速开发平台
平台简介
JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。
JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
    

    • 

  • 通过Spring Mail Api发送邮件
120153216
邮件main

    原文地址：http://www.open-open.com/lib/view/open1346857871615.html
使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】
Spring Mail API都在org.spri
    

    • 

  • Pysvn 程序员使用指南
2002wmj
SVN

    源文件:http://ju.outofmemory.cn/entry/35762
这是一篇关于pysvn模块的指南.
完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html.
pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个.
该
    

    • 

  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL
357029540
SQL Server

    SELECT  R.session_id AS BlockedSessionID , 
        S.session_id AS BlockingSessionID , 
        Q1.text AS Block
    

    • 

  • Intent 常用的用法备忘
7454103
.netandroidGoogleBlogF#

    Intent
    应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。
下面列出几种Intent 的用法
显示网页:

    

    • 

  • Spring定时器时间配置
adminjun
spring时间配置定时器

    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />
测试的时候，由于是每天定时执行，所以后面三个数
    

    • 

  • POJ 2421 Constructing Roads 最小生成树
aijuans
最小生成树

    来源：http://poj.org/problem?id=2421
题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。
思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。
代码：
#include <iostream>
#include <cstdio>
    

    • 

  • 重构笔记——提取方法（Extract Method）
ayaoxinchao
java重构提炼函数局部变量提取方法

    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。
 
下面是我学习这个重构手法的笔记：
 
提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
    

    • 

  • 为UILabel添加点击事件
bewithme
UILabel

        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。
 
UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
    

    • 

  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例)
bijian1013
redis数据库NoSQL

    一.redis.php
<?php
//实例化
$redis = new Redis();
//连接服务器
$redis->connect("localhost");
//授权
$redis->auth("lamplijie");
//相关操
    

    • 

  • SecureCRT使用备注
bingyingao
secureCRT每页行数

    SecureCRT日志和卷屏行数设置
一、使用securecrt时，设置自动日志记录功能。
1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs；
2、点击Options -> Global Options -> Default Session -> Edite Default Sett
    

    • 

  • 【Scala九】Scala核心三：泛型
bit1129
scala

    泛型类
package spark.examples.scala.generics
class GenericClass[K, V](val k: K, val v: V) {
def print() {
println(k + "," + v)
}
}
object GenericClass {
def main(args: Arr
    

    • 

  • 素数与音乐
bookjovi
素数数学haskell

        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。
    闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
    

    • 

  • Java-Collections Framework学习与总结-IdentityHashMap
BrokenDreams
Collections

            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。
        简单的说，IdentityHashMap和HashM
    

    • 

  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java
    

    • 

  • PS人像润饰&调色教程集锦
cherishLC
PS

      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓
http://www.howzhi.com/course/retouching/
  新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。
  所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
    

    • 

  • 更新多个字段的UPDATE语句
crabdave
update

    更新多个字段的UPDATE语句
 
                
update tableA a
set (a.v1, a.v2, a.v3, a.v4) = --使用括号确定更新的字段范围

    

    • 

  • hive实例讲解实现in和not in子句
daizj
hivenot inin

    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html
当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。
假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
    

    • 

  • 一道24点的10+种非人类解法（2,3,10,10）
dsjt
算法

    这是人类算24点的方法？！！！
事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态
朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。
然后么。。。我就在深夜很得瑟的问室友求室友算
刚出完题，文哥的暴走之旅开始了
5秒后
    

    • 

  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题
dcj3sjt126com
yiiframework

    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
    

    • 

  • 对象与关系之间的矛盾：“阻抗失配”效应[转]
come_for_dream
对象

    概述
 
“阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。
 
“阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
    

    • 

  • 学习编程那点事
gcq511120594
编程互联网

    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    

    • 

  • Reverse Linked List II
hcx2013
list

    Reverse a linked list from position m to n. Do it in-place and in one-pass.
For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4,
return 
    

    • 

  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介
jinnianshilongnian
spring 4.1

    目录
Spring4.1新特性——综述
Spring4.1新特性——Spring核心部分及其他
Spring4.1新特性——Spring缓存框架增强
Spring4.1新特性——异步调用和事件机制的异常处理
Spring4.1新特性——数据库集成测试脚本初始化
Spring4.1新特性——Spring MVC增强
Spring4.1新特性——页面自动化测试框架Spring MVC T
    

    • 

  • Hadoop集群工具distcp
liyonghui160com

     
 
1. 环境描述
两个集群：rock 和 stone
rock无kerberos权限认证，stone有要求认证。
1. 从rock复制到stone，采用hdfs
Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
    

    • 

  • 一个备份MySQL数据库的简单Shell脚本
pda158
mysql脚本

    　　主脚本（用于备份mysql数据库）： 　　该Shell脚本可以自动备份
数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。 　　
1. 分别建立目录“backup”和“oldbackup” 　　#mkdir /backup 　　#mkdir /oldbackup 　
    

    • 

  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇
shoothao
IT资源图标库图片库色彩板字体

    
A. 免费的设计资源
Freebbble:来自于Dribbble的免费的高质量作品。
Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。
Graphic Burger:每个像素点都做得很细的绝佳的设计资源。
Pixel Buddha:免费和优质资源的专业社区。
Premium Pixels:为那些有创意的人提供免费的素材。

    

    • 

  • thrift总结 - 跨语言服务开发
uule
thrift

    官网
官网JAVA例子
thrift入门介绍
IBM-Apache Thrift - 可伸缩的跨语言服务开发框架
Thrift入门及Java实例演示
thrift的使用介绍
 
RPC 
 
POM：
<dependency>
<groupId>org.apache.thrift</groupId>

    

    •