王崧 库超 现在干什么

1. 王崧 库超 现在干什么

我同学，都在美国，王崧博士毕业在普林斯顿做数论研究！

2. 超库智能科技上海有限公司怎么样？

超库智能科技上海有限公司是2016-11-02在上海市奉贤区注册成立的有限责任公司(自然人投资或控股)，注册地址位于上海市奉贤区柘林镇胡桥新街17号7幢1272室。
超库智能科技上海有限公司的统一社会信用代码/注册号是91310120MA1HLMGX0G，企业法人吴超，目前企业处于开业状态。
超库智能科技上海有限公司的经营范围是：从事智能科技、自动化设备科技领域内的技术开发、技术咨询、技术服务、技术转让，金属货架、自动化设备、电子产品、电子元器件、机械设备、机电设备设计、制造、加工（以上限分支机构经营）、安装、维修、批发、零售，仓储设备、通信设备、计算机、软件及辅助设备、物流设备、冷库设备、停车库设备、安防设备、办公设备批发、零售，钢结构建设工程专项设计，钢结构建设工程专业施工。【依法须经批准的项目，经相关部门批准后方可开展经营活动】。本省范围内，当前企业的注册资本属于一般。
通过百度企业信用查看超库智能科技上海有限公司更多信息和资讯。

3. 欧尚超市仓库存储现状

1: 根据分类来检查，将总的库存金额划分到每个分类
2：根据每个分类库存/销量的比值，可以计算出一个数值（可以简单定义为库存天数）
3：当库存天数到每个分类后，可以通过分类库存天数和总库存天数的GAP来找到，动销率最差的分类
4：改进优先寻找到那些库存金额大&动销率低的分类。问题无非2点：订货太多或销量太差
接下来你只要针对这2点拓展开来去处理即可（比如销量差的原因是：入选问题，陈列问题，促销问题等等。。。。。。。。

4. 数据库超难查询问题 菜鸟勿入

说实话这个句子蛮难写的
如果纯粹是为了考智力可以尝试一下
不过我觉的如果是为了解决问题最好将时间按照y-m-d-h-m-s的方式拆分开来,这样想做什么统计都方便
如果不想这么做的话确实有点难,我测试了几下都不成功,因为group by无法使用一个列的别名,操作起来实在是不太好`~~~~~~~

5. 大虾请进：oracle数据库超大数据量的处理

通过使用一些辅助性工具来找到程序中的瓶颈，然后就可以对瓶颈部分的代码进行优化。一般有两种方案：即优化代码或更改设计方法。我们一般会选择后者，因为不去调用以下代码要比调用一些优化的代码更能提高程序的性能。而一个设计良好的程序能够精简代码，从而提高性能。
下面将提供一些在JAVA程序的设计和编码中，为了能够提高JAVA程序的性能，而经常采用的一些方法和技巧。
1．对象的生成和大小的调整。

　　JAVA程序设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数，从而常常会生成大量的对象（或实例）。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。
　　例1：关于String ,StringBuffer，+和append
　　JAVA语言提供了对于String类型变量的操作。但如果使用不当，会给程序的性能带来影响。如下面的语句：
　　String name=new String("HuangWeiFeng");
　　System.out.println(name+"is my name");
　　看似已经很精简了，其实并非如此。为了生成二进制的代码，要进行如下的步骤和操作：
　　(1) 生成新的字符串 new String（STR_1);
　　(2) 复制该字符串;
　　(3) 加载字符串常量"HuangWeiFeng"（STR_2);
　　(4) 调用字符串的构架器（Constructor）;
　　(5) 保存该字符串到数组中（从位置0开始）;
　　(6) 从java.io.PrintStream类中得到静态的out变量;
　　(7) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
　　(8) 复制该字符串缓冲变量;
　　(9) 调用字符串缓冲的构架器（Constructor）;
　　(10) 保存该字符串缓冲到数组中（从位置1开始）;
　　(11) 以STR_1为参数，调用字符串缓冲(StringBuffer)类中的append方法;
　　(12) 加载字符串常量"is my name"(STR_3);
　　(13) 以STR_3为参数，调用字符串缓冲(StringBuffer)类中的append方法;
　　(14) 对于STR_BUF_1执行toString命令;
　　(15) 调用out变量中的println方法，输出结果。
　　由此可以看出，这两行简单的代码，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。
　　经修改，上面的代码可以用如下的代码来替换。
　　StringBuffer name=new StringBuffer("HuangWeiFeng");
　　System.out.println(name.append("is my name.").toString());
　　系统将进行如下的操作：
　　(1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
　　(2) 复制该字符串缓冲变量;
　　(3) 加载字符串常量"HuangWeiFeng"(STR_1);
　　(4) 调用字符串缓冲的构架器（Constructor）;
　　(5) 保存该字符串缓冲到数组中（从位置1开始）;
　　(6) 从java.io.PrintStream类中得到静态的out变量;
　　(7) 加载STR_BUF_1;
　　(8) 加载字符串常量"is my name"(STR_2);
　　(9) 以STR_2为参数，调用字符串缓冲(StringBuffer)实例中的append方法;
　　(10) 对于STR_BUF_1执行toString命令(STR_3);
　　(11)调用out变量中的println方法，输出结果。
　　由此可以看出，经过改进后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程序的性能有很大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象，而代码段2只生成了四个对象。
　　代码段1：
　　String name= new StringBuffer("HuangWeiFeng");
　　name+="is my";
　　name+="name";
　　代码段2：
　　StringBuffer name=new StringBuffer("HuangWeiFeng");
　　name.append("is my");
　　name.append("name.").toString();
　　因此，充分的利用JAVA提供的库函数来优化程序，对提高JAVA程序的性能时非常重要的.其注意点主要有如下几方面； 
　　(1) 尽可能的使用静态变量（Static Class Variables）
　　如果类中的变量不会随他的实例而变化，就可以定义为静态变量，从而使他所有的实例都共享这个变量。
　　例：
　　public class foo
　　{
　　　SomeObject so=new SomeObject();
　　}
　　就可以定义为：
　　public class foo
　　{
　　　static SomeObject so=new SomeObject();
　　}
　　(2) 不要对已生成的对象作过多的改变。
　　对于一些类(如：String类)来讲，宁愿在重新生成一个新的对象实例，而不应该修改已经生成的对象实例。
　　例：
　　String name="Huang";
　　name="Wei";
　　name="Feng";
　　上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的操作，性能将得更差，因为系统将不得为此生成更多得临时变量，如上例1所示。
　　(3) 生成对象时，要分配给它合理的空间和大小JAVA中的很多类都有它的默认的空间分配大小。对于StringBuffer类来讲，默认的分配空间大小是16个字符。如果在程序中使用StringBuffer的空间大小不是16个字符，那么就必须进行正确的初始化。
　　(4) 避免生成不太使用或生命周期短的对象或变量。对于这种情况，因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。
　　(5) 只在对象作用范围内进行初始化。JAVA允许在代码的任何地方定义和初始化对象。这样，就可以只在对象作用的范围内进行初始化。从而节约系统的开销。
　　例：
　　SomeObject so=new SomeObject();
　　If(x==1) then
　　{
　　　Foo=so.getXX();
　　}
　　可以修改为：
　　if(x==1) then
　　{
　　　SomeObject so=new SomeObject();
　　　Foo=so.getXX();
　　}
2．异常(Exceptions)
　　JAVA语言中提供了try/catch来发方便用户捕捉异常，进行异常的处理。但是如果使用不当，也会给JAVA程序的性能带来影响。因此，要注意以下两点：
　　(1) 避免对应用程序的逻辑使用try/catch
　　如果可以用if,while等逻辑语句来处理，那么就尽可能的不用try/catch语句。
　　(2) 重用异常
　　在必须要进行异常的处理时，要尽可能的重用已经存在的异常对象。以为在异常的处理中，生成一个异常对象要消耗掉大部分的时间。
3. 线程(Threading)
　　一个高性能的应用程序中一般都会用到线程。因为线程能充分利用系统的资源。在其他线程因为等待硬盘或网络读写而 时，程序能继续处理和运行。但是对线程运用不当，也会影响程序的性能。
　　例2：正确使用Vector类
　　Vector主要用来保存各种类型的对象（包括相同类型和不同类型的对象）。但是在一些情况下使用会给程序带来性能上的影响。这主要是由Vector类的两个特点所决定的。第一，Vector提供了线程的安全保护功能。即使Vector类中的许多方法同步。但是如果你已经确认你的应用程序是单线程，这些方法的同步就完全不必要了。第二，在Vector查找存储的各种对象时，常常要花很多的时间进行类型的匹配。而当这些对象都是同一类型时，这些匹配就完全不必要了。因此，有必要设计一个单线程的，保存特定类型对象的类或集合来替代Vector类.用来替换的程序如下（StringVector.java）：
　　public class StringVector
　　{
　　　private String [] data;
　　　private int count;
　　　public StringVector()
　　　{
　　　　this(10); // default size is 10
　　　}
　　　public StringVector(int initialSize)
　　　{
　　　　data = new String[initialSize];
　　　}
　　　public void add(String str)
　　　{
　　　// ignore null strings
　　　if(str == null) { return; }
　　　ensureCapacity(count + 1);
　　　data[count++] = str;
　　　}
　　　private void ensureCapacity(int minCapacity)
　　　{
　　　　int oldCapacity = data.length;
　　　　if (minCapacity > oldCapacity)
　　　　{
　　　　　String oldData[] = data;
　　　　　int newCapacity = oldCapacity * 2;
　　　　　data = new String[newCapacity];
　　　　　System.arraycopy(oldData, 0, data, 0, count);
　　　　}
　　　}
　　　public void remove(String str)
　　　{
　　　if(str == null) { return; // ignore null str }
　　　for(int i = 0; i < count; i++)
　　　{
　　　　// check for a match
　　　　if(data[i].equals(str))
　　　　{
　　　　　System.arraycopy(data,i+1,data,i,count-1); // copy data
　　　　　// allow previously valid array element be gc'd
　　　　　data[--count] = null;
　　　　　return;
　　　　}
　　　}
　　　}
　　　public final String getStringAt(int index)
　　　{
　　　if(index < 0) { return null; }
　　　else if(index > count) { return null; // index is > # strings }
　　　else { return data[index]; // index is good }
　　　}
　　}
　　因此，代码：
　　Vector Strings=new Vector();
　　Strings.add("One");
　　Strings.add("Two");
　　String Second=(String)Strings.elementAt(1);
　　可以用如下的代码替换：
　　StringVector Strings=new StringVector();
　　Strings.add("One");
　　Strings.add("Two");
　　String Second=Strings.getStringAt(1); 
　　这样就可以通过优化线程来提高JAVA程序的性能。用于测试的程序如下（TestCollection.java）: 
　　import java.util.Vector;
　　public class TestCollection
　　{
　　　public static void main(String args [])
　　　{
　　　　TestCollection collect = new TestCollection();
　　　　if(args.length == 0)
　　　　{
　　　　　System.out.println("Usage: java TestCollection [ vector | stringvector ]");
　　　　　System.exit(1);
　　　　}
　　　　if(args[0].equals("vector"))
　　　　{
　　　　　Vector store = new Vector();
　　　　　long start = System.currentTimeMillis();
　　　　　for(int i = 0; i < 1000000; i++)
　　　　　{
　　　　　　store.addElement("string");
　　　　　}
　　　　　long finish = System.currentTimeMillis();
　　　　　System.out.println((finish-start));
　　　　　start = System.currentTimeMillis();
　　　　　for(int i = 0; i < 1000000; i++)
　　　　　{
　　　　　　String result = (String)store.elementAt(i);
　　　　　}
　　　　　finish = System.currentTimeMillis();
　　　　　System.out.println((finish-start));
　　　　}
　　　　else if(args[0].equals("stringvector"))
　　　　{
　　　　　StringVector store = new StringVector();
　　　　　long start = System.currentTimeMillis();
　　　　　for(int i = 0; i < 1000000; i++) { store.add("string"); }
　　　　　long finish = System.currentTimeMillis();
　　　　　System.out.println((finish-start));
　　　　　start = System.currentTimeMillis();
　　　　　for(int i = 0; i < 1000000; i++) {
　　　　　　String result = store.getStringAt(i);
　　　　　}
　　　　　finish = System.currentTimeMillis();
　　　　　System.out.println((finish-start));
　　　　}
　　　}
　　}
　　关于线程的操作，要注意如下几个方面：
　　(1) 防止过多的同步
　　如上所示，不必要的同步常常会造成程序性能的下降。因此，如果程序是单线程，则一定不要使用同步。
　　(2) 同步方法而不要同步整个代码段
　　对某个方法或函数进行同步比对整个代码段进行同步的性能要好。
　　(3) 对每个对象使用多”锁”的机制来增大并发。
　　一般每个对象都只有一个”锁”，这就表明如果两个线程执行一个对象的两个不同的同步方法时，会发生”死锁”。即使这两个方法并不共享任何资源。为了避免这个问题，可以对一个对象实行”多锁”的机制。如下所示：
　　class foo
　　{
　　　private static int var1;
　　　private static Object lock1=new Object();
　　　private static int var2;
　　　private static Object lock2=new Object();
　　　public static void increment1()
　　　{
　　　　synchronized(lock1)
　　　　{
　　　　　var1++;
　　　　}
　　　}
　　　public static void increment2()
　　　{
　　　　synchronized(lock2)
　　　　{
　　　　　var2++;
　　　　}
　　　}
　　}
4．输入和输出(I/O) 

　　输入和输出包括很多方面，但涉及最多的是对硬盘，网络或数据库的读写操作。对于读写操作，又分为有缓存和没有缓存的；对于数据库的操作，又可以有多种类型的JDBC驱动器可以选择。但无论怎样，都会给程序的性能带来影响。因此，需要注意如下几点：
　　(1) 使用输入输出缓冲
　　尽可能的多使用缓存。但如果要经常对缓存进行刷新（flush）,则建议不要使用缓存。
　　(2) 输出流(Output Stream)和Unicode字符串
当时用Output Stream和Unicode字符串时，Write类的开销比较大。因为它要实现Unicode到字节(byte)的转换.因此，如果可能的话,在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用。
　　(3) 当需序列化时使用transient
当序列化一个类或对象时，对于那些原子类型（atomic）或可以重建的原素要表识为transient类型。这样就不用每一次都进行序列化。如果这些序列化的对象要在网络上传输，这一小小的改变对性能会有很大的提高。
　　(4) 使用高速缓存（Cache）
对于那些经常要使用而又不大变化的对象或数据，可以把它存储在高速缓存中。这样就可以提高访问的速度。这一点对于从数据库中返回的结果集尤其重要。
　　(5) 使用速度快的JDBC驱动器（Driver）
JAVA对访问数据库提供了四种方法。这其中有两种是JDBC驱动器。一种是用JAVA外包的本地驱动器；另一种是完全的JAVA驱动器。具体要使用哪一种得根据JAVA布署的环境和应用程序本身来定。
5.一些其他的经验和技巧

　　(1) 使用局部变量。
　　(2) 避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量。
　　(3) 避免在循环中生成同一个变量或调用同一个函数（参数变量也一样）。
　　(4) 尽可能的使用static,final,private等关键字。
　　(5) 当复制大量数据时，使用System.arraycopy()命令。

6. 数据库超过最大链接数，如何使用navicat查看???

关于Navicat查看，可参考教程搜索筛选的教程

Navicat 教程：如何进行搜索筛选
在数据库或模式中查找（只限于完整版本）
Navicat 提供的“在数据库或模式中查找：功能用于一个数据库和/或模式内搜索表和视图的记录。打开查找的方法：从主菜单选择工具->在数据库或模式中查找。
选择目标连接、数据库和/或模式，输入关键字以及选择搜索准则。点击“查找”按钮，然后在“查找结果”列表中双击表或视图即可查看记录。
搜索筛选
Navicat 为连接树的连接、对象列表的对象提供筛选，“对象筛选”功能可以让用户在对象列表或模型中筛选包含筛选字符串的对象。
在 Navicat 主窗口或模型设计器点击“查找”按钮并指定一个筛选字符串。
连接树筛选能让用户在连接树筛选包含筛选字符串的连接。
点击连接树聚焦并直接指定筛选字符串。如果连接已打开，筛选也会同时应用到连接中的数据库对象。
要移除筛选，只需删除筛选字符串。

7. 什么是仓库超额物料

对仓库中的物料进行分类管理是必须的，如一家最简单的生产型企业，其仓库中的物料至少可以分为成品与原材料两种。不过更多的企业，在划分物料类别是会更加的细。如原材料可以分为零件、包装材料、辅助材料;而成品也可以进行更加细致的分类。现在项目管理员需要考虑的是，该分到哪一个级别为止？在考虑分类规则时，要兼顾如下几个因素。 一、统计的需要。 在统计库存金额时，是否要按明细来进行统计。如是否需要对成品库存按手工工具、电动工具等类别来统计库存金额。如果需要的话，那么就要这个类别来进行划分。 二、根据发料的需要。 在原材料发料或者成品出库时，不同的人员负责不同类别的材料。此时为了管理的方便，最好能够按人对物料进行分类。如此的话，就可以通过权限控制，不同的人员只能够维护自己所负责类别的物料的单据。防止其他用户不小心的误操作。 三、根据成本核算的需要。 在核算材料成本时，有可能管理者需要对成本进行细分，如分为零件成本、包装材料成本、辅助材料成本。此时就应该至少将原材料分为这三类。然后在统计时才能够根据零件类别来统计成本。

8. pip下载库超时是什么原因？

用pip管理工具安装库文件时，默认使用国外的源文件。
因此在国内的下载速度会比较慢，使用国内镜像会大大缩短下载时间。
常用的国内镜像：
https://pypi.tuna.tsinghua.edu.cn/simple/   # 清华大学https://mirrors.aliyun.com/pypi/simple/     # 阿里云https://pypi.douban.com/simple/             # 豆瓣https://pypi.mirrors.ustc.edu.cn/simple/    # 中国科学技术大学https://pypi.hustunique.com/                # 华中科技大学
设置方法：
（以清华镜像为例，其它镜像同理）
临时使用：
示例：
可以在使用pip的时候，加上参数-i和镜像地址
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/ pip
具体可参考：pip源更换为国内镜像