diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/attr/ConstantValue.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/attr/ConstantValue.java new file mode 100644 index 0000000000..2dce853e5e --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/attr/ConstantValue.java @@ -0,0 +1,21 @@ +package com.coding.mini_jvm.src.com.coderising.jvm.attr; + +public class ConstantValue extends AttributeInfo { + + private int constValueIndex; + + public ConstantValue(int attrNameIndex, int attrLen) { + super(attrNameIndex, attrLen); + } + + + public int getConstValueIndex() { + return constValueIndex; + } + public void setConstValueIndex(int constValueIndex) { + this.constValueIndex = constValueIndex; + } + + + +} diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/ByteCodeCommand.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/ByteCodeCommand.java index d22bd332ba..33db2d02a3 100644 --- a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/ByteCodeCommand.java +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/ByteCodeCommand.java @@ -19,7 +19,9 @@ public abstract class ByteCodeCommand { static { codeMap.put("01", "aconst_null"); - + codeMap.put("A2", "if_icmp_ge"); + codeMap.put("A4", "if_icmple"); + codeMap.put("A7", "goto"); codeMap.put("BB", "new"); codeMap.put("37", "lstore"); codeMap.put("B7", "invokespecial"); diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/CommandParser.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/CommandParser.java index dd01d38872..28976cd26b 100644 --- a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/CommandParser.java +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/CommandParser.java @@ -32,6 +32,7 @@ public class CommandParser { public static final String astore_1 = "4C"; public static final String if_icmp_ge = "A2"; + public static final String if_icmp_gt = "A3"; public static final String if_icmple = "A4"; public static final String goto_no_condition = "A7"; public static final String iconst_0 = "03"; @@ -99,12 +100,33 @@ public static ByteCodeCommand[] parse(ClassFile clzFile, String codes) { case aload_1: case iload_1: case iload_2: + case iload_3: case istore_1: case voidreturn: + case iconst_0: + case iconst_1: + case istore_2: + case iadd: + case ireturn: case dup: NoOperandCmd noOperandCmd = new NoOperandCmd(clzFile, operCode); cmds.add(noOperandCmd); break; + case if_icmp_ge: + case if_icmple: + case if_icmp_gt: + case goto_no_condition: + ComparisonCmd cmd1 = new ComparisonCmd(clzFile,operCode); + cmd1.setOprand1(cmdIter.next2CharAsInt()); + cmd1.setOprand2(cmdIter.next2CharAsInt()); + cmds.add(cmd1); + break; + case iinc: + IncrementCmd incrementCmd = new IncrementCmd(clzFile,operCode); + incrementCmd.setOprand1(cmdIter.next2CharAsInt()); + incrementCmd.setOprand2(cmdIter.next2CharAsInt()); + cmds.add(incrementCmd); + break; default: throw new RuntimeException("this oper [ " +operCode+ " ]not impl yet"); } diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/ComparisonCmd.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/ComparisonCmd.java new file mode 100644 index 0000000000..78af7a4dbe --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/ComparisonCmd.java @@ -0,0 +1,85 @@ +package com.coding.mini_jvm.src.com.coderising.jvm.cmd; + + +import com.coding.mini_jvm.src.com.coderising.jvm.clz.ClassFile; +import com.coding.mini_jvm.src.com.coderising.jvm.constant.ConstantPool; +import com.coding.mini_jvm.src.com.coderising.jvm.engine.ExecutionResult; +import com.coding.mini_jvm.src.com.coderising.jvm.engine.JavaObject; +import com.coding.mini_jvm.src.com.coderising.jvm.engine.StackFrame; + +public class ComparisonCmd extends TwoOperandCmd { + + protected ComparisonCmd(ClassFile clzFile, String opCode) { + super(clzFile, opCode); + + } + + + @Override + public void execute(StackFrame frame,ExecutionResult result) { + + if(CommandParser.if_icmp_ge.equals(this.getOpCode())){ + //注意次序 + JavaObject jo2 = frame.getOprandStack().pop(); + JavaObject jo1 = frame.getOprandStack().pop(); + + if(jo1.getIntValue() >= jo2.getIntValue()){ + + this.setJumpResult(result); + + } + + } else if(CommandParser.if_icmple.equals(this.getOpCode())){ + //注意次序 + JavaObject jo2 = frame.getOprandStack().pop(); + JavaObject jo1 = frame.getOprandStack().pop(); + + if(jo1.getIntValue() <= jo2.getIntValue()){ + this.setJumpResult(result); + } + + } else if(CommandParser.goto_no_condition.equals(this.getOpCode())){ + this.setJumpResult(result); + + } else{ + throw new RuntimeException(this.getOpCode() + "has not been implemented"); + } + + + + + } + + private int getOffsetFromStartCmd(){ + //If the comparison succeeds, the unsigned branchbyte1 and branchbyte2 + //are used to construct a signed 16-bit offset, where the offset is calculated + //to be (branchbyte1 << 8) | branchbyte2. Execution then proceeds at that + //offset from the address of the opcode of this if_icmp instruction + + + int index1 = this.getOprand1(); + int index2 = this.getOprand2(); + short offsetFromCurrent = (short)(index1 << 8 | index2); + return this.getOffset() + offsetFromCurrent ; + } + private void setJumpResult(ExecutionResult result){ + + int offsetFromStartCmd = this.getOffsetFromStartCmd(); + + result.setNextAction(ExecutionResult.JUMP); + result.setNextCmdOffset(offsetFromStartCmd); + } + + @Override + public String toString() { + int index = this.getIndex(); + String text = this.getReadableCodeText(); + return this.getOffset()+":"+ this.getOpCode() + " "+text + " " + this.getOffsetFromStartCmd(); + } + + @Override + public String toString(ConstantPool pool) { + return null; + } + +} diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/IncrementCmd.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/IncrementCmd.java new file mode 100644 index 0000000000..c11e04ea15 --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/IncrementCmd.java @@ -0,0 +1,45 @@ +package com.coding.mini_jvm.src.com.coderising.jvm.cmd; + + +import com.coding.mini_jvm.src.com.coderising.jvm.clz.ClassFile; +import com.coding.mini_jvm.src.com.coderising.jvm.constant.ConstantPool; +import com.coding.mini_jvm.src.com.coderising.jvm.engine.ExecutionResult; +import com.coding.mini_jvm.src.com.coderising.jvm.engine.Heap; +import com.coding.mini_jvm.src.com.coderising.jvm.engine.JavaObject; +import com.coding.mini_jvm.src.com.coderising.jvm.engine.StackFrame; + +public class IncrementCmd extends TwoOperandCmd { + + public IncrementCmd(ClassFile clzFile, String opCode) { + super(clzFile, opCode); + + } + + @Override + public String toString() { + + return this.getOffset()+":"+this.getOpCode()+ " " +this.getReadableCodeText(); + } + + @Override + public String toString(ConstantPool pool) { + return null; + } + + @Override + public void execute(StackFrame frame, ExecutionResult result) { + + int index = this.getOprand1(); + + int constValue = this.getOprand2(); + + int currentValue = frame.getLocalVariableValue(index).getIntValue(); + + JavaObject jo = Heap.getInstance().newInt(constValue+currentValue); + + frame.setLocalVariableValue(index, jo); + + + } + +} \ No newline at end of file diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/NoOperandCmd.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/NoOperandCmd.java index afbbd6248e..0ae1536043 100644 --- a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/NoOperandCmd.java +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/cmd/NoOperandCmd.java @@ -35,6 +35,9 @@ public void execute(StackFrame frame, ExecutionResult result) { } else if (CommandParser.iload_2.equals(this.getOpCode())) { JavaObject jo = frame.getLocalVariableValue(2); frame.getOprandStack().push(jo); + } else if (CommandParser.iload_3.equals(this.getOpCode())) { + JavaObject jo = frame.getLocalVariableValue(3); + frame.getOprandStack().push(jo); } else if (CommandParser.istore_1.equals(this.getOpCode())) { JavaObject jo = frame.getOprandStack().pop(); frame.setLocalVariableValue(1, jo); diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/field/Field.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/field/Field.java index 18bcdb2851..280f67d640 100644 --- a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/field/Field.java +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/field/Field.java @@ -1,15 +1,19 @@ package com.coding.mini_jvm.src.com.coderising.jvm.field; +import com.coding.mini_jvm.src.com.coderising.jvm.attr.AttributeInfo; +import com.coding.mini_jvm.src.com.coderising.jvm.attr.ConstantValue; import com.coding.mini_jvm.src.com.coderising.jvm.constant.ConstantPool; import com.coding.mini_jvm.src.com.coderising.jvm.loader.ByteCodeIterator; -public class Field { - private int accessFlag; - private int nameIndex; - private int descriptorIndex; +public class Field { + private int accessFlag; + private int nameIndex; + private int descriptorIndex; + private ConstantValue constValue; + private ConstantPool pool; public Field(int accessFlag, int nameIndex, int descriptorIndex, ConstantPool pool) { @@ -20,17 +24,33 @@ public Field(int accessFlag, int nameIndex, int descriptorIndex, ConstantPool po } - public static Field parse(ConstantPool pool,ByteCodeIterator iter){ + public static Field parse(ConstantPool pool, ByteCodeIterator iter) { int accessFlag = iter.readTwoBytesToInt(); int nameIndex = iter.readTwoBytesToInt(); int descIndex = iter.readTwoBytesToInt(); int attributesCount = iter.readTwoBytesToInt(); - if (attributesCount > 0) - throw new RuntimeException("attributeCount of field not impl"); - return new Field(accessFlag, nameIndex, descIndex, pool); + Field f = new Field(accessFlag, nameIndex, descIndex, pool); + for( int i=1; i<= attributesCount; i++){ + int attrNameIndex = iter.readTwoBytesToInt(); + String attrName = pool.getUTF8String(attrNameIndex); + + if(AttributeInfo.CONST_VALUE.equals(attrName)){ + int attrLen = iter.readFourBytesToInt(); + ConstantValue constValue = new ConstantValue(attrNameIndex, attrLen); + constValue.setConstValueIndex(iter.readTwoBytesToInt()); + f.setConstValue(constValue); + } else{ + throw new RuntimeException("the attribute " + attrName + " has not been implemented yet."); + } + } + return f; } + public void setConstValue(ConstantValue constValue) { + this.constValue = constValue; + } + @Override public String toString() { return pool.getUTF8String(nameIndex)+":"+pool.getUTF8String(descriptorIndex); diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/EmployeeV1.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/EmployeeV1.java similarity index 90% rename from group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/EmployeeV1.java rename to group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/EmployeeV1.java index e6bc33f6b0..cda835cf9f 100644 --- a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/EmployeeV1.java +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/EmployeeV1.java @@ -1,4 +1,4 @@ -package com.coding.mini_jvm.src.com.coderising.jvm; +package com.coding.mini_jvm.src.com.coderising.jvm.test; public class EmployeeV1 { diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/EmployeeV2.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/EmployeeV2.java new file mode 100644 index 0000000000..5dbdba24f8 --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/EmployeeV2.java @@ -0,0 +1,54 @@ +package com.coding.mini_jvm.src.com.coderising.jvm.test; + +public class EmployeeV2 { + + public final static String TEAM_NAME = "Dev Team"; + private String name; + private int age; + public EmployeeV2(String name, int age) { + this.name = name; + this.age = age; + } + + public void sayHello() { + System.out.println("Hello , this is class Employee "); + System.out.println(TEAM_NAME); + System.out.println(this.name); + } + + public void setName(String name) { + this.name = name; + } + + public void setAge(int age) { + this.age = age; + } + + + + public void isYouth() { + if (age < 40) { + System.out.println("You're still young"); + } else { + System.out.println("You're old"); + } + } + + + + public void testAdd() { + int sum = 0; + for (int i = 1; i <= 100; i++) { + sum += i; + } + System.out.println(sum); + } + + + public static void main(String[] args) { + EmployeeV2 p = new EmployeeV2("Andy", 35); + p.sayHello(); + p.isYouth(); + p.testAdd(); + } +} \ No newline at end of file diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/Example.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/Example.java new file mode 100644 index 0000000000..afb71ca6d1 --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/Example.java @@ -0,0 +1,16 @@ +package com.coding.mini_jvm.src.com.coderising.jvm.test; + +public class Example { + public void disp(char c){ + System.out.println(c); + } + public void disp(int c){ + System.out.println(c ); + } + public static void main(String args[]){ + Example obj = new Example(); + obj.disp('a'); + obj.disp(5); + } +} + diff --git a/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/HourlyEmployee.java b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/HourlyEmployee.java new file mode 100644 index 0000000000..371f281bf4 --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/mini_jvm/src/com/coderising/jvm/test/HourlyEmployee.java @@ -0,0 +1,27 @@ +package com.coding.mini_jvm.src.com.coderising.jvm.test; + +public class HourlyEmployee extends EmployeeV2 { + + int hourlySalary; + + public HourlyEmployee(String name, + int age, int hourlySalary) { + super(name, age); + this.hourlySalary = hourlySalary; + } + + public void sayHello(){ + System.out.println("Hello , this is Hourly Employee"); + } + public static void main(String[] args){ + EmployeeV2 e = new HourlyEmployee("Lisa", 20, 40); + e.sayHello(); + } + + public int getHourlySalary(){ + return this.hourlySalary; + } + + + +} diff --git a/group24/494800949/src/main/java/com/coding/week10/BinaryTreeNode.java b/group24/494800949/src/main/java/com/coding/week10/BinaryTreeNode.java new file mode 100644 index 0000000000..c7fdd2b665 --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/week10/BinaryTreeNode.java @@ -0,0 +1,63 @@ +package com.coding.week10; + + +public class BinaryTreeNode>{ + + private T data; + private BinaryTreeNode left; + private BinaryTreeNode right; + + public BinaryTreeNode(T data){ + this.data=data; + } + public T getData() { + return data; + } + public void setData(T data) { + this.data = data; + } + public BinaryTreeNode getLeft() { + return left; + } + public void setLeft(BinaryTreeNode left) { + this.left = left; + } + public BinaryTreeNode getRight() { + return right; + } + public void setRight(BinaryTreeNode right) { + this.right = right; + } + + public BinaryTreeNode insert(Object o){ + @SuppressWarnings("unchecked") + T o1 = (T)o; + BinaryTreeNode newNode = new BinaryTreeNode<>(o1); + if (data.compareTo(o1) > 0 ) { + if (left == null) { + left = newNode; + } else { + left.insert(o); + } + } else { + if (right == null) { + right = newNode; + } else { + right.insert(o); + } + } + return newNode; + } + + public static void main(String[] args) { + BinaryTreeNode b = new BinaryTreeNode<>(2); + b.insert(3).insert(5).insert(1); + b.insert(6); + b.insert(8); + b.insert(1); + System.out.println(BinaryTreeUtil.preOrderVisit(b)); + +// BinaryTreeNode b1 = new BinaryTreeNode<>(new AtomicInteger(3)); +// b1.insert(new AtomicInteger(4)); + } +} diff --git a/group24/494800949/src/main/java/com/coding/week10/BinaryTreeUtil.java b/group24/494800949/src/main/java/com/coding/week10/BinaryTreeUtil.java new file mode 100644 index 0000000000..6855d2cbc2 --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/week10/BinaryTreeUtil.java @@ -0,0 +1,130 @@ +package com.coding.week10; + +import java.util.ArrayList; +import java.util.List; +import java.util.Stack; + +public class BinaryTreeUtil { + /** + * 用递归的方式实现对二叉树的前序遍历， 需要通过BinaryTreeUtilTest测试 + * + * @param root + * @return + */ + public static > List preOrderVisit(BinaryTreeNode root) { + List result = new ArrayList(); + BinaryTreeNode left = root.getLeft(); + BinaryTreeNode right = root.getRight(); + result.add(root.getData()); + if (left != null) { + List leftList = preOrderVisit(left); + result.addAll(leftList); + } + if (right != null) { + List rightList = preOrderVisit(right); + result.addAll(rightList); + } + return result; + } + + /** + * 用递归的方式实现对二叉树的中遍历 + * + * @param root + * @return + */ + public static > List inOrderVisit(BinaryTreeNode root) { + List result = new ArrayList<>(); + BinaryTreeNode left = root.getLeft(); + BinaryTreeNode right = root.getRight(); + + if (left != null) { + List leftList = inOrderVisit(left); + result.addAll(leftList); + } + result.add(root.getData()); + if (right != null) { + List rightList = inOrderVisit(right); + result.addAll(rightList); + } + return result; + } + + /** + * 用递归的方式实现对二叉树的后遍历 + * + * @param root + * @return + */ + public static > List postOrderVisit(BinaryTreeNode root) { + List result = new ArrayList<>(); + BinaryTreeNode left = root.getLeft(); + BinaryTreeNode right = root.getRight(); + + if (left != null) { + List leftList = postOrderVisit(left); + result.addAll(leftList); + } + + if (right != null) { + List rightList = postOrderVisit(right); + result.addAll(rightList); + } + result.add(root.getData()); + return result; + } + /** + * 用非递归的方式实现对二叉树的前序遍历 + * @param root + * @return + */ + public static > List preOrderWithoutRecursion(BinaryTreeNode root) { + + List result = new ArrayList(); + Stack> stack = new Stack<>(); + stack.push(root); + while (!stack.isEmpty()){ + BinaryTreeNode node = stack.pop(); + result.add(node.getData()); + if (node.getRight() != null) { + stack.push(node.getRight()); + } + if (node.getLeft() != null) { + stack.push(node.getLeft()); + } + + } + + return result; + } + /** + * 用非递归的方式实现对二叉树的中序遍历 + * @param root + * @return + */ + public static > List inOrderWithoutRecursion(BinaryTreeNode root) { + List result = new ArrayList(); + Stack> stack = new Stack>(); + BinaryTreeNode p = root; + while (p != null) { + while (p != null) { + if (p.getRight() != null) + stack.push(p.getRight());// 当前节点右子入栈 + stack.push(p);// 当前节点入栈 + p = p.getLeft(); + } + p = stack.pop(); + while (!stack.empty() && p.getRight() == null) { + result.add(p.getData()); + p = stack.pop(); + } + result.add(p.getData()); + if (!stack.empty()) + p = stack.pop(); + else + p = null; + } + return result; + } + +} diff --git a/group24/494800949/src/main/java/com/coding/week10/FileList.java b/group24/494800949/src/main/java/com/coding/week10/FileList.java new file mode 100644 index 0000000000..578c036ba5 --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/week10/FileList.java @@ -0,0 +1,47 @@ +package com.coding.week10; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +public class FileList { + + private List fileList = new ArrayList<>(); + + public void list(File f) { + + /* + 1 如果f为空或不存在返回 + 2 如果f是文件，则直接add并返回 + 3 如果f是文件夹，则递归调用list + */ + if (f == null || !f.exists()) { + return; + } + if (f.isFile()) { + fileList.add(f); + return; + } + if (f.isDirectory()) { + File[] files = f.listFiles(); + if (files != null) { + for (File file : files) { + list(file); + } + } + } + } + + public static void main(String[] args) { + FileList list = new FileList(); + File f = new File("H:\\sourceCode\\coding2017\\group24\\494800949"); + + list.list(f); + + System.out.println(list.fileList.size()); + for (File file : list.fileList) { + System.out.println(file.getName()); + } + } + +} diff --git a/group24/494800949/src/main/java/com/coding/week11/BinarySearchTree.java b/group24/494800949/src/main/java/com/coding/week11/BinarySearchTree.java new file mode 100644 index 0000000000..c49d57586a --- /dev/null +++ b/group24/494800949/src/main/java/com/coding/week11/BinarySearchTree.java @@ -0,0 +1,99 @@ +package com.coding.week11; + +import com.coding.week10.BinaryTreeNode; + +public class BinarySearchTree> { + + BinaryTreeNode root; + + public BinarySearchTree(BinaryTreeNode root) { + this.root = root; + } + + public BinaryTreeNode getRoot() { + return root; + } + public T findMin(){ + BinaryTreeNode min = findMin(root); + return min == null ? null : min.getData(); + } + + private BinaryTreeNode findMin(BinaryTreeNode node) { + if (node == null) { + return null; + } + BinaryTreeNode left = node.getLeft(); + if (left == null) { + return node; + } else { + return findMin(left); + } + } + public T findMax(){ + if (root == null) { + throw new RuntimeException("has no data"); + } + BinaryTreeNode t = root.getRight(); + T data = null; + while (t != null) { + data = t.getData(); + t = t.getRight(); + } + + return data; + } + public int height() { + return height(root); + } + + private int height(BinaryTreeNode temp) { + if (temp == null) { + return 0; + } + return 1 + Math.max(height(temp.getRight()), height(temp.getLeft())); + } + + public int size() { + return size(root); + } + + public int size(BinaryTreeNode node) { + if (node == null) { + return 0; + } + return 1 + size(node.getLeft()) + size(node.getRight()); + } + + + public void remove(T e){ + remove(root, e); + } + + private BinaryTreeNode remove(BinaryTreeNode node, T e) { + if (node == null) { + return node; + } + int compareRes = node.getData().compareTo(e); + if (compareRes < 0) { + node.setRight(remove(node.getRight(), e)); + } else if (compareRes > 0) { + node.setLeft(remove(node.getLeft(), e)); + } else { + BinaryTreeNode left = node.getLeft(); + BinaryTreeNode right = node.getRight(); + if (left != null && right != null) { + T data = findMin(right).getData(); + node.setData(data); + node.setRight(remove(right, data)); + } else { + node = left != null ? left : right; + } + } + return node; + } + + public static void main(String[] args) { + System.out.println(Math.max(0,0)); + } +} + diff --git a/group24/494800949/src/main/java/com/coding/week9/StackWithTwoQueues.java b/group24/494800949/src/main/java/com/coding/week9/StackWithTwoQueues.java index f55bad77ca..76494e20df 100644 --- a/group24/494800949/src/main/java/com/coding/week9/StackWithTwoQueues.java +++ b/group24/494800949/src/main/java/com/coding/week9/StackWithTwoQueues.java @@ -24,13 +24,14 @@ public int pop() { queue2.enQueue(queue1.deQueue()); } return queue1.deQueue(); - } else { + } + if (queue1.isEmpty()){ while (queue2.size() > 1) { queue1.enQueue(queue2.deQueue()); } return queue2.deQueue(); } - + throw new UnsupportedOperationException(); } diff --git a/group24/494800949/src/test/java/com/coding/mini_jvm/test/EmployeeV2.java b/group24/494800949/src/test/java/com/coding/mini_jvm/test/EmployeeV2.java new file mode 100644 index 0000000000..4cee388114 --- /dev/null +++ b/group24/494800949/src/test/java/com/coding/mini_jvm/test/EmployeeV2.java @@ -0,0 +1,54 @@ +package com.coding.mini_jvm.test; + +public class EmployeeV2 { + + public final static String TEAM_NAME = "Dev Team"; + private String name; + private int age; + public EmployeeV2(String name, int age) { + this.name = name; + this.age = age; + } + + public void sayHello() { + System.out.println("Hello , this is class Employee "); + System.out.println(TEAM_NAME); + System.out.println(this.name); + } + + public void setName(String name) { + this.name = name; + } + + public void setAge(int age) { + this.age = age; + } + + + + public void isYouth() { + if (age < 40) { + System.out.println("You're still young"); + } else { + System.out.println("You're old"); + } + } + + + + public void testAdd() { + int sum = 0; + for (int i = 1; i <= 100; i++) { + sum += i; + } + System.out.println(sum); + } + + + public static void main(String[] args) { + EmployeeV2 p = new EmployeeV2("Andy", 35); + p.sayHello(); + p.isYouth(); + p.testAdd(); + } +} \ No newline at end of file diff --git a/group24/494800949/src/test/java/com/coding/mini_jvm/test/Example.java b/group24/494800949/src/test/java/com/coding/mini_jvm/test/Example.java new file mode 100644 index 0000000000..4fe1db46fb --- /dev/null +++ b/group24/494800949/src/test/java/com/coding/mini_jvm/test/Example.java @@ -0,0 +1,16 @@ +package com.coding.mini_jvm.test; + +public class Example{ + public void disp(char c){ + System.out.println(c); + } + public void disp(int c){ + System.out.println(c ); + } + public static void main(String args[]){ + Example obj = new Example(); + obj.disp('a'); + obj.disp(5); + } +} + diff --git a/group24/494800949/src/test/java/com/coding/mini_jvm/test/HourlyEmployee.java b/group24/494800949/src/test/java/com/coding/mini_jvm/test/HourlyEmployee.java new file mode 100644 index 0000000000..3d428a8a2c --- /dev/null +++ b/group24/494800949/src/test/java/com/coding/mini_jvm/test/HourlyEmployee.java @@ -0,0 +1,27 @@ +package com.coding.mini_jvm.test; + +public class HourlyEmployee extends EmployeeV2 { + + int hourlySalary; + + public HourlyEmployee(String name, + int age, int hourlySalary) { + super(name, age); + this.hourlySalary = hourlySalary; + } + + public void sayHello(){ + System.out.println("Hello , this is Hourly Employee"); + } + public static void main(String[] args){ + EmployeeV2 e = new HourlyEmployee("Lisa", 20, 40); + e.sayHello(); + } + + public int getHourlySalary(){ + return this.hourlySalary; + } + + + +} diff --git a/group24/494800949/src/test/java/com/coding/mini_jvm/test/MiniJVMTest.java b/group24/494800949/src/test/java/com/coding/mini_jvm/test/MiniJVMTest.java index 53694f30a4..614c2daff6 100644 --- a/group24/494800949/src/test/java/com/coding/mini_jvm/test/MiniJVMTest.java +++ b/group24/494800949/src/test/java/com/coding/mini_jvm/test/MiniJVMTest.java @@ -20,13 +20,20 @@ public void setUp() throws Exception { @After public void tearDown() throws Exception { } +// +// @Test +// public void testMain() throws Exception { +// String[] classPaths = {PATH, PATH1, PATH2}; +// MiniJVM jvm = new MiniJVM(); +// jvm.run(classPaths, "com.coding.mini_jvm.src.com.coderising.jvm.test.EmployeeV1"); +// +// } @Test - public void testMain() throws Exception { - String[] classPaths = {PATH, PATH1, PATH2}; + public void testMain() throws Exception{ + String[] classPaths = {PATH}; MiniJVM jvm = new MiniJVM(); - jvm.run(classPaths, "com.coding.mini_jvm.src.com.coderising.jvm.EmployeeV1"); - - } + jvm.run(classPaths, "com.coding.mini_jvm.src.com.coderising.jvm.test.HourlyEmployee"); + } } diff --git a/group24/494800949/src/test/java/com/coding/week10/BinaryTreeUtilTest.java b/group24/494800949/src/test/java/com/coding/week10/BinaryTreeUtilTest.java new file mode 100644 index 0000000000..3f9127679a --- /dev/null +++ b/group24/494800949/src/test/java/com/coding/week10/BinaryTreeUtilTest.java @@ -0,0 +1,75 @@ +package com.coding.week10; + +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.List; + + + +public class BinaryTreeUtilTest { + + BinaryTreeNode root = null; + @Before + public void setUp() throws Exception { + root = new BinaryTreeNode(1); + root.setLeft(new BinaryTreeNode(2)); + root.setRight(new BinaryTreeNode(5)); + root.getLeft().setLeft(new BinaryTreeNode(3)); + root.getLeft().setRight(new BinaryTreeNode(4)); + } + + @After + public void tearDown() throws Exception { + } + + @Test + public void testPreOrderVisit() { + + List result = BinaryTreeUtil.preOrderVisit(root); + Assert.assertEquals("[1, 2, 3, 4, 5]", result.toString()); + + + } + @Test + public void testInOrderVisit() { + + + List result = BinaryTreeUtil.inOrderVisit(root); + Assert.assertEquals("[3, 2, 4, 1, 5]", result.toString()); + + } + + @Test + public void testPostOrderVisit() { + + + List result = BinaryTreeUtil.postOrderVisit(root); + Assert.assertEquals("[3, 4, 2, 5, 1]", result.toString()); + + } + + + @Test + public void testInOrderVisitWithoutRecursion() { + BinaryTreeNode node = root.getLeft().getRight(); + node.setLeft(new BinaryTreeNode(6)); + node.setRight(new BinaryTreeNode(7)); + + List result = BinaryTreeUtil.inOrderWithoutRecursion(root); + Assert.assertEquals("[3, 2, 6, 4, 7, 1, 5]", result.toString()); + + } + @Test + public void testPreOrderVisitWithoutRecursion() { + BinaryTreeNode node = root.getLeft().getRight(); + node.setLeft(new BinaryTreeNode(6)); + node.setRight(new BinaryTreeNode(7)); + + List result = BinaryTreeUtil.preOrderWithoutRecursion(root); + Assert.assertEquals("[1, 2, 3, 4, 6, 7, 5]", result.toString()); + + } +} diff --git a/group24/494800949/src/test/java/com/coding/week11/BinarySearchTreeTest.java b/group24/494800949/src/test/java/com/coding/week11/BinarySearchTreeTest.java new file mode 100644 index 0000000000..433d3dba55 --- /dev/null +++ b/group24/494800949/src/test/java/com/coding/week11/BinarySearchTreeTest.java @@ -0,0 +1,66 @@ +package com.coding.week11; + +import com.coding.week10.BinaryTreeNode; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + + + +public class BinarySearchTreeTest { + + BinarySearchTree tree = null; + + @Before + public void setUp() throws Exception { + BinaryTreeNode root = new BinaryTreeNode(6); + root.setLeft(new BinaryTreeNode(2)); + root.setRight( new BinaryTreeNode(8)); + root.getLeft().setLeft(new BinaryTreeNode(1)); + root.getLeft().setRight(new BinaryTreeNode(4)); + root.getLeft().getRight().setLeft(new BinaryTreeNode(3)); + tree = new BinarySearchTree(root); + } + + @After + public void tearDown() throws Exception { + tree = null; + } + + @Test + public void testFindMin() { + Assert.assertEquals(1, tree.findMin().intValue()); + + } + + @Test + public void testFindMax() { + Assert.assertEquals(8, tree.findMax().intValue()); + } + + @Test + public void testHeight() { + Assert.assertEquals(4, tree.height()); + } + + @Test + public void testSize() { + Assert.assertEquals(6, tree.size()); + } + + @Test + public void testRemoveLeaf() { + tree.remove(4); + BinaryTreeNode root= tree.getRoot(); + Assert.assertEquals(3, root.getLeft().getRight().getData().intValue()); + + } + @Test + public void testRemoveMiddleNode() { + tree.remove(2); + BinaryTreeNode root= tree.getRoot(); + Assert.assertEquals(3, root.getLeft().getData().intValue()); + Assert.assertEquals(4, root.getLeft().getRight().getData().intValue()); + } +} diff --git a/liuxin/mini-jvm/assignment/src/com/coderising/jvm/attr/ConstantValue.java b/liuxin/mini-jvm/assignment/src/com/coderising/jvm/attr/ConstantValue.java new file mode 100644 index 0000000000..9b23856bf4 --- /dev/null +++ b/liuxin/mini-jvm/assignment/src/com/coderising/jvm/attr/ConstantValue.java @@ -0,0 +1,21 @@ +package com.coderising.jvm.attr; + +public class ConstantValue extends AttributeInfo { + + private int constValueIndex; + + public ConstantValue(int attrNameIndex, int attrLen) { + super(attrNameIndex, attrLen); + } + + + public int getConstValueIndex() { + return constValueIndex; + } + public void setConstValueIndex(int constValueIndex) { + this.constValueIndex = constValueIndex; + } + + + +}