diff --git a/group23/601689050/ArrayList.java b/group23/601689050/1List&BinaryTreeNode/ArrayList.java
similarity index 100%
rename from group23/601689050/ArrayList.java
rename to group23/601689050/1List&BinaryTreeNode/ArrayList.java
diff --git a/group23/601689050/BinaryTreeNode.java b/group23/601689050/1List&BinaryTreeNode/BinaryTreeNode.java
similarity index 100%
rename from group23/601689050/BinaryTreeNode.java
rename to group23/601689050/1List&BinaryTreeNode/BinaryTreeNode.java
diff --git a/group23/601689050/Iterator.java b/group23/601689050/1List&BinaryTreeNode/Iterator.java
similarity index 100%
rename from group23/601689050/Iterator.java
rename to group23/601689050/1List&BinaryTreeNode/Iterator.java
diff --git a/group23/601689050/LinkedList.java b/group23/601689050/1List&BinaryTreeNode/LinkedList.java
similarity index 100%
rename from group23/601689050/LinkedList.java
rename to group23/601689050/1List&BinaryTreeNode/LinkedList.java
diff --git a/group23/601689050/List.java b/group23/601689050/1List&BinaryTreeNode/List.java
similarity index 100%
rename from group23/601689050/List.java
rename to group23/601689050/1List&BinaryTreeNode/List.java
diff --git a/group23/601689050/Queue.java b/group23/601689050/1List&BinaryTreeNode/Queue.java
similarity index 100%
rename from group23/601689050/Queue.java
rename to group23/601689050/1List&BinaryTreeNode/Queue.java
diff --git a/group23/601689050/Stack.java b/group23/601689050/1List&BinaryTreeNode/Stack.java
similarity index 100%
rename from group23/601689050/Stack.java
rename to group23/601689050/1List&BinaryTreeNode/Stack.java
diff --git a/group23/601689050/4LRU&JVM/JVM/ClassFileLoader.java b/group23/601689050/4LRU&JVM/JVM/ClassFileLoader.java
new file mode 100644
index 0000000000..6a7ab61bc0
--- /dev/null
+++ b/group23/601689050/4LRU&JVM/JVM/ClassFileLoader.java
@@ -0,0 +1,63 @@
+package com.loader;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.Dictionary;
+import java.util.List;
+
+
+
+public class ClassFileLoader {
+
+	private List<String> clzPaths = new ArrayList<>();
+	
+	public byte[] readBinaryCode(String className) throws ClassNotFoundException {
+
+		String fileName = className.replace('.',File.separatorChar)+".class";
+		InputStream is = null;
+		try{
+			is = new FileInputStream(fileName);
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			byte[] buffer = new byte[1024];
+			int length = 0;
+			while((length = is.read(buffer)) != -1){
+				baos.write(buffer,0,length);
+			}
+			return baos.toByteArray();
+		} catch (IOException e){
+			e.printStackTrace();
+		} finally {
+			if(is!=null){
+				try{
+					is.close();
+				} catch (IOException e){
+					e.printStackTrace();
+				}
+			}
+		}
+		return null;
+	}
+
+
+
+
+	public void addClassPath(String path) {
+
+		StringBuilder str = new StringBuilder(path);
+
+	}
+	
+	
+	
+	public String getClassPath(){
+
+		String path = Thread.currentThread().getContextClassLoader().getResource("/").getPath();
+
+		return path;
+	}
+
+	
+
+	
+
+}
diff --git a/group23/601689050/4LRU&JVM/JVM/ClassFileloaderTest.java b/group23/601689050/4LRU&JVM/JVM/ClassFileloaderTest.java
new file mode 100644
index 0000000000..eae77d6dd4
--- /dev/null
+++ b/group23/601689050/4LRU&JVM/JVM/ClassFileloaderTest.java
@@ -0,0 +1,88 @@
+package com.test;
+
+import com.loader.ClassFileLoader;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.Before;
+import org.junit.After;
+
+
+public class ClassFileloaderTest {
+
+
+	public static String path1 = "C:\\Users\\liuxin\\git\\coding2017\\liuxin\\mini-jvm\\bin";
+	public static String path2 = "C:\\temp";
+	
+	
+	
+	@Before
+	public void setUp() throws Exception {		 
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+	
+	@Test
+	public void testClassPath(){		
+		
+		ClassFileLoader loader = new ClassFileLoader();
+		loader.addClassPath(path1);
+		loader.addClassPath(path2);
+		
+		String clzPath = loader.getClassPath();
+		
+		Assert.assertEquals(path1+";"+path2,clzPath);
+		
+	}
+	
+	@Test
+	public void testClassFileLength() throws ClassNotFoundException {
+		
+		ClassFileLoader loader = new ClassFileLoader();
+		loader.addClassPath(path1);
+		
+		String className = "EmployeeV1";
+		
+		byte[] byteCodes = loader.readBinaryCode(className);
+		
+		// 注意：这个字节数可能和你的JVM版本有关系， 你可以看看编译好的类到底有多大
+		Assert.assertEquals(1056, byteCodes.length-1);
+		
+	}
+	
+	
+    @Test	
+	public void testMagicNumber() throws ClassNotFoundException {
+    	ClassFileLoader loader = new ClassFileLoader();
+		loader.addClassPath(path1);
+		String className = "EmployeeV1";
+		byte[] byteCodes = loader.readBinaryCode(className);
+		byte[] codes = new byte[]{byteCodes[0],byteCodes[1],byteCodes[2],byteCodes[3]};
+		
+		
+		String acctualValue = this.byteToHexString(codes);
+		
+		Assert.assertEquals("cafebabe", acctualValue);
+	}
+    
+    
+    
+    
+    
+    
+	private String byteToHexString(byte[] codes ){
+		StringBuffer buffer = new StringBuffer();
+		for(int i=0;i<codes.length;i++){
+			byte b = codes[i];
+			int value = b & 0xFF;
+			String strHex = Integer.toHexString(value);
+			if(strHex.length()< 2){
+				strHex = "0" + strHex;
+			}		
+			buffer.append(strHex);
+		}
+		return buffer.toString();
+	}
+
+}
diff --git a/group23/601689050/4LRU&JVM/JVM/EmployeeV1.java b/group23/601689050/4LRU&JVM/JVM/EmployeeV1.java
new file mode 100644
index 0000000000..5785c48cc0
--- /dev/null
+++ b/group23/601689050/4LRU&JVM/JVM/EmployeeV1.java
@@ -0,0 +1,28 @@
+package com.test;
+
+public class EmployeeV1 {
+	
+	
+	private String name;
+    private int age;
+    
+    public EmployeeV1(String name, int age) {
+        this.name = name;
+        this.age = age;        
+    }    
+
+    public void setName(String name) {
+        this.name = name;
+    }
+    public void setAge(int age){
+    	this.age = age;
+    }
+    public void sayHello() {        
+    	System.out.println("Hello , this is class Employee ");    	
+    }
+    public static void main(String[] args){
+    	EmployeeV1 p = new EmployeeV1("Andy",29);
+    	p.sayHello();    
+    	
+    }
+}
\ No newline at end of file
diff --git a/group23/601689050/4LRU&JVM/LRU/Iterator.java b/group23/601689050/4LRU&JVM/LRU/Iterator.java
new file mode 100644
index 0000000000..96a43dbe0a
--- /dev/null
+++ b/group23/601689050/4LRU&JVM/LRU/Iterator.java
@@ -0,0 +1,5 @@
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group23/601689050/4LRU&JVM/LRU/LRUPageFrame.java b/group23/601689050/4LRU&JVM/LRU/LRUPageFrame.java
new file mode 100644
index 0000000000..c065298de9
--- /dev/null
+++ b/group23/601689050/4LRU&JVM/LRU/LRUPageFrame.java
@@ -0,0 +1,117 @@
+/**
+ * 用双向链表实现LRU算法
+ * @author liuxin
+ *
+ */
+public class LRUPageFrame {
+	
+	private static class Node {
+		
+		Node prev;
+		Node next;
+		int pageNum;
+
+		Node() {
+		}
+	}
+
+	private int capacity;
+	
+	
+	private Node first;// 链表头
+	private Node last;// 链表尾
+
+	
+	public LRUPageFrame(int capacity) {
+		
+		this.capacity = capacity;
+		
+	}
+
+	/**
+	 * 获取缓存中对象
+	 * 
+	 * @param
+	 * @return
+	 */
+	int size = 0;
+	public void access(int pageNum) {
+
+		if(size == 0){
+			Node node = new Node();
+			node.pageNum = pageNum;
+			node.prev = node.next = null;
+			first = last = node;
+			size++;
+		}else{
+			if(first.pageNum == pageNum){
+				return;
+			}
+			if(size == 1){
+				addToFirst(pageNum);
+			}else {
+				if (last.pageNum == pageNum) {
+					moveLastToFirst();
+					return;
+				}
+				Node iteratorNode = first;
+				while (iteratorNode.next != null && iteratorNode.pageNum != pageNum) {
+					iteratorNode = iteratorNode.next;
+				}
+				if (iteratorNode == last) {
+					addToFirst(pageNum);
+					if (size > capacity) {
+						last = last.prev;
+						last.next = null;
+					}
+				} else {
+				moveToFirst(iteratorNode);
+			}
+			}
+		}
+	
+	}
+
+	private void moveLastToFirst() {
+		last.next = first;
+		first.prev = last;
+		first = last;
+		last = last.prev;
+		last.next = null;
+		first.prev = null;
+	}
+	private void moveToFirst(Node iteratorNode){
+		iteratorNode.prev.next = iteratorNode.next;
+		iteratorNode.next.prev = iteratorNode.prev;
+		iteratorNode.prev = null;
+		iteratorNode.next = first;
+		first.prev = iteratorNode;
+		first = iteratorNode;
+	}
+
+	private void addToFirst(int pageNum) {
+		Node node = new Node();
+		node.pageNum = pageNum;
+		node.prev = null;
+		node.next = first;
+		first.prev = node;
+		first = node;
+		size++;
+	}
+
+
+	public String toString(){
+		StringBuilder buffer = new StringBuilder();
+		Node node = first;
+		while(node != null){
+			buffer.append(node.pageNum);			
+			
+			node = node.next;
+			if(node != null){
+				buffer.append(",");
+			}
+		}
+		return buffer.toString();
+	}
+	
+}
diff --git a/group23/601689050/4LRU&JVM/LRU/LRUPageFrameTest.java b/group23/601689050/4LRU&JVM/LRU/LRUPageFrameTest.java
new file mode 100644
index 0000000000..a7dd99ec58
--- /dev/null
+++ b/group23/601689050/4LRU&JVM/LRU/LRUPageFrameTest.java
@@ -0,0 +1,29 @@
+import  org.junit.Assert;
+
+import org.junit.Test;
+
+
+public class LRUPageFrameTest {
+	
+	@Test
+	public void testAccess() {
+		LRUPageFrame frame = new LRUPageFrame(3);
+		frame.access(7);
+		frame.access(0);
+		frame.access(1);
+		Assert.assertEquals("1,0,7", frame.toString());
+		frame.access(2);
+		Assert.assertEquals("2,1,0", frame.toString());
+		frame.access(0);
+		Assert.assertEquals("0,2,1", frame.toString());
+		frame.access(0);
+		Assert.assertEquals("0,2,1", frame.toString());
+		frame.access(3);
+		Assert.assertEquals("3,0,2", frame.toString());
+		frame.access(0);
+		Assert.assertEquals("0,3,2", frame.toString());
+		frame.access(4);
+		Assert.assertEquals("4,0,3", frame.toString());
+	}
+
+}
diff --git a/group23/601689050/4LRU&JVM/LRU/LinkedList.java b/group23/601689050/4LRU&JVM/LRU/LinkedList.java
new file mode 100644
index 0000000000..4a71816e5d
--- /dev/null
+++ b/group23/601689050/4LRU&JVM/LRU/LinkedList.java
@@ -0,0 +1,313 @@
+import java.util.Objects;
+import java.util.Stack;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	private Node rear;
+	public boolean isEmpty(){
+		return true;
+	}
+	
+	public void add(Object o){
+		if(isEmpty())
+		addFirst(o);
+		else
+			addLast(o);
+	}
+	public void add(int index , Object o){
+		if(index<0 || o ==null){
+			throw new IllegalArgumentException("不合法");
+		} else if (index == 0 && head == null){
+			addFirst(o);
+		}else if(index>0 && head == null){
+			throw new IllegalArgumentException("不合法");
+		}else{
+			Node srcNode = (Node) this.get(index);
+			Node newNode = new Node();
+			newNode.data = o;
+			newNode.next = srcNode.next;
+			srcNode.next.previous = newNode;
+			srcNode.next = newNode;
+			newNode.previous = srcNode;
+		}
+	}
+	public Object get(int index){
+		Node newNode = new Node();
+		for(int i = 0;i<index;i++){
+			newNode = newNode.next;
+		}
+		return newNode;
+	}
+	public Object remove(int index){
+		Node srcNode = (Node)this.get(index);
+		srcNode.previous.next = srcNode.next;
+		srcNode.next.previous = srcNode.previous;
+		return srcNode.data;
+	}
+	
+	public int size(){
+		Node newNode = new Node();
+		newNode = head;
+		int size = 0;
+		while (newNode != rear){
+			newNode = newNode.next;
+			size++;
+		}
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		Node newNode = new Node();
+		newNode.data = o;
+		if(isEmpty()){
+			rear = newNode;
+		}else{
+			head.previous = newNode;
+		}
+		newNode.next = head;
+		head = newNode;
+	}
+	public void addLast(Object o){
+		Node newNode = new Node();
+		newNode.data = o;
+		if(isEmpty()){
+			head = newNode;
+		} else {
+			rear.next = newNode;
+		}
+		newNode.previous = rear;
+		rear = newNode;
+	}
+	public Object removeFirst(){
+		if(isEmpty())
+		return null;
+		Node temp = head;
+		head = head.next;
+		if (head != null){
+			head.previous = null;
+		}else{
+			rear = null;
+		}
+		return temp.data;
+	}
+	public Object removeLast(){
+		if(isEmpty())
+		return null;
+		Node temp = rear;
+		rear = rear.previous;
+		if(rear != null){
+			rear.next = null;
+		} else {
+			head = null;
+		}
+		return  temp.data;
+	}
+	public Iterator iterator(){
+		Iterator ite = new Iterator() {
+			private Node temp = head;
+			@Override
+			public boolean hasNext() {
+				return temp != null;
+			}
+
+			@Override
+			public Object next() {
+				Object data = temp.data;
+				temp = temp.next;
+				return data;
+			}
+		};
+		return ite;
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		Node previous;
+		
+	}
+	
+	/**
+	 * 把该链表逆置
+	 * 例如链表为 3->7->10 , 逆置后变为  10->7->3
+	 */
+	public void reverse(){
+		Node p1,p2 = null;
+		p1 = head;
+		while (head.next != null){
+			p2 = head.next;
+			head.next = p2.next;
+			p2.next = p1;
+			p1 = p2;
+		}
+	}
+	
+	/**
+	 * 删除一个单链表的前半部分
+	 * 例如：list = 2->5->7->8 , 删除以后的值为 7->8
+	 * 如果list = 2->5->7->8->10 ,删除以后的值为7,8,10
+
+	 */
+	public  void removeFirstHalf(){
+		int size = this.size();
+		Node newNode = new Node();
+		newNode = head;
+		if(size%2 == 0){
+			int length = size/2;
+			for(int i = 0;i<length;i++){
+				newNode = newNode.next;
+			}
+			head.next = newNode.next;
+			head = newNode;
+		}else{
+			int length = (size+1)/2;
+			for(int i = 0;i<length;i++){
+				newNode = newNode.next;
+			}
+			head.next = newNode.next;
+			head = newNode;
+		}
+	}
+	
+	/**
+	 * 从第i个元素开始， 删除length 个元素 ， 注意i从0开始
+	 * @param i
+	 * @param length
+	 */
+	public  void remove(int i, int length){
+		Node newNode = (Node) this.get(i-1);
+		Node remNode = (Node) this.get(i);
+		for(int j=0;j<length-1;j++){
+			remNode = remNode.next;
+		}
+		newNode.next = remNode;
+		remNode.previous = newNode;
+	}
+	/**
+	 * 假定当前链表和listB均包含已升序排列的整数
+	 * 从当前链表中取出那些listB所指定的元素
+	 * 例如当前链表 = 11->101->201->301->401->501->601->701
+	 * listB = 1->3->4->6
+	 * 返回的结果应该是[101,301,401,601]  
+	 * @param list
+	 */
+	public  int[] getElements(LinkedList list){
+		int[] listB = new int[list.size()-1];
+		int[] listA = new int[list.size()-1];
+		int size = list.size();
+		for(int i=0;i<size;i++){
+			Node newNode = (Node) this.get(i);
+			listB[i] = (int) newNode.data;
+		}
+		for(int i=0;i<size;i++){
+			Node newNode = (Node) this.get(listB[i]);
+			listA[i] = (int) newNode.data;
+		}
+		return listA;
+	}
+	/**
+	 * 已知链表中的元素以值递增有序排列，并以单链表作存储结构。
+	 * 从当前链表中中删除在listB中出现的元素 
+
+	 * @param list
+	 */
+	
+	public  void subtract(LinkedList list){
+		int[] listB = new int[list.size()-1];
+		int[] listA = new int[this.size()-1];
+		int sizeB = list.size();
+		int sizeA = listA.length;
+		for(int i=0;i<sizeB;i++){
+			Node newNode = (Node) this.get(i);
+			listB[i] = (int) newNode.data;
+		}
+	    for(int i=0;i<sizeA;i++){
+			Node newNode = (Node) this.get(i);
+			listA[i] = (int) newNode.data;
+		}
+		for(int i = 0;i<sizeB ;i++){
+		for(int j = 0;j<sizeA ;j++){
+			if(listB[i] == listA [j]){
+				this.remove(j);
+			}else if(listB[i] < listA [j])
+				break;
+		}
+
+		}
+	}
+	
+	/**
+	 * 已知当前链表中的元素以值递增有序排列，并以单链表作存储结构。
+	 * 删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同）
+	 */
+	public  void removeDuplicateValues(){
+		int size = this.size();
+		Node newNode1 = new Node();
+		Node newNode2 = new Node();
+		for (int i = 0;i<size;i++){
+			newNode1 = (Node) this.get(i);
+			newNode2 = (Node) this.get(i+1);
+			if(newNode1.data == newNode2.data){
+				this.remove(i);
+			}
+		}
+	}
+	
+	/**
+	 * 已知链表中的元素以值递增有序排列，并以单链表作存储结构。
+	 * 试写一高效的算法，删除表中所有值大于min且小于max的元素（若表中存在这样的元素）
+	 * @param min
+	 * @param max
+	 */
+	public  void removeRange(int min, int max){
+		Node newNode = new Node();
+		int size = this.size();
+		for (int i = 0;i<size;i++){
+			newNode = (Node) this.get(i);
+			if((int)newNode.data > min && (int)newNode.data <max){
+				this.remove(i);
+			}else if ((int)newNode.data > min && (int)newNode.data > max){
+				break;
+			}
+		}
+	}
+	
+	/**
+	 * 假设当前链表和参数list指定的链表均以元素依值递增有序排列（同一表中的元素值各不相同）
+	 * 现要求生成新链表C，其元素为当前链表和list中元素的交集，且表C中的元素有依值递增有序排列
+	 * @param list
+	 */
+	public  LinkedList intersection( LinkedList list){
+		LinkedList listA = this;
+		LinkedList listB = list;
+		LinkedList listC = new LinkedList();
+		if(listA == null){
+			return list;
+		}
+		if(listB == null){
+			return this;
+		}
+		Node p1 = listA.head;
+		Node p2 = listB.head;
+		Node p3 = listC.head;
+		while(p1 != null && p2 !=null) {
+			if ((int) p1.data <= (int) p2.data) {
+				p3.next = p1;
+				p1 = p1.next;
+			} else {
+				p3.next = p2;
+				p2 = p2.next;
+			}
+			p3 = p3.next;
+		}
+		if(p1 == null){
+			p3.next = p2;
+		}
+		if(p2 == null){
+			p3.next = p1;
+		}
+		return listC;
+	}
+}
diff --git a/group23/601689050/4LRU&JVM/LRU/List.java b/group23/601689050/4LRU&JVM/LRU/List.java
new file mode 100644
index 0000000000..4f7bcc71a8
--- /dev/null
+++ b/group23/601689050/4LRU&JVM/LRU/List.java
@@ -0,0 +1,7 @@
+public interface List {
+	public void add(Object o);
+	public void add(int index, Object o);
+	public Object get(int index);
+	public Object remove(int index);
+	public int size();
+}