raincoffee
raincoffee

Hive-ObjectInspector

Serde

Serde是什么：Serde实现数据序列化和反序列化以及提供一个辅助类ObjectInspector帮助使用者访问需要序列化或者反序列化的对象。

Serde层构建在数据存储和执行引擎之间，实现数据存储+中间数据存储和执行引擎的解耦。

public abstract class AbstractSerDe implements SerDe {
    public abstract void initialize(Configuration paramConfiguration, Properties paramProperties) throws SerDeException;

    public abstract Class getSerializedClass();

    public abstract Writable serialize(Object paramObject, ObjectInspector paramObjectInspector) throws SerDeException;

    public abstract SerDeStats getSerDeStats();

    public abstract Object deserialize(Writable paramWritable) throws SerDeException;

    public abstract ObjectInspector getObjectInspector() throws SerDeException;
}

这里为什么提到数据存储和中间数据存储两个概念，因为数据序列化和反序列化不仅仅用在对目标文件的读取和结果数据写入，还需要实现中间结果保存和传输，Hive最终会将SQL转化为mapreduce程序，而mapreduce程序需要读取原始数据，并将最终的结果数据写入存储介质，Serde一方面用在针对inputformat中RecordReader读取数据的解析和最终结果的保存，另一方面，在map和reduce之间有一层shuffle，中间结果由Hadoop完成shuffle后也需要读取并反序列化成内部的object，这个object实际上通常是一个Array或者list，但hive会提供一个StandardStructObjectInspector给用户进行该Object的访问。

上一个Operator的输出是下一个Operator的输入，每一个Operator处理后，数据已经发生变化，比如SelectOperator会将用户没有选择的列去掉（如果数据读取端没有按列存储，一般将读取所有列数据上来），再比如经过groupby算子(map阶段被下推的group by)的数据，key已经变为聚类的列，value已经变成局部聚类的结果，所以每一个operator必须知道上一个operator结果数据的格式，我们先看下operator对象的一个重要方法：

void forward(Object row, ObjectInspector rowInspector)；其实rowInspector这个参数已经没用了。

每一个operator处理完数据后就通过该方法将结果推给下一个operator，但是针对ReduceSinkOperator是个例外，它需要把中间结果序列化交给hadoop框架进行数据shuffle，在reduce时，再反序列化回来（通过上文提到的Serde），继续遍历Operator树进行处理。

为什么说这里的rowInspector参数已经没用了呢，我们先看ExecMapper的configure方法，ExecMapper是唯一一个map实现类，针对reducer还有一个ExecReducer：这里只列出了相关内容的代码。

public void configure(JobConf job){
    //实例化一个MapOperator作为map执行的起点，保存一些上下文对象
    mo = new MapOperator();
    //这里的初始化方法其实调用的是Operator的初始化方法，最终调用到了Operator的initializeOp方法。
    mo.initialize(jc, null);
}

每个Operator在initializeOp方法中实例化自己的outputObjInspector对象，因为只有自己知道自己需要产生的数据是什么结构，并将该outputObjInspector最为参数调用自己childOperator的initialize(Configuration hconf, ObjectInspector inputOI, int parentId)方法，这样自己的childOperator就拿到了上一个Operator生成结果对象的ObjectOperator，也就是说，上一个Operator把数据对象推下来后，自己已经知道这个对象是什么结构了，至此完成了整个operator树的初始化。

ObjectInspector

public abstract interface ObjectInspector extends Cloneable {
    public abstract String getTypeName();

    public abstract Category getCategory();

    public static enum Category {
        PRIMITIVE, LIST, MAP, STRUCT, UNION;
    }
}
Hive-ObjectInspector_第1张图片

通过getCategory方法可以知道该ObjectInspector是什么类型，我们通过一个实例了解该对象的使用，通过ObjectInspector帮助我们序列化对象。

    static void serialize(OutputByteBuffer buffer, Object o, 
            ObjectInspector oi, boolean invert){
        switch (oi.getCategory()) {
        case PRIMITIVE:{
            PrimitiveObjectInspector poi = (PrimitiveObjectInspector) oi;
            switch (poi.getPrimitiveCategory()) {
            case BOOLEAN:
                boolean v=((BooleanObjectInspector)poi).get(o);
                buffer.write((byte) (v ? 2 : 1), invert);
                break;          
            default:
                break;
            }
        }
        case STRUCT:{
            StructObjectInspector soi=(StructObjectInspector)oi;
            List fields = soi.getAllStructFieldRefs();
            for (int i = 0; i < fields.size(); i++) {
                serialize(buffer, soi.getStructFieldData(o, fields.get(i)), 
                        fields.get(i).getFieldObjectInspector(), invert);
            }
            return;
        }
        default:
            break;
        }
    }

primitiveObjectInspector

继承关系如下：


Hive-ObjectInspector_第2张图片

首先查看primitiveObjectInspector接口如下：

public abstract interface PrimitiveObjectInspector extends ObjectInspector {
    public abstract PrimitiveTypeInfo getTypeInfo();

    public abstract PrimitiveCategory getPrimitiveCategory();

    public abstract Class getPrimitiveWritableClass();

    public abstract Object getPrimitiveWritableObject(Object paramObject);

    public abstract Class getJavaPrimitiveClass();

    public abstract Object getPrimitiveJavaObject(Object paramObject);

    public abstract Object copyObject(Object paramObject);

    public abstract boolean preferWritable();

    public abstract int precision();

    public abstract int scale();

    public static enum PrimitiveCategory {
        VOID, BOOLEAN, BYTE, SHORT, INT, LONG, FLOAT, DOUBLE, STRING, DATE, TIMESTAMP, BINARY, DECIMAL, VARCHAR, CHAR, UNKNOWN;
    }
}

可以根据PrimitiveCategory得知具体是哪个基本类型。DoubleObjectInspector在原接口基础上提供了get方法。public abstract double get(Object paramObject);SettableDoubleObjectInspector接口提供了
set和create方法。

WritableDoubleObjectInspector实现如下：

public class WritableDoubleObjectInspector extends AbstractPrimitiveWritableObjectInspector
        implements SettableDoubleObjectInspector {
    WritableDoubleObjectInspector() {
        super(TypeInfoFactory.doubleTypeInfo);
    }

    public double get(Object o) {
        return ((DoubleWritable) o).get();
    }

    public Object copyObject(Object o) {
        return new DoubleWritable(((DoubleWritable) o).get());
    }

    public Object getPrimitiveJavaObject(Object o) {
        return ((o == null) ? null : Double.valueOf(((DoubleWritable) o).get()));
    }

    public Object create(double value) {
        return new DoubleWritable(value);
    }

    public Object set(Object o, double value) {
        ((DoubleWritable) o).set(value);
        return o;
    }
}

注意这里面返回的都是writable形式的，如DoubleWritable。不是java中基本类型。

ListObjectInspector

list结构使用ListObjectInspector类型来表示。
层次关系如下：

Hive-ObjectInspector_第3张图片

接口如下：

public abstract interface ListObjectInspector extends ObjectInspector {
    public abstract ObjectInspector getListElementObjectInspector();//获取list中element的类型

    public abstract Object getListElement(Object paramObject, int paramInt);

    public abstract int getListLength(Object paramObject);

    public abstract List getList(Object paramObject);
}

SettableListObjectInspector,继承ListObjectInspector接口，提供接口如下：

public abstract interface SettableListObjectInspector extends ListObjectInspector {
    public abstract Object create(int paramInt);

    public abstract Object set(Object paramObject1, int paramInt, Object paramObject2);

    public abstract Object resize(Object paramObject, int paramInt);
}

StandardListObjectInspector是一个标准实现。实现见代码。比较简单。

/*** Eclipse Class Decompiler plugin, copyright (c) 2016 Chen Chao ([email protected]) ***/
package org.apache.hadoop.hive.serde2.objectinspector;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StandardListObjectInspector implements SettableListObjectInspector {
    private ObjectInspector listElementObjectInspector;//元素类型

    protected StandardListObjectInspector() {
    }

    protected StandardListObjectInspector(ObjectInspector listElementObjectInspector) {
        this.listElementObjectInspector = listElementObjectInspector;
    }

    public final ObjectInspector.Category getCategory() {
        return ObjectInspector.Category.LIST;
    }

    public ObjectInspector getListElementObjectInspector() {
        return this.listElementObjectInspector;
    }

    public Object getListElement(Object data, int index) {
        if (data == null) {
            return null;
        }

        boolean isArray = !(data instanceof List);
        if (isArray) {
            Object[] list = (Object[]) (Object[]) data;
            if ((index < 0) || (index >= list.length)) {
                return null;
            }
            return list[index];
        }
        List list = (List) data;
        if ((index < 0) || (index >= list.size())) {
            return null;
        }
        return list.get(index);
    }

    public int getListLength(Object data) {
        if (data == null) {
            return -1;
        }

        boolean isArray = !(data instanceof List);
        if (isArray) {
            Object[] list = (Object[]) (Object[]) data;
            return list.length;
        }
        List list = (List) data;
        return list.size();
    }

    public List getList(Object data) {
        if (data == null) {
            return null;
        }

        if (!(data instanceof List)) {
            data = Arrays.asList((Object[]) (Object[]) data);
        }
        List list = (List) data;
        return list;
    }

    public String getTypeName() {
        return "array<" + this.listElementObjectInspector.getTypeName() + ">";
    }

    public Object create(int size) {
        List a = new ArrayList(size);
        for (int i = 0; i < size; ++i) {
            a.add(null);
        }
        return a;
    }

    public Object resize(Object list, int newSize) {
        List a = (List) list;
        while (a.size() < newSize) {
            a.add(null);
        }
        while (a.size() > newSize) {
            a.remove(a.size() - 1);
        }
        return a;
    }

    public Object set(Object list, int index, Object element) {
        List a = (List) list;
        a.set(index, element);
        return a;
    }
}

MapObjectInspector

继承关系类似list。

MapObjectInspector接口主要定义了key和value类型的获取方法，获取map元素，获取一个map对象，及map大小等通用接口。

public abstract interface MapObjectInspector extends ObjectInspector {
    public abstract ObjectInspector getMapKeyObjectInspector();

    public abstract ObjectInspector getMapValueObjectInspector();

    public abstract Object getMapValueElement(Object paramObject1, Object paramObject2);

    public abstract Map getMap(Object paramObject);

    public abstract int getMapSize(Object paramObject);
}

SettableMapObjectInspector接口主要提供了添加 移除 创建等接口、

public abstract interface SettableMapObjectInspector extends MapObjectInspector {
    public abstract Object create();

    public abstract Object put(Object paramObject1, Object paramObject2, Object paramObject3);

    public abstract Object remove(Object paramObject1, Object paramObject2);

    public abstract Object clear(Object paramObject);
}

StandardMapObjectInspector一个标准实现，实现如下：

public class StandardMapObjectInspector implements SettableMapObjectInspector {
    private ObjectInspector mapKeyObjectInspector;
    private ObjectInspector mapValueObjectInspector;

    protected StandardMapObjectInspector() {
    }

    protected StandardMapObjectInspector(ObjectInspector mapKeyObjectInspector,
            ObjectInspector mapValueObjectInspector) {
        this.mapKeyObjectInspector = mapKeyObjectInspector;
        this.mapValueObjectInspector = mapValueObjectInspector;
    }

    public ObjectInspector getMapKeyObjectInspector() {
        return this.mapKeyObjectInspector;
    }

    public ObjectInspector getMapValueObjectInspector() {
        return this.mapValueObjectInspector;
    }

    public Object getMapValueElement(Object data, Object key) {
        if ((data == null) || (key == null)) {
            return null;
        }
        Map map = (Map) data;
        return map.get(key);
    }

    public int getMapSize(Object data) {
        if (data == null) {
            return -1;
        }
        Map map = (Map) data;
        return map.size();
    }

    public Map getMap(Object data) {
        if (data == null) {
            return null;
        }
        Map map = (Map) data;
        return map;
    }

    public final ObjectInspector.Category getCategory() {
        return ObjectInspector.Category.MAP;
    }

    public String getTypeName() {
        return "map<" + this.mapKeyObjectInspector.getTypeName() + "," + this.mapValueObjectInspector.getTypeName()
                + ">";
    }

    public Object create() {
        Map m = new HashMap();
        return m;
    }

    public Object clear(Object map) {
        Map m = (HashMap) map;
        m.clear();
        return m;
    }

    public Object put(Object map, Object key, Object value) {
        Map m = (HashMap) map;
        m.put(key, value);
        return m;
    }

    public Object remove(Object map, Object key) {
        Map m = (HashMap) map;
        m.remove(key);
        return m;
    }
}

StructObjectInspector

StructObjectInspector是一个抽象类。

public abstract class StructObjectInspector implements ObjectInspector {
    public abstract List getAllStructFieldRefs();

    public abstract StructField getStructFieldRef(String paramString);

    public abstract Object getStructFieldData(Object paramObject, StructField paramStructField);

    public abstract List getStructFieldsDataAsList(Object paramObject);

    public boolean isSettable() {
        return false;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        List fields = getAllStructFieldRefs();
        sb.append(super.getClass().getName());
        sb.append("<");
        for (int i = 0; i < fields.size(); ++i) {
            if (i > 0) {
                sb.append(",");
            }
            sb.append(((StructField) fields.get(i)).getFieldObjectInspector().toString());
        }
        sb.append(">");
        return sb.toString();
    }
}
 
 
我们来看一个标准实现。StandardStructObjectInspector。
 其中 包含一个静态类MyField，继承StructField。定义了fieldname 和fieldcoment 以及fieldobjectInspector等属性。
 主要实现如下：
 
 
protected static class MyField implements StructField {
        protected int fieldID;
        protected String fieldName;
        protected ObjectInspector fieldObjectInspector;
        protected String fieldComment;

        protected MyField() {
        }

        public MyField(int fieldID, String fieldName, ObjectInspector fieldObjectInspector) {
            this.fieldID = fieldID;
            this.fieldName = fieldName.toLowerCase();
            this.fieldObjectInspector = fieldObjectInspector;
        }

        public MyField(int fieldID, String fieldName, ObjectInspector fieldObjectInspector, String fieldComment) {
            this(fieldID, fieldName, fieldObjectInspector);
            this.fieldComment = fieldComment;
        }
    }

 
 
StandardStructObjectInspector中定义了一个list对象，来存储field。protected List fields;
 
 
通过init方法来初始化。
 
 
protected StandardStructObjectInspector(List structFieldNames,
            List structFieldObjectInspectors) {
        init(structFieldNames, structFieldObjectInspectors, null);
    }

    protected StandardStructObjectInspector(List structFieldNames,
            List structFieldObjectInspectors, List structFieldComments) {
        init(structFieldNames, structFieldObjectInspectors, structFieldComments);
    }

    protected void init(List structFieldNames, List structFieldObjectInspectors,
            List structFieldComments) {
        assert (structFieldNames.size() == structFieldObjectInspectors.size());
        assert ((structFieldComments == null) || (structFieldNames.size() == structFieldComments.size()));

        this.fields = new ArrayList(structFieldNames.size());
        for (int i = 0; i < structFieldNames.size(); ++i)
            this.fields.add(new MyField(i, (String) structFieldNames.get(i),
                    (ObjectInspector) structFieldObjectInspectors.get(i),
                    (structFieldComments == null) ? null : (String) structFieldComments.get(i)));
    }

    protected StandardStructObjectInspector(List fields) {
        init(fields);
    }

    protected void init(List fields) {
        this.fields = new ArrayList(fields.size());
        for (int i = 0; i < fields.size(); ++i)
            this.fields.add(new MyField(i, ((StructField) fields.get(i)).getFieldName(),
                    ((StructField) fields.get(i)).getFieldObjectInspector()));
    }

 
 
获取某一个fieldname对应的fieldcomment方法实现如下：
 
 
public Object getStructFieldData(Object data, StructField fieldRef) {
        if (data == null) {
            return null;
        }

        boolean isArray = !(data instanceof List);
        if ((!(isArray)) && (!(data instanceof List))) {
            return data;
        }
        int listSize = (isArray) ? ((Object[]) (Object[]) data).length : ((List) data).size();

        MyField f = (MyField) fieldRef;
        if ((this.fields.size() != listSize) && (!(this.warned))) {
            this.warned = true;
            LOG.warn("Trying to access " + this.fields.size() + " fields inside a list of " + listSize + " elements: "
                    + ((isArray) ? Arrays.asList((Object[]) (Object[]) data) : (List) data));

            LOG.warn("ignoring similar errors.");
        }
        int fieldID = f.getFieldID();
        assert ((fieldID >= 0) && (fieldID < this.fields.size()));

        if (fieldID >= listSize)
            return null;
        if (isArray) {
            return ((Object[]) (Object[]) data)[fieldID];
        }
        return ((List) data).get(fieldID);
    }

 
 
其他方法：
 
 
public String getTypeName() {
        return ObjectInspectorUtils.getStandardStructTypeName(this);
    }

    public final ObjectInspector.Category getCategory() {
        return ObjectInspector.Category.STRUCT;
    }

    public StructField getStructFieldRef(String fieldName) {
        return ObjectInspectorUtils.getStandardStructFieldRef(fieldName, this.fields);
    }

 
 
这里面使用了一个工具类ObjectInspectorUtils。
 
 
ObjectInspectorUtils
 
 
主要提供一些工具方法、
 
 
 
  
 
   
 
    Hive-ObjectInspector_第4张图片 
   
 
  
 
  
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Hive-ObjectInspector)

        

            

                
    
                    
  • Hive-ObjectInspector
                        raincoffee

                        
    SerdeSerde是什么：Serde实现数据序列化和反序列化以及提供一个辅助类ObjectInspector帮助使用者访问需要序列化或者反序列化的对象。Serde层构建在数据存储和执行引擎之间，实现数据存储+中间数据存储和执行引擎的解耦。publicabstractclassAbstractSerDeimplementsSerDe{publicabstractvoidinitialize(Con
    
                    
    • 
                                
  • windows下源码安装golang
                                    616050468
golang安装golang环境windows
                                    
             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1 
  
 1.  安装前准备(gcc, gdb, git) 
       golang在64位系
    
                                
    • 
                                
  • redis批量删除带空格的key
                                    bylijinnan
redis
                                    
    redis批量删除的通常做法： 
 
 
redis-cli keys "blacklist*" | xargs redis-cli del 
 
上面的命令在key的前后没有空格时是可以的，但有空格就不行了： 
 

$redis-cli keys "blacklist*"
1) "blacklist:12: [email protected]
    
                                
    • 
                                
  • oracle正则表达式的用法
                                    0624chenhong
oracle正则表达式
                                    
      方括号表达示 
方括号表达式 
描述 
[[:alnum:]] 
字母和数字混合的字符 
[[:alpha:]] 
字母字符 
[[:cntrl:]] 
控制字符 
[[:digit:]] 
数字字符 
[[:graph:]] 
图像字符 
[[:lower:]] 
小写字母字符 
[[:print:]] 
打印字符 
[[:punct：]] 
标点符号字符 
[[:space:]]
    
                                
    • 
                                
  • 2048源码(核心算法有，缺少几个anctionbar，以后补上)
                                    不懂事的小屁孩
2048
                                    
    2048游戏基本上有四部分组成， 
1：主activity，包含游戏块的16个方格，上面统计分数的模块 
2：底下的gridview，监听上下左右的滑动，进行事件处理， 
3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 
4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 
 
写代码的流程 
1：设计游戏的布局，基本是两块，上面是分
    
                                
    • 
                                
  • jquery内部链式调用机理
                                    换个号韩国红果果
JavaScriptjquery
                                    
    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） 

function  create(type){
var element=document.createElement(type);
    //this=element;

    
                                
    • 
                                
  • 你订酒店时的每一次点击 背后都是NoSQL和云计算
                                    蓝儿唯美
NoSQL
                                    
    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。 
云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 
Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
    
                                
    • 
                                
  • java笔记1
                                    a-john
java
                                    
    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 
2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 
3，面向对象程序设计方式的特性： 
    3.1 万物皆为对象。 
   
    
                                
    • 
                                
  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一）
                                    aijuans
C/C++求职面试必备考点
                                    
            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。 
       后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
    
                                
    • 
                                
  • 程序员写代码时就不要管需求了吗？
                                    asia007
程序员不能一味跟需求走
                                    
          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。 
      我的技术不是很好，但是就不代
    
                                
    • 
                                
  • Activity的四种启动模式
                                    百合不是茶
android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动
                                    
    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ; 
  
启动模式xml中配置 
    <activity android:name=".MainActivity" android:launchMode="standard&quo
    
                                
    • 
                                
  • Spring中@Autowired标签与@Resource标签的区别
                                    bijian1013
javaspring@Resource@Autowired@Qualifier
                                    
    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。 
  
1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
    
                                
    • 
                                
  • Changes Between SOAP 1.1 and SOAP 1.2
                                    sunjing
ChangesEnableSOAP 1.1SOAP 1.2
                                    
    JAX-WS 
SOAP Version 1.2 Part 0: Primer (Second Edition) 
SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) 
SOAP Version 1.2 Part 2: Adjuncts (Second Edition) 
  
Which style of WSDL
    
                                
    • 
                                
  • 【Hadoop二】Hadoop常用命令
                                    bit1129
hadoop
                                    
    以Hadoop运行Hadoop自带的wordcount为例， 
  
hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行 
  Hadoop HDFS相关命令 
 
  hadoop fs -ls 
 
 列出HDFS文件系统的第一级文件和第一级
    
                                
    • 
                                
  • java异常处理（初级）
                                    白糖_
javaDAOspring虚拟机Ajax
                                    
    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。 
最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
    
                                
    • 
                                
  • 记录整理-工作问题
                                    braveCS
工作
                                    
    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 
2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
    
                                
    • 
                                
  • org.apache.tools.zip实现文件的压缩和解压，支持中文
                                    bylijinnan
apache
                                    
    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦） 
后改用org.apache.tools.zip 
org.apache.tools.zip的使用网上有更简单的例子 
下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 
 



import java.io.BufferedReader;
import java.io.BufferedWrit
    
                                
    • 
                                
  • 读书笔记-4
                                    chengxuyuancsdn
读书笔记
                                    
    1、JSTL 核心标签库标签 
2、避免SQL注入 
3、字符串逆转方法 
4、字符串比较compareTo 
5、字符串替换replace 
6、分拆字符串 
 
 
1、JSTL 核心标签库标签共有13个，
学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html
功能上分为4类：
(1)表达式控制标签：out
    
                                
    • 
                                
  • [物理与电子]半导体教材的一个小问题
                                    comsci
问题
                                    
     
 
      各种模拟电子和数字电子教材中都有这个词汇-空穴 
 
      书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴 
 
      我现在回过头翻大学时候的教材,觉得这个
    
                                
    • 
                                
  • Flashback Database --闪回数据库
                                    daizj
oracle闪回数据库
                                    
    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。 
在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
    
                                
    • 
                                
  • 简单排序:插入排序
                                    dieslrae
插入排序
                                    
    
    public void insertSort(int[] array){
        int temp;
        
        for(int i=1;i<array.length;i++){
            temp = array[i];
            
            for(int k=i-1;k>=0;k--)
    
                                
    • 
                                
  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int * p; //等价于 int *p 也等价于 int* p;
	int i = 5;
	char ch = 'A';

	//p = 5;	//error
	//p = &ch;	//error
	//p = ch;	//error

	p = &i;		// 
    
                                
    • 
                                
  • centos下php redis扩展的安装配置3种方法
                                    dcj3sjt126com
redis
                                    
    方法一 
1.下载php redis扩展包     代码如下 复制代码    
#wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz     
2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
    
                                
    • 
                                
  • 线程池(Executors)
                                    shuizhaosi888
线程池
                                    
    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 
	public interface Executor {

	    void execute(Runnable command);
	}
 
  
public class RunMain implements Executor{

	@Override
	pub
    
                                
    • 
                                
  • openstack 快速安装笔记
                                    haoningabc
openstack
                                    
    前提是要配置好yum源 
版本icehouse，操作系统redhat6.5 
最简化安装，不要cinder和swift 
三个节点 
172 control节点keystone glance horizon 
173 compute节点nova 
173 network节点neutron 
 

control
/etc/sysctl.conf

net.ipv4.ip_forward =
    
                                
    • 
                                
  • 从c面向对象的实现理解c++的对象（二）
                                    jimmee
C++面向对象虚函数
                                    
    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 
2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 
3. c++中类的析构函数，就时回收内存(free) 
4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。 
专门在
    
                                
    • 
                                
  • 如何让那个一个div可以拖动
                                    lingfeng520240
html
                                    
    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml
    
                                
    • 
                                
  • 第10章 高级事件（中）
                                    onestopweb
事件
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • 计算两个经纬度之间的距离
                                    roadrunners
计算纬度LBS经度距离
                                    
    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 
	/**
	 * 
	 * @param longitudeA
	 *            经度A点
	 * @param latitudeA
	 *            纬度A点
	 * @param longitudeB
	 *    
    
                                
    • 
                                
  • 最具争议的10个Java话题
                                    tomcat_oracle
java
                                    
    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！   　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。   　 
　2、Java 9 即将到来   　　 
Oracle早在8月份就发布
    
                                
    • 
                                
  • zoj 3826 Hierarchical Notation(模拟)
                                    阿尔萨斯
rar
                                    
     题目链接：zoj 3826 Hierarchical Notation 
 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。 
 解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
    
                                
    •