add

Author: codingWang

bin/com/duwei/designpattern/abstractfactory/config.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0"?>  
+<config>  
+    <className>com.duwei.designpattern.abstractfactory.SpringSkinFactory</className>  
+</config>  

src/com/alibaba/Banker.java

@@ -4,14 +4,14 @@
 
 
 public class Banker{
-	int available[] = new int[]{3,3,2};//可得到的资源
-	int max[][] = new int[][]{{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//每个进程最大资源数
-	int allocation[][] = new int[][]{{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//每个进程目前拥有的资源数
-	int need[][] = new int[][]{{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//每个进程需要的资源数
+	int available[] = new int[]{3,3,2};//可得到的资源
+	int max[][] = new int[][]{{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//每个进程最大资源数
+	int allocation[][] = new int[][]{{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//每个进程目前拥有的资源数
+	int need[][] = new int[][]{{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//每个进程需要的资源数
 
-	void showData()//展示数据输出每个进程的相关数据
+	void showData()//展示数据输出每个进程的相关数据
 	{
-		System.out.println("进程号      Max   Allocation Need   ");
+		System.out.println("进程号      Max   Allocation Need   ");
 		System.out.println("     A  B  C  A  B  C  A  B  C");
 		for(int i = 0;i<5;i++)
 		{
@@ -23,19 +23,19 @@ public class Banker{
 		}
 	}
 
-	boolean change(int inRequestNum,int inRequest[]){//分配数据
+	boolean change(int inRequestNum,int inRequest[]){//分配数据
 		int requestNum = inRequestNum;
 		int request[] = inRequest;
-		// for(int i=0;i<3;i++)System.out.println("修改前available"+available[i]);
+		// for(int i=0;i<3;i++)System.out.println("修改前available"+available[i]);
 		if(!(request[0]<=need[requestNum][0]&&request[1]<=need[requestNum][1]&&request[2]<=need[requestNum][2])){
-			System.out.println("请求的资源数超过了所需要的最大值，分配错误");
+			System.out.println("请求的资源数超过了所需要的最大值，分配错误");
 			return false;
 		}
 		if((request[0]<=available[0]&&request[1]<=available[1]&&request[2]<=available[2])==false){
-			System.out.println("尚无足够资源分配，必须等待");
+			System.out.println("尚无足够资源分配，必须等待");
 			return false;
 		}
-		for(int i = 0;i<3;i++){//试分配数据给请求的线程
+		for(int i = 0;i<3;i++){//试分配数据给请求的线程
 
 			available[i] = available[i]-request[i];
 
@@ -44,13 +44,13 @@ public class Banker{
 			need[requestNum][i] = need[requestNum][i] - request[i];
 
 		}
-		boolean flag = checkSafe(available[0],available[1],available[2]);//进行安全性检查并返回是否安全
+		boolean flag = checkSafe(available[0],available[1],available[2]);//进行安全性检查并返回是否安全
 
 		if(flag==true){
-			System.out.println("能够安全分配");
+			System.out.println("能够安全分配");
 			return true;
 		}else{	
-			System.out.println("不能够安全分配");		
+			System.out.println("不能够安全分配");		
 			for(int i = 0;i<3;i++){		
 				available[i] = available[i]+request[i];			
 				allocation[requestNum][i] = allocation[requestNum][i] - request[i];
@@ -68,15 +68,15 @@ boolean checkSafe(int a,int b,int c){
 		work[2] = c;
 		int i=0;
 		boolean finish[] =  new boolean[5];
-		while(i<5)//寻找一个能够满足的认为完成后才去执行下一进程
+		while(i<5)//寻找一个能够满足的认为完成后才去执行下一进程
 		{
-			if(finish[i]==false&&need[i][0]<=work[0]&&need[i][1]<=work[1]&&need[i][2]<=work[2]){//找到满足的修改work值，然后i=0，重新从开始的为分配的中寻找
-				System.out.println("分配成功的是"+i);
+			if(finish[i]==false&&need[i][0]<=work[0]&&need[i][1]<=work[1]&&need[i][2]<=work[2]){//找到满足的修改work值，然后i=0，重新从开始的为分配的中寻找
+				System.out.println("分配成功的是"+i);
 			for(int m = 0;m<3;m++)
 				work[m] =work[m] + allocation[i][m];
 			finish[i] = true;
 			i=0;
-			}else//如果没有找到直接i++
+			}else//如果没有找到直接i++
 				i++;
 			}
 
@@ -110,29 +110,29 @@ public static void main(String[] args)
 
 	String choice = new String();
 
-	while(true)//循环进行分配
+	while(true)//循环进行分配
 
 	{
 
-	System.out.println("请输入要请求的进程号（0--4）：");
+	System.out.println("请输入要请求的进程号（0--4）：");
 
 	requestNum = s.nextInt();
 
-	System.out.print("请输入请求的资源数目");
+	System.out.print("请输入请求的资源数目");
 
 	for(int i = 0;i<3;i++)
 
 	{
 
-	System.out.println(source[i]+"资源的数目：");
+	System.out.println(source[i]+"资源的数目：");
 
 	request[i] = s.nextInt();
 
 	}
 
 	bank.change(requestNum, request);
 
-	System.out.println("是否再请求分配(y/n)");
+	System.out.println("是否再请求分配(y/n)");
 
 	choice = s.next();
 

src/com/alibaba/Test_2.java

@@ -7,12 +7,12 @@ public static void main(String[] args){
 		Integer j = new Integer(3000);
 
 		System.out.println(i == j);
-		//自动拆箱
+		//自动拆箱
 
 		System.out.println(j.equals(i));
-		//自动装箱
-		//Integer的equals方法比较的是值不是地址
-		//String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
+		//自动装箱
+		//Integer的equals方法比较的是值不是地址
+		//String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
 	}
 
 }

src/com/duwei/lintcode/MaxNodeInBinaryTree.java

@@ -0,0 +1,44 @@
+package com.duwei.lintcode;
+
+
+import java.util.List;
+
+/**
+ * 返回二叉树的最大节点
+ */
+public class MaxNodeInBinaryTree {
+
+    TreeNode treeNode = new TreeNode(-100000);//初始值设置极小
+
+    public TreeNode maxNode(TreeNode root) {
+
+        if (root == null) {
+            return null;
+        }
+        if (root.value > treeNode.value) {
+            treeNode = root;
+        }
+
+        if (root.left != null) {
+            maxNode(root.left);
+        }
+
+        if (root.right != null) {
+            maxNode(root.right);
+        }
+
+        return treeNode;
+    }
+
+    private static class TreeNode {
+        public int value;
+        public TreeNode left, right;
+
+        public TreeNode(int value) {
+            this.value = value;
+            this.left = this.right = null;
+        }
+    }
+
+
+}

src/com/duweri/interview/Sort.java

@@ -20,39 +20,39 @@ public static void display(int[] arr){
 	}
 
 	/**
-	 * 插入排序
-	 * 关键：1、临时变量保存待排序的数字
-	 * 		2、边比较边后移
-	 * 适用情况：序列基本有序的时候
+	 * 插入排序
+	 * 关键：1、临时变量保存待排序的数字
+	 * 		2、边比较边后移
+	 * 适用情况：序列基本有序的时候
 	 */
 	public static void insertSort(int[] arr){
 		for (int i = 1; i < arr.length; i++) {
-			int temp = arr[i];//临时保存待插入序列
-			int j;//下面先保证J大于0再去访问arr[j]!!!!
-			for (j = i-1;j >= 0 && temp > arr[j]    ; j--) {//带插入序列大于当前序列就前移--》从大到小排列
+			int temp = arr[i];//临时保存待插入序列
+			int j;//下面先保证J大于0再去访问arr[j]!!!!
+			for (j = i-1;j >= 0 && temp > arr[j]    ; j--) {//带插入序列大于当前序列就前移--》从大到小排列
 				arr[j+1] = arr[j];
 			}
 			arr[j+1]=temp;
 		}
 	}
 	/**
-	 * 希尔排序
+	 * 希尔排序
 	 */
 	public static void shellSort(int[] arr){
 
-		for (int i = arr.length/2; i >= 1; i=i/2) {//子序列的划分
+		for (int i = arr.length/2; i >= 1; i=i/2) {//子序列的划分
 
 		}
 
 	}
 	/**
-	 * 冒泡排序
-	 * 关键：1、外循环标识无序区和有序区
-	 * 		2、内循环每次将一个无序区的数字排到最前面
+	 * 冒泡排序
+	 * 关键：1、外循环标识无序区和有序区
+	 * 		2、内循环每次将一个无序区的数字排到最前面
 	 */
 	public static void bubbleSort(int[] arr){
-		for (int i = 0; i <arr.length-1; i++) {//从后往前推小的
-			for (int j = arr.length-1; j>i; j--) {//从最后一个开始遍历
+		for (int i = 0; i <arr.length-1; i++) {//从后往前推小的
+			for (int j = arr.length-1; j>i; j--) {//从最后一个开始遍历
 				if (arr[j]>arr[j-1]) {
 					int temp = arr[j];//swap
 					arr[j] = arr[j-1];
@@ -63,10 +63,10 @@ public static void bubbleSort(int[] arr){
 	}
 
 	/**
-	 * 快速排序
-	 * 关键: 1、选轴值
-	 * 		2、一次划分
-	 * 		3、递归快排
+	 * 快速排序
+	 * 关键: 1、选轴值
+	 * 		2、一次划分
+	 * 		3、递归快排
 	 */
 	public static void quickSort(int[] arr,int start,int end){
 		if(start<end){
@@ -76,12 +76,12 @@ public static void quickSort(int[] arr,int start,int end){
 		}
 	}
 	/**
-	 * 以arr[0]为基准进行一次划分算法，左边都小于arr[0]，右边都大于arr[0]
+	 * 以arr[0]为基准进行一次划分算法，左边都小于arr[0]，右边都大于arr[0]
 	 */
 	private static int partition(int[] arr,int first,int end){
 
 		while(first < end){
-			//先扫描右端
+			//先扫描右端
 			while(first < end && arr[first]<arr[end]){
 				end--;
 			}
@@ -91,7 +91,7 @@ private static int partition(int[] arr,int first,int end){
 				arr[first] = temp;
 				first++;
 			}
-			//扫描左边
+			//扫描左边
 			while(first < end && arr[first]<arr[end]){
 				first++;
 			}
@@ -106,23 +106,23 @@ private static int partition(int[] arr,int first,int end){
 	}
 
 	/**
-	 * 选择排序：
-	 * 每次遍历无序区选出最小的
+	 * 选择排序：
+	 * 每次遍历无序区选出最小的
 	 * @param arr
 	 */
 	public static void selectSort(int[] arr){
 		int minIndex = 0;
 		for (int i = 0; i < arr.length-1; i++) {
-			minIndex = i;//指向最小的值的角标
-			for (int j = i+1; j < arr.length; j++) {//遍历无序区
+			minIndex = i;//指向最小的值的角标
+			for (int j = i+1; j < arr.length; j++) {//遍历无序区
 				if(arr[j] < arr[minIndex]){
 					minIndex = j;
 				}
 			}
-			if (minIndex != i) {		//无序区遍历完了，找到最小的角标了，交换
+			if (minIndex != i) {		//无序区遍历完了，找到最小的角标了，交换
 				int temp = arr[minIndex];
 				arr[minIndex] = arr[i];
-				arr[i] = temp;//把temp放到有序区
+				arr[i] = temp;//把temp放到有序区
 			}
 		}
 	}

src/com/duweri/interview/string/StringTest.java

@@ -1,7 +1,7 @@
 package com.duweri.interview.string;
 /**
- * ×Ö·û´®ÄÚ´æ·ÖÅä
- * @author ¶Åΰ
+ * 字符串内存分配
+ * @author 杜伟
  */
 public class StringTest {
 

src/com/duweri/interview/string/Test1.java

@@ -4,8 +4,8 @@ public class Test1 {
 
 	public static void main(String[] args) {
 
-		String s1="abc"+"def";//1		³Ø
-		String s2=new String(s1);//2	¶Ñ
+		String s1="abc"+"def";//1		池
+		String s2=new String(s1);//2	堆
 		if(s1.equals(s2))//3			
 			System.out.println(".equals succeeded");//4
 		if(s1==s2)//5					X

src/com/duweri/interview/string/Test2.java

@@ -6,8 +6,7 @@ public class Test2 {
 	 * @param args
 	 */
 	public static void main(String[] args) {
-		// TODO Auto-generated method stub
-		
+
 		Integer i01=59;
 		int i02=59;
 		Integer i03=Integer.valueOf(59);

src/com/duweri/interview/string/Test4.java

@@ -0,0 +1,27 @@
+package com.duweri.interview.string;
+
+public class Test4 {
+
+    public static void main(String[] args) {
+        Test4.test1();
+        Test4.test2();
+    }
+
+    private static void test1(){
+        String s1 ="abc";
+        String s2 ="a";
+        String s3 = "bc";
+        String s4 = s2 + s3;
+        System.out.println(s1 == s4);
+    }
+
+
+    private static void test2(){
+        String s1 ="abc";
+        final String s2 ="a";
+        final String s3 = "bc";
+        String s4 = s2 + s3;
+        System.out.println(s1 == s4);
+    }
+
+}