有意者请发送简历到：houbl#foxmail.com，请标明“应聘淘宝工程师”。

欢迎加入我们，一起来实现梦想！

淘宝新业务技术研发部目前负责支持的业务有：
机票 彩票 酒店旅行 保险 充值 淘工作 淘宝大学 垂直资讯 搜索社区

工作地点：北京
薪酬：10K-20K/月
工作年限：最少3年以上正式工作经历，请在简历中说明

淘宝Java开发高级工程师（5人）
岗位职责：
1.根据产品需求进行技术架构设计和代码开发；
2.对线上问题进行排查，对系统进行优化；
岗位要求：
1. 计算机相关专业大学本科以上学历，具有扎实的计算机基础理论知识；
2. 熟悉Java相关技术，尤其是Velocity、Spring、Ibatis开发，熟悉J2EE规范；
3. 熟悉基于数据库的设计和开发；
4. 熟悉Linux操作系统和大型数据库；
5. 了解HTML、CSS、Javascript，有互联网Web方面开发经验者优先；
6. 有相关开发经验的优先；
7. 有开源项目、分布式系统开发经验优先；

淘宝测试高级工程师（5人）
岗位职责：
1. 参与产品的需求、开发设计讨论，对产品进行功能及性能测试；
2. 制定测试方案、编写测试计划、设计测试用例，评估项目的风险；
3. 搭建测试环境，执行项目测试，进行项目总结；
4. 编写单元/接口测试Java代码，Bug定位及代码调试；
5. 能开发工作中需要的测试工具及测试框架。
岗位要求：
1. 计算机相关专业大学本科以上学历，具有扎实的计算机基础理论知识；
2. 了解测试流程和测试用例设计方法，能主动进行技术钻研，对一些常见的测试工具有所了解；
4. 熟悉Linux或Unix操作系统，熟悉J2EE优先；
5、熟练使用至少一种脚本语言，如：Shell、PHP、Perl、Ruby等；
6. 工作积极主动，乐于思考，认真细致，执行能力强，有良好的学习能力和团队合作精神。

淘宝视觉高级设计师（3人）
岗位职责：
1.参与项目规划和构思的过程；
2.完成所负责项目的界面设计工作。
岗位要求：
1.美术、设计或相关专业的本科或研究生；
2.有相关行业经验或是实习经验者优先；
3.设计基础扎实，对互联网产品设计相关理念和技术有一定的了解；
4.能够熟练使用Photoshop、Flash、Illustrator等软件；
5.良好的沟通能力和团队协作精神，能承受高强度的工作压力。

淘宝交互高级设计师（2人）
岗位职责：
1.参与项目的规划过程；
2.设计网站页面的页面结构和用户操作流程。
岗位要求：
1.工业设计或计算机相关专业的本科或研究生；
2.有相关行业经验或是实习经验者优先；
3.对互联网的各种新产品和应用有强烈的兴趣，了解互联网产品形态；
4.较强的逻辑思维能力和文档撰写能力；
5.良好的沟通能力和团队协作精神，能承受高强度的工作压力。

淘宝前端高级开发工程师（5人）
岗位职责：
1.与产品经理、交互设计师、视觉设计师协作，根据产品需求文档、线框图、视觉设计图完成页面制作；
2.与后台开发工程师协作，完成各种数据交互、动态信息展现和用户的互动；
3.使用JavaScript或ActionScript编写封装良好的前端交互组件；
4.维护及优化网站前端页面性能。
岗位要求：
1.熟悉Web前端技术，包括(X)HTML/CSS/JavaScript；
2.对Web标准，对可用性、可访问性等相关知识有一定的了解，对最新的Web前端技术有浓厚的兴趣；
3.个性乐观开朗，逻辑性强，善于和各种背景的人沟通合作；
4.计算机、通信、自动化等相关专业本科以上学历优先。

加入我们你将：
1.有全面专业的技术培训和一对一的资深工程师指导；
2.参与到许多传统行业电子商务化的变革中；
3.帮助大淘宝生态圈中许多辛勤纯朴的普通人改善生活，改变命运；
4.有机会随着大淘宝的发展而不断自我提升；
5.开创淘宝新的业务发展模式。

1.下载源码
2.将那个源码文件解压，并在你的SDK安装目录里面新建一个文件夹，取名为“sources”，把之前解压得到的所有文件都复制到新建的 “sources”文件夹里面。

CAP
CAP理论是由Brewer远在2000年的PODC会议上提出来的。CAP指的是：Consistency、Availability和Partition Tolerance，下面简述此三者：

1、Consistency（一致性）：一致性是说数据的原子性，这种原子性在经典的数据库中是通过事务来保证的，当事务完成时，无论其是成功还是回滚，数据都会处于一致的状态。在分布式环境中，一致性是说多点的数据是否一致。

2、Availability（可用性）：可用性是说服务能一直保证是可用的状态，当用户发出一个请求，服务能在有限时间内返回结果。而这种可用性是不关乎结果的正确与否，所以，如果服务一致返回错误的结果，其实也可以称为其是可用的。

3、Partition Tolerance（分区容忍性）：Partition这个词不是常说的操作系统或数据库中的用语，而是指网络的分区。网络中的两个服务结点出现分区的原因很多，比如网络断了、对方结点因为程序bug或死机等原因不能访问。

对于CAP三者，Brewer给出的结论是三者在分布式环境中不能鼎力，一个分布式系统只能有限的实现两者要求，并且这个结论又被另一高人证明了一番。
一致性问题

一致性可分为强一致性和弱一致性，弱一致性又称为最终一致性。

在单机环境中，强一致性可以由数据库的事务保证。但在多机环境中，强一致性就很难做到。尽管可以使用2PC来实现分布式事务，但它的低性能（很多情况下满足不了可用性需求）使得不适合于互联网应用。这种强一致性效果的取得，其实是让提交处理过程同步化。

在多机环境中，通过使提交处理半同步半异步、或者全异步，取得最终一致性效果。例如数据库中的主从复制，在提交时就是主库同步从库异步，这对从库复制进度落后不多的场景很简单有效，但在从库落后主库很多时，如果应用还从从库读数据，就会读出脏数据，可以通过监控从库复制进度来选择读哪个从库以避免这个问题。在NOSQL模式下，以Dynamo为例，可以通过确定NRW的不同取值，可以做到同步、半同步半异步、或者全异步的效果。

最终一致性使得数据的提交效果具有延时性，而在一定的延时性范围内（比如1秒以内），应用的可用性就是OK的，比如提交后在客户端通过JS等停一段时间刷新页面就是要取得这种效果。
像数据库这样的主从系统有着广泛的应用，它很适合于提交压力不会使得从库复制明显落后的场景。它的缺点是，当主从提交压力增大、或者存在耗时长的提交命令时，从库复制进度会明显落后于主库。在Cache+DB的应用场景下，Cache的填充时机和策略也会受到主从模式影响。如果在一个Session 中提交DB后作废Cache，而由后续的（或并发的）另一个Session来再次设置Cache、并且数据是从从库获取，就很有可能缓存住脏数据，如果 Cache时间很长，那问题可能就很严重了。可以变通的策略是，在一个Session中提交DB后不是作废Cache，而是更新Cache，并且数据是从主库获取或者直接从应用环境获取。主从的另一个问题是，它有提交单点，但是，如果主从能满足应用需要，在具有完备的主备切换的保证下，这个单点问题并不见得有多大。

因为Dynamo的时兴，对等系统成为另一种选择。对等系统解决了单点问题，有着高分区容忍性，但它的效果仍得商榷。NRW的不同取值会影响读写数据效果，多点提交带来的冲突解决也是个问题，尽管通常采用高版本替换低版本的粗暴策略。现在的NOSQL对等系统存储的是简单的kv，并且可以采用加机器来扩容，所以性能方面应该是可接受的（尽管常见的单机kv存储性能要比数据库高很多，但在对等系统中，因为其复杂性，换算下来单机的性能并不见得有多高）。

SQL和NOSQL各有其优缺点。如果存储一些实体数据并且查询提交只是根据唯一标识来，使用NOSQL也许就很合适。但像复杂的关系数据，使用 SQL就更合适些。而就提交模式来说，如果并发提交的数据隔离性不好（比如需要同时对同一个数值做更新），那么对等系统的提交冲突就会增多，数据的正确性就会受到影响。
BASE

上面提到，在分布式环境中，CAP只能取两者。但是，因为网络分区的情况不可避免，并且它对可用性有着重要影响，所以互联网中的分布式系统多在一致性方面做些折中。虽然不能达到强一致性，但可以根据应用特点采用适用的手段来达到够用的一致性效果。比如，对于微博系统，当用户新增一条消息，能够达到用户能看到刚才发的消息、而他的follower们能在尽快时间看到他新发的消息的效果就可以了。而在实现时，就可以结合同步和异步多种策略、 SQL+NOSQL多种存储方案来满足应用需要。

BASE（Basically Available、Soft state、Eventually consistent）是对CAP中的AP的延伸。

在单机环境中，ACID是数据的属性；而在分布式环境中，BASE就是数据的属性。ACID有“尖刻”之含义，所以单机环境的数据有着很高的要求。而因为分布式环境的网络分区性及复杂性，对数据也只能有“基本”的要求了。

从ACID到CAP和BASE，从单机到分布式，从SQL到NOSQL，互联网应用的大规模发展促使不断出现可替代旧方案的新技术。在技术选型方面，重要的是根据自己的应用特点选择自己能驾驭的技术。而现实的应用场景，也大多是多种技术方案的结合。

相关教程参见： 教程

reverse:

        public static void stringReverser() {
		String strOld = "aaabbb";
		String strNew = new StringBuffer(a).reverse().toString();
		System.out.println(strNew);
	}

	public static String replace(String text, String repl, String with) {
		if ((text == null) || (repl == null) || (with == null)
				|| (repl.length() == 0) || (max == 0)) {
			return text;
		}

		StringBuffer buf = new StringBuffer(text.length());
		int start = 0;
		int end = 0;

		while ((end = text.indexOf(repl, start)) != -1) {
			buf.append(text.substring(start, end)).append(with);
			start = end + repl.length();
		}

		buf.append(text.substring(start));
		return buf.toString();
	}

二: size增长.当需要增长时,Vectory为原来默认的一倍

 private void ensureCapacityHelper(int minCapacity) {
	int oldCapacity = elementData.length;
	if (minCapacity > oldCapacity) {
	    Object[] oldData = elementData;
	    int newCapacity = (capacityIncrement > 0) ?
		(oldCapacity + capacityIncrement) : (oldCapacity * 2);
    	    if (newCapacity < minCapacity) {
		newCapacity = minCapacity;
	    }
            elementData = Arrays.copyOf(elementData, newCapacity);
	}
    }

   public void ensureCapacity(int minCapacity) {
	modCount++;
	int oldCapacity = elementData.length;
	if (minCapacity > oldCapacity) {
	    Object oldData[] = elementData;
	    int newCapacity = (oldCapacity * 3)/2 + 1;
    	    if (newCapacity < minCapacity)
		newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
	}
    }

二: HashMao 是可以用 null作为key和value的

3 char型能不能储存一个中文汉子?为什么?
答: 是能够储存一个中文汉字的,java使用的是unicode编码.一个char占16个字节,所以存储一个中文没问题哦.

4 多线程有几种实现方案？同步呢?
答: 有两种实现方案:
分别是继承 Runnable接口和Thread类.
同步也有两种实现方案 分别是 synchronized和notify

JAVA语言引入泛型要解决的问题是 实现参数的 任意化 , 好处是安全简单。

在JAVA SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

泛型在使用中还有一些规则和限制：
1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句，例如。习惯上成为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class classType = Class.forName(java.lang.String);

例如,

package generic;
 
public class Gen<T> {
	private T t; // 定义泛型成员变量
 
	public Gen(T t) {
		this.t = t;
	}
 
	public T getT() {
		return t;
	}
 
	public void setT(T t) {
		this.t = t;
	}
 
	public void showType() {
		System.out.println(" T的实际类型是＝ " + t.getClass().getName());
	}
}

package generic;
 
public class genTest {
 
	public static void main(String args[]) {
		Gen<Integer> intOb = new Gen<Integer>(88);
		intOb.showType();
		int i = intOb.getT();
		System.out.println("value= " + i);
 
 
		Gen<String> st = new Gen<String>("this is a String");
		st.showType();
		String j = st.getT();
		System.out.println("value= " + j);
 
	}
}
 

优点：减少了在类文件编译后的产生的字节码文件的大小
缺点：使程序结构不清晰

使用内部类的注意事项：

内部类的使用一般都与所在的外部类有一定的关联，它是在一个类的内部嵌套定义的类，它可以是其它类的成员，也可以在一个语句块的内部定义，还可以在表达式内部匿名定义(匿名内部类)。

内部类有如下的特性：

.一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称，名字不能与包含它的数百名相同

. 可以使用包含它的类的表态和实例成员变量，也可以使用它所在方法的局部变量

.可以定义为abstract

.若被声明为static,就变成了顶层类，不能再使用局部变量

.若想在inner class 中声明任何static成员，则该inner class必须声明为static.

.匿名类是一种特殊的内部类，它是在一个表达式的内部包含一个完整的类的定义。匿名内部类不需要任何的修饰词。

.内部类可以使用任何听修饰符，但是如果声明为static类，则等同于一个标准类。

.如果非表态内部类，就拥有对外部类的所有成员的完全访问权限，包括实例字段和方法。为实现这一行为，非表态内部类存着对外部类的实例的一个隐匿的引用。

.所以对一个非表态内部类进行实例化需要采用不同语法的new 语句，这种开工的new 语句要求外部类的一个实例，使内部类能在那个实例的上下文中创建。

.非表态内部类具有一些限制。尤其是，它们不能声明表态初始化列表和表态成员，除非是在常量字段中。此外方法内部声明的内部类不能访问方法的局部变量和参数，除非它们被初始化成final.

.表态内部类当中可以有表态数据，表态方法或者是又一个表态内部类。而非表态内部类当中不能有静态数据。这是它们的区别。

.局部内部类：Java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。

有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：

　　如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。

　　将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。

　　在这个匿名内部类中使用初始化代码块。

　　为什么需要内部类？

　　java内部类有什么好处？为什么需要内部类？

　　首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。

　　不过你可能要质疑，更改一下方法的不就行了吗？

　　的确，以此作为设计内部类的理由，实在没有说服力。

　　真正的原因是这样的，java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题——没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。

下面是使用内部类的几个小例子：

JAVA的内部类的构造方法是不会自动调用，必须在外部类当中的某个方法当中或构造函数当中显示调用才能够正确使用。

   Class Outer{
  
        public outer(){
 System.out.println("....");
       }

        Class Inner{

 public Innter(){
 
       System.out.println("inner");
 }
        }

       public static void Main(String[] args){

            Outer a = new Outer();
       }
}

在Outer构造函数中加入 Innter b = new Innter();
就可以直接调用它的输出或方法体了。

不过我们经常使用的还是匿名内部类：

   class Outer{

       Outer(){

 (new Inner(){
  public void print(){
   System.out.println("Inner");
   }
  }
 ).print();
 System.out.println("Outer");
       }
}

public class Study {
	public static void main(String[] args){
		Student st = new Student();
		Student.Inner in = st.new Inner();
		in.ss();
	}
}

class Student{
	
	public class Inner{
		public void  ss()
		{
			System.out.println("THis is inner class function..");
		}
	}
}